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

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,74 +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():
 
-    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),
-    )
+        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 sequence in database")
+            if db_upload_set is None:
+                raise Exception("Impossible to insert upload_set in database")
 
-    return db_upload_set
+        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,
+                )
 
+    return db_upload_set
 
-def update_upload_set(upload_set_id: UUID, params: UploadSetUpdateParameter) -> UploadSet:
-    db_params = model_query.get_db_params_and_values(params)
 
+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():
-        import psycopg
+        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
 
-        cur = psycopg.ClientCursor(conn)
-        q = SQL("UPDATE upload_sets SET {fields} WHERE id = %(upload_set_id)s").format(fields=db_params.fields_for_set())
-        print(cur.mogrify(q, db_params.params_as_dict | {"upload_set_id": upload_set_id}))
+            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,
+                )
 
-    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)
+                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,
+                        )
+
+        if params.model_fields_set != {"semantics"}:
+            # if there was other fields to update
+            db_params = model_query.get_db_params_and_values(params)
+
+            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"])
@@ -139,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:
@@ -165,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)
@@ -185,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
@@ -201,7 +308,7 @@ def patchUploadSet(upload_set_id, account=None):
         content:
             application/json:
                 schema:
-                    $ref: '#/components/schemas/GeoVisioUploadSet'
+                    $ref: '#/components/schemas/UploadSetUpdateParameter'
     security:
         - bearerToken: []
         - cookieAuth: []
@@ -222,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"}
 
@@ -522,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
@@ -853,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