Fix meta-data loaded for Analysis screening

Author: adelavega

autonima.egg-info/PKG-INFO

@@ -88,7 +88,7 @@ Autonima enables end-to-end automation of systematic review steps:
 
 3. **Full-Text Retrieval**
 
-   * Downloads full texts of candidate papers via a combination of **PubGet** and **ACE**.
+   * Downloads full texts of candidate papers via a combination of **PubGet**
 
 4. **Eligibility & Inclusion**
 

autonima.egg-info/SOURCES.txt

@@ -6,7 +6,6 @@ autonima/cli.py
 autonima/config.py
 autonima/meta.py
 autonima/pipeline.py
-autonima/utils.py
 autonima.egg-info/PKG-INFO
 autonima.egg-info/SOURCES.txt
 autonima.egg-info/dependency_links.txt
@@ -29,7 +28,6 @@ autonima/llm/client.py
 autonima/models/__init__.py
 autonima/models/types.py
 autonima/retrieval/__init__.py
-autonima/retrieval/ace.py
 autonima/retrieval/base.py
 autonima/retrieval/pubget.py
 autonima/retrieval/utils.py
@@ -42,10 +40,16 @@ autonima/screening/screener.py
 autonima/search/__init__.py
 autonima/search/base.py
 autonima/search/pubmed.py
+autonima/utils/__init__.py
+autonima/utils/base.py
+autonima/utils/criteria.py
+tests/test_annotation_incremental_caching.py
 tests/test_basic.py
 tests/test_confidence_reporting.py
+tests/test_criteria_mapping.py
 tests/test_fulltext_loading.py
 tests/test_fulltext_screening.py
+tests/test_multi_annotation.py
 tests/test_objective_in_prompt.py
 tests/test_parallel_screening.py
 tests/test_pipeline_retrieval.py

autonima/annotation/client.py

@@ -5,7 +5,7 @@
 from typing import List, Dict, Any
 from pydantic import BaseModel
 from ..llm.client import GenericLLMClient
-from .schema import AnalysisMetadata, AnnotationCriteriaConfig, AnnotationDecision, StudyAnalysisGroup
+from .schema import AnalysisMetadata, AnnotationConfig, AnnotationCriteriaConfig, AnnotationDecision, StudyAnalysisGroup
 
 logger = logging.getLogger(__name__)
 
@@ -122,14 +122,14 @@ def make_multi_decision(
         metadata: AnalysisMetadata,
         criteria_list: List[AnnotationCriteriaConfig],
         model: str = "gpt-4o-mini",
-        prompt_type: str = "multi_analysis_table",
+        prompt_type: str = "single_analysis",
         study_group: StudyAnalysisGroup = None
     ) -> List[AnnotationDecision]:
         """
         Make decisions about whether an analysis should be included in multiple annotations.
         
         Args:
-            metadata: Analysis metadata (used for multi_analysis_table)
+            metadata: Analysis metadata
             criteria_list: List of annotation criteria configurations
             model: LLM model to use
             prompt_type: Type of prompt ("single_analysis" or "multi_analysis")
@@ -142,25 +142,28 @@ def make_multi_decision(
             return []
 
         try:
+            # Extract metadata fields that are actually present in the metadata object
+            # (non-None values, excluding required fields)
+            metadata_fields = []
+            metadata_dict = metadata.model_dump()
+            for field_name, field_value in metadata_dict.items():
+                # Skip required fields and None values
+                if field_name not in ['analysis_id', 'study_id', 'table_id', 'custom_fields'] and field_value is not None:
+                    metadata_fields.append(field_name)
+            
             # Select the appropriate prompt based on prompt_type
             if prompt_type == "multi_analysis":
                 if study_group is None:
                     raise ValueError(
                         "study_group is required for multi_analysis prompt type"
                     )
                 from .prompts import create_study_multi_annotation_prompt
-                metadata_fields = getattr(
-                    criteria_list[0], 'metadata_fields', None
-                )
                 prompt = create_study_multi_annotation_prompt(
                     study_group, criteria_list, metadata_fields
                 )
             else:  # Default to single_analysis
-                from .prompts import create_multi_annotation_prompt
-                metadata_fields = getattr(
-                    criteria_list[0], 'metadata_fields', None
-                )
-                prompt = create_multi_annotation_prompt(
+                from .prompts import create_single_study_annotation_prompt
+                prompt = create_single_study_annotation_prompt(
                     metadata, criteria_list, metadata_fields
                 )
 
@@ -238,22 +241,12 @@ def make_multi_decision(
                             exclusion_criteria_applied=decision_output.exclusion_criteria_applied
                         )
                         decisions.append(decision)
-                
-                # If we didn't get enough responses, fill in with fallback
-                while len(decisions) < len(criteria_list):
-                    criteria = criteria_list[len(decisions)]
-                    decision = self.make_decision(metadata, criteria, model)
-                    decisions.append(decision)
 
             return decisions
 
         except Exception as e:
             logger.error(f"Error making multi annotation decisions: {e}")
-            # Return individual decisions as fallback
-            return [
-                self.make_decision(metadata, criteria, model)
-                for criteria in criteria_list
-            ]
+            raise
 
     def chat_completion(self, messages, model, response_format=None):
         """

autonima/annotation/processor.py

@@ -3,7 +3,7 @@
 import logging
 import json
 from pathlib import Path
-from typing import List, Set
+from typing import List, Set, Optional
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from tqdm import tqdm
 
@@ -252,7 +252,7 @@ def _process_custom_annotations_by_study(self, studies: List[Study], model: str,
             for study, annotations_to_process in tqdm(studies_to_process, desc="Processing studies"):
                 try:
                     study_decisions = self._process_single_study_annotations(
-                        study, annotations_to_process, model
+                        study, self.config.metadata_fields, annotations_to_process, model
                     )
                     decisions.extend(study_decisions)
                 except Exception as e:
@@ -263,7 +263,7 @@ def _process_custom_annotations_by_study(self, studies: List[Study], model: str,
             with ThreadPoolExecutor(max_workers=self.num_workers) as executor:
                 # Submit all studies for processing
                 future_to_study = {
-                    executor.submit(self._process_single_study_annotations, study, annotations_to_process, model): (study, annotations_to_process)
+                    executor.submit(self._process_single_study_annotations, study, self.config.metadata_fields, annotations_to_process, model): (study, annotations_to_process)
                     for study, annotations_to_process in studies_to_process
                 }
 
@@ -279,12 +279,13 @@ def _process_custom_annotations_by_study(self, studies: List[Study], model: str,
 
         return decisions
 
-    def _process_single_study_annotations(self, study: Study, annotations_to_process: List[AnnotationCriteriaConfig], model: str) -> List[AnnotationDecision]:
+    def _process_single_study_annotations(self, study: Study, metadata_fields: List[str], annotations_to_process: List[AnnotationCriteriaConfig], model: str) -> List[AnnotationDecision]:
         """
         Process annotations for a single study.
         
         Args:
             study: Study to process
+            metadata_fields: List of metadata fields to extract
             annotations_to_process: List of annotations to process
             model: LLM model to use
             
@@ -298,8 +299,8 @@ def _process_single_study_annotations(self, study: Study, annotations_to_process
             # Create a unique analysis ID
             analysis_id = f"{study.pmid}_analysis_{i}"
 
-            # Extract metadata for this analysis
-            metadata = self._extract_analysis_metadata(study, analysis, analysis_id)
+            # Extract metadata for the analysis 
+            metadata = self._extract_analysis_metadata(study, analysis, analysis_id, metadata_fields)
 
             # Make multi-annotation decision for this analysis
             analysis_decisions = self.client.make_multi_decision(
@@ -401,42 +402,72 @@ def _process_single_decision(self, metadata: AnalysisMetadata, criteria: Annotat
         """
         return self.client.make_decision(metadata, criteria, model)
 
-    def _extract_analysis_metadata(self, study: Study, analysis: Analysis, analysis_id: str) -> AnalysisMetadata:
+    def _extract_analysis_metadata(
+        self,
+        study: Study,
+        analysis: Analysis,
+        analysis_id: str,
+        metadata_fields: Optional[List[str]] = None
+    ) -> AnalysisMetadata:
         """
         Extract metadata for an analysis from a study.
 
         Args:
             study: Study containing the analysis
             analysis: Analysis to extract metadata for
             analysis_id: Unique ID for the analysis
+            metadata_fields: Optional list of fields to include. If None, includes all fields.
 
         Returns:
-            Analysis metadata
+            Analysis metadata with only the requested fields populated
         """
         # Extract table information if available
+        table_id = None
         table_caption = None
         table_footer = None
         if study.activation_tables:
             # Use the first table's information for now
             # In the future, we might want to associate analyses with specific tables
+            table_id = study.activation_tables[0].table_id
             table_caption = study.activation_tables[0].table_caption
             table_footer = study.activation_tables[0].table_foot
 
+        # If no activation tables exist, generate a default table_id
+        if table_id is None:
+            table_id = f"{study.pmid}_default_table"
+        
+        # Build kwargs with required fields
+        kwargs = {
+            "analysis_id": analysis_id,
+            "study_id": study.pmid,
+            "table_id": table_id,
+        }
+        
+        # Map of field names to their values
+        field_mapping = {
+            "analysis_name": analysis.name,
+            "analysis_description": analysis.description,
+            "table_caption": table_caption,
+            "table_footer": table_footer,
+            "study_title": study.title,
+            "study_abstract": study.abstract,
+            "study_authors": study.authors,
+            "study_journal": study.journal,
+            "study_publication_date": study.publication_date,
+            "study_fulltext": study.full_text,
+        }
+        
+        # If metadata_fields is None, include all fields
+        if metadata_fields is None:
+            kwargs.update(field_mapping)
+        else:
+            # Only include requested fields
+            for field in metadata_fields:
+                if field in field_mapping:
+                    kwargs[field] = field_mapping[field]
+        
         # Create the metadata object
-        metadata = AnalysisMetadata(
-            analysis_id=analysis_id,
-            study_id=study.pmid,
-            analysis_name=analysis.name,
-            analysis_description=analysis.description,
-            table_caption=table_caption,
-            table_footer=table_footer,
-            study_title=study.title,
-            study_abstract=study.abstract,
-            study_authors=study.authors,
-            study_journal=study.journal,
-            study_publication_date=study.publication_date,
-            study_fulltext=study.full_text  # Add full text
-        )
+        metadata = AnalysisMetadata(**kwargs)
 
         return metadata