feat(medcat-trainer): improved / fixed demo screen (#293)

* feat(medcat-trainer):  improved demo screen, model pack selection, new clinical text component, improved demo filtering concept picker

* fix(medcat-trainer): CU-8699ryke4: test type fixes

* fix(medcat-trainer): pr review changes

* fix(medcat-trainer): address auto feedback

---------

Co-authored-by: Tom Searle <tom@cogstack.org>

Author: tomolopolis

medcat-trainer/webapp/api/api/model_cache.py

@@ -11,7 +11,7 @@
 from medcat.vocab import Vocab
 from medcat.utils.legacy.convert_cdb import get_cdb_from_old
 
-from api.models import ConceptDB
+from api.models import ConceptDB, ModelPack
 
 """
 Module level caches for CDBs, Vocabs and CAT instances.
@@ -163,6 +163,22 @@ def get_medcat_from_model_pack(project, cat_map: Dict[str, CAT]=CAT_MAP) -> CAT:
     return cat
 
 
+def get_medcat_from_model_pack_id(modelpack_id: int, cat_map: Dict[str, CAT]=CAT_MAP) -> CAT:
+    """
+    Load (and cache) a MedCAT model pack directly from a ModelPack id.
+    """
+    cat_id = f'mp{modelpack_id}'
+    if cat_id in cat_map:
+        return cat_map[cat_id]
+
+    model_pack_obj = ModelPack.objects.get(id=modelpack_id)
+    logger.info('Loading model pack from:%s', model_pack_obj.model_pack.path)
+    cat = CAT.load_model_pack(model_pack_obj.model_pack.path)
+    cat_map[cat_id] = cat
+    _clear_models(cat_map=cat_map)
+    return cat
+
+
 def get_medcat(project,
                cdb_map: Dict[str, CDB]=CDB_MAP,
                vocab_map: Dict[str, Vocab]=VOCAB_MAP,
@@ -204,6 +220,16 @@ def clear_cached_medcat(project, cat_map: Dict[str, CAT]=CAT_MAP):
         del cat_map[cat_id]
 
 
+def is_model_pack_loaded(modelpack_id: int, cat_map: Dict[str, CAT]=CAT_MAP) -> bool:
+    return f'mp{modelpack_id}' in cat_map
+
+
+def clear_cached_medcat_by_model_pack_id(modelpack_id: int, cat_map: Dict[str, CAT]=CAT_MAP) -> None:
+    cat_id = f'mp{modelpack_id}'
+    if cat_id in cat_map:
+        del cat_map[cat_id]
+
+
 def get_cached_cdb(cdb_id: str, cdb_map: Dict[str, CDB]=CDB_MAP) -> CDB:
     from api.utils import clear_cdb_cnf_addons
     if cdb_id not in cdb_map:

medcat-trainer/webapp/api/api/views.py

@@ -24,7 +24,7 @@
     import_concepts_from_cdb
 from .data_utils import upload_projects_export
 from .metrics import calculate_metrics
-from .model_cache import get_medcat, get_cached_cdb, VOCAB_MAP, clear_cached_medcat, CAT_MAP, CDB_MAP, is_model_loaded
+from .model_cache import get_medcat, get_medcat_from_model_pack_id, get_cached_cdb, VOCAB_MAP, clear_cached_medcat, clear_cached_medcat_by_model_pack_id, is_model_pack_loaded, CAT_MAP, CDB_MAP, is_model_loaded
 from .permissions import *
 from .serializers import *
 from .solr_utils import collections_available, search_collection, ensure_concept_searchable
@@ -637,32 +637,87 @@ def update_meta_annotation(request):
 
 @api_view(http_method_names=['POST'])
 def annotate_text(request):
-    p_id = request.data['project_id']
-    message = request.data['message']
-    cuis = request.data['cuis']
-    if message is None or p_id is None:
-        return HttpResponseBadRequest('No message to annotate')
+    message = request.data.get('message')
+    cuis = request.data.get('cuis', [])
+    p_id = request.data.get('project_id')
+    modelpack_id = request.data.get('modelpack_id')
+    include_sub_concepts = request.data.get('include_sub_concepts', False)
 
-    project = ProjectAnnotateEntities.objects.get(id=p_id)
+    if message is None or (p_id is None and modelpack_id is None):
+        return HttpResponseBadRequest('No message to annotate')
 
-    cat = get_medcat(project=project)
-    cat.config.components.linking.filters.cuis = set(cuis)
+    if modelpack_id is not None:
+        try:
+            cat = get_medcat_from_model_pack_id(int(modelpack_id))
+        except (ValueError, TypeError):
+            logger.warning(f'Invalid modelpack_id received for project:{p_id}')
+            return HttpResponseBadRequest('Invalid modelpack_id for project')
+        except ModelPack.DoesNotExist:
+            logger.warning(f'ModelPack does not exist received for project:{p_id}')
+            return HttpResponseBadRequest('ModelPack does not exist for project')
+    else:
+        project = ProjectAnnotateEntities.objects.get(id=p_id)
+        cat = get_medcat(project=project)
+
+    # Normalise cuis to a set[str]
+    if isinstance(cuis, str):
+        cuis_set = {c.strip() for c in cuis.split(',') if c.strip()}
+    elif isinstance(cuis, (list, tuple, set)):
+        cuis_set = {str(c).strip() for c in cuis if str(c).strip()}
+    else:
+        cuis_set = set()
+
+    # Expand CUIs to include sub-concepts if requested
+    if include_sub_concepts and cuis_set and cat.cdb:
+        expanded_cuis = set(cuis_set)
+        for parent_cui in cuis_set:
+            try:
+                child_cuis = get_all_ch(parent_cui, cat.cdb)
+                expanded_cuis.update(child_cuis)
+            except Exception as e:
+                logger.warning(f'Failed to get children for CUI {parent_cui}: {e}')
+        cuis_set = expanded_cuis
+
+    curr_cuis = cat.config.components.linking.filters
+    cat.config.components.linking.filters.cuis = cuis_set
     spacy_doc = cat(message)
+    cat.config.components.linking.filters = curr_cuis
 
     ents = []
     anno_tkns = []
     for ent in spacy_doc.linked_ents:
         cnt = Entity.objects.filter(label=ent.cui).count()
         inc_ent = all(tkn not in anno_tkns for tkn in ent)
         if inc_ent and cnt != 0:
+            meta_annotations = []
+            if 'meta_cat_meta_anns' in ent.get_available_addon_paths():
+                meta_anns = ent.get_addon_data('meta_cat_meta_anns')
+                for meta_ann_task, pred in meta_anns.items():
+                    # Extract value and confidence from pred
+                    # pred can be a dict, object, or string
+                    if isinstance(pred, dict):
+                        pred_value = pred.get('value', str(pred))
+                        pred_confidence = pred.get('confidence', None)
+                    elif hasattr(pred, 'value'):
+                        pred_value = pred.value
+                        pred_confidence = getattr(pred, 'confidence', None)
+                    else:
+                        pred_value = str(pred)
+                        pred_confidence = None
+                    meta_annotations.append({
+                        'task': meta_ann_task,
+                        'value': pred_value,
+                        'confidence': pred_confidence
+                    })
             anno_tkns.extend([tkn for tkn in ent])
             entity = Entity.objects.get(label=ent.cui)
             ents.append({
                 'entity': entity.id,
                 'value': ent.base.text,
                 'start_ind': ent.base.start_char_index,
                 'end_ind': ent.base.end_char_index,
-                'acc': ent.context_similarity
+                'acc': ent.context_similarity,
+                'meta_annotations': meta_annotations
             })
 
     ents.sort(key=lambda e: e['start_ind'])
@@ -752,7 +807,7 @@ def upload_deployment(request):
 
 
 @api_view(http_method_names=['GET', 'DELETE'])
-def cache_model(request, project_id):
+def cache_project_model(request, project_id):
     try:
         project = ProjectAnnotateEntities.objects.get(id=project_id)
         is_loaded = is_model_loaded(project)
@@ -772,6 +827,24 @@ def cache_model(request, project_id):
         return Response({'message': f'{str(e)}'}, 500)
 
 
+@api_view(http_method_names=['GET', 'DELETE'])
+def cache_modelpack(request, modelpack_id: int):
+    try:
+        if request.method == 'GET':
+            if not is_model_pack_loaded(modelpack_id):
+                get_medcat_from_model_pack_id(modelpack_id)
+            return Response('success', 200)
+        elif request.method == 'DELETE':
+            clear_cached_medcat_by_model_pack_id(modelpack_id)
+            return Response('success', 200)
+        else:
+            return Response(f'Invalid method', 404)
+    except ModelPack.DoesNotExist:
+        return Response(f'ModelPack with id:{modelpack_id} does not exist', 404)
+    except Exception as e:
+        return Response({'message': f'{str(e)}'}, 500)
+
+
 
 @api_view(http_method_names=['GET'])
 def model_loaded(_):

medcat-trainer/webapp/api/core/urls.py

@@ -50,7 +50,8 @@
     path('api/project-progress/', api.views.project_progress),
     path('api/concept-db-search-index-created/', api.views.concept_search_index_available),
     path('api/model-loaded/', api.views.model_loaded),
-    path('api/cache-model/<int:project_id>/', api.views.cache_model),
+    path('api/cache-project-model/<int:project_id>/', api.views.cache_project_model),
+    path('api/cache-modelpack/<int:modelpack_id>/', api.views.cache_modelpack),
     path('api/upload-deployment/', api.views.upload_deployment),
     path('api/model-concept-children/<int:cdb_id>/', api.views.cdb_cui_children),
     path('api/metrics/<int:report_id>/', api.views.view_metrics),

medcat-trainer/webapp/frontend/env.d.ts

@@ -1 +1,7 @@
 /// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue'
+  const component: DefineComponent<object, object, any>
+  export default component
+}

medcat-trainer/webapp/frontend/src/components/anns/AddAnnotation.vue

@@ -133,6 +133,7 @@ export default {
         this.loading = false
         this.errorMessage = err.response.data.message || 'Error loading model.'
       })
+
     },
     cancel () {
       this.$emit('request:addAnnotationComplete')