geovisio 2.8.1__py3-none-any.whl → 2.10.0__py3-none-any.whl

geovisio/web/map.py

@@ -352,23 +352,35 @@ def _get_query(z: int, x: int, y: int, onlyForUser: Optional[UUID], additional_f
         sql.SQL("nb_360_pictures"),
         sql.SQL("nb_pictures - nb_360_pictures AS nb_flat_pictures"),
         sql.SQL(
-            """((CASE WHEN nb_pictures = 0 THEN 0 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
+            """((CASE WHEN nb_pictures = 0 
+                    THEN 0 
+                WHEN nb_pictures <= (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) FILTER (WHERE nb_pictures > 0) FROM pictures_grid)
+                THEN 
+                    nb_pictures::float / (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_pictures) FILTER (WHERE nb_pictures > 0) 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"""
         ),
         sql.SQL(
-            """((CASE WHEN nb_360_pictures = 0 THEN 0
-                WHEN nb_360_pictures <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) from pictures_grid)
-                THEN nb_360_pictures::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) from pictures_grid) * 0.5
-                ELSE 0.5 + nb_360_pictures::float / (SELECT MAX(nb_360_pictures) FROM pictures_grid) * 0.5
+            """((CASE WHEN nb_360_pictures = 0 
+                    THEN 0
+                WHEN (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) FILTER (WHERE nb_360_pictures > 0) FROM pictures_grid) = 0 
+                    THEN 0
+                WHEN nb_360_pictures <= (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) FILTER (WHERE nb_360_pictures > 0) FROM pictures_grid)
+                    THEN nb_360_pictures::float / (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY nb_360_pictures) FILTER (WHERE nb_360_pictures > 0) FROM pictures_grid) * 0.5
+                ELSE 
+                    0.5 + nb_360_pictures::float / (SELECT MAX(nb_360_pictures) FROM pictures_grid) * 0.5
             END) * 10)::int / 10::float AS coef_360_pictures"""
         ),
         sql.SQL(
-            """((CASE WHEN (nb_pictures - nb_360_pictures) = 0 THEN 0 
-                WHEN (nb_pictures - nb_360_pictures) <= (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) from pictures_grid)
-                    THEN (nb_pictures - nb_360_pictures)::float / (select PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) from pictures_grid) * 0.5
-                ELSE 0.5 + (nb_pictures - nb_360_pictures)::float / (SELECT MAX((nb_pictures - nb_360_pictures)) FROM pictures_grid) * 0.5
+            """((CASE WHEN (nb_pictures - nb_360_pictures) = 0 
+                    THEN 0 
+                WHEN (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) FILTER (WHERE (nb_pictures - nb_360_pictures) > 0) FROM pictures_grid) = 0 
+                    THEN 0
+                WHEN (nb_pictures - nb_360_pictures) <= (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) FILTER (WHERE (nb_pictures - nb_360_pictures) > 0) FROM pictures_grid)
+                    THEN (nb_pictures - nb_360_pictures)::float / (SELECT PERCENTILE_CONT(0.5) WITHIN GROUP(ORDER BY (nb_pictures - nb_360_pictures)) FILTER (WHERE (nb_pictures - nb_360_pictures) > 0) FROM pictures_grid) * 0.5
+                ELSE 
+                    0.5 + (nb_pictures - nb_360_pictures)::float / (SELECT MAX((nb_pictures - nb_360_pictures)) FROM pictures_grid) * 0.5
             END) * 10)::int / 10::float AS coef_flat_pictures"""
         ),
     ]
@@ -616,7 +628,7 @@ def getUserTile(userId: UUID, z: int, x: int, y: int, format: str):
                         format: binary
     """
 
-    filter = params.parse_filter(request.args.get("filter"))
+    filter = params.parse_collection_filter(request.args.get("filter"))
     return _getTile(z, x, y, format, onlyForUser=userId, filter=filter)
 
 
@@ -688,5 +700,5 @@ def getMyTile(account: Account, z: int, x: int, y: int, format: str):
                         type: string
                         format: binary
     """
-    filter = params.parse_filter(request.args.get("filter"))
+    filter = params.parse_collection_filter(request.args.get("filter"))
     return _getTile(z, x, y, format, onlyForUser=UUID(account.id), filter=filter)

geovisio/web/params.py

@@ -8,14 +8,15 @@ import datetime
 import re
 from werkzeug.datastructures import MultiDict
 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 pygeofilter import ast
 from pygeofilter.backends.evaluator import Evaluator, handle
 from psycopg import sql
 from geovisio.utils.sequences import STAC_FIELD_MAPPINGS, STAC_FIELD_TO_SQL_FILTER
 from geovisio.utils.fields import SortBy, SQLDirection, SortByField
 from flask_babel import gettext as _
+from geovisio.utils import items as utils_items
+
+from geovisio.utils.cql2 import parse_cql2_filter
 
 
 RGX_SORTBY = re.compile("[+-]?[A-Za-z_].*(,[+-]?[A-Za-z_].*)*")
@@ -43,11 +44,11 @@ def parse_datetime(value, error, fallback_as_UTC=False):
 
     """
     # Hack to parse a date
-    # dateutils know how to parse lots of date, but fail to correctly parse date formated by `datetime.isoformat()`
+    # dateutils know how to parse lots of date, but fail to correctly parse date formatted by `datetime.isoformat()`
     # (like all the dates returned by the API).
     # datetime.isoformat is like: `2023-06-17T21:22:18.406856+02:00`
-    # dateutils silently fails the parse, and create an incorect date
-    # so we first try to parse it like an isoformated date, and if this fails we try the flexible dateutils
+    # dateutils silently fails the parse, and create an incorrect date
+    # so we first try to parse it like an isoformatted date, and if this fails we try the flexible dateutils
     d = None
     try:
         d = datetime.datetime.fromisoformat(value)
@@ -325,37 +326,27 @@ def parse_list(value: Optional[Any], tryFallbacks: bool = True, paramName: Optio
         return None
 
 
-def parse_filter(value: Optional[str]) -> Optional[sql.SQL]:
+def parse_collection_filter(value: Optional[str]) -> Optional[sql.SQL]:
     """Reads STAC filter parameter and sends SQL condition back.
 
-    >>> parse_filter('')
+    >>> parse_collection_filter('')
 
-    >>> parse_filter("updated >= '2023-12-31'")
+    >>> parse_collection_filter("updated >= '2023-12-31'")
     SQL("(s.updated_at >= '2023-12-31')")
-    >>> parse_filter("updated >= '2023-12-31' AND created < '2023-10-31'")
+    >>> parse_collection_filter("updated >= '2023-12-31' AND created < '2023-10-31'")
     SQL("((s.updated_at >= '2023-12-31') AND (s.inserted_at < '2023-10-31'))")
-    >>> parse_filter("status IN ('deleted','ready')") # when we ask for deleted, we should also have hidden collections
+    >>> parse_collection_filter("status IN ('deleted','ready')") # when we ask for deleted, we should also have hidden collections
     SQL("s.status IN ('deleted', 'ready', 'hidden')")
-    >>> parse_filter("status = 'deleted' OR status = 'ready'")
+    >>> parse_collection_filter("status = 'deleted' OR status = 'ready'")
     SQL("(((s.status = 'deleted') OR (s.status = 'hidden')) OR (s.status = 'ready'))")
-    >>> parse_filter('invalid = 10') # doctest: +IGNORE_EXCEPTION_DETAIL
+    >>> parse_collection_filter('invalid = 10') # doctest: +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
     geovisio.errors.InvalidAPIUsage: Unsupported filter parameter
-    >>> parse_filter('updated == 10') # doctest: +IGNORE_EXCEPTION_DETAIL
+    >>> parse_collection_filter('updated == 10') # doctest: +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
     geovisio.errors.InvalidAPIUsage: Unsupported filter parameter
     """
-    if value is not None and len(value) > 0:
-        try:
-            filterAst = ecql_parser(value)
-            altered_ast = _alterFilterAst(filterAst)  # type: ignore
-
-            f = to_sql_where(altered_ast, STAC_FIELD_TO_SQL_FILTER).replace('"', "")
-            return sql.SQL(f)  # type: ignore
-        except:
-            raise errors.InvalidAPIUsage(_("Unsupported filter parameter"), status_code=400)
-    else:
-        return None
+    return parse_cql2_filter(value, STAC_FIELD_TO_SQL_FILTER, ast_updater=_alterFilterAst)
 
 
 def parse_picture_heading(heading: Optional[str]) -> Optional[int]:
@@ -410,7 +401,25 @@ def _alterFilterAst(ast: ast.Node):
     return filtered
 
 
-def parse_sortby(value: Optional[str]) -> Optional[SortBy]:
+def _parse_sorty_by(value: Optional[str], field_mapping_func, SortByCls):
+    if not value:
+        return None
+    # Check value pattern
+    if not RGX_SORTBY.match(value):
+        raise errors.InvalidAPIUsage(_("Unsupported sortby parameter: syntax isn't correct"), status_code=400)
+    values = value.split(",")
+    orders = []
+    for v in values:
+        direction = SQLDirection.DESC if v.startswith("-") else SQLDirection.ASC
+        raw_field = v.lstrip("+-")
+        f = field_mapping_func(raw_field, direction)
+
+        orders.append(f)
+
+    return SortByCls(fields=orders)
+
+
+def parse_collection_sortby(value: Optional[str]) -> Optional[SortBy]:
     """Reads STAC/OGC sortby parameter, and sends a SQL ORDER BY string.
 
     Parameters
@@ -426,46 +435,40 @@ def parse_sortby(value: Optional[str]) -> Optional[SortBy]:
 
     None if no sort by is found
 
-    >>> parse_sortby(None)
-    >>> parse_sortby("")
-    >>> parse_sortby('updated')
+    >>> parse_collection_sortby(None)
+    >>> parse_collection_sortby("")
+    >>> parse_collection_sortby('updated')
     SortBy(fields=[SortByField(field=FieldMapping(sql_column=SQL('updated_at'), stac='updated'), direction=<SQLDirection.ASC: SQL('ASC')>)])
-    >>> parse_sortby('+created')
+    >>> parse_collection_sortby('+created')
     SortBy(fields=[SortByField(field=FieldMapping(sql_column=SQL('inserted_at'), stac='created'), direction=<SQLDirection.ASC: SQL('ASC')>)])
-    >>> parse_sortby('-created')
+    >>> parse_collection_sortby('-created')
     SortBy(fields=[SortByField(field=FieldMapping(sql_column=SQL('inserted_at'), stac='created'), direction=<SQLDirection.DESC: SQL('DESC')>)])
-    >>> parse_sortby('+updated,-created')
+    >>> parse_collection_sortby('+updated,-created')
     SortBy(fields=[SortByField(field=FieldMapping(sql_column=SQL('updated_at'), stac='updated'), direction=<SQLDirection.ASC: SQL('ASC')>), SortByField(field=FieldMapping(sql_column=SQL('inserted_at'), stac='created'), direction=<SQLDirection.DESC: SQL('DESC')>)])
-    >>> parse_sortby('invalid') # doctest: +IGNORE_EXCEPTION_DETAIL
+    >>> parse_collection_sortby('invalid') # doctest: +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
     geovisio.errors.InvalidAPIUsage: Unsupported sortby parameter
-    >>> parse_sortby('~nb') # doctest: +IGNORE_EXCEPTION_DETAIL
+    >>> parse_collection_sortby('~nb') # doctest: +IGNORE_EXCEPTION_DETAIL
     Traceback (most recent call last):
     geovisio.errors.InvalidAPIUsage: Unsupported sortby parameter
     """
 
-    if value is not None and len(value) > 0:
-        # Check value pattern
-        if RGX_SORTBY.match(value):
-            values = value.split(",")
-            orders = []
-            for v in values:
-                direction = SQLDirection.DESC if v.startswith("-") else SQLDirection.ASC
-                vOnly = v.replace("+", "").replace("-", "")
+    def mapping(raw_field: str, direction: SQLDirection):
+        if raw_field not in STAC_FIELD_MAPPINGS:
+            raise errors.InvalidAPIUsage(_("Unsupported sortby parameter: invalid column name"), status_code=400)
+        return SortByField(field=STAC_FIELD_MAPPINGS[raw_field], direction=direction)
 
-                # Check if in value mapping
-                if vOnly not in STAC_FIELD_MAPPINGS:
-                    raise errors.InvalidAPIUsage(_("Unsupported sortby parameter: invalid column name"), status_code=400)
-                field_mapping = STAC_FIELD_MAPPINGS[vOnly]
+    return _parse_sorty_by(value, mapping, SortByCls=SortBy)
 
-                orders.append(SortByField(field=field_mapping, direction=direction))
 
-            # Create definitive ORDER string
-            return SortBy(fields=orders)
-        else:
-            raise errors.InvalidAPIUsage(_("Unsupported sortby parameter: syntax isn't correct"), status_code=400)
-    else:
-        return None
+def parse_item_sortby(value: Optional[str]) -> Optional[utils_items.SortBy]:
+    def mapping(raw_field: str, direction: SQLDirection):
+        if raw_field == "distance_to" or raw_field not in utils_items.SortableItemField.__dict__:
+            # distance to is for the moment only an implicit sort when search a point or in a bbox
+            raise errors.InvalidAPIUsage(_("Unsupported sortby parameter: invalid field"), status_code=400)
+        return utils_items.ItemSortByField(field=utils_items.SortableItemField[raw_field], direction=direction)
+
+    return _parse_sorty_by(value, mapping, SortByCls=utils_items.SortBy)
 
 
 def parse_collections_limit(limit: Optional[str]) -> int:

geovisio/web/pictures.py

@@ -208,3 +208,37 @@ def getPictureTile(pictureId, col, row, format):
         raise errors.InvalidAPIUsage(_("Unable to read picture on filesystem"), status_code=500)
 
     return utils.pictures.sendInFormat(picture, "jpeg", format)
+
+
+@bp.route("/<uuid:pictureId>")
+def getPictureById(pictureId):
+    """Get picture's STAC definition.
+
+    It's the non-stac alias to the `/api/collections/<collectionId>/items/<itemId>` endpoint (but you don't need to know the collection ID here).
+    ---
+    tags:
+        - Pictures
+    parameters:
+        - name: pictureId
+          in: path
+          description: ID of the picture (called item in STAC) to retrieve
+          required: true
+          schema:
+            type: string
+    responses:
+        102:
+            description: the picture (which is still under process)
+            content:
+                application/geo+json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioItem'
+        200:
+            description: the wanted picture
+            content:
+                application/geo+json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioItem'
+    """
+    from geovisio.web.items import getCollectionItem
+
+    return getCollectionItem(collectionId=None, itemId=pictureId)

geovisio/web/stac.py

@@ -20,10 +20,11 @@ from geovisio.utils.sequences import (
     get_collections,
     CollectionsRequest,
     STAC_FIELD_MAPPINGS,
+    get_dataset_bounds,
     get_pagination_links,
 )
 from geovisio.web.params import (
-    parse_filter,
+    parse_collection_filter,
     parse_collections_limit,
 )
 
@@ -334,12 +335,17 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
     """
 
     collection_request = CollectionsRequest(
-        sort_by=SortBy(fields=[SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.ASC)]),
+        sort_by=SortBy(
+            fields=[
+                SortByField(field=STAC_FIELD_MAPPINGS["created"], direction=SQLDirection.ASC),
+                SortByField(field=STAC_FIELD_MAPPINGS["id"], direction=SQLDirection.ASC),
+            ]
+        ),
         user_id=userId,
         userOwnsAllCollections=userIdMatchesAccount,
     )
     collection_request.limit = parse_collections_limit(request.args.get("limit"))
-    collection_request.pagination_filter = parse_filter(request.args.get("page"))
+    collection_request.pagination_filter = parse_collection_filter(request.args.get("page"))
 
     userName = None
     meta_collection = None
@@ -350,12 +356,14 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
             raise errors.InvalidAPIUsage(_("Impossible to find user %(u)s", u=userId))
         userName = userName["name"]
 
-        meta_collection = cursor.execute(
-            SQL("SELECT MIN(inserted_at) AS min_order, MAX(inserted_at) AS max_order FROM sequences s WHERE account_id = %(account)s"),
-            params={"account": userId},
-        ).fetchone()
+        datasetBounds = get_dataset_bounds(
+            cursor.connection,
+            collection_request.sort_by,
+            additional_filters=SQL("s.account_id = %(account)s"),
+            additional_filters_params={"account": userId},
+        )
 
-        if not meta_collection or meta_collection["min_order"] is None:
+        if datasetBounds is None:
             # No data found, trying to give the most meaningfull error message
             raise errors.InvalidAPIUsage(_("No data loaded for user %(u)s", u=userId), 404)
 
@@ -388,10 +396,9 @@ def getUserCatalog(userId, userIdMatchesAccount=False):
     pagination_links = get_pagination_links(
         route="stac.getUserCatalog",
         routeArgs={"userId": str(userId), "limit": collection_request.limit},
-        field=collection_request.sort_by.fields[0].field.stac,
-        direction=collection_request.sort_by.fields[0].direction,
-        datasetBounds=Bounds(min=meta_collection["min_order"], max=meta_collection["max_order"]),
-        dataBounds=db_collections.query_first_order_bounds,
+        sortBy=collection_request.sort_by,
+        datasetBounds=datasetBounds,
+        dataBounds=db_collections.query_bounds,
         additional_filters=None,
     )
 

geovisio/web/tokens.py

@@ -22,7 +22,7 @@ def list_tokens(account):
 
     The list of tokens will not contain their JWT counterpart (the JWT is the real token used in authentication).
 
-    The JWT counterpart can be retreived by providing the token's id to the endpoint [/users/me/tokens/{token_id}](#/Auth/get_api_users_me_tokens__token_id_).
+    The JWT counterpart can be retrieved by providing the token's id to the endpoint [/users/me/tokens/{token_id}](#/Auth/get_api_users_me_tokens__token_id_).
     ---
     tags:
         - Auth
@@ -254,6 +254,54 @@ def claim_non_associated_token(token_id, account):
         return "You are now logged in the CLI, you can upload your pictures", 200
 
 
+@bp.route("/users/me/tokens", methods=["POST"])
+@auth.login_required_with_redirect()
+def generate_associated_token(account: auth.Account):
+    """
+    Generate a new token associated to the current user
+
+    The response contains the JWT token and is directly usable (unlike tokens created by `/auth/tokens/generate` that are not associated to a user by default). This token does not need to be claimed.
+    ---
+    tags:
+        - Auth
+    requestBody:
+        content:
+            application/json:
+                schema:
+                    $ref: '#/components/schemas/GeovisioPostToken'
+    responses:
+        200:
+            description: The newly generated token
+            content:
+                application/json:
+                    schema:
+                        $ref: '#/components/schemas/GeoVisioEncodedToken'
+    """
+    if request.is_json:
+        description = request.json.get("description", "")
+    else:
+        description = None
+
+    token = db.fetchone(
+        current_app,
+        "INSERT INTO tokens (description, account_id) VALUES (%(description)s, %(account_id)s) RETURNING *",
+        {"account_id": account.id, "description": description},
+        row_factory=dict_row,
+    )
+    if not token:
+        raise errors.InternalError(_("Impossible to generate a new token"))
+
+    jwt_token = _generate_jwt_token(token["id"])
+    return flask.jsonify(
+        {
+            "jwt_token": jwt_token,
+            "id": token["id"],
+            "description": token["description"],
+            "generated_at": token["generated_at"].astimezone(tz.gettz("UTC")).isoformat(),
+        }
+    )
+
+
 def _generate_jwt_token(token_id: uuid.UUID) -> str:
     """
     Generate a JWT token from a token's id.