output default annotation

Author: adelavega

autonima/coordinates/nimads_models.py

@@ -10,6 +10,13 @@ class PointValue:
     """Represents a value associated with a coordinate point."""
     kind: Optional[str] = None
     value: Optional[Union[float, str]] = None
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "kind": self.kind,
+            "value": self.value
+        }
 
 
 @dataclass
@@ -21,6 +28,51 @@ class Point:
     label_id: Optional[str] = None
     values: List[PointValue] = field(default_factory=list)
     analysis_id: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "coordinates": self.coordinates,
+            "space": self.space,
+            "kind": self.kind,
+            "label_id": self.label_id,
+            "values": [value.to_dict() for value in self.values],
+            "analysis_id": self.analysis_id
+        }
+
+
+@dataclass
+class Condition:
+    """A representative term for a psychological, pharmacological, medical, or physical state."""
+    name: Optional[str] = None
+    description: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "name": self.name,
+            "description": self.description
+        }
+
+
+@dataclass
+class Image:
+    """Statistical image (e.g., beta, t-statistic, and/or z-statistic image)."""
+    id: Optional[str] = None
+    filename: Optional[str] = None
+    space: Optional[str] = None
+    kind: Optional[str] = None
+    analysis_id: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "id": self.id,
+            "filename": self.filename,
+            "space": self.space,
+            "kind": self.kind,
+            "analysis_id": self.analysis_id
+        }
 
 
 @dataclass
@@ -30,8 +82,23 @@ class NimadsAnalysis:
     name: Optional[str] = None
     description: Optional[str] = None
     weights: List[float] = field(default_factory=list)
+    conditions: List[Condition] = field(default_factory=list)
+    images: List[Image] = field(default_factory=list)
     points: List[Point] = field(default_factory=list)
     study_id: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "weights": self.weights,
+            "conditions": [condition.to_dict() for condition in self.conditions],
+            "images": [image.to_dict() for image in self.images],
+            "points": [point.to_dict() for point in self.points],
+            "study_id": self.study_id
+        }
 
 
 @dataclass
@@ -47,6 +114,21 @@ class Study:
     authors: Optional[str] = None
     year: Optional[int] = None
     analyses: List[NimadsAnalysis] = field(default_factory=list)
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "id": self.id,
+            "doi": self.doi,
+            "name": self.name,
+            "metadata": self.metadata,
+            "description": self.description,
+            "publication": self.publication,
+            "pmid": self.pmid,
+            "authors": self.authors,
+            "year": self.year,
+            "analyses": [analysis.to_dict() for analysis in self.analyses]
+        }
 
 
 @dataclass
@@ -59,6 +141,18 @@ class Studyset:
     doi: Optional[str] = None
     pmid: Optional[str] = None
     studies: List[Study] = field(default_factory=list)
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "publication": self.publication,
+            "doi": self.doi,
+            "pmid": self.pmid,
+            "studies": [study.to_dict() for study in self.studies]
+        }
 
 
 def convert_to_nimads_point(analysis_id: str, point: CoordinatePoint) -> Point:
@@ -131,6 +225,46 @@ def convert_to_nimads_study(study_id: str, autonima_study: 'autonima.models.type
     return nimads_study
 
 
+@dataclass
+class NoteCollection:
+    """The storage object for all notes within an annotation for a single analysis."""
+    note: Optional[dict] = None
+    analysis_id: Optional[str] = None
+    annotation_id: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "note": self.note,
+            "analysis": self.analysis_id,
+            "annotation": self.annotation_id
+        }
+
+
+@dataclass
+class Annotation:
+    """An annotation describes each analysis within a studyset with typically subjective information."""
+    id: str
+    name: Optional[str] = None
+    description: Optional[str] = None
+    metadata: Optional[dict] = None
+    note_keys: Optional[dict] = None
+    studyset_id: Optional[str] = None
+    notes: List[NoteCollection] = field(default_factory=list)
+    
+    def to_dict(self) -> dict:
+        """Convert to dictionary representation."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "description": self.description,
+            "metadata": self.metadata,
+            "note_keys": self.note_keys,
+            "studyset": self.studyset_id,
+            "notes": [note.to_dict() for note in self.notes]
+        }
+
+
 def convert_to_nimads_studyset(studyset_id: str, studies: List['autonima.models.types.Study'], name: Optional[str] = None) -> Studyset:
     """Convert a list of autonima studies to a NiMADS studyset."""
     studyset = Studyset(
@@ -144,4 +278,28 @@ def convert_to_nimads_studyset(studyset_id: str, studies: List['autonima.models.
         nimads_study = convert_to_nimads_study(study_id, study)
         studyset.studies.append(nimads_study)
 
-    return studyset
+    return studyset
+
+
+def create_default_annotation(studyset_id: str, studyset: Studyset) -> Annotation:
+    """Create a default annotation with include=True for all analyses in the studyset."""
+    annotation_id = f"annotation_{studyset_id}"
+    annotation = Annotation(
+        id=annotation_id,
+        name="replication_annotations",
+        description="",
+        note_keys={"include": "boolean"},
+        studyset_id=studyset_id
+    )
+    
+    # Create notes for each analysis
+    for study in studyset.studies:
+        for analysis in study.analyses:
+            note = NoteCollection(
+                note={"include": True},
+                analysis_id=analysis.id,
+                annotation_id=annotation_id
+            )
+            annotation.notes.append(note)
+    
+    return annotation

autonima/pipeline.py

@@ -2,6 +2,7 @@
 
 import logging
 import csv
+import json
 from datetime import datetime
 from pathlib import Path
 from typing import Dict, Any
@@ -16,6 +17,7 @@
 from .screening import LLMScreener
 from .retrieval import PubGetRetriever
 from .utils import log_error_with_debug
+from .coordinates.nimads_models import convert_to_nimads_studyset
 
 logger = logging.getLogger(__name__)
 
@@ -705,8 +707,7 @@ async def _generate_nimads_output(self):
 
         try:
             # Import NiMADS models
-            from .coordinates.nimads_models import convert_to_nimads_studyset
-            import json
+            from .coordinates.nimads_models import convert_to_nimads_studyset, create_default_annotation
 
             # Create a studyset from the included studies
             studyset_id = f"autonima_studyset_{self.results.started_at.strftime('%Y%m%d_%H%M%S')}"
@@ -716,63 +717,19 @@ async def _generate_nimads_output(self):
                 name="Autonima Generated Studyset"
             )
 
-            # Convert to dictionary for JSON serialization
-            def studyset_to_dict(studyset):
-                return {
-                    "id": studyset.id,
-                    "name": studyset.name,
-                    "description": studyset.description,
-                    "publication": studyset.publication,
-                    "doi": studyset.doi,
-                    "pmid": studyset.pmid,
-                    "studies": [study_to_dict(study) for study in studyset.studies]
-                }
-            
-            def study_to_dict(study):
-                return {
-                    "id": study.id,
-                    "doi": study.doi,
-                    "name": study.name,
-                    "metadata": study.metadata,
-                    "description": study.description,
-                    "publication": study.publication,
-                    "pmid": study.pmid,
-                    "authors": study.authors,
-                    "year": study.year,
-                    "analyses": [analysis_to_dict(analysis) for analysis in study.analyses]
-                }
-            
-            def analysis_to_dict(analysis):
-                return {
-                    "id": analysis.id,
-                    "name": analysis.name,
-                    "description": analysis.description,
-                    "weights": analysis.weights,
-                    "points": [point_to_dict(point) for point in analysis.points],
-                    "study_id": analysis.study_id
-                }
-            
-            def point_to_dict(point):
-                return {
-                    "coordinates": point.coordinates,
-                    "space": point.space,
-                    "kind": point.kind,
-                    "label_id": point.label_id,
-                    "values": [point_value_to_dict(value) for value in point.values],
-                    "analysis_id": point.analysis_id
-                }
+            # Create a default annotation
+            annotation = create_default_annotation(studyset_id, studyset)
 
-            def point_value_to_dict(point_value):
-                return {
-                    "kind": point_value.kind,
-                    "value": point_value.value
-                }
-            
-            # Save NiMADS output
+            # Save NiMADS studyset output using the to_dict method
             output_dir = Path(self.config.output.directory)
-            nimads_output_file = output_dir / "outputs" / "nimads_output.json"
+            nimads_output_file = output_dir / "outputs" / "nimads_studyset.json"
             with open(nimads_output_file, 'w') as f:
-                json.dump(studyset_to_dict(studyset), f, indent=2)
+                json.dump(studyset.to_dict(), f, indent=2)
+            
+            # Save NiMADS annotation output using the to_dict method
+            nimads_annotation_file = output_dir / "outputs" / "nimads_annotation.json"
+            with open(nimads_annotation_file, 'w') as f:
+                json.dump(annotation.to_dict(), f, indent=2)
 
             logger.info(
                 f"NiMADS output generated: {len(included_studies_with_analyses)} studies "