adapt new n-data versioN

requirements.txt

@@ -7,4 +7,4 @@ python-jose[cryptography]==3.3.0
 passlib[bcrypt]==1.7.4
 httpx[http2]==0.23.0
 pymitter==0.4.0
--e git+ssh://git@gitlab.pik-potsdam.de/mcc-apsis/nacsos/nacsos-data.git@ee523bfb02974fc47ca51b5abe592ac465d0c179#egg=nacsos_data
\ No newline at end of file
+-e git+ssh://git@gitlab.pik-potsdam.de/mcc-apsis/nacsos/nacsos-data.git@0880bc8a47ba79ce7e2fa927716c7887d96f2cf4#egg=nacsos_data
\ No newline at end of file

server/api/routes/annotations.py

@@ -11,7 +11,7 @@ from nacsos_data.models.bot_annotations import \
     ResolutionMethod, \
     AnnotationFilters, \
     BotAnnotationModel, \
-    AnnotationMatrix, \
+    AnnotationCollection, \
     BotMetaResolve
 from nacsos_data.models.items import AnyItemModel
 from nacsos_data.db.crud.items import read_any_item_by_item_id
@@ -48,6 +48,7 @@ from nacsos_data.util.annotations.validation import \
     flatten_annotation_scheme
 from nacsos_data.util.annotations.assignments.random import random_assignments
 
+from uuid import UUID
 from pydantic import BaseModel
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -321,28 +322,24 @@ async def make_assignments(payload: MakeAssignmentsRequestModel,
 
 
 class ResolutionProposalResponse(BaseModel):
-    matrix: AnnotationMatrix
+    collection: AnnotationCollection
     proposal: list[BotAnnotationModel]
 
 
 class SavedResolutionResponse(BaseModel):
-    bot_annotation_metadata_id: str
-    name: str
-    project_id: str
-    annotation_scope_id: str | None = None
-    annotation_scheme_id: str | None = None
-
     meta: BotMetaResolve
     saved: list[BotAnnotationModel]
 
 
 @router.get('/config/resolve/', response_model=ResolutionProposalResponse)
 async def get_item_annotation_matrix(strategy: ResolutionMethod,
-                                     scheme_id: str | None = None,
+                                     scheme_id: str,
                                      scope_id: list[str] | None = Query(default=None),
                                      user_id: list[str] | None = Query(default=None),
                                      key: list[str] | None = Query(default=None),
                                      repeat: list[int] | None = Query(default=None),
+                                     ignore_order: bool | None = Query(default=False),
+                                     ignore_hierarchy: bool | None = Query(default=False),
                                      permissions=Depends(UserPermissionChecker('annotations_edit'))):
     """
     Get all annotations that match the filters (e.g. all annotations made by users in scope with :scope_id).
@@ -358,6 +355,8 @@ async def get_item_annotation_matrix(strategy: ResolutionMethod,
     :param key:
     :param repeat:
     :param permissions:
+    :param ignore_order:
+    :param ignore_hierarchy:
     :return:
     """
     filters = AnnotationFilters(
@@ -367,21 +366,12 @@ async def get_item_annotation_matrix(strategy: ResolutionMethod,
         key=key,
         repeat=repeat,
     )
-    matrix, proposal = await get_resolved_item_annotations(strategy=strategy,
-                                                           filters=AnnotationFilterObject.parse_obj(filters),
-                                                           db_engine=db_engine)
-    return ResolutionProposalResponse(matrix=matrix,
-                                      proposal=[BotAnnotationModel(
-                                          item_id=item_id,
-                                          key=matrix.labels[i][-1].key,
-                                          repeat=matrix.labels[i][-1].repeat,
-                                          value_int=p.v_int,
-                                          value_str=p.v_str,
-                                          value_bool=p.v_bool,
-                                          value_float=p.v_float,
-                                      ) for item_id, annotations in proposal.items()
-                                          for i, p in enumerate(annotations)
-                                          if p is not None])
+    collection, resolved = await get_resolved_item_annotations(strategy=strategy,
+                                                               filters=AnnotationFilterObject.parse_obj(filters),
+                                                               ignore_order=ignore_order,
+                                                               ignore_hierarchy=ignore_hierarchy,
+                                                               db_engine=db_engine)
+    return ResolutionProposalResponse(collection=collection, proposal=resolved)
 
 
 @router.get('/config/resolved/:bot_annotation_meta_id', response_model=SavedResolutionResponse)
@@ -391,15 +381,10 @@ async def get_saved_resolved_annotations(bot_annotation_meta_id: str,
         meta = await session.get(BotAnnotationMetaData, bot_annotation_meta_id)
         if meta is None:
             raise NoDataForKeyError(f'No `BotAnnotationMetaData` for "{bot_annotation_meta_id}"!')
-        annotations = (await session.scalars(
+        bot_annotations = (await session.scalars(
             select(BotAnnotation).where(BotAnnotation.bot_annotation_metadata_id == bot_annotation_meta_id))).all()
 
         return SavedResolutionResponse(
-            bot_annotation_metadata_id=meta.bot_annotation_metadata_id,
-            name=meta.name,
-            project_id=meta.project_id,
-            annotation_scope_id=meta.annotation_scope_id,
-            annotation_scheme_id=meta.annotation_scheme_id,
             meta=meta.meta,
-            saved=annotations
+            saved=[BotAnnotationModel.parse_obj(bot_annotation)for bot_annotation in bot_annotations]
         )

server/api/routes/project/items.py

 from fastapi import APIRouter, Depends, HTTPException, status, Query
-from nacsos_data.db.schemas import Project
+from nacsos_data.db.schemas import Project, ItemTypeLiteral, GenericItem
 
-from nacsos_data.models.projects import ProjectTypeLiteral
-from nacsos_data.models.items import AnyItemModel
+from nacsos_data.models.items import AnyItemModel, GenericItemModel
 from nacsos_data.models.items.twitter import TwitterItemModel
 from nacsos_data.db.crud.items import \
-    read_item_count_for_project
-from nacsos_data.db.crud.items.basic import \
-    read_all_basic_items_for_project, \
-    read_all_basic_items_for_project_paged, \
-    read_basic_item_by_item_id
+    read_item_count_for_project, \
+    read_all_for_project, \
+    read_paged_for_project, \
+    read_any_item_by_item_id
 from nacsos_data.db.crud.items.twitter import \
     read_all_twitter_items_for_project, \
     read_all_twitter_items_for_project_paged, \
     read_twitter_item_by_item_id, \
-    create_twitter_item
+    import_tweet
 
 from server.api.errors import ItemNotFoundError
 from server.data import db_engine
@@ -28,11 +26,12 @@ logger.info('Setting up data route')
 
 
 @router.get('/{item_type}/list', response_model=list[AnyItemModel])
-async def list_project_data(item_type: ProjectTypeLiteral,
+async def list_project_data(item_type: ItemTypeLiteral,
                             permission=Depends(UserPermissionChecker('dataset_read'))):
     project_id = permission.permissions.project_id
-    if item_type == 'basic':
-        return await read_all_basic_items_for_project(project_id=project_id, engine=db_engine)
+    if item_type == 'generic':
+        return await read_all_for_project(Model=GenericItemModel, Schema=GenericItem,
+                                          project_id=project_id, engine=db_engine)
     if item_type == 'twitter':
         return await read_all_twitter_items_for_project(project_id=project_id, engine=db_engine)
     raise HTTPException(status_code=status.HTTP_501_NOT_IMPLEMENTED,
@@ -40,12 +39,13 @@ async def list_project_data(item_type: ProjectTypeLiteral,
 
 
 @router.get('/{item_type}/list/{page}/{page_size}', response_model=list[AnyItemModel])
-async def list_project_data_paged(item_type: ProjectTypeLiteral, page: int, page_size: int,
+async def list_project_data_paged(item_type: ItemTypeLiteral, page: int, page_size: int,
                                   permission=Depends(UserPermissionChecker('dataset_read'))):
     project_id = permission.permissions.project_id
     if item_type == 'basic':
-        return await read_all_basic_items_for_project_paged(project_id=project_id,
-                                                            page=page, page_size=page_size, engine=db_engine)
+        return await read_paged_for_project(Model=GenericItemModel, Schema=GenericItem,
+                                            page=page, page_size=page_size,
+                                            project_id=project_id, engine=db_engine)
     if item_type == 'twitter':
         return await read_all_twitter_items_for_project_paged(project_id=project_id,
                                                               page=page, page_size=page_size, engine=db_engine)
@@ -55,7 +55,7 @@ async def list_project_data_paged(item_type: ProjectTypeLiteral, page: int, page
 
 @router.get('/detail/{item_id}', response_model=AnyItemModel)
 async def get_detail_for_item(item_id: str,
-                              item_type: ProjectTypeLiteral | None = Query(default=None),
+                              item_type: ItemTypeLiteral | None = Query(default=None),
                               permission=Depends(UserPermissionChecker('dataset_read'))) -> AnyItemModel:
     if item_type is None:
         async with db_engine.session() as session:
@@ -65,7 +65,7 @@ async def get_detail_for_item(item_id: str,
 
     result: AnyItemModel | None = None
     if item_type == 'basic':
-        result = await read_basic_item_by_item_id(item_id=item_id, engine=db_engine)
+        result = await read_any_item_by_item_id(item_id=item_id, item_type=item_type, engine=db_engine)
     elif item_type == 'twitter':
         result = await read_twitter_item_by_item_id(item_id=item_id, engine=db_engine)
     else:
@@ -84,6 +84,7 @@ async def count_project_items(permission=Depends(UserPermissionChecker('dataset_
 
 
 @router.post('/twitter/add')
-async def add_tweet(tweet: TwitterItemModel,
+async def add_tweet(tweet: TwitterItemModel, import_id: str | None = None,
                     permission=Depends(UserPermissionChecker('dataset_edit'))):
-    return await create_twitter_item(tweet=tweet, project_id=permission.permissions.project_id, engine=db_engine)
+    return await import_tweet(tweet=tweet, project_id=permission.permissions.project_id,
+                              import_id=import_id, engine=db_engine)