Source code for luna_faces.db.context

import contextlib
from asyncio import CancelledError
from dataclasses import dataclass
from datetime import datetime, timedelta
from itertools import chain
from typing import Any, Callable, Iterable, Literal, Optional, TypeVar, Union
from uuid import uuid4

from apscheduler.schedulers.asyncio import AsyncIOScheduler
from asyncpg import ForeignKeyViolationError, Record, UndefinedFunctionError, UniqueViolationError
from sqlalchemy import Column, and_, asc, delete, desc, exists, func, insert, select, text, union_all, update
from sqlalchemy.dialects import oracle, postgresql
from sqlalchemy.exc import DatabaseError, IntegrityError
from sqlalchemy.orm import Query, aliased
from sqlalchemy.orm.util import AliasedClass
from sqlalchemy.sql.elements import BooleanClauseList, ColumnClause, TextClause, not_
from sqlalchemy.sql.operators import mod
from sqlalchemy.sql.selectable import CompoundSelect
from tzlocal import get_localzone_name
from vlutils.helpers import bytesToBase64, convertTimeToString
from vlutils.jobs.async_runner import AsyncRunner

from app.handlers.helpers import SearchFacesFilters, SearchListsFilters
from attributes_db.model import BasicAttributes, Descriptor, TemporaryAttributes
from configs.config import BACKGROUND_REMOVAL_BATCH_SIZE, DB_CONNECT_TIMEOUT, DELETE_REQUEST_MAX_SIZE
from configs.configs.configs.settings.classes import DBSetting
from crutches_on_wheels.cow.adaptors.connection import AbstractDBConnection
from crutches_on_wheels.cow.db.base_context import BaseDBContext
from crutches_on_wheels.cow.enums.attributes import TemporaryAttributeTargets as FaceAttributeTargets
from crutches_on_wheels.cow.errors.errors import Error
from crutches_on_wheels.cow.errors.exception import VLException
from crutches_on_wheels.cow.utils.db_functions import currentDBTimestamp, dbExceptionWrap as exceptionWrap
from crutches_on_wheels.cow.utils.functions import getPageCount
from crutches_on_wheels.cow.utils.log import Logger
from db.faces_db_tools.models import faces_models as models
from db.faces_db_tools.models.enums import AttributeSample, SampleType
from db.faces_db_tools.models.faces_models import DB_LIST_LIMIT, LINK_SEQUENCE
from db.functions import ArrayAgg
from utils.encrypton import decryptCacheValue, encryptMessage

SAMPLE_POSTFIX = "_samples"
OBTAINING_METHOD_POSTFIX = "_obtaining_method"
VERSION_POSTFIX = "_version"
DESCRIPTOR = "descriptor"
MIN_GEN = 0  # minimum attribute generation
FACE_TO_LIST_TARGETS = frozenset(("face_id", "lists", "account_id"))
indexFaceName = None
indexDescriptorName = None


_FACE_BY_LIST_GETTER_COLUMNS_MAP = {
    "lists": select([ArrayAgg((lists := aliased(models.ListFace)).list_id)])
    .where(lists.face_id == models.ListFace.face_id)
    .label("lists"),
    "face_id": models.ListFace.face_id,
    "account_id": models.List.account_id,
    "event_id": models.Face.event_id,
    "user_data": models.Face.user_data,
    "external_id": models.Face.external_id,
    "avatar": models.Face.avatar,
    "create_time": models.Face.create_time,
}


_FACE_BY_FACE_GETTER_COLUMNS_MAP = {
    "lists": select([ArrayAgg((lists := aliased(models.ListFace)).list_id)])
    .where(and_(lists.face_id == models.Face.face_id))
    .label("lists"),
    "face_id": models.Face.face_id,
    "account_id": models.Face.account_id,
    "event_id": models.Face.event_id,
    "user_data": models.Face.user_data,
    "external_id": models.Face.external_id,
    "avatar": models.Face.avatar,
    "create_time": models.Face.create_time,
}

FACES_COUNT_CACHE_NAME = "faces_attributes_count"
REQUESTS_ENCRYPTION_KEY = "^&*Tyghuk2v47fg90vpyuhjn2ewsdgv8]-90i"
REQUEST_CACHE_TTL_SECONDS = 10


[docs]@dataclass class Reference: """Reference class.""" descriptorVersion: int descriptor: bytes = None attributeId: str = None faceId: str = None
# Dict with raw sqls for getting link/unlink keys RAW_SQLS = { "postgres": { "link": """(SELECT listId, linkKey FROM (SELECT list_id AS listId, link_key AS linkKey FROM list_face WHERE list_id = '{listId}' AND mod(link_key, 2) = {mod} ORDER BY link_key DESC) as f LIMIT 1)""", "unlink": """(SELECT listId, unLinkKey FROM (SELECT list_id AS listId, unlink_key AS unLinkKey FROM unlink_attributes_log WHERE list_id = '{listId}' AND mod(unlink_key, 2) = {mod} ORDER BY unlink_key DESC) as f LIMIT 1)""", }, "oracle": { "link": """(SELECT listId, linkKey FROM (SELECT list_id AS listId, link_key AS linkKey FROM list_face WHERE list_id = '{listId}' AND mod(link_key, 2) = {mod} ORDER BY link_key DESC) WHERE ROWNUM <= 1)""", "unlink": """(SELECT listId, unLinkKey FROM (SELECT list_id AS listId, unlink_key AS unLinkKey FROM unlink_attributes_log WHERE list_id = '{listId}' AND mod(unlink_key, 2) = {mod} ORDER BY unlink_key DESC) WHERE ROWNUM <= 1)""", }, }
[docs]def getCompiledQuery(query: Union[Query, CompoundSelect], dbType: str) -> str: """ Compile query to with literal_binds = True Args: query: query made by sqlalchemy or CompoundSelect as result of union_all from n queries operation dbType: database type Returns: string with compiled query """ currentDialect = oracle if dbType == "oracle" else postgresql kwargs = {"dialect": currentDialect.dialect(), "compile_kwargs": {"literal_binds": True}} if isinstance(query, Query): return str(query.statement.compile(**kwargs)) else: return str(query.compile(**kwargs))
X = TypeVar("X") Y = TypeVar("Y")
[docs]class DBContext(BaseDBContext): """ DB context Attributes: logger: request logger """ defaultDescriptorVersion: Optional[int] = None # (AsyncRunner): background task executor backgroundWorker: Optional[AsyncRunner] = None # (AsyncIOScheduler): background scheduler backgroundScheduler: Optional[AsyncIOScheduler] = None # (set): list ids set for deferred updating a last_update_time of list _listsForUpdate: set = set() # (Logger): background task logger backgroundLogger: Optional[Logger] = None # cached value converters from db format to face api format _faceProcessFunctions: dict[str, Callable[[Y], X]] = {} # cached value converters from db format to list api format _listProcessFunctions: dict[str, Callable[[Y], X]] = {}
[docs] @classmethod def makeOutputFaces(cls, faceRows: list[Record | dict], columns: Iterable[str]) -> list[dict[str, Any]]: """ Make result faces (from the database reply) proper for an user. Args: faceRows: face list from db columns: selected columns Returns: faces with changed fields """ if not faceRows: return [] processableTargets = set(cls._faceProcessFunctions) & set(columns) if processableTargets: faces = [] for row in faceRows: face = dict(row) for target in processableTargets: face[target] = cls._faceProcessFunctions[target](face[target]) faces.append(face) else: faces = [dict(row) for row in faceRows] return faces
[docs] @classmethod def makeOutputLists(cls, lists: list[Record | dict]) -> list[dict[str, Any]]: """ Make result of lists (from the database reply) proper for an user. Args: lists: list with lists Returns: lists with changed fields """ result = [] for row in lists: facesList = {} for field, value in row.items(): if pf := cls._listProcessFunctions.get(field): value = pf(value) facesList[field] = value result.append(facesList) return result
@classmethod async def _deferredUpdateListLastUpdateTime(cls): """ Deferred update list last update time. Lists for updating are cached in the '_listsForUpdate' """ if not cls._listsForUpdate: return cls.backgroundLogger.debug(f"start to update {len(cls._listsForUpdate)} lists last update time") context = cls(cls.backgroundLogger) for listId in list(cls._listsForUpdate): try: # batch update provokes deadlocks (for several luna-faces instances) await context.updateListLastUpdateTime(listId) cls._listsForUpdate.remove(listId) except Exception: cls.backgroundLogger.exception() else: cls.backgroundLogger.debug(f"updated last update time for {listId}") @classmethod def _addListsToDeferrerUpdateListLastUpdateTime(cls, listIds: Iterable[str]): """ Add lists to deferrer update list last update time Args: listIds: list ids """ cls._listsForUpdate.update(listIds)
[docs] @classmethod async def initDBContext(cls, dbSettings: DBSetting, storageTime: str, defaultDescriptorVersion: int) -> None: """ Initialize context Args: dbSettings: database settings storageTime: storage time defaultDescriptorVersion: default descriptor version """ await super().initDBContext(dbSettings=dbSettings, storageTime=storageTime, connectTimeout=DB_CONNECT_TIMEOUT) cls.backgroundLogger = Logger(template="backgroundDatabase") cls.defaultDescriptorVersion = defaultDescriptorVersion cls.backgroundScheduler = AsyncIOScheduler(timezone=get_localzone_name()) cls.backgroundWorker = AsyncRunner(max(cls.adaptor.sessionCount // 2, 1), closeTimeout=5) cls.backgroundScheduler.add_job(cls._deferredUpdateListLastUpdateTime, trigger="interval", seconds=1) cls.backgroundScheduler.start() if dbSettings.type == "oracle": await cls.setOracleIndexNames(Logger("initialize faces db")) storageTimeIsUTC = cls.storageTime == "UTC" cls._faceProcessFunctions = { "create_time": lambda t: convertTimeToString(t, storageTimeIsUTC), "external_id": lambda s: s if s is not None else "", "user_data": lambda s: s if s is not None else "", "avatar": lambda s: s if s is not None else "", "lists": ArrayAgg.typeHandler, } cls._listProcessFunctions = { "create_time": lambda t: convertTimeToString(t, storageTimeIsUTC), "last_update_time": lambda t: convertTimeToString(t, storageTimeIsUTC), "user_data": lambda s: s if s is not None else "", }
@property def currentDBTimestamp(self) -> TextClause: """ Get current db timestamp function Returns: function for computation current db timestamp """ return currentDBTimestamp(self.dbConfig.type)
[docs] @classmethod async def closeDBContext(cls): """ Close all database contexts """ try: await cls.backgroundWorker.close() except CancelledError: pass await cls._deferredUpdateListLastUpdateTime() if cls.adaptor: await cls.adaptor.close() if cls.backgroundScheduler: cls.backgroundScheduler.shutdown()
[docs] @staticmethod async def setOracleIndexNames(logger): """ Set index names for some requests with 'use-force-index' """ async with DBContext.adaptor.connection(logger) as connection: indexNames = await connection.fetchall( "select index_name from all_indexes where table_name in ('FACE', 'DESCRIPTOR') and " "index_name like 'SYS_%' order by table_name" ) global indexDescriptorName, indexFaceName indexDescriptorName, indexFaceName = [indexName[0] for indexName in indexNames]
[docs] async def ping(self, pingCount: int) -> bool: """ Ping database. Execute 'SELECT 1' from one to 'pingCount' times. Args: pingCount: ping count Returns: True - if any request success execute otherwise False """ async def ping(): async with DBContext.adaptor.connection(self.logger) as connection: st = select([1]) await connection.execute(st) for i in range(pingCount): try: await ping() except Exception: self.logger.exception(f"failed db ping, try {i + 1}") else: return True return False
[docs] @exceptionWrap async def checkDbMatchFunctionExistence( self, saFuncCall: ColumnClause, comparator: Callable[[Any], bool], *, name: str ) -> bool: """ Try call custom function that should exist in database. Assert expected result. Args: saFuncCall: constructed sqlalchemy function object comparator: function for checking `saFuncCall` result name: function name for logging Returns: True - if request success execute otherwise False """ self.logger.debug(f"Check database function '{name}' correctness: begin") try: async with DBContext.adaptor.connection(self.logger) as connection: dbRes = await connection.fetchall(select([saFuncCall])) except (DatabaseError, UndefinedFunctionError): self.logger.debug(f"Database function '{name}' is not implemented.") return False if comparator(dbRes): self.logger.debug(f"Check database function '{name}' correctness: success") return True self.logger.debug(f"Check database function '{name}' correctness: function returns incorrect result '{dbRes}'.") return False
[docs] async def insertFaceAttributeData( self, connection: AbstractDBConnection, faceId: str, attribute: TemporaryAttributes ) -> None: """ Insert face attribute data. Args: connection: db connection faceId: face id attribute: temporary attribute container """ insertToAttributesValue = { "face_id": faceId, "descriptor_samples_generation": 0, "create_time": attribute.createTime.replace(tzinfo=None), } if attribute.basicAttributes: insertToAttributesValue["age"] = attribute.basicAttributes.age insertToAttributesValue["gender"] = attribute.basicAttributes.gender insertToAttributesValue["ethnicity"] = attribute.basicAttributes.ethnicity insertToAttributesValue["gender_obtaining_method"] = 1 insertToAttributesValue["gender_version"] = 1 insertToAttributesValue["age_obtaining_method"] = 1 insertToAttributesValue["age_version"] = 1 insertToAttributesValue["ethnicity_obtaining_method"] = 1 insertToAttributesValue["ethnicity_version"] = 1 insertToSamplesValues = [ {"face_id": faceId, "sample_id": sampleId, "type": SampleType.basic_attributes.value} for sampleId in attribute.basicAttributesSamples ] insertToSamplesValues += [ {"face_id": faceId, "sample_id": sampleId, "type": SampleType.face_descriptor.value} for sampleId in attribute.descriptorSamples ] insertDescriptorValues = [ { "descriptor_version": descriptor.version, "face_id": faceId, "descriptor": descriptor.descriptor, "descriptor_obtaining_method": 1, "descriptor_generation": 0, } for descriptor in attribute.descriptors ] await connection.execute(insert(models.Attribute).values(insertToAttributesValue)) if self.dbConfig.type == "oracle": for value in insertToSamplesValues: await connection.execute(insert(models.Sample).values(value)) for value in insertDescriptorValues: await connection.execute(insert(models.Descriptor).values(value)) else: if insertToSamplesValues: await connection.execute(insert(models.Sample).values(insertToSamplesValues)) if insertDescriptorValues: await connection.execute(insert(models.Descriptor).values(insertDescriptorValues))
[docs] async def createFace( self, externalFaceId: Optional[str] = None, listIds: Optional[set[str]] = None, attribute: Optional[TemporaryAttributes] = None, **kwargs, ) -> str: """ Create face. Args: externalFaceId: external faceId listIds: luna lists attribute: temporary attribute container Keyword Args: event_id: reference to event which created face user_data: face information account_id: id of account, required external_id: external id of the face, if it has its own mapping in external system avatar: image url that represents the face Returns: faceId: face id in uuid4 format """ kwargs["face_id"] = faceId = str(uuid4()) if externalFaceId is None else externalFaceId accountId = kwargs["account_id"] async def processFaceListsAndAttributes(openConnection): if attribute is not None: await self.insertFaceAttributeData(openConnection, faceId=faceId, attribute=attribute) if listIds: selectLists = select([models.List.list_id, text(f"'{faceId}'"), LINK_SEQUENCE.next_value()]).where( and_(models.List.account_id == accountId, models.List.list_id.in_(listIds)) ) insertFaceListSt = insert(models.ListFace).from_select( [models.ListFace.list_id, models.ListFace.face_id, models.ListFace.link_key], selectLists ) listCount = await openConnection.execute(insertFaceListSt) if len(listIds) != listCount: # stupid oracle return only one updated row selectListSt = select([models.List.list_id]).where( and_(models.List.list_id.in_(listIds), models.List.account_id == accountId) ) updatedLists = await openConnection.fetchall(selectListSt) updatedLists = set(chain(*updatedLists)) nonExistListId = next(iter(listIds - updatedLists)) raise VLException(Error.ListsNotFound.format(nonExistListId), 400, False) return faceId async with DBContext.adaptor.connection(self.logger) as connection: deleteSt = delete(models.Face).where(models.Face.face_id == faceId) insertSt = insert(models.Face).values(**kwargs) # fast way creating face try: await connection.execute(insertSt) except (IntegrityError, UniqueViolationError): # face with same id already exists, need remove it, go to slow way pass else: await processFaceListsAndAttributes(connection) if listIds: self._addListsToDeferrerUpdateListLastUpdateTime(listIds) return faceId # slow way async with DBContext.adaptor.connection(self.logger) as connection: await connection.execute(deleteSt) await connection.execute(insertSt) await processFaceListsAndAttributes(connection) if listIds: self._addListsToDeferrerUpdateListLastUpdateTime(listIds) return faceId
[docs] @exceptionWrap async def updateFace(self, faceId: str, accountId: Optional[str] = None, **kwargs) -> int: """ Update face. Args: faceId: face id accountId: account id Keyword Args: user_data: face information event_id: reference to event which created face external_id: external id of the face, if it has its own mapping in external system avatar: image url that represents the face Returns: updated face count """ async with DBContext.adaptor.connection(self.logger) as connection: updateFaceSt = ( update(models.Face) .where(and_(models.Face.face_id == faceId, models.Face.account_id @ accountId)) .values(**kwargs) ) return await connection.execute(updateFaceSt)
[docs] @exceptionWrap async def linkFacesToList(self, listId: str, faces: list[str]) -> tuple[list[str], list[str]]: """ Attach faces to list. Args: listId: list id faces: face ids Raises: IntegrityError Exception Returns: list of success link faces and failed link faces. """ success = [] error = [] async def linkFace(faceId, conn): try: updateFaceListSt = insert(models.ListFace).values( list_id=listId, face_id=faceId, link_key=LINK_SEQUENCE.next_value() ) await conn.execute(updateFaceListSt) except (IntegrityError, UniqueViolationError, ForeignKeyViolationError): error.append(faceId) return False else: success.append(faceId) return True async with DBContext.adaptor.connection(self.logger) as connection: updateFaceSt = ( update(models.Face) .where(models.Face.face_id.in_(faces)) .values(last_update_time=self.currentDBTimestamp) ) await connection.execute(updateFaceSt) self._addListsToDeferrerUpdateListLastUpdateTime((listId,)) for face in faces: async with DBContext.adaptor.connection(self.logger) as connection: await linkFace(face, connection) return success, error
[docs] @exceptionWrap async def unlinkFacesFromList(self, listId: str, faces: list[str], accountId: Optional[str] = None): """ Unlink faces from list. Args: listId: list id faces: face ids accountId: account id """ async def updateHistoryLog(): querySelect = select([models.ListFace.list_id, models.Face.face_id, models.ListFace.link_key]).where( and_( models.Face.face_id.in_(faces), models.Face.face_id == models.ListFace.face_id, models.ListFace.list_id == listId, ) ) insertSt = insert(models.UnlinkAttributesLog).from_select( [ models.UnlinkAttributesLog.list_id, models.UnlinkAttributesLog.face_id, models.UnlinkAttributesLog.link_key, ], querySelect, ) await connection.execute(insertSt) async def unlinkFaces(): deleteFacesSt = delete(models.ListFace).where( and_( models.ListFace.face_id.in_(faces), models.ListFace.list_id == listId, models.List.account_id @ accountId, ) ) await connection.execute(deleteFacesSt) updateFaceSt = ( update(models.Face) .where(models.Face.face_id.in_(faces)) .values(last_update_time=self.currentDBTimestamp) ) await connection.execute(updateFaceSt) async with DBContext.adaptor.connection(self.logger) as connection: await self.blockFaces(connection, [models.Face.face_id.in_(faces)]) await updateHistoryLog() await unlinkFaces() self._addListsToDeferrerUpdateListLastUpdateTime((listId,))
[docs] @exceptionWrap async def createList(self, account_id: str, listId: str, user_data: Optional[str] = "") -> None: """ Create list for account. Args: account_id: account id user_data: user data listId: list id """ async with DBContext.adaptor.connection(self.logger) as connection: insertSt = insert(models.List).values(list_id=listId, account_id=account_id, user_data=user_data) try: await connection.execute(insertSt) except (IntegrityError, UniqueViolationError): raise VLException(Error.ListAlreadyExist.format(listId), 409, isCriticalError=False)
[docs] @staticmethod def prepareSearchFacesFilters( filters: SearchFacesFilters, modelsFace: Optional[AliasedClass] = None, modelsListFace: Optional[AliasedClass] = None, ) -> list[BooleanClauseList]: """ Prepare search query filters on "Face" models. Args: filters: query filters modelsFace: database table model for faces modelsListFace: database table model for list face Returns: filters for Face model """ modelsFace = modelsFace or models.Face modelsListFace = modelsListFace or models.ListFace return [ modelsFace.account_id == filters.account_id if filters.account_id is not None else True, modelsFace.user_data.like("%{}%".format(filters.user_data)) if filters.user_data is not None else True, modelsFace.event_id == filters.event_id if filters.event_id is not None else True, modelsFace.create_time < filters.create_time__lt if filters.create_time__lt is not None else True, modelsFace.create_time >= filters.create_time__gte if filters.create_time__gte is not None else True, modelsFace.face_id < filters.face_id__lt if filters.face_id__lt is not None else True, modelsFace.face_id >= filters.face_id__gte if filters.face_id__gte is not None else True, modelsFace.external_id.in_(filters.external_ids) if filters.external_ids is not None else True, modelsFace.face_id.in_(filters.face_ids) if filters.face_ids is not None else True, modelsListFace.face_id == modelsFace.face_id if filters.list_id is not None else True, modelsListFace.list_id == filters.list_id if filters.list_id is not None else True, ]
[docs] @staticmethod def setOffsetAndOrderToQuery( query: Query, order: Optional[Literal["desc", "asc"]] = "desc", orderColumn: Optional[Column] = None, page: Optional[int] = 1, pageSize: Optional[int] = 100, ) -> Query: """ Apply `OFFSET` and `ORDER BY` criterion to the query. Args: query: query object order: result sort order (ask or desc) orderColumn: result sort column page: pagination page value pageSize: pagination page size value, set -1 to get all faces Returns: updated query """ if orderColumn is not None: query = query.order_by((asc if order == "asc" else desc)(orderColumn)) if pageSize != -1: query = query.offset((page - 1) * pageSize).limit(pageSize) return query
[docs] @staticmethod def prepareListQueryFilters(filters: SearchListsFilters) -> BooleanClauseList: """ Prepare search query filters on "List" models. Args: filters: query filters Returns: filters for List select query """ sqlFilters = [ models.List.account_id @ filters.account_id, models.List.user_data.like("%{}%".format(filters.user_data)) if filters.user_data is not None else True, models.List.user_data @ filters.user_data__eq, models.List.create_time < filters.create_time__lt if filters.create_time__lt is not None else True, models.List.create_time >= filters.create_time__gte if filters.create_time__gte is not None else True, models.List.last_update_time < filters.last_update_time__lt if filters.last_update_time__lt is not None else True, models.List.last_update_time >= filters.last_update_time__gte if filters.last_update_time__gte is not None else True, models.List.list_id < filters.list_id__lt if filters.list_id__lt is not None else True, models.List.list_id >= filters.list_id__gte if filters.list_id__gte is not None else True, models.List.list_id.in_(filters.list_ids) if filters.list_ids is not None else True, ] return and_(*sqlFilters)
[docs] @exceptionWrap async def executeSearchFaces( self, filters: SearchFacesFilters, targets: Optional[list[str]], page: Optional[int] = 1, pageSize: Optional[int] = 100, ) -> list[dict[str, str]]: """ Get faces searched by filters Args: filters: raw search request filters targets: target Face columns' names to get info on page: page pageSize: page size Returns: faces list """ queryColumns = [_FACE_BY_FACE_GETTER_COLUMNS_MAP[target] for target in targets] orderColumn = ( models.Face.face_id if any((filters.face_id__gte, filters.face_id__lt)) else models.Face.create_time ) slqFilters = self.prepareSearchFacesFilters(filters) query = Query(queryColumns).filter( and_( *slqFilters, ) ) query = self.setOffsetAndOrderToQuery(query=query, orderColumn=orderColumn, page=page, pageSize=pageSize) async with DBContext.adaptor.connection(self.logger) as connection: faceRows = await connection.fetchall(query.statement) return self.makeOutputFaces(faceRows, targets)
[docs] @exceptionWrap async def executeSearchFacesFilteredByList( self, filters: SearchFacesFilters, targets: list[str], page: Optional[int] = 1, pageSize: Optional[int] = 100 ) -> list[dict[str, str]]: """ Get faces searched by filters associated with face-list model Args: filters: raw search request filters targets: target Face columns' names to get info on page: page pageSize: page size Returns: faces list """ queryFilters = and_( models.List.account_id == filters.account_id if filters.account_id is not None else True, models.List.list_id == filters.list_id, models.ListFace.list_id == models.List.list_id, models.ListFace.face_id < filters.face_id__lt if filters.face_id__lt is not None else True, models.ListFace.face_id >= filters.face_id__gte if filters.face_id__gte is not None else True, models.ListFace.face_id.in_(filters.face_ids) if filters.face_ids is not None else True, models.Face.face_id == models.ListFace.face_id if set(targets) - {"face_id", "account_id", "lists"} else True, ) query = select([_FACE_BY_LIST_GETTER_COLUMNS_MAP[target] for target in targets]).where(queryFilters) query = self.setOffsetAndOrderToQuery( query=query, orderColumn=models.ListFace.face_id, page=page, pageSize=pageSize ) async with DBContext.adaptor.connection(self.logger) as connection: faceRows = await connection.fetchall(query) return self.makeOutputFaces(faceRows, targets)
[docs] @exceptionWrap async def getFaces( self, filters: SearchFacesFilters, targets: Optional[list[str]] = None, page: Optional[int] = 1, pageSize: Optional[int] = 100, ) -> list[dict[str, str]]: """ Get faces. Args: filters: raw search request filters targets: target Face columns' names to get info on page: page pageSize: page size Returns: list of faces """ if filters.listFaceFiltersAreUsed() and any((filters.face_id__gte, filters.face_id__lt)): # getting faces from a list-face model only when appropriate filters and targets are available # more profitable with a large count of faces in the list return await self.executeSearchFacesFilteredByList(filters, targets, page=page, pageSize=pageSize) return await self.executeSearchFaces(filters, targets, page=page, pageSize=pageSize)
[docs] @exceptionWrap async def getNonexistentFaceId( self, requiredFaceIds: set[str], accountId: Optional[str] = None, dbConnection: Optional[AbstractDBConnection] = None, ) -> Union[str, None]: """ Get one of requiredFaceIds that not exists. Args: requiredFaceIds: set of required face ids accountId: account id dbConnection: current connection. Needed not to get new connection from pool or to do some stuff in scope of the transaction. Returns: Non existing face id """ async with contextlib.AsyncExitStack() as stack: connection = ( await stack.enter_async_context(DBContext.adaptor.connection(self.logger)) if dbConnection is None else dbConnection ) query = Query([models.Face.face_id]).filter( models.Face.account_id == accountId if accountId is not None else True, models.Face.face_id.in_(requiredFaceIds), ) existFaceIds = set(chain(*await connection.fetchall(query.statement))) nonexistentFaceIds = requiredFaceIds - existFaceIds return next(iter(nonexistentFaceIds)) if nonexistentFaceIds else None
[docs] @exceptionWrap async def getFacesCountByList(self, filters: SearchFacesFilters) -> int: """ Get count of faces filtered by list id. Args: filters: raw search request filters Returns: Number of faces """ async with DBContext.adaptor.connection(self.logger) as connection: if filters.account_id is not None: # checking the list by account before getting the faces count is more profitable listCountSt = select([func.count(models.List.list_id)]).where( and_(models.List.account_id == filters.account_id, models.List.list_id == filters.list_id) ) if not await connection.scalar(listCountSt): return 0 selectSt = select([func.count(models.ListFace.face_id)]).where( and_( models.ListFace.list_id == filters.list_id, models.ListFace.face_id < filters.face_id__lt if filters.face_id__lt is not None else True, models.ListFace.face_id >= filters.face_id__gte if filters.face_id__gte is not None else True, models.ListFace.face_id.in_(filters.face_ids) if filters.face_ids is not None else True, ) ) return await connection.scalar(selectSt)
[docs] @exceptionWrap async def getCachedFaceAttributesCount(self) -> int: """ Get cached count of faces attributes. Returns: Number of faces attributes """ lockCachedCount = select([1]).where(models.RequestsCache.name == FACES_COUNT_CACHE_NAME).with_for_update() delta = timedelta(seconds=REQUEST_CACHE_TTL_SECONDS) selectActualCache = select([models.RequestsCache.value]).where( and_( models.RequestsCache.name == FACES_COUNT_CACHE_NAME, models.RequestsCache.created_at + delta > self.currentDBTimestamp, ) ) async with DBContext.adaptor.connection(self.logger) as connection: facesAttributesCount = None await connection.scalar(lockCachedCount) if requestedCache := await connection.scalar(selectActualCache): facesAttributesCount = decryptCacheValue(requestedCache, REQUESTS_ENCRYPTION_KEY) try: facesAttributesCount = int(facesAttributesCount) except TypeError: self.logger.error("Unable to process decrypted cache value") facesAttributesCount = None if facesAttributesCount is None: selectFaceAttrsCount = select([func.count(models.Attribute.face_id)]) facesAttributesCount = await connection.scalar(selectFaceAttrsCount) updateQuery = ( update(models.RequestsCache) .where(models.RequestsCache.name == FACES_COUNT_CACHE_NAME) .values( value=encryptMessage(facesAttributesCount, REQUESTS_ENCRYPTION_KEY), created_at=self.currentDBTimestamp, ) ) await connection.execute(updateQuery) return facesAttributesCount
[docs] @exceptionWrap async def getFacesCount(self, filters: SearchFacesFilters) -> int: """ Get count of faces. Args: filters: raw search request filters Returns: Number of faces """ if filters.listFaceFiltersAreUsed(): return await self.getFacesCountByList(filters) else: selectSt = select([func.count(models.Face.face_id)]).where( and_( *self.prepareSearchFacesFilters(filters), ) ) async with DBContext.adaptor.connection(self.logger) as connection: return await connection.scalar(selectSt)
[docs] @exceptionWrap async def getFacesAttributesCount(self, accountId: Optional[str] = None) -> int: """ Return face attribute count Args: accountId: account id Returns: face attribute count """ if accountId: filters = and_(models.Face.account_id == accountId, models.Attribute.face_id == models.Face.face_id) else: filters = and_() selectSt = select([func.count(models.Attribute.face_id)]).where(filters) async with DBContext.adaptor.connection(self.logger) as connection: faceAttributeCount = await connection.scalar(selectSt) return faceAttributeCount
[docs] @exceptionWrap async def getLists( self, filters: SearchListsFilters, page: Optional[int] = 1, pageSize: Optional[int] = 100 ) -> list[dict[str, str]]: """ Get list Args: filters: raw search request filters page: page pageSize: page size Returns: List with dicts """ queryFilters = self.prepareListQueryFilters(filters) orderColumn = ( models.List.list_id if filters.list_id__gte is not None or filters.list_id__lt is not None else models.List.create_time ) async with DBContext.adaptor.connection(self.logger) as connection: query = ( Query(models.List) .filter(queryFilters) .order_by(orderColumn.desc()) .offset((page - 1) * pageSize) .limit(pageSize) ) listRows = await connection.fetchall(query.statement) return self.makeOutputLists(listRows)
[docs] @exceptionWrap async def getNonexistentListId( self, requiredListIds: set[str], accountId: Optional[str] = None ) -> Union[str, None]: """ Get one of requiredListIds that not exists. Args: requiredListIds: set of required face ids accountId: account id Returns: Non existsing list id """ async with DBContext.adaptor.connection(self.logger) as connection: query = Query(models.List.list_id).filter( models.List.account_id @ accountId, models.List.list_id.in_(requiredListIds) ) res = await connection.fetchall(query.statement) existListIds = set(chain(*res)) nonexistentListIds = requiredListIds - existListIds return next(iter(nonexistentListIds)) if nonexistentListIds else None
[docs] @exceptionWrap async def getListsCount(self, filters: SearchListsFilters) -> int: """ Count lists Args: filters: raw search request filters Returns: Count of lists """ queryFilters = self.prepareListQueryFilters(filters) async with DBContext.adaptor.connection(self.logger) as connection: query = Query([func.count(models.List.list_id).label("count")]) query = query.filter(queryFilters) listCount = await connection.scalar(query.statement) return listCount
[docs] @exceptionWrap async def getListsAndKeysFromMV(self, listIds: set[str], useParity: int) -> list[dict[str, Any]]: """ Get lists with last link and unlink keys from materialized views Args: listIds: list ids useParity: if 1 - get even and odd max link/unlink keys else max link/unlink keys Returns: List with list ids and its link/unlink keys """ listIdsList = list(listIds) listIdsBatches = [listIdsList[idx : idx + DB_LIST_LIMIT] for idx in range(0, len(listIdsList), DB_LIST_LIMIT)] if useParity: async with DBContext.adaptor.connection(self.logger) as connection: selectQueryList = [ Query( [ models.List.list_id, models.MV_LINK_0.link_key.label("link_key_even"), models.MV_LINK_1.link_key.label("link_key_odd"), models.MV_UNLINK_0.unlink_key.label("unlink_key_even"), models.MV_UNLINK_1.unlink_key.label("unlink_key_odd"), ] ) .join(models.MV_LINK_0, models.MV_LINK_0.list_id == models.List.list_id, full=True) .join(models.MV_LINK_1, models.MV_LINK_1.list_id == models.List.list_id, full=True) .join(models.MV_UNLINK_0, models.MV_UNLINK_1.list_id == models.List.list_id, full=True) .join(models.MV_UNLINK_1, models.MV_UNLINK_1.list_id == models.List.list_id, full=True) .filter(models.List.list_id.in_(listIdsBatch)) for listIdsBatch in listIdsBatches ] selectResult = [] for selectQuery in selectQueryList: selectResult.extend(await connection.fetchall(selectQuery.statement)) result = [ { "list_id": listId, "link_key_even": linkKeyEven, "link_key_odd": linkKeyOdd, "unlink_key_even": unlinkKeyEven, "unlink_key_odd": unlinkKeyOdd, } for listId, linkKeyEven, linkKeyOdd, unlinkKeyEven, unlinkKeyOdd in selectResult ] else: async with DBContext.adaptor.connection(self.logger) as connection: selectQueryList = [ Query([models.List.list_id, models.MV_LINK.link_key, models.MV_UNLINK.unlink_key]) .join(models.MV_LINK, models.MV_LINK.list_id == models.List.list_id, full=True) .join(models.MV_UNLINK, models.MV_UNLINK.list_id == models.List.list_id, full=True) .filter(models.List.list_id.in_(listIdsBatch)) for listIdsBatch in listIdsBatches ] selectResult = [] for selectQuery in selectQueryList: selectResult.extend(await connection.fetchall(selectQuery.statement)) result = [ {"list_id": listId, "link_key": linkKey, "unlink_key": unlinkKey} for listId, linkKey, unlinkKey in selectResult ] return result
[docs] @exceptionWrap async def getListsWithKeys(self, listIds: set[str], useParity: int) -> list[dict[str, Any]]: """ Get lists with last link and unlink keys from usual tables Args: listIds: list ids useParity: if 1 - get even and odd max link/unlink keys, if 0 - max link/unlink keys Returns: list with list ids and its link/unlink keys """ listIdsList = list(listIds) listIdsBatches = [listIdsList[idx : idx + DB_LIST_LIMIT] for idx in range(0, len(listIdsList), DB_LIST_LIMIT)] async def getKeysFromDb( searchLists: list[str], dbConnection, keyType: str, parity: Optional[str] = None ) -> dict: """ Get link/unlink keys from db Args: searchLists: list of searching lists dbConnection: database connection keyType: link or unlink parity: none, odd or even Returns: dict with listIds and keys """ if parity is not None: rawSql = " UNION ALL ".join( ( RAW_SQLS[self.dbConfig.type][keyType].format(listId=listId, mod=1 if parity == "odd" else 0) for listId in searchLists ) ) res = await dbConnection.fetchall(rawSql) return dict(res) else: queries = [] for listId in searchLists: if keyType == "link": selectParams = [models.ListFace.list_id, models.ListFace.link_key] basicFilters = models.ListFace.list_id == listId key = models.ListFace.link_key else: selectParams = [models.UnlinkAttributesLog.list_id, models.UnlinkAttributesLog.unlink_key] basicFilters = models.UnlinkAttributesLog.list_id == listId key = models.UnlinkAttributesLog.unlink_key query = Query(selectParams).filter(basicFilters).order_by(key.desc()).limit(1) queries.append(query) linkKeyAndLists = await dbConnection.fetchall(union_all(*queries)) return dict(linkKeyAndLists) async with DBContext.adaptor.connection(self.logger) as connection: existsListSts = [ Query(models.List.list_id).filter(models.List.list_id.in_(listIdsBatch)).statement for listIdsBatch in listIdsBatches ] res = [] for existListSt in existsListSts: res.extend(await connection.fetchall(existListSt)) existsLists = [listId[0] for listId in res] existsListsBatches = [ existsLists[idx : idx + DB_LIST_LIMIT] for idx in range(0, len(existsLists), DB_LIST_LIMIT) ] if not existsListsBatches: return [] result = dict() for existsListsBatch in existsListsBatches: if useParity: mapListIdMaxEvenLinkKey = await getKeysFromDb(existsListsBatch, connection, "link", "odd") mapListIdMaxEvenUnlinkKey = await getKeysFromDb(existsListsBatch, connection, "unlink", "odd") mapListIdMaxOddLinkKey = await getKeysFromDb(existsListsBatch, connection, "link", "even") mapListIdMaxOddUnlinkKey = await getKeysFromDb(existsListsBatch, connection, "unlink", "even") result.update( dict( zip( existsListsBatch, [ { "link_key_even": mapListIdMaxOddLinkKey.get(listId, None), "unlink_key_even": mapListIdMaxOddUnlinkKey.get(listId, None), "link_key_odd": mapListIdMaxEvenLinkKey.get(listId, None), "unlink_key_odd": mapListIdMaxEvenUnlinkKey.get(listId, None), } for listId in existsListsBatch ], ) ) ) else: mapListIdMaxLinkKey = await getKeysFromDb(existsListsBatch, connection, "link") mapListIdMaxUnlinkKey = await getKeysFromDb(existsListsBatch, connection, "unlink") result.update( dict( zip( existsListsBatch, [ { "link_key": mapListIdMaxLinkKey.get(listId, None), "unlink_key": mapListIdMaxUnlinkKey.get(listId, None), } for listId in existsListsBatch ], ) ) ) return [{"list_id": listId, **listData} for listId, listData in result.items()]
[docs] @exceptionWrap async def deleteFaces( self, faces: list[str] | None = None, accountId: str | None = None, createTimeGte: str | None = None, createTimeLt: str | None = None, userData: str | None = None, listId: str | None = None, ) -> int: """ Remove faces. Args: accountId: faces account id faces: faces ids createTimeGte: creation time greater createTimeLt: create time lower userData: user data listId: list id where face exists Returns: removed face count """ filters = [ models.Face.face_id.in_(faces) if faces is not None else True, models.Face.user_data.like("%{}%".format(userData)) if userData is not None else True, models.Face.create_time >= createTimeGte if createTimeGte is not None else True, models.Face.create_time < createTimeLt if createTimeLt is not None else True, models.Face.account_id == accountId if accountId is not None else True, and_( models.ListFace.face_id == models.Face.face_id, models.ListFace.list_id == listId, ) if listId is not None else True, ] async with DBContext.adaptor.connection(self.logger) as connection: async def updateHistoryLog(facesForRemove): linkedLists = await self._moveFacesLinksToLog(facesForRemove, connection) self.logger.debug(f"update history log") return linkedLists if faces: self.logger.debug(f"start delete {len(faces)} faces") _, blockedFaces = await self.blockFaces(connection, filters=filters, returnBlockedFaces=True) updatedLists = await updateHistoryLog(blockedFaces) deleteFacesSt = delete(models.Face).where(and_(*filters)) removedFaceCount = await connection.execute(deleteFacesSt) self.logger.debug(f"delete {removedFaceCount} faces") self._addListsToDeferrerUpdateListLastUpdateTime(updatedLists) return removedFaceCount
[docs] @exceptionWrap async def deleteFacesExtended( self, targets: list[str], accountId: str | None = None, createTimeGte: str | None = None, createTimeLt: str | None = None, userData: str | None = None, listId: str | None = None, ) -> list[dict] | None: """ Remove faces. Args: targets: deletion info targets accountId: faces account id createTimeGte: creation time greater createTimeLt: create time lower userData: user data listId: list id where face exists Returns: list with dicts for each deleted face. """ filters = and_( models.Face.user_data.like("%{}%".format(userData)) if userData is not None else True, models.Face.create_time >= createTimeGte if createTimeGte is not None else True, models.Face.create_time < createTimeLt if createTimeLt is not None else True, models.Face.account_id == accountId if accountId is not None else True, and_( models.ListFace.face_id == models.Face.face_id, models.ListFace.list_id == listId, ) if listId is not None else True, ) async def collectFacesToDeletion(conn) -> Iterable[dict]: """Get targets from Sample table.""" selectFaceIds = Query([models.Face.face_id]).filter(filters).limit(DELETE_REQUEST_MAX_SIZE) faceData = await conn.fetchall(selectFaceIds.statement) faceDict = { row["face_id"]: { "face_id": row["face_id"], "basic_attributes_samples": [], "face_descriptor_samples": [], } for row in faceData } faceIds = list(faceDict.keys()) sampleTypes = [] if "basic_attributes_samples" in targets: sampleTypes.append(models.SampleType["basic_attributes"].value) if "face_descriptor_samples" in targets: sampleTypes.append(models.SampleType["face_descriptor"].value) if sampleTypes: selectQuery = Query([models.Sample.face_id, models.Sample.sample_id, models.Sample.type]).filter( and_(models.Sample.face_id.in_(faceIds), models.Sample.type.in_(sampleTypes)) ) sampleData = await conn.fetchall(selectQuery.statement) for row in sampleData: if row["face_id"] in faceDict: if row["type"] == models.SampleType["basic_attributes"].value: faceDict[row["face_id"]]["basic_attributes_samples"].append(row["sample_id"]) else: faceDict[row["face_id"]]["face_descriptor_samples"].append(row["sample_id"]) targetsList = [] for value in faceDict.values(): targetItem = {} if "basic_attributes_samples" in targets: targetItem["basic_attributes_samples"] = value["basic_attributes_samples"] if "face_descriptor_samples" in targets: targetItem["face_descriptor_samples"] = value["face_descriptor_samples"] if "face_id" in targets: targetItem["face_id"] = value["face_id"] targetsList.append(targetItem) return faceIds, targetsList async with DBContext.adaptor.connection(self.logger) as connection: if targets: faceIds, targetsData = await collectFacesToDeletion(connection) await self.deleteFaces(faces=faceIds, accountId=accountId) return targetsData await self.deleteFaces( accountId=accountId, createTimeGte=createTimeGte, createTimeLt=createTimeLt, userData=userData, listId=listId, ) return None
@exceptionWrap async def _deleteLists(self, lists: list[str], accountId: Optional[str] = None) -> int: """ Remove lists. Args: accountId: lists account id lists: lists Returns: removed list count Warnings: trigger `trg_lists_deletion_log` will insert a data to the table `ListsDeletionLog` """ async with DBContext.adaptor.connection(self.logger) as connection: deleteListsSt = delete(models.List).where( and_(models.List.list_id.in_(lists), models.List.account_id @ accountId) ) return await connection.execute(deleteListsSt)
[docs] @exceptionWrap async def deleteLists(self, lists: list[str], accountId: Optional[str] = None, withFaces: bool = False) -> int: """ Remove lists. Args: accountId: lists account id lists: lists withFaces: remove lists with all faces which is contained in these lists Returns: removed list count """ if not withFaces: return await self._deleteLists(lists, accountId) listsFilters = [models.List.list_id.in_(lists), models.List.account_id @ accountId] async with DBContext.adaptor.connection(self.logger) as connection: query = Query([models.List.list_id]).filter(and_(*listsFilters)).with_for_update() blockListsRes = await connection.fetchall(query.statement) if not blockListsRes: return 0 listsToRealDeletion = [blockedList[0] for blockedList in blockListsRes] query = select([models.ListFace.face_id]).where( and_( models.List.list_id.in_(listsToRealDeletion), models.List.list_id == models.ListFace.list_id, models.List.account_id @ accountId, ) ) faceIdsToDeletion = [row[0] for row in await connection.fetchall(query)] deleteListsSt = delete(models.List).where(and_(*listsFilters)) removedListCount = await connection.execute(deleteListsSt) pageSize = BACKGROUND_REMOVAL_BATCH_SIZE pageCount = getPageCount(len(faceIdsToDeletion), pageSize) coros = [ self.deleteFaces(faces=faceIdsToDeletion[page * pageSize : (page + 1) * pageSize]) for page in range(pageCount) ] DBContext.backgroundWorker.runNoWait(coros) return removedListCount
[docs] @exceptionWrap async def updateListUserData(self, listId: str, userData: str, accountId: Optional[str] = None) -> int: """ Update user data of list Args: listId: list id userData: user data accountId : account id Returns: updated list count """ async with DBContext.adaptor.connection(self.logger) as connection: updateListSt = ( update(models.List) .where(and_(models.List.list_id == listId, models.List.account_id @ accountId)) .values(user_data=userData) ) return await connection.execute(updateListSt)
[docs] @exceptionWrap async def isFacesExist(self, faceIds: list[str], accountId: Optional[str] = None) -> bool: """ Checking to exist faces or not. Args: accountId: account id faceIds: face ids Returns: True if all faces exist else false """ async with DBContext.adaptor.connection(self.logger) as connection: query = Query([func.count(models.Face.face_id).label("count")]) query = query.filter(models.Face.face_id.in_(faceIds), models.Face.account_id @ accountId) res = await connection.fetchone(query.statement) faceCount = res[0] return True if faceCount == len(faceIds) else False
[docs] @exceptionWrap async def isListsExist(self, listIds: set[str], accountId: Optional[str] = None) -> bool: """ Checking to exist lists or not. Args: accountId: account id listIds: list ids Returns: True if all lists exist else false """ async with DBContext.adaptor.connection(self.logger) as connection: query = Query([func.count(models.List.list_id).label("count")]) query = query.filter(models.List.list_id.in_(listIds), models.List.account_id @ accountId) res = await connection.fetchone(query.statement) listCount = res[0] return True if listCount == len(listIds) else False
[docs] @exceptionWrap async def getListPlusDelta( self, listId, linkKeyGte: Optional[int] = None, linkKeyLt: Optional[int] = None, limit: int = 10000, parity: Optional[int] = None, ) -> list[dict]: """ Get attach attributes to lists Args: listId: list id linkKeyLt: upper bound of link key value linkKeyGte: lower bound of link key value limit: limit parity: 0 for odd or 1 for even link keys to search for Returns: List of dicts with following keys: "face_id", "link_key" """ async with DBContext.adaptor.connection(self.logger) as connection: filters = and_( models.ListFace.link_key < linkKeyLt if linkKeyLt is not None else True, models.ListFace.link_key >= linkKeyGte if linkKeyGte is not None else True, models.ListFace.list_id == listId, models.Attribute.face_id == models.ListFace.face_id, mod(models.ListFace.link_key, 2) == parity if parity is not None else True, ) query = Query([models.Attribute.face_id, models.ListFace.link_key]) query = query.filter(filters).order_by(models.ListFace.link_key.asc()).limit(limit) attributesRows = await connection.fetchall(query.statement) # used by matcher res = [dict(zip(("attribute_id", "link_key"), attributesRow)) for attributesRow in attributesRows] return res
[docs] @exceptionWrap async def getListMinusDelta( self, listId, unlinkKeyGte: Optional[int] = None, unlinkKeyLt: Optional[int] = None, limit: int = 10000, parity: Optional[int] = None, ) -> list[dict]: """ Get history of detach attribute to lists Args: listId: list id unlinkKeyLt: upper bound of unlink key value unlinkKeyGte: lower bound of unlink key value limit: limit parity: 0 for odd or 1 for even link keys to search for Returns: List of dicts with following keys: "face_id", "link_key", "unlink_key" """ async with DBContext.adaptor.connection(self.logger) as connection: filters = and_( models.UnlinkAttributesLog.unlink_key < unlinkKeyLt if unlinkKeyLt is not None else True, models.UnlinkAttributesLog.unlink_key >= unlinkKeyGte if unlinkKeyGte is not None else True, models.UnlinkAttributesLog.list_id == listId, mod(models.UnlinkAttributesLog.unlink_key, 2) == parity if parity is not None else True, models.UnlinkAttributesLog.face_id != None, ) query = Query( [ models.UnlinkAttributesLog.face_id, models.UnlinkAttributesLog.link_key, models.UnlinkAttributesLog.unlink_key, ] ) query = query.filter(filters).order_by(models.UnlinkAttributesLog.unlink_key.asc()).limit(limit) attributesRows = await connection.fetchall(query.statement) res = [ dict(zip(("attributes_id", "link_key", "unlink_key"), attributesRow)) for attributesRow in attributesRows ] return res
[docs] @exceptionWrap async def cleanLog(self, updateTimeLt: Optional[datetime] = None) -> None: """ Remove notes from unlink tables. Args: updateTimeLt: lower bound of update time """ async with DBContext.adaptor.connection(self.logger) as connection: cleanLogSt = delete(models.UnlinkAttributesLog).where( and_(models.UnlinkAttributesLog.update_time < updateTimeLt if updateTimeLt is not None else True) ) await connection.execute(cleanLogSt)
[docs] @exceptionWrap async def getFacesAttributes( self, faceIds: list[str], retrieveAttrs: Iterable[str], descriptorVersion: int, accountId: Optional[str], getDescriptorAsBytes: bool = False, ) -> list[dict[str, Any]]: """ Retrieve attributes Args: faceIds: face ids retrieveAttrs: tuple of attributes what need retrieve descriptorVersion: requested descriptor version accountId: account id getDescriptorAsBytes: whether to get descriptor as bytes otherwise as base64 Returns: face attributes list with items with the following properties: face_id: face id attributes: target-specific face attributes dict If some attribute data is not found it will be filled with 'empty' value: None for attributes, [] for samples """ faceAttributes = {} async with DBContext.adaptor.connection(self.logger) as connection: async def getAttributeModelData( faceIds_: list[str], accountId_: Optional[str], retrieveAttrs_: Iterable[str], descriptorVersion_: int ) -> Iterable[dict]: """Get attribute data from Attribute and Descriptor tables.""" filters = [models.Face.face_id.in_(faceIds_), models.Face.account_id @ accountId_] selectQuery = Query([models.Face.face_id]) if ( FaceAttributeTargets.createTime.value in retrieveAttrs_ or FaceAttributeTargets.basicAttributes.value in retrieveAttrs_ ): if FaceAttributeTargets.createTime.value in retrieveAttrs_: selectQuery = selectQuery.add_column(models.Attribute.create_time) if FaceAttributeTargets.basicAttributes.value in retrieveAttrs_: selectQuery = selectQuery.add_columns( models.Attribute.age, models.Attribute.gender, models.Attribute.ethnicity ) selectQuery = selectQuery.outerjoin( models.Attribute, models.Attribute.face_id == models.Face.face_id ) if FaceAttributeTargets.faceDescriptor.value in retrieveAttrs: selectQuery = selectQuery.add_column(models.Descriptor.descriptor) selectQuery = selectQuery.outerjoin( models.Descriptor, and_( models.Descriptor.face_id == models.Face.face_id, models.Descriptor.descriptor_version == descriptorVersion_, ), ) selectQuery = selectQuery.filter(and_(*filters)) attributesData = await connection.fetchall(selectQuery.statement) responseFields = [str(field) for field in selectQuery.statement.columns] attributes_ = [{name: data for name, data in zip(responseFields, row)} for row in attributesData] return attributes_ async def getSampleModelData(faceIds_: list[str], accountId_: Optional[str]) -> Iterable[dict]: """Get attribute data from Sample table.""" filters = [models.Face.face_id.in_(faceIds_), models.Face.account_id @ accountId_] selectQuery = ( Query([models.Face.face_id, models.Sample.sample_id, models.Sample.type]) .outerjoin(models.Sample, models.Sample.face_id == models.Face.face_id) .filter(and_(*filters)) ) samplesData = await connection.fetchall(selectQuery.statement) responseFields = [str(field) for field in selectQuery.statement.columns] samples_ = [{name: data for name, data in zip(responseFields, row)} for row in samplesData] return samples_ def updateFaceAttributesWithAttributeData(retrieveAttrs_: Iterable[str], attributes_: Iterable[dict]): """Update faceAttributes result dict with attribute data.""" for attribute in attributes_: attributeFaceId = attribute.pop("face_id") faceAttributes[attributeFaceId] = {} if FaceAttributeTargets.createTime.value in retrieveAttrs_: createTime = attribute.pop(FaceAttributeTargets.createTime.value) if createTime is not None: createTime = convertTimeToString(createTime, self.storageTime == "UTC") faceAttributes[attributeFaceId][FaceAttributeTargets.createTime.value] = createTime if FaceAttributeTargets.faceDescriptor.value in retrieveAttrs_: descriptor = attribute.pop("descriptor") descriptorData = ( { "descriptor": descriptor if getDescriptorAsBytes else bytesToBase64(descriptor), "descriptor_version": descriptorVersion, } if descriptor is not None else None ) faceAttributes[attributeFaceId][FaceAttributeTargets.faceDescriptor.value] = descriptorData if FaceAttributeTargets.basicAttributes.value in retrieveAttrs_: basicAttributes = attribute if any(attr is not None for attr in attribute.values()) else None faceAttributes[attributeFaceId][FaceAttributeTargets.basicAttributes.value] = basicAttributes def updateFaceAttributesWithSampleData(retrieveAttrs_: Iterable[str], samples_: Iterable[dict]): """Update faceAttributes result dict with sample data.""" for sample in samples_: sampleType = sample["type"] if sampleType is None: for attr in (SampleType.face_descriptor, SampleType.basic_attributes): attrType = f"{attr.name}{SAMPLE_POSTFIX}" if attrType in retrieveAttrs_: faceAttributes.setdefault(sample["face_id"], {})[attrType] = [] else: attrType = f"{SampleType(sampleType).name}{SAMPLE_POSTFIX}" if attrType in retrieveAttrs_: faceAttributes.setdefault(sample["face_id"], {}).setdefault(attrType, []).append( sample["sample_id"] ) if { FaceAttributeTargets.createTime.value, FaceAttributeTargets.basicAttributes.value, FaceAttributeTargets.faceDescriptor.value, } | set(retrieveAttrs): attributes = await getAttributeModelData( faceIds_=faceIds, accountId_=accountId, retrieveAttrs_=retrieveAttrs, descriptorVersion_=descriptorVersion, ) updateFaceAttributesWithAttributeData(retrieveAttrs_=retrieveAttrs, attributes_=attributes) if ( FaceAttributeTargets.basicAttributesSamples.value in retrieveAttrs or FaceAttributeTargets.faceDescriptorSamples.value in retrieveAttrs ): samples = await getSampleModelData(faceIds_=faceIds, accountId_=accountId) updateFaceAttributesWithSampleData(retrieveAttrs_=retrieveAttrs, samples_=samples) return [{"face_id": faceId, "attributes": attribute} for faceId, attribute in faceAttributes.items()]
[docs] @exceptionWrap async def getFacesAttributeSamples(self, faceId: list[str], accountId: Optional[str]) -> list[str]: """ Get all the attribute samples of the specified face Args: faceId: face id accountId: account id Returns: face attribute samples list Raises: VLException(Error.FaceNotFound.format(faceId), 404, isCriticalError=False) if face not found """ async with DBContext.adaptor.connection(self.logger) as connection: selectSt = select([models.Sample.sample_id]).where( and_( models.Sample.face_id == faceId, models.Face.account_id @ accountId, models.Sample.face_id == models.Face.face_id, ) ) sampleIds = list(set(chain(*await connection.fetchall(selectSt)))) if not sampleIds: # Check the face existence selectSt = select([models.Face.face_id]).where( and_(models.Face.face_id == faceId, models.Face.account_id @ accountId) ) if await connection.scalar(selectSt) is None: raise VLException(Error.FaceNotFound.format(faceId), 404, isCriticalError=False) return sampleIds
[docs] @exceptionWrap async def putFaceAttributes(self, faceId: str, attribute: TemporaryAttributes, accountId: Optional[str]) -> None: """ Create attributes with exception wrap Args: faceId: face id attribute: temporary attribute container accountId: account id Raises: VLException(Error.FaceNotFound.format(faceId), 404, isCriticalError=False) if face not found """ async with DBContext.adaptor.connection(self.logger) as connection: async def updateHistoryLog(): linkedLists = await self._moveFacesLinksToLog((faceId,), connection) updateFaceListSt = ( update(models.ListFace) .where(models.ListFace.face_id == faceId) .values(last_update_time=self.currentDBTimestamp, link_key=LINK_SEQUENCE.next_value()) ) await connection.execute(updateFaceListSt) return linkedLists # Do select for update lockFaceCount, _ = await self.blockFaces( connection, filters=[models.Face.face_id == faceId, models.Face.account_id @ accountId] ) if lockFaceCount == 0: raise VLException(Error.FaceNotFound.format(faceId), 404, isCriticalError=False) linkedLists = await updateHistoryLog() await connection.execute(delete(models.Attribute).where(models.Attribute.face_id == faceId)) await self.insertFaceAttributeData(connection, faceId=faceId, attribute=attribute) self._addListsToDeferrerUpdateListLastUpdateTime(linkedLists)
@exceptionWrap async def _updateAttributeDescriptor( self, connection: AbstractDBConnection, faceId: str, descriptors: list[Descriptor], generation: int ) -> None: """ Partial update attribute Args: connection: connection faceId: face id descriptors: list of descriptor containers for patch generation: descriptor generation """ descriptorData = [ { "descriptor_version": descriptor.version, "descriptor": descriptor.descriptor, "descriptor_obtaining_method": 1, } for descriptor in descriptors ] for descriptorDataItem in descriptorData: values = {k: v for k, v in descriptorDataItem.items() if k != "descriptor_version"} updateSt = ( update(models.Descriptor) .where( and_( models.Descriptor.face_id == faceId, models.Descriptor.descriptor_version == descriptorDataItem["descriptor_version"], ) ) .values(**values) ) if not await connection.execute(updateSt): # insert full values if cannot update insertDescriptorSt = insert(models.Descriptor).values( **descriptorDataItem, face_id=faceId, descriptor_generation=generation ) await connection.execute(insertDescriptorSt)
[docs] @exceptionWrap async def updateFaceAttributes( self, faceId: str, attribute: TemporaryAttributes, accountId: Optional[str] = None, forceUpdate: Optional[bool] = False, ) -> None: """ Update attribute Args: faceId: updated attribute face id attribute: temporary attributes container accountId: account id forceUpdate: whether not to compare existing samples and new ones Raises: VLException(Error.FaceSampleConflict.format(faceId), 400, False) if samples conflict VLException(Error.AttributesForUpdateNotFound.format(faceId), 400, False) if attribute for update not found VLException(Error.FaceNotFound.format(faceId), 404, False) if face not found """ async with DBContext.adaptor.connection(self.logger) as connection: async def checkSamples( faceId_: str, filteredSamples_: dict[int, set[str]], updDescriptorVersions_: list[int] ) -> None: """ Check conformity of old and new sample ids. Args: faceId_: face id filteredSamples_: {<sample type>: <samples>} map updDescriptorVersions_: versions of updating descriptors Raises: VLException(Error.FaceSampleConflict.format(attributeId), 400, False) if old samples do not match specified samples in attribute """ isNeedToCheckSamples = not forceUpdate for sampleTypeToCheck in SampleType: sampleTypeToCheck = sampleTypeToCheck.value if sampleTypeToCheck not in filteredSamples_: continue newSamplesSet = filteredSamples_[sampleTypeToCheck] selectSt = select([models.Sample.sample_id]).where( and_(models.Sample.face_id == faceId_, models.Sample.type == sampleTypeToCheck) ) if sampleTypeToCheck == SampleType.face_descriptor.value: # (if descriptor samples seems to be updated and descriptors not fully updated) dbReply = await connection.fetchall(selectSt) existingSampleIds = set(chain(*dbReply)) if existingSampleIds and existingSampleIds != newSamplesSet: # mb replace all descriptors selectSt = select([models.Descriptor.descriptor_version]).where( and_( models.Descriptor.face_id == faceId_, not_(models.Descriptor.descriptor_version.in_(updDescriptorVersions_)), ) ) notUpdatedDescriptorVersions = await connection.fetchall(selectSt) if notUpdatedDescriptorVersions: raise VLException(Error.FaceSampleConflict.format(faceId_), 400, False) else: # basic attributes samples if not isNeedToCheckSamples: continue dbReply = await connection.fetchall(selectSt) existingSampleIds = set(chain(*dbReply)) if existingSampleIds and existingSampleIds != newSamplesSet: raise VLException(Error.FaceSampleConflict.format(faceId_), 400, False) async def updateAttributeModel( faceId_: str, accountId_: Optional[str], basicAttributes: Optional[BasicAttributes], isNeedToUpdGeneration: bool, ) -> int: """ Update attribute model. Increase current descriptor's generation if it needs (depends on descriptor samples in attributes) Args: faceId_: face id accountId_: account id basicAttributes: basic attributes container isNeedToUpdGeneration: whether to increase descriptor sample generation or not Returns: descriptor generation """ if accountId is None: filters = and_(models.Attribute.face_id == faceId_) else: filters = exists([models.Attribute.face_id]).where( and_( models.Face.face_id == faceId_, models.Face.account_id == accountId_, models.Attribute.face_id == models.Face.face_id, ) ) values = { "descriptor_samples_generation": models.Attribute.descriptor_samples_generation + int(isNeedToUpdGeneration) } if basicAttributes is not None: values.update( { "age": basicAttributes.age, "gender": basicAttributes.gender, "ethnicity": basicAttributes.ethnicity, } ) updateQuery = ( update(models.Attribute) .where(filters) .values(**values) .returning(models.Attribute.descriptor_samples_generation) ) generation = await connection.scalar(updateQuery) if generation is None: raise VLException(Error.AttributesForUpdateNotFound.format(faceId_), 400, isCriticalError=False) return generation async def replaceSamples(faceId_: str, filteredSamples_: dict[int, set[str]]) -> None: """ Replace samples Args: faceId_: face id filteredSamples_: {<sample type>: <samples>} map """ for sampleType, samples in filteredSamples_.items(): deleteSt = delete(models.Sample).where( and_(models.Sample.type == sampleType, models.Sample.face_id == faceId_) ) await connection.execute(deleteSt) for sampleType, sampleIds in filteredSamples_.items(): for sampleId in sampleIds: query = insert(models.Sample).values(face_id=faceId_, sample_id=sampleId, type=sampleType) await connection.execute(query) async def recreateLinks(faceId_: str, updDescriptorVersions_: list[int]) -> list[str]: """ Recreate face-list links if the descriptor of the current version was changed. Needed for matcher if a descriptor was changed. Args: faceId_: face id updDescriptorVersions_: versions of updating descriptors """ needToUpdate = self.defaultDescriptorVersion in updDescriptorVersions_ if not needToUpdate: return [] updateLinkKeysSt = ( update(models.ListFace) .where(models.ListFace.face_id.in_([faceId_])) .values(link_key=LINK_SEQUENCE.next_value()) ) linkedLists = await self._moveFacesLinksToLog((faceId,), connection) await connection.execute(updateLinkKeysSt) return linkedLists # Do select for update lockFaceCount, _ = await self.blockFaces( connection, filters=[models.Face.face_id == faceId, models.Face.account_id @ accountId] ) if lockFaceCount == 0: raise VLException(Error.FaceNotFound.format(faceId), 404, isCriticalError=False) # Prepare map: {<sample type>: <samples>} filteredSamples = {} if len(attribute.basicAttributesSamples) > 0: filteredSamples[SampleType[AttributeSample.basic_attributes.value].value] = set( attribute.basicAttributesSamples ) if len(attribute.descriptorSamples) > 0: filteredSamples[SampleType[AttributeSample.face_descriptors.value].value] = set( attribute.descriptorSamples ) # Check no sample conflict updDescriptorVersions = [descr.version for descr in attribute.descriptors] await checkSamples( faceId_=faceId, filteredSamples_=filteredSamples, updDescriptorVersions_=updDescriptorVersions ) # Update attribute data isNeedToUpdGeneration = filteredSamples.get(SampleType.face_descriptor.value) is not None generation = await updateAttributeModel( faceId_=faceId, accountId_=accountId, basicAttributes=attribute.basicAttributes, isNeedToUpdGeneration=isNeedToUpdGeneration, ) if forceUpdate: await replaceSamples(faceId_=faceId, filteredSamples_=filteredSamples) await self._updateAttributeDescriptor( connection=connection, faceId=faceId, descriptors=attribute.descriptors, generation=generation ) listsForUpdate = await recreateLinks(faceId_=faceId, updDescriptorVersions_=updDescriptorVersions) self._addListsToDeferrerUpdateListLastUpdateTime(listsForUpdate)
[docs] @exceptionWrap async def deleteFaceAttributes(self, faceId: str, accountId: Optional[str] = None) -> None: """ Delete face attributes. Args: faceId: face id to remove its attributes accountId: account id """ async with DBContext.adaptor.connection(self.logger) as connection: await self.blockFaces(connection, [models.Face.face_id == faceId]) faceCheckFilter = and_(models.Face.face_id == faceId, models.Face.account_id @ accountId) updateFaceSt = update(models.Face).where(faceCheckFilter).values(last_update_time=self.currentDBTimestamp) faceCount = await connection.execute(updateFaceSt) if not faceCount: raise VLException(Error.FaceNotFound.format(faceId), 404, isCriticalError=False) updateListSt = ( update(models.List) .where( exists( select([models.List.list_id]).where( and_( models.List.list_id == models.ListFace.list_id, models.ListFace.face_id == models.Face.face_id, faceCheckFilter, ) ) ) ) .values(last_update_time=self.currentDBTimestamp) ) await connection.execute(updateListSt) deleteAttributeSt = delete(models.Attribute).where( exists( select([models.Attribute.face_id]).where( and_(faceCheckFilter, models.Attribute.face_id == models.Face.face_id) ) ) ) await connection.execute(deleteAttributeSt)
[docs] @exceptionWrap async def getDescriptorsBatchByFaceIds( self, facesIds: set[str], accountId: Optional[str] = None, checkObjectExistence: bool = True, descriptorVersion: Optional[int] = None, receiveExternalId: Optional[bool] = None, ) -> dict[str, Union[list[bytes], int, list[str]]]: """ Get descriptors batch by faces Ids. ! Splitting into batches is used due to enormous queries (25Mb for 100k faces) that fails Oracle DB. (LUNA-3734) Args: facesIds: faces ids the descriptors were attached to accountId: account id of the faces checkObjectExistence: check faces existence or not descriptorVersion: requested descriptor version receiveExternalId: receive or not external ids Returns: Dict: descriptors: list[bytes] descriptorVersion: int faceUuids: list[str] notFoundUuids: list[str] notExtractedUuids: list[str] externalIds: list[str] Raises: VLException(Error.FacesNotFound) """ if descriptorVersion is None: descriptorVersion = self.defaultDescriptorVersion selectFields = [models.Descriptor.descriptor, models.Face.face_id] if receiveExternalId: selectFields.append(models.Face.external_id) # 1k batching splitting facesIdsList = list(facesIds) faceIdsBatches = [facesIdsList[idx : idx + DB_LIST_LIMIT] for idx in range(0, len(facesIdsList), DB_LIST_LIMIT)] queries = [ select(selectFields).where( and_( models.Descriptor.face_id.in_(faceIds_), models.Descriptor.descriptor_version == descriptorVersion, # if need filtration by account models.Face.face_id == models.Descriptor.face_id, models.Face.account_id @ accountId, ) ) for faceIds_ in faceIdsBatches ] getNotExtractedQuery = lambda existFaceIds: Query([models.Face.face_id]).filter( and_( models.Face.face_id.in_(list(set(facesIds).difference(set(existFaceIds)))), models.Face.account_id @ accountId, ~exists( select([models.Face.face_id]).where( and_( models.Face.face_id == models.Descriptor.face_id, models.Descriptor.descriptor_version == descriptorVersion, ) ) ), ) ) async with DBContext.adaptor.connection(self.logger) as connection: unitedResults = [] for query in queries: unitedResults.extend(await connection.fetchall(query)) # 1k batching join if receiveExternalId: descriptors, replyFaceIds, externalIds = tuple(zip(*unitedResults)) or ([], [], []) externalIds = list(map(lambda x: x or "", externalIds)) else: descriptors, replyFaceIds = tuple(zip(*unitedResults)) or ([], []) externalIds = None notFoundUuids = [] if len(replyFaceIds) != len(facesIds): notExtractedFaceIds = [ faceId[0] for faceId in (await connection.fetchall(getNotExtractedQuery(replyFaceIds).statement)) ] if checkObjectExistence: firstNotFoundFace = await self.getNonexistentFaceId(facesIds, accountId, connection) if firstNotFoundFace: raise VLException(Error.FacesNotFound.format(firstNotFoundFace), 400, isCriticalError=False) else: notFoundUuids = list(facesIds.difference(notExtractedFaceIds).difference(replyFaceIds)) else: notExtractedFaceIds = [] result = dict( descriptors=list(map(bytes, descriptors)), uuids=replyFaceIds, descriptorVersion=descriptorVersion, notFoundUuids=notFoundUuids, notExtractedUuids=notExtractedFaceIds, externalIds=externalIds, ) return result
[docs] @exceptionWrap async def getListFacesDescriptorsBatch( self, listId: str, linkKeyGte: int, limit: int, descriptorVersion: Optional[int] = None, parity: Optional[int] = None, receiveExternalId: Optional[bool] = None, ) -> dict[str, Union[list[bytes], int, list[int], list[str]]]: """ Get descriptors batch Args: listId: list id the descriptors were attached to linkKeyGte: the lower including boundary limit: descriptors count to return descriptorVersion: descriptor version parity: 0 for odd or 1 for even link keys to search for receiveExternalId: receive or not external ids Returns: Dict: descriptors: list[bytes] descriptorVersion: int faceUuids: list[str] linkKeys: list[int] faceIds: list[str] externalIds: list[str] """ if descriptorVersion is None: descriptorVersion = self.defaultDescriptorVersion selectFields = [models.Descriptor.descriptor, models.ListFace.link_key, models.Descriptor.face_id] if receiveExternalId: selectFields.append(models.Face.external_id) query = Query(selectFields).filter( models.Descriptor.face_id == models.Face.face_id if receiveExternalId else True, models.Descriptor.face_id == models.ListFace.face_id, models.Descriptor.descriptor_version == descriptorVersion, models.ListFace.list_id == listId, models.ListFace.link_key >= linkKeyGte, mod(models.ListFace.link_key, 2) == parity if parity is not None else True, ) if parity is not None: query = query.order_by( models.ListFace.list_id, mod(models.ListFace.link_key, 2), models.ListFace.link_key.asc() ) else: query = query.order_by(models.ListFace.link_key.asc()) query = query.limit(limit) async with DBContext.adaptor.connection(self.logger) as connection: if self.dbConfig.type == "oracle": global indexFaceName, indexDescriptorName if not (indexFaceName is indexDescriptorName is None): query = query.with_hint( models.ListFace, f"INDEX(LIST_FACE LINK_KEY_FUNC_INDEX) INDEX(FACE {indexFaceName}) " f"INDEX(DESCRIPTOR {indexDescriptorName})", ) else: self.logger.warning("Database indexes may not using") if self.dbConfig.type == "oracle": queryCursor = await connection.fetchall(getCompiledQuery(query, self.dbConfig.type)) else: # for postgres compiling wrong request in mod(models.ListFace.link_key, 2) == parity queryCursor = await connection.fetchall(query.statement) if receiveExternalId: descriptors, linkKeys, faceIds, externalIds = tuple(zip(*queryCursor)) or ([], [], [], []) externalIds = list(map(lambda x: x or "", externalIds)) else: descriptors, linkKeys, faceIds = tuple(zip(*queryCursor)) or ([], [], []) externalIds = None result = dict( descriptors=descriptors, descriptorVersion=descriptorVersion, linkKeys=linkKeys, uuids=faceIds, externalIds=externalIds, ) return result
def _prepareMissingDescriptorsFilters( self, missingVersion, accountId: Optional[str] = None, faceIds: Optional[list[str]] = None, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None, ) -> and_: """ Prepare filters for missing descriptors query. Args: missingVersion: missing descriptor version accountId: account id of the attributes faceIds: list of face ids faceIdGte: lower face id including boundary faceIdLt: upper face id excluding boundary Returns: prepared sa.and_() with filters """ nestedDescriptor = aliased(models.Descriptor) # table from the nested query need to be aliased return and_( # whether we need to reextract models.Attribute.face_id == models.Descriptor.face_id, models.Descriptor.descriptor_version == self.defaultDescriptorVersion, # filters models.Attribute.face_id == models.Face.face_id if accountId is not None else True, models.Face.account_id @ accountId, models.Attribute.face_id >= faceIdGte if faceIdGte is not None else True, models.Attribute.face_id < faceIdLt if faceIdLt is not None else True, models.Attribute.face_id.in_(faceIds) if faceIds is not None else True, # whether descriptor was not reextracted ~exists( select([nestedDescriptor.descriptor_version]).where( and_( nestedDescriptor.face_id == models.Attribute.face_id, nestedDescriptor.descriptor_version == missingVersion, nestedDescriptor.descriptor_generation == models.Attribute.descriptor_samples_generation, ) ) ), )
[docs] @exceptionWrap async def getMissingDescriptors( self, missingVersion: int, accountId: Optional[str] = None, faceIds: Optional[list[str]] = None, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None, limit: int = 1000, ) -> list[dict[str, Union[str, list[str]]]]: """ Get missing descriptors of 'missingVersion' version: get attributes not having descriptor get samples Args: missingVersion: missing descriptor version accountId: account id of the attributes faceIds: list of attribute ids faceIdGte: lower face id including boundary faceIdLt: upper face id excluding boundary limit: maximum attributes amount to return Returns: data array in the format: {"face_id": "<face_id>", "generation": <generation>, "samples": ["<sample_id>"]} """ async with DBContext.adaptor.connection(self.logger) as connection: selectSt = ( select([models.Attribute.face_id]) .where(self._prepareMissingDescriptorsFilters(missingVersion, accountId, faceIds, faceIdGte, faceIdLt)) .order_by(models.Attribute.face_id.asc()) .limit(limit) ) facesRes = await connection.fetchall(selectSt) # {face_id: {face_id: id, samples:[]}} result = {faceId: {"face_id": faceId, "samples": []} for (faceId,) in facesRes} samplesSt = select([models.Sample.face_id, models.Sample.sample_id]).where( and_(models.Sample.face_id.in_(result.keys()), models.Sample.type == SampleType.face_descriptor.value) ) samplesRes = await connection.fetchall(samplesSt) for faceId, sampleId in samplesRes: result[faceId]["samples"].append(sampleId) return list(result.values())
[docs] @exceptionWrap async def getMissingDescriptorsCount( self, missingVersion: int, accountId: Optional[str] = None, faceIds: Optional[list[str]] = None, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None, ) -> int: """ Get count of missing descriptors of 'missingVersion' version. Args: missingVersion: missing descriptor version accountId: account id of the attributes faceIds: list of face ids faceIdGte: lower attribute id including boundary faceIdLt: upper attribute id excluding boundary Returns: missing descriptors count """ async with DBContext.adaptor.connection(self.logger) as connection: selectSt = select([func.count(models.Attribute.face_id)]).where( self._prepareMissingDescriptorsFilters(missingVersion, accountId, faceIds, faceIdGte, faceIdLt) ) count = await connection.scalar(selectSt) return count
[docs] @exceptionWrap async def getDescriptorsCount(self, accountId: Optional[str] = None) -> list[dict[str, int]]: """ Get face descriptors count with filters. Args: accountId: account id Returns: list of dict. Keys of each dict are "descriptor_version" and "descriptor_count" """ async with DBContext.adaptor.connection(self.logger) as connection: filters = and_(models.Face.account_id @ accountId, models.Face.face_id == models.Descriptor.face_id) selectSt = ( select([models.Descriptor.descriptor_version, func.count(models.Descriptor.face_id)]) .where(filters) .group_by(models.Descriptor.descriptor_version) ) resRows = await connection.fetchall(selectSt) return [{"descriptor_version": version, "descriptor_count": count} for version, count in resRows]
def _prepareMissingBasicAttrsFilters( self, accountId: Optional[str] = None, faceIds: Optional[list[str]] = None, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None, ) -> and_: """ Prepare filters for missing basic attributes query. Args: accountId: account id of the attributes faceIds: list of face ids faceIdGte: lower face id including boundary faceIdLt: upper face id excluding boundary Returns: prepared sa.and_() with filters """ return and_( # whether we need to reextract models.Attribute.ethnicity.is_(None), # filters models.Attribute.face_id == models.Face.face_id if accountId is not None else True, models.Face.account_id @ accountId, models.Attribute.face_id >= faceIdGte if faceIdGte is not None else True, models.Attribute.face_id < faceIdLt if faceIdLt is not None else True, models.Attribute.face_id.in_(faceIds) if faceIds is not None else True, )
[docs] @exceptionWrap async def getMissingBasicAttrs( self, accountId: Optional[str] = None, faceIds: Optional[list[str]] = None, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None, limit: int = 1000, ) -> list[dict[str, Union[str, list[str]]]]: """ Get missing basic attributes: get attributes without basic attributes get samples Args: accountId: account id of the attributes faceIds: list of attribute ids faceIdGte: lower face id including boundary faceIdLt: upper face id excluding boundary limit: maximum attributes amount to return Returns: data array in the format: {"face_id": "<face_id>", "samples": ["<sample_id>"]} """ async with DBContext.adaptor.connection(self.logger) as connection: selectSt = ( select([models.Attribute.face_id]) .where(self._prepareMissingBasicAttrsFilters(accountId, faceIds, faceIdGte, faceIdLt)) .order_by(models.Attribute.face_id.asc()) .limit(limit) ) facesRes = await connection.fetchall(selectSt) # {face_id: {face_id: id, samples:[]}} result = {face[0]: {"face_id": face[0], "samples": []} for face in facesRes} samplesSt = select([models.Sample.face_id, models.Sample.sample_id]).where( and_(models.Sample.face_id.in_(result.keys()), models.Sample.type == SampleType.face_descriptor.value) ) samplesRes = await connection.fetchall(samplesSt) for sample in samplesRes: result[sample[0]]["samples"].append(sample[1]) return list(result.values())
[docs] @exceptionWrap async def getMissingBasicAttrsCount( self, accountId: Optional[str] = None, faceIds: Optional[list[str]] = None, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None, ) -> int: """ Get count of missing basic attributes. Args: accountId: account id of the attributes faceIds: list of face ids faceIdGte: lower attribute id including boundary faceIdLt: upper attribute id excluding boundary Returns: missing basic attributes count """ async with DBContext.adaptor.connection(self.logger) as connection: selectSt = select([func.count(models.Attribute.face_id)]).where( self._prepareMissingBasicAttrsFilters(accountId, faceIds, faceIdGte, faceIdLt) ) count = await connection.scalar(selectSt) return count
[docs] @exceptionWrap async def getBasicAttrsCount(self, accountId: Optional[str] = None) -> int: """ Get count of basic attributes. Args: accountId: account id of the attributes Returns: basic attributes count """ async with DBContext.adaptor.connection(self.logger) as connection: selectSt = select([func.count(models.Attribute.face_id)]).where( and_( models.Attribute.ethnicity.isnot(None), models.Face.account_id @ accountId, models.Attribute.face_id == models.Face.face_id if accountId is not None else True, ) ) count = await connection.scalar(selectSt) return count
@staticmethod def _prepareDescriptorsFilters( descriptorVersion: int, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None ) -> BooleanClauseList: """ Prepare filters for descriptors query. Args: descriptorVersion:descriptor version faceIdGte: lower face id including boundary faceIdLt: upper face id excluding boundary Returns: prepared sa.and_() with filters """ return and_( models.Descriptor.descriptor_version == descriptorVersion, models.Descriptor.face_id >= faceIdGte if faceIdGte is not None else True, models.Descriptor.face_id < faceIdLt if faceIdLt is not None else True, )
[docs] @exceptionWrap async def deleteDescriptors( self, descriptorVersion: int, faceIdGte: Optional[str] = None, faceIdLt: Optional[str] = None, limit: int = 1000 ) -> list[dict[str, Union[str, int, list[str]]]]: """ Delete descriptors by version: delete descriptors of preassigned version Args: descriptorVersion: descriptor version faceIdGte: lower face id including boundary faceIdLt: upper face id excluding boundary limit: maximum attributes amount to delete Returns: list of face ids id for deleted descriptors of preassigned version """ async with DBContext.adaptor.connection(self.logger) as connection: selectSt = ( select([models.Descriptor.face_id]) .where(self._prepareDescriptorsFilters(descriptorVersion, faceIdGte, faceIdLt)) .order_by(models.Descriptor.face_id.asc()) .limit(limit) ) faces = [row["face_id"] for row in await connection.fetchall(selectSt)] deleteSt = delete(models.Descriptor).where( and_(models.Descriptor.face_id.in_(faces), models.Descriptor.descriptor_version == descriptorVersion) ) await connection.execute(deleteSt) return faces
[docs] async def blockFaces( self, connection, filters: list[ColumnClause], returnBlockedFaces: bool = False ) -> tuple[int, Union[tuple[str, ...], None]]: """ Block some faces rows in the db, mechanics "select for update". Returns: number of blocked faces and blocked faces or number of blocked faces and None, depends on the argument """ query = select([models.Face.face_id]).where(and_(*filters)).with_for_update() if self.dbConfig.type == "oracle" or returnBlockedFaces: _blockedFaces = await connection.fetchall(query) blockedFaces = tuple(face[0] for face in _blockedFaces) blockedFaceCount = len(blockedFaces) else: blockedFaces = None count = select([func.count()], from_obj=aliased(query)) blockedFaceCount = await connection.scalar(count) self.logger.debug(f"lock {blockedFaceCount} faces") if returnBlockedFaces: return blockedFaceCount, blockedFaces else: return blockedFaceCount, None
[docs] async def updateListLastUpdateTime(self, listId: str): """ Update last update time of lists. Args: listId: list id """ async with DBContext.adaptor.connection(self.logger) as connection: st = ( update(models.List) .where(models.List.list_id == listId) .values(last_update_time=self.currentDBTimestamp) ) await connection.execute(st)
async def _moveFacesLinksToLog( self, faceIds: Union[list[str], tuple[str, ...]], connection: AbstractDBConnection ) -> list[str]: """ Move face to list links to unlink attributes log Args: faceIds: face ids connection: open connection Returns: linked to faces list ids """ query = select([models.ListFace.list_id, models.ListFace.face_id, models.ListFace.link_key]).where( models.ListFace.face_id.in_(faceIds) ) insertSt = insert(models.UnlinkAttributesLog).from_select( [ models.UnlinkAttributesLog.list_id, models.UnlinkAttributesLog.face_id, models.UnlinkAttributesLog.link_key, ], query, ) if self.dbConfig.type == "oracle": listCount = await connection.execute(insertSt) if listCount: query = select([models.ListFace.list_id]).where(models.ListFace.face_id.in_(faceIds)) _linkedLists = await connection.fetchall(query) else: _linkedLists = [] else: st = insertSt.returning(models.UnlinkAttributesLog.list_id) _linkedLists = await connection.fetchall(st) linkedLists = [listId[0] for listId in _linkedLists] return linkedLists
[docs] async def getListDeletions( self, deletionTimeLt: Optional[datetime] = None, deletionTimeGte: Optional[datetime] = None, page: Optional[int] = 1, pageSize: Optional[int] = 100, ): """ Get lists deletion logs Args: deletionTimeLt: upper bound of list deletion time deletionTimeGte: lower bound of list deletion time page: page pageSize: page size Warnings: trigger `trg_lists_deletion_log` inserts a data for table `ListsDeletionLog` Returns: list of deletions in the reverse order of deletion of lists """ query = ( select( [ models.ListsDeletionLog.list_id, models.ListsDeletionLog.account_id, models.ListsDeletionLog.create_time, models.ListsDeletionLog.deletion_id, models.ListsDeletionLog.deletion_time, ] ) .where( and_( models.ListsDeletionLog.deletion_time >= deletionTimeGte if deletionTimeGte else True, models.ListsDeletionLog.deletion_time < deletionTimeLt if deletionTimeLt else True, ) ) .order_by(models.ListsDeletionLog.deletion_time.desc()) .offset((page - 1) * pageSize) .limit(pageSize) .offset((page - 1) * pageSize) .limit(pageSize) ) async with DBContext.adaptor.connection(self.logger) as connection: records = await connection.fetchall(query) listsDeletions = [] for row in records: removedList = dict(row) removedList["create_time"] = convertTimeToString(removedList["create_time"], self.storageTime == "UTC") removedList["deletion_time"] = convertTimeToString( removedList["deletion_time"], self.storageTime == "UTC" ) listsDeletions.append(removedList) return listsDeletions
[docs] async def cleanListsDeletionLog(self, deletionTimeLt: datetime) -> int: """ Clear lists deletion log Args: deletionTimeLt: upper bound of list deletion time Returns: count of removed rows """ query = delete(models.ListsDeletionLog).where(models.ListsDeletionLog.deletion_time < deletionTimeLt) async with DBContext.adaptor.connection(self.logger) as connection: count = await connection.execute(query) return count