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

geovisio/web/params.py

@@ -14,6 +14,7 @@ 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
 
@@ -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)
@@ -400,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
@@ -416,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/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.

geovisio/web/upload_set.py

@@ -1,6 +1,5 @@
 from copy import deepcopy
 from dataclasses import dataclass
-
 import PIL
 from geovisio.utils import auth, model_query
 from psycopg.rows import class_row, dict_row
@@ -9,7 +8,7 @@ from flask import current_app, request, Blueprint, url_for
 from flask_babel import gettext as _, get_locale
 from geopic_tag_reader import sequence as geopic_sequence
 from geovisio.web.utils import accountIdOrDefault
-from psycopg.types.json import Jsonb
+from geovisio.utils.fields import parse_relative_heading
 from geovisio.web.params import (
     as_latitude,
     as_longitude,
@@ -20,6 +19,8 @@ from geovisio.utils import db
 from geovisio import utils
 from geopic_tag_reader.writer import writePictureMetadata, PictureMetadata
 from geovisio.utils.params import validation_error
+from geovisio.utils.semantics import SemanticTagUpdate
+from geovisio.utils import semantics
 from geovisio import errors
 from pydantic import BaseModel, ConfigDict, ValidationError, Field, field_validator, model_validator
 from uuid import UUID
@@ -37,7 +38,7 @@ from geovisio.utils.upload_set import (
 import os
 import hashlib
 import sentry_sdk
-from typing import Optional, Any, Dict
+from typing import Optional, Any, Dict, List
 
 
 bp = Blueprint("upload_set", __name__, url_prefix="/api")
@@ -52,67 +53,177 @@ class UploadSetCreationParameter(BaseModel):
     """Estimated number of items that will be sent to the UploadSet"""
     sort_method: Optional[geopic_sequence.SortMethod] = None
     """Strategy used for sorting your pictures. Either by filename or EXIF time, in ascending or descending order."""
+    no_split: Optional[bool] = None
+    """If True, all pictures of this upload set will be grouped in the same sequence. Is incompatible with split_distance / split_time."""
     split_distance: Optional[int] = None
-    """Maximum distance between two pictures to be considered in the same sequence (in meters)."""
+    """Maximum distance between two pictures to be considered in the same sequence (in meters). If not set, the instance default will be used. The instance defaults can be see in /api/configuration."""
     split_time: Optional[timedelta] = None
-    """Maximum time interval between two pictures to be considered in the same sequence."""
+    """Maximum time interval between two pictures to be considered in the same sequence.
+    If not set, the instance default will be used. The instance defaults can be see in /api/configuration."""
+    no_deduplication: Optional[bool] = None
+    """If True, no duplication will be done. Is incompatible with duplicate_distance / duplicate_rotation."""
     duplicate_distance: Optional[float] = None
-    """Maximum distance between two pictures to be considered as duplicates (in meters)."""
+    """Maximum distance between two pictures to be considered as duplicates (in meters).
+    If not set, the instance default will be used. The instance defaults can be see in /api/configuration."""
     duplicate_rotation: Optional[int] = None
-    """Maximum angle of rotation for two too-close-pictures to be considered as duplicates (in degrees)."""
+    """Maximum angle of rotation for two too-close-pictures to be considered as duplicates (in degrees).
+    If not set, the instance default will be used. The instance defaults can be see in /api/configuration."""
     metadata: Optional[Dict[str, Any]] = None
     """Optional metadata associated to the upload set. Can contain any key-value pair."""
     user_agent: Optional[str] = None
     """Software used by client to create this upload set, in HTTP Header User-Agent format"""
+    semantics: Optional[List[SemanticTagUpdate]] = None
+    """Semantic tags associated to the upload_set. Those tags will be added to all sequences linked to this upload set"""
+    relative_heading: Optional[int] = None
+    """The relative heading (in degrees), offset based on movement path (0° = looking forward, -90° = looking left, 90° = looking right). For single picture upload_sets, 0° is heading north). Headings are unchanged if this parameter is not set."""
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
+    def validate(self):
+        if self.no_split is True and (self.split_distance is not None or self.split_time is not None):
+            raise errors.InvalidAPIUsage("The `no_split` parameter is incompatible with specifying `split_distance` / `split_duration`")
+        if self.no_deduplication is True and (self.duplicate_distance is not None or self.duplicate_rotation is not None):
+            raise errors.InvalidAPIUsage(
+                "The `no_deduplication` parameter is incompatible with specifying `duplicate_distance` / `duplicate_rotation`"
+            )
+
+    @field_validator("relative_heading", mode="before")
+    @classmethod
+    def parse_relative_heading(cls, value):
+        return parse_relative_heading(value)
+
 
 class UploadSetUpdateParameter(BaseModel):
     """Parameters used to update an UploadSet"""
 
     sort_method: Optional[geopic_sequence.SortMethod] = None
     """Strategy used for sorting your pictures. Either by filename or EXIF time, in ascending or descending order."""
+    no_split: Optional[bool] = None
+    """If True, all pictures of this upload set will be grouped in the same sequence. Is incompatible with split_distance / split_time."""
     split_distance: Optional[int] = None
     """Maximum distance between two pictures to be considered in the same sequence (in meters)."""
     split_time: Optional[timedelta] = None
     """Maximum time interval between two pictures to be considered in the same sequence."""
+    no_deduplication: Optional[bool] = None
+    """If True, no deduplication will be done. Is incompatible with duplicate_distance / duplicate_rotation
+
+    Note that if the upload_set has already been dispatched, the deduplication has already been done so it cannot be deactivated.
+    """
     duplicate_distance: Optional[float] = None
     """Maximum distance between two pictures to be considered as duplicates (in meters)."""
     duplicate_rotation: Optional[int] = None
     """Maximum angle of rotation for two too-close-pictures to be considered as duplicates (in degrees)."""
+    semantics: Optional[List[SemanticTagUpdate]] = None
+    """Semantic tags associated to the upload_set. Those tags will be added to all sequences linked to this upload set.
+    By default each tag will be added to the upload set's tags, but you can change this behavior by setting the `action` parameter to `delete`.
+
+    If you want to replace a tag, you need to first delete it, then add it again.
+
+    Like:
+    [
+        {"key": "some_key", "value": "some_value", "action": "delete"},
+        {"key": "some_key", "value": "some_new_value"}
+    ]
+    
+    Note: for the moment it's not possible to update the semantics of an upload set after it has been dispatched.
+    If that is something needed, feel free to open an issue.
+    """
+    relative_heading: Optional[int] = None
+    """The relative heading (in degrees), offset based on movement path (0° = looking forward, -90° = looking left, 90° = looking right). For single picture upload_sets, 0° is heading north). Headings are unchanged if this parameter is not set."""
 
     model_config = ConfigDict(use_attribute_docstrings=True, extra="forbid")
 
+    def validate(self):
+        if self.no_split is True and (self.split_distance is not None or self.split_time is not None):
+            raise errors.InvalidAPIUsage("The `no_split` parameter is incompatible with specifying `split_distance` / `split_duration`")
+        if self.no_deduplication is True and (self.duplicate_distance is not None or self.duplicate_rotation is not None):
+            raise errors.InvalidAPIUsage(
+                "The `no_deduplication` parameter is incompatible with specifying `duplicate_distance` / `duplicate_rotation`"
+            )
+
+    def has_only_semantics_updates(self):
+        return self.model_fields_set == {"semantics"}
+
+    @field_validator("relative_heading", mode="before")
+    @classmethod
+    def parse_relative_heading(cls, value):
+        return parse_relative_heading(value)
+
 
 def create_upload_set(params: UploadSetCreationParameter, accountId: UUID) -> UploadSet:
+    sem = params.semantics
+    params.semantics = None
     db_params = model_query.get_db_params_and_values(params, account_id=accountId)
+    with db.conn(current_app) as conn, conn.transaction():
+
+        with conn.cursor(row_factory=class_row(UploadSet)) as cursor:
+            db_upload_set = cursor.execute(
+                SQL("INSERT INTO upload_sets({fields}) VALUES({values}) RETURNING *").format(
+                    fields=db_params.fields(), values=db_params.placeholders()
+                ),
+                db_params.params_as_dict,
+            ).fetchone()
+
+            if db_upload_set is None:
+                raise Exception("Impossible to insert upload_set in database")
+
+        if sem:
+            with conn.cursor() as cursor:
+                semantics.update_tags(
+                    cursor=cursor,
+                    entity=semantics.Entity(semantics.EntityType.upload_set, db_upload_set.id),
+                    actions=sem,
+                    account=accountId,
+                )
 
-    db_upload_set = db.fetchone(
-        current_app,
-        SQL("INSERT INTO upload_sets({fields}) VALUES({values}) RETURNING *").format(
-            fields=db_params.fields(), values=db_params.placeholders()
-        ),
-        db_params.params_as_dict,
-        row_factory=class_row(UploadSet),
-    )
+    return db_upload_set
 
-    if db_upload_set is None:
-        raise Exception("Impossible to insert upload_set in database")
 
-    return db_upload_set
+def update_upload_set(upload_set_id: UUID, params: UploadSetUpdateParameter, account) -> UploadSet:
+    """Update an upload set
+    Since the semantic tags are handled in a separate table, split the update in 2, the semantic update, and the upload_sets table update"""
+    with db.conn(current_app) as conn, conn.transaction():
+        if params.semantics:
+            # update the semantics if needed, and remove the semantic from the params for the other fields update
+            sem = params.semantics
+            params.semantics = None
 
+            with conn.cursor() as cursor:
+                semantics.update_tags(
+                    cursor=cursor,
+                    entity=semantics.Entity(semantics.EntityType.upload_set, upload_set_id),
+                    actions=sem,
+                    account=account.id if account is not None else None,
+                )
+
+                us_dispatched = cursor.execute(
+                    SQL("SELECT dispatched FROM upload_sets WHERE id = %(upload_set_id)s"),
+                    {"upload_set_id": upload_set_id},
+                ).fetchone()
+
+                if us_dispatched[0] is True:
+                    # if the upload set is already dispatched, we propagate the semantic update to all the associated collections
+                    # Note that there is a lock on the `upload_sets` row to avoid updating the semantics while dispatching the upload set
+                    associated_cols = conn.execute("SELECT id FROM sequences WHERE upload_set_id = %s", [upload_set_id]).fetchall()
+                    for c in associated_cols:
+                        col_id = c[0]
+                        semantics.update_tags(
+                            cursor=cursor,
+                            entity=semantics.Entity(semantics.EntityType.seq, col_id),
+                            actions=sem,
+                            account=account.id if account is not None else None,
+                        )
 
-def update_upload_set(upload_set_id: UUID, params: UploadSetUpdateParameter) -> UploadSet:
-    db_params = model_query.get_db_params_and_values(params)
+        if params.model_fields_set != {"semantics"}:
+            # if there was other fields to update
+            db_params = model_query.get_db_params_and_values(params)
 
-    with db.execute(
-        current_app,
-        SQL("UPDATE upload_sets SET {fields} WHERE id = %(upload_set_id)s").format(fields=db_params.fields_for_set()),
-        db_params.params_as_dict | {"upload_set_id": upload_set_id},
-    ):
-        # we get a full uploadset response
-        return get_upload_set(upload_set_id)
+            conn.execute(
+                SQL("UPDATE upload_sets SET {fields} WHERE id = %(upload_set_id)s").format(fields=db_params.fields_for_set()),
+                db_params.params_as_dict | {"upload_set_id": upload_set_id},
+            )
+    # we get a full uploadset response
+    return get_upload_set(upload_set_id)
 
 
 @bp.route("/upload_sets", methods=["POST"])
@@ -132,7 +243,7 @@ def postUploadSet(account=None):
           required: false
           schema:
             type: string
-          description: An explicit User-Agent value is prefered if you create a production-ready tool, formatted like "GeoVisioCLI/1.0"
+          description: An explicit User-Agent value is preferred if you create a production-ready tool, formatted like "GeoVisioCLI/1.0"
     requestBody:
         content:
             application/json:
@@ -158,6 +269,7 @@ def postUploadSet(account=None):
     else:
         raise errors.InvalidAPIUsage(_("Parameter for creating an UploadSet should be a valid JSON"), status_code=415)
 
+    params.validate()
     account_id = UUID(accountIdOrDefault(account))
 
     upload_set = create_upload_set(params, account_id)
@@ -178,7 +290,9 @@ def postUploadSet(account=None):
 def patchUploadSet(upload_set_id, account=None):
     """Update an existing UploadSet.
 
-    Note that the upload set will not be dispatched again, so if you changed the dispatch parameters (like split_distance, split_time, duplicate_distance, duplicate_rotation, ...), you need to call the `POST /api/upload_sets/:id/complete` endpoint to dispatch the upload set afterward.
+    For most fields, only the owner of the UploadSet can update it. The only exception is the `semantics` field, which can be updated by any user.
+
+    Note that the upload set will not be dispatched again, so if you changed the dispatch parameters (like split_distance, split_time, duplicate_distance, duplicate_rotation, relative_heading, ...), you need to call the `POST /api/upload_sets/:id/complete` endpoint to dispatch the upload set afterward.
     ---
     tags:
         - Upload
@@ -215,18 +329,20 @@ def patchUploadSet(upload_set_id, account=None):
     else:
         raise errors.InvalidAPIUsage(_("Parameter for updating an UploadSet should be a valid JSON"), status_code=415)
 
+    params.validate()
     upload_set = get_simple_upload_set(upload_set_id)
     if upload_set is None:
         raise errors.InvalidAPIUsage(_("UploadSet doesn't exist"), status_code=404)
 
     if account and str(upload_set.account_id) != account.id:
-        raise errors.InvalidAPIUsage(_("You are not allowed to update this upload set"), status_code=403)
+        if not params.has_only_semantics_updates():
+            raise errors.InvalidAPIUsage(_("You are not allowed to update this upload set"), status_code=403)
 
     if not params.model_fields_set:
         # nothing to update, return the upload set
         upload_set = get_upload_set(upload_set_id)
     else:
-        upload_set = update_upload_set(upload_set_id, params)
+        upload_set = update_upload_set(upload_set_id, params, account)
 
     return upload_set.model_dump_json(exclude_none=True), 200, {"Content-Type": "application/json"}
 
@@ -515,7 +631,7 @@ def mark_upload_set_completed_if_needed(cursor, upload_set_id: UUID) -> bool:
         """WITH nb_items AS (
             SELECT count(*) AS nb, upload_set_id
             FROM files f
-            WHERE upload_set_id = %(id)s 
+            WHERE upload_set_id = %(id)s
             GROUP BY upload_set_id
         )
         UPDATE upload_sets
@@ -846,6 +962,8 @@ def deleteUploadSet(upload_set_id: UUID, account=None):
 
     upload_set = get_upload_set(upload_set_id)
 
+    if not upload_set:
+        raise errors.InvalidAPIUsage(_("UploadSet %(u)s does not exist", u=upload_set_id), status_code=404)
     # Account associated to uploadset doesn't match current user
     if account is not None and account.id != str(upload_set.account_id):
         raise errors.InvalidAPIUsage(_("You're not authorized to delete this upload set"), status_code=403)

geovisio/web/users.py

@@ -91,13 +91,13 @@ def _get_user_info(account: auth.Account):
 @bp.route("/me")
 @auth.login_required_with_redirect()
 def getMyUserInfo(account):
-    """Get current logged user informations
+    """Get current logged user information
     ---
     tags:
         - Users
     responses:
         200:
-            description: Information about the logged account
+            description: Information about the logged in account
             content:
                 application/json:
                     schema:
@@ -108,7 +108,7 @@ def getMyUserInfo(account):
 
 @bp.route("/<uuid:userId>")
 def getUserInfo(userId):
-    """Get user informations
+    """Get user information
     ---
     tags:
         - Users
@@ -152,7 +152,7 @@ def getMyCatalog(account):
     deprecated: true
     responses:
         200:
-            description: the Catalog listing all sequences associated to given user. Note that it's similar to the user's colletion, but with less metadata since a STAC collection is an enhanced STAC catalog.
+            description: the Catalog listing all sequences associated to given user. Note that it's similar to the user's collection, but with less metadata since a STAC collection is an enhanced STAC catalog.
             content:
                 application/json:
                     schema:

geovisio/web/utils.py

@@ -14,12 +14,12 @@ STAC_VERSION = "1.0.0"
 
 
 def removeNoneInDict(val):
-    """Removes empty values from dictionnary"""
+    """Removes empty values from dictionary"""
     return {k: v for k, v in val.items() if v is not None}
 
 
 def cleanNoneInDict(val):
-    """Removes empty values from dictionnary, and return None if dict is empty"""
+    """Removes empty values from dictionary, and return None if dict is empty"""
     res = removeNoneInDict(val)
     return res if len(res) > 0 else None