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

geovisio/utils/pictures.py

@@ -1,6 +1,8 @@
+import json
 import math
-from typing import Dict, Optional
+from typing import Any, Dict, List, Optional, Tuple
 from uuid import UUID
+from attr import dataclass
 from flask import current_app, redirect, send_file
 from flask_babel import gettext as _
 import os
@@ -13,14 +15,28 @@ import logging
 from dataclasses import asdict
 from fs.path import dirname
 from psycopg.errors import UniqueViolation, InvalidParameterValue
+from psycopg.types.json import Jsonb
+from psycopg import sql, Connection
+import sentry_sdk
 from geovisio import utils, errors
 from geopic_tag_reader import reader
 import re
+import multipart
+
+from geovisio.utils import db
 
 log = logging.getLogger(__name__)
 
 
-def createBlurredHDPicture(fs, blurApi, pictureBytes, outputFilename):
+@dataclass
+class BlurredPicture:
+    """Blurred picture's response"""
+
+    image: Image
+    metadata: Dict[str, str] = {}
+
+
+def createBlurredHDPicture(fs, blurApi, pictureBytes, outputFilename, keep_unblured_parts=False) -> Optional[BlurredPicture]:
     """Create the blurred version of a picture using a blurMask
 
     Parameters
@@ -39,20 +55,49 @@ def createBlurredHDPicture(fs, blurApi, pictureBytes, outputFilename):
     PIL.Image
             The blurred version of the image
     """
+    if blurApi is None:
+        return None
+    # Call blur API, asking for multipart response if available
+    pictureBytes.seek(0)
+    query_params = {"keep": 1} if keep_unblured_parts else {}
+    blurResponse = requests.post(
+        f"{blurApi}/blur/",
+        files={"picture": ("picture.jpg", pictureBytes.read(), "image/jpeg")},
+        headers={"Accept": "multipart/form-data"},
+        params=query_params,
+    )
+    blurResponse.raise_for_status()
+
+    metadata, blurred_pic = None, None
+    content_type, content_type_params = multipart.parse_options_header(blurResponse.headers.get("content-type", ""))
+    if content_type == "multipart/form-data":
+        # New blurring api can return multipart response, with separated blurring picture/metadata
+        multipart_response = multipart.MultipartParser(io.BytesIO(blurResponse.content), boundary=content_type_params["boundary"])
+
+        metadata = multipart_response.get("metadata")
+        if metadata:
+            metadata = metadata.raw
+        blurred_pic = multipart_response.get("image")
+        if blurred_pic:
+            blurred_pic = blurred_pic.raw
+    else:
+        # old blurring API, no multipart response, we read the `x-sgblur` header
+        blurred_pic = blurResponse.content
+        metadata = blurResponse.headers.get("x-sgblur")
 
-    if blurApi is not None:
-        # Call blur API
-        pictureBytes.seek(0)
-        blurResponse = requests.post(blurApi + "/blur/", files={"picture": ("picture.jpg", pictureBytes.read(), "image/jpeg")})
-        blurResponse.raise_for_status()
-
-        # Save mask to FS
-        fs.writebytes(outputFilename, blurResponse.content)
+    # Save mask to FS
+    fs.writebytes(outputFilename, blurred_pic)
 
-        return Image.open(io.BytesIO(blurResponse.content))
+    if metadata:
+        try:
+            metadata = json.loads(metadata)
+        except (json.decoder.JSONDecodeError, TypeError) as e:
+            # we skip the metadata's response if we are not able to understand it
+            log.warning(f"Impossible to parse blurring metadata API response: {e}")
+            sentry_sdk.capture_exception(e)
+            metadata = None
 
-    else:
-        return None
+    return BlurredPicture(image=Image.open(io.BytesIO(blurred_pic)), metadata=metadata)
 
 
 def getTileSize(imgSize):
@@ -511,6 +556,25 @@ class MetadataReadingError(Exception):
         self.missing_mandatory_tags = missing_mandatory_tags
 
 
+def get_lighter_metadata(metadata):
+    """Create a lighter metadata field to remove duplicates fields"""
+    lighterMetadata = dict(
+        filter(
+            lambda v: v[0] not in ["ts", "heading", "lon", "lat", "exif", "originalContentMd5", "ts_by_source", "gps_accuracy"],
+            metadata.items(),
+        )
+    )
+    if lighterMetadata.get("tagreader_warnings") is not None and len(lighterMetadata["tagreader_warnings"]) == 0:
+        del lighterMetadata["tagreader_warnings"]
+    lighterMetadata["tz"] = metadata["ts"].tzname()
+    if metadata.get("ts_by_source", {}).get("gps") is not None:
+        lighterMetadata["ts_gps"] = metadata["ts_by_source"]["gps"].isoformat()
+    if metadata.get("ts_by_source", {}).get("camera") is not None:
+        lighterMetadata["ts_camera"] = metadata["ts_by_source"]["camera"].isoformat()
+
+    return lighterMetadata
+
+
 def insertNewPictureInDatabase(
     db, sequenceId, position, pictureBytes, associatedAccountID, additionalMetadata, uploadSetID=None, lang="en"
 ):
@@ -537,11 +601,10 @@ def insertNewPictureInDatabase(
     -------
     uuid : The uuid of the new picture entry in the database
     """
-    from psycopg.types.json import Jsonb
 
     # Create a fully-featured metadata object
-    picturePillow = Image.open(io.BytesIO(pictureBytes))
-    metadata = readPictureMetadata(pictureBytes, lang) | utils.pictures.getPictureSizing(picturePillow) | additionalMetadata
+    with Image.open(io.BytesIO(pictureBytes)) as picturePillow:
+        metadata = readPictureMetadata(pictureBytes, lang) | utils.pictures.getPictureSizing(picturePillow) | additionalMetadata
 
     # Remove cols/rows information for flat pictures
     if metadata["type"] == "flat":
@@ -549,19 +612,7 @@ def insertNewPictureInDatabase(
         metadata.pop("rows")
 
     # Create a lighter metadata field to remove duplicates fields
-    lighterMetadata = dict(
-        filter(
-            lambda v: v[0] not in ["ts", "heading", "lon", "lat", "exif", "originalContentMd5", "ts_by_source", "gps_accuracy"],
-            metadata.items(),
-        )
-    )
-    if lighterMetadata.get("tagreader_warnings") is not None and len(lighterMetadata["tagreader_warnings"]) == 0:
-        del lighterMetadata["tagreader_warnings"]
-    lighterMetadata["tz"] = metadata["ts"].tzname()
-    if metadata.get("ts_by_source", {}).get("gps") is not None:
-        lighterMetadata["ts_gps"] = metadata["ts_by_source"]["gps"].isoformat()
-    if metadata.get("ts_by_source", {}).get("camera") is not None:
-        lighterMetadata["ts_camera"] = metadata["ts_by_source"]["camera"].isoformat()
+    lighterMetadata = get_lighter_metadata(metadata)
 
     exif = cleanupExif(metadata["exif"])
 
@@ -597,6 +648,90 @@ def insertNewPictureInDatabase(
     return picId
 
 
+def _get_metadata_to_update(db_picture: Dict, new_reader_metadata: reader.GeoPicTags) -> Tuple[List[str], Dict[str, Any]]:
+    fields_to_update = []
+    params = {}
+
+    if new_reader_metadata.ts != db_picture["ts"]:
+        fields_to_update.append(sql.SQL("ts = %(ts)s"))
+        params["ts"] = new_reader_metadata.ts.isoformat()
+    if db_picture["heading_computed"] is False and new_reader_metadata.heading != db_picture["heading"]:
+        fields_to_update.append(sql.SQL("heading = %(heading)s"))
+        params["heading"] = new_reader_metadata.heading
+    if new_reader_metadata.gps_accuracy != db_picture["gps_accuracy_m"]:
+        fields_to_update.append(sql.SQL("gps_accuracy_m = %(gps_accuracy_m)s"))
+        params["gps_accuracy_m"] = new_reader_metadata.gps_accuracy
+
+    # Note: The db metadata can have more stuff (like originalFileName, size, ...), we so only check if the new value is different from the old one
+    # we cannot check directly for dict equality
+    new_lighterMetadata = get_lighter_metadata(asdict(new_reader_metadata))
+    metadata_updates = {}
+    for k, v in new_lighterMetadata.items():
+        if v != db_picture["metadata"].get(k):
+            metadata_updates[k] = v
+
+    # if the position has been updated (by more than ~10cm)
+    lon, lat = db_picture["lon"], db_picture["lat"]
+    new_lon, new_lat = new_reader_metadata.lon, new_reader_metadata.lat
+    if not math.isclose(lon, new_lon, abs_tol=0.0000001) or not math.isclose(lat, new_lat, abs_tol=0.0000001):
+        fields_to_update.append(sql.SQL("geom = ST_SetSRID(ST_MakePoint(%(lon)s, %(lat)s), 4326)"))
+        params["lon"] = new_reader_metadata.lon
+        params["lat"] = new_reader_metadata.lat
+
+    if metadata_updates:
+        fields_to_update.append(sql.SQL("metadata = metadata || %(new_metadata)s"))
+        params["new_metadata"] = Jsonb(metadata_updates)
+
+    return fields_to_update, params
+
+
+def ask_for_metadata_update(picture_id: UUID, read_file=False):
+    """Enqueue an async job to reread the picture's metadata"""
+    args = Jsonb({"read_file": True}) if read_file else None
+    with db.conn(current_app) as conn:
+        conn.execute(
+            "INSERT INTO job_queue(picture_id, task, args) VALUES (%s, 'read_metadata', %s)",
+            [picture_id, args],
+        )
+
+
+def update_picture_metadata(conn: Connection, picture_id: UUID, read_file=False) -> bool:
+    """Update picture metadata in database, using either the stored metadata or the original file
+
+    Only updates metadata that have changed.
+    Returns True if some metadata have been updated, False otherwise
+    """
+
+    with conn.cursor(row_factory=dict_row) as cursor:
+        db_picture = cursor.execute(
+            "SELECT ts, heading, metadata, ST_X(geom) as lon, ST_Y(geom) as lat, account_id, exif, gps_accuracy_m, heading_computed FROM pictures WHERE id = %s",
+            [picture_id],
+        ).fetchone()
+        if db_picture is None:
+            raise Exception(f"Picture {picture_id} not found")
+
+    if read_file:
+        pic_path = getHDPicturePath(picture_id)
+
+        with current_app.config["FILESYSTEMS"].permanent.openbin(pic_path) as picture_bytes:
+            new_metadata = reader.readPictureMetadata(picture_bytes.read())
+    else:
+        new_metadata = reader.getPictureMetadata(db_picture["exif"], db_picture["metadata"]["width"], db_picture["metadata"]["height"])
+
+    # we want to only updates values that have changed
+    fields_to_update, params = _get_metadata_to_update(db_picture, new_metadata)
+
+    if not fields_to_update:
+        logging.debug(f"No metadata update needed for picture {picture_id}")
+        return False
+
+    conn.execute(
+        sql.SQL("UPDATE pictures SET {f} WHERE id = %(pic_id)s").format(f=sql.SQL(", ").join(fields_to_update)),
+        params | {"pic_id": picture_id},
+    )
+    return True
+
+
 # Note: we don't want to store and expose exif binary fields as they are difficult to use and take a lot of storage in the database (~20% for maker notes only)
 # This list has been queried from real data (cf [this comment](https://gitlab.com/panoramax/server/api/-/merge_requests/241#note_1790580636)).
 # Update this list (and do a sql migration) if new binary fields are added

geovisio/utils/reports.py

@@ -4,7 +4,7 @@ from typing import Optional, List
 from typing_extensions import Self
 from datetime import datetime
 from pydantic import BaseModel, ConfigDict
-from geovisio.utils import db
+from geovisio.utils import cql2, db
 from geovisio.errors import InvalidAPIUsage
 from flask import current_app
 from psycopg.sql import SQL
@@ -103,6 +103,13 @@ def is_picture_owner(report: Report, account_id: UUID):
     return isOwner
 
 
+REPORT_FILTER_TO_DB_FIELDS = {
+    "status": "r.status",
+    "reporter": "reporter_account_id",
+    "owner": "COALESCE(p.account_id, s.account_id)",
+}
+
+
 def _parse_filter(filter: Optional[str]) -> SQL:
     """
     Parse a filter string and return a SQL expression
@@ -124,22 +131,8 @@ def _parse_filter(filter: Optional[str]) -> SQL:
     """
     if not filter:
         return SQL("TRUE")
-    from pygeofilter.backends.sql import to_sql_where
-    from pygeofilter.parsers.ecql import parse as ecql_parser
-
-    try:
-        filterAst = ecql_parser(filter)
-        fieldsToFilter = {
-            "status": "r.status",
-            "reporter": "reporter_account_id",
-            "owner": "COALESCE(p.account_id, s.account_id)",
-        }
-
-        f = to_sql_where(filterAst, fieldsToFilter).replace('"', "").replace("'me'", "%(account_id)s")  # type: ignore
-        return SQL(f)  # type: ignore
-    except Exception as e:
-        print(e)
-        raise InvalidAPIUsage(_("Unsupported filter parameter"), status_code=400)
+
+    return cql2.parse_cql2_filter(filter, REPORT_FILTER_TO_DB_FIELDS)
 
 
 def list_reports(account_id: UUID, limit: int = 100, filter: Optional[str] = None, forceAccount: bool = True) -> Reports:

geovisio/utils/semantics.py

@@ -1,42 +1,20 @@
+from ast import Dict
+from collections import defaultdict
 from dataclasses import dataclass
+import re
 from uuid import UUID
-from psycopg import Cursor
-from psycopg.sql import SQL, Identifier
+from psycopg import Connection, Cursor
+from psycopg.sql import SQL, Identifier, Placeholder
 from psycopg.types.json import Jsonb
 from psycopg.errors import UniqueViolation
-from pydantic import BaseModel, ConfigDict, Field
-from typing import List
+from psycopg.rows import dict_row
+from typing import Generator, List, Optional
 from enum import Enum
 
 from geovisio import errors
-
-
-class TagAction(str, Enum):
-    """Actions to perform on a tag list"""
-
-    add = "add"
-    delete = "delete"
-
-
-class SemanticTagUpdate(BaseModel):
-    """Parameters used to update a tag list"""
-
-    action: TagAction = Field(default=TagAction.add)
-    """Action to perform on the tag list. The default action is `add` which will add the given tag to the list.
-    The action can also be to `delete` the key/value"""
-    key: str = Field(max_length=256)
-    """Key of the tag to update limited to 256 characters"""
-    value: str = Field(max_length=2048)
-    """Value of the tag to update limited ot 2048 characters"""
-
-    model_config = ConfigDict(use_attribute_docstrings=True)
-
-
-class SemanticTag(BaseModel):
-    key: str
-    """Key of the tag"""
-    value: str
-    """Value of the tag"""
+from geovisio.utils.annotations import Annotation, get_picture_annotations
+from geovisio.utils.pic_shape import Geometry
+from geovisio.utils.tags import SemanticTag, SemanticTagUpdate, TagAction
 
 
 class EntityType(Enum):
@@ -44,9 +22,7 @@ class EntityType(Enum):
     pic = "picture_id"
     seq = "sequence_id"
     annotation = "annotation_id"
-
-    def entitiy_id_field(self) -> Identifier:
-        return Identifier(self.value)
+    upload_set = "upload_set_id"
 
 
 @dataclass
@@ -62,59 +38,222 @@ class Entity:
                 return Identifier("sequences_semantics")
             case EntityType.annotation:
                 return Identifier("annotations_semantics")
+            case EntityType.upload_set:
+                return Identifier("upload_sets_semantics")
             case _:
                 raise ValueError(f"Unknown entity type: {self.type}")
 
-    def get_history_table(self) -> Identifier:
+    def get_history_table(self) -> Optional[Identifier]:
         match self.type:
             case EntityType.pic:
                 return Identifier("pictures_semantics_history")
             case EntityType.seq:
                 return Identifier("sequences_semantics_history")
             case EntityType.annotation:
-                return Identifier("annotations_semantics_history")
+                return Identifier("pictures_semantics_history")
+            case EntityType.upload_set:
+                return None
             case _:
                 raise ValueError(f"Unknown entity type: {self.type}")
 
 
-def update_tags(cursor: Cursor, entity: Entity, actions: List[SemanticTagUpdate], account: UUID) -> SemanticTag:
+def update_tags(cursor: Cursor, entity: Entity, actions: List[SemanticTagUpdate], account: UUID, annotation=None):
     """Update tags for an entity
     Note: this should be done inside an autocommit transaction
     """
     table_name = entity.get_table()
-    fields = [entity.type.entitiy_id_field(), Identifier("key"), Identifier("value")]
     tag_to_add = [t for t in actions if t.action == TagAction.add]
     tag_to_delete = [t for t in actions if t.action == TagAction.delete]
     try:
         if tag_to_delete:
-            cursor.execute(SQL("CREATE TEMPORARY TABLE tags_to_delete(key TEXT, value TEXT) ON COMMIT DROP"))
-            with cursor.copy(SQL("COPY tags_to_delete (key, value) FROM STDIN")) as copy:
-                for tag in tag_to_delete:
-                    copy.write_row((tag.key, tag.value))
+            filter_query = []
+            params = [entity.id]
+            for tag in tag_to_delete:
+                filter_query.append(SQL("(key = %s AND value = %s)"))
+                params.append(tag.key)
+                params.append(tag.value)
+
             cursor.execute(
                 SQL(
                     """DELETE FROM {table}
-    WHERE {entity_id} = %(entity)s 
-    AND (key, value) IN (
-        SELECT key, value FROM tags_to_delete
-    )"""
-                ).format(table=table_name, entity_id=entity.type.entitiy_id_field()),
-                {"entity": entity.id, "key_values": [(t.key, t.value) for t in tag_to_delete]},
+WHERE {entity_id} = %s 
+AND ({filter})"""
+                ).format(table=table_name, entity_id=Identifier(entity.type.value), filter=SQL(" OR ").join(filter_query)),
+                params,
             )
         if tag_to_add:
-            with cursor.copy(SQL("COPY {table} ({fields}) FROM STDIN").format(table=table_name, fields=SQL(",").join(fields))) as copy:
+            fields = [Identifier(entity.type.value), Identifier("key"), Identifier("value")]
+            if entity.type == EntityType.upload_set:
+                # upload_set semantics have no history, the account is directly stored in the table
+                fields.append(Identifier("account_id"))
+
+            with cursor.copy(
+                SQL("COPY {table} ({fields}) FROM STDIN").format(
+                    table=table_name,
+                    fields=SQL(",").join(fields),
+                )
+            ) as copy:
                 for tag in tag_to_add:
-                    copy.write_row((entity.id, tag.key, tag.value))
-        if tag_to_add or tag_to_delete:
-            # we track the history changes of the semantic tags
+                    row = [entity.id, tag.key, tag.value]
+                    if entity.type == EntityType.upload_set:
+                        row.append(account)
+                    copy.write_row(row)
+        if tag_to_delete and entity.type == EntityType.annotation and not tag_to_add:
+            # if tags have been deleted, we check if some annotations are now empty and need to be deleted
             cursor.execute(
-                SQL("INSERT INTO {history_table} ({entity_id_field}, account_id, updates) VALUES (%(id)s, %(account)s, %(tags)s)").format(
-                    history_table=entity.get_history_table(), entity_id_field=entity.type.entitiy_id_field()
-                ),
-                {"id": entity.id, "account": account, "tags": Jsonb([t.model_dump() for t in tag_to_add + tag_to_delete])},
+                """DELETE FROM annotations
+WHERE id  = %(annotation_id)s AND 
+(
+    SELECT count(*) AS nb_semantics 
+    FROM annotations_semantics 
+    WHERE annotation_id = %(annotation_id)s
+) = 0""",
+                {"annotation_id": entity.id},
             )
+        if tag_to_add or tag_to_delete:
+            # we track the history changes of the semantic tags
+            track_semantic_history(cursor, entity, actions, account, annotation)
     except UniqueViolation as e:
         # if the tag already exists, we don't want to add it again
         raise errors.InvalidAPIUsage(
             "Impossible to add semantic tags because of duplicates", payload={"details": {"duplicate": e.diag.message_detail}}
         )
+
+
+class SemanticTagUpdateOnAnnotation(SemanticTagUpdate):
+    annotation_shape: Geometry
+
+
+def track_semantic_history(cursor: Cursor, entity: Entity, actions: List[SemanticTagUpdate], account: UUID, annotation):
+    history_table = entity.get_history_table()
+    if history_table is None:
+        # no history for upload_set semantics
+        return
+    params = {
+        "account_id": account,
+    }
+    if annotation is not None:
+        # the annotations are historized in the pictures_semantics_history table
+        # and additional information about the annotation.
+        # This makes it easier to track annotations deletions
+        params["picture_id"] = annotation.picture_id
+
+        params["updates"] = Jsonb(
+            [
+                SemanticTagUpdateOnAnnotation(action=t.action, key=t.key, value=t.value, annotation_shape=annotation.shape).model_dump()
+                for t in actions
+            ]
+        )
+    else:
+        params[entity.type.value] = entity.id
+        params["updates"] = Jsonb([t.model_dump() for t in actions])
+
+    sql = SQL("INSERT INTO {history_table} ({fields}) VALUES ({values})").format(
+        history_table=entity.get_history_table(),
+        fields=SQL(", ").join([Identifier(k) for k in params.keys()]),
+        values=SQL(", ").join([Placeholder(k) for k in params.keys()]),
+    )
+    cursor.execute(sql, params)
+
+
+def delete_annotation_tags_from_service(conn: Connection, picture_id: UUID, service_name: str, account: UUID) -> List[Dict]:
+    """Delete all tags from a blurring service on a given picture"""
+    annotations_tags = list(get_annotation_tags_from_service(conn, picture_id, service_name))
+
+    with conn.transaction(), conn.cursor(row_factory=dict_row) as cursor:
+        for a in annotations_tags:
+            actions = [SemanticTagUpdate(action=TagAction.delete, key=t.key, value=t.value) for t in a.semantics]
+            entity = Entity(id=a.id, type=EntityType.annotation)
+            update_tags(cursor, entity, actions, account, annotation=a)
+
+    return annotations_tags
+
+
+QUALIFIER_REGEXP = re.compile(r"^(?P<qualifier>[^\[]*)\[(?P<key>[^=]+)(=(?P<value>.*))?\]$")
+
+
+@dataclass
+class QualifierSemantic:
+    qualifier: str
+    associated_key: str
+    associated_value: Optional[str]
+    raw_tag: SemanticTag
+
+    def qualifies(self, semantic_tag: SemanticTag) -> bool:
+        """Check if a semantic tag is qualified by the qualifier"""
+        if semantic_tag.key != self.associated_key:
+            return False
+        if self.associated_value is None or self.associated_value == "*":
+            return True
+        return semantic_tag.value == self.associated_value
+
+
+def as_qualifier(s: SemanticTag) -> Optional[QualifierSemantic]:
+    """Try to convert a semantic tag into a qualifier"""
+    m = QUALIFIER_REGEXP.search(s.key)
+    if m:
+        return QualifierSemantic(
+            qualifier=m.group("qualifier"),
+            associated_key=m.group("key"),
+            associated_value=m.group("value"),
+            raw_tag=s,
+        )
+
+
+def get_qualifiers(semantics: List[SemanticTag]) -> List[QualifierSemantic]:
+    """Find all qualifiers in a list of semantic tags"""
+    res = []
+    for s in semantics:
+        q = as_qualifier(s)
+        if q is not None:
+            res.append(q)
+    return res
+
+
+def find_detection_model_tags(qualifiers: List[QualifierSemantic], service_name: str) -> List[QualifierSemantic]:
+    """Find all detection models associated to a picture, from a given service"""
+    res = []
+    for q in qualifiers:
+        if not q.raw_tag.value.startswith(f"{service_name}-"):
+            continue
+        if q.qualifier != "detection_model":
+            continue
+        res.append(q)
+    return res
+
+
+def find_semantics_from_service(annotation, service_name: str) -> Generator[SemanticTag, None, None]:
+    """Find all semantics tags related from a given bluring service
+
+    The blurring service will add a `detection_model` qualifier with a value starting by its name (like `SGBlur-yolo11n/0.1.0` for `SGBlur`)
+
+    This method will return all linked semantics tags, and all their qualifiers.
+    """
+    qualifiers = get_qualifiers(annotation.semantics)
+    detection_model_tags = find_detection_model_tags(qualifiers, service_name)
+    qualified_tags = []
+    for s in annotation.semantics:
+        for qualifier_tag in detection_model_tags:
+            if qualifier_tag.qualifies(s):
+                qualified_tags.append(s)
+                break
+
+    # we then have to get all qualifiers on those tags
+    related_qualifiers = []
+    for q in qualifiers:
+        for t in qualified_tags:
+            if q.qualifies(t):
+                related_qualifiers.append(q.raw_tag)
+                break
+
+    return qualified_tags + related_qualifiers
+
+
+def get_annotation_tags_from_service(conn: Connection, picture_id: UUID, service_name: str) -> Generator[Annotation, None, None]:
+    """Get all annotations semantics from a blurring service"""
+
+    annotations = get_picture_annotations(conn, picture_id)
+
+    for a in annotations:
+        semantics = [s for s in find_semantics_from_service(a, service_name)]
+        yield Annotation(id=a.id, picture_id=a.picture_id, shape=a.shape, semantics=semantics)

geovisio/utils/sentry.py

@@ -60,7 +60,6 @@ def _wrap_cursor_execute(f):
             return f(self, query, params, prepare=prepare, binary=binary)
 
         with record_sql_queries(
-            hub=hub,
             cursor=self,
             query=query,
             params_list=params,
@@ -74,7 +73,7 @@ def _wrap_cursor_execute(f):
 
 
 class FileSystemIntegration(Integration):
-    """Add metrics to the 2 most usefull filesystem, the 'os file' filesystem and the s3 filesystem"""
+    """Add metrics to the 2 most useful filesystem, the 'os file' filesystem and the s3 filesystem"""
 
     identifier = "filesystem"