[ENH] add conditions and weights to specification (#597)

* add studyset-references endpoint

* allow version to be none

* update how specification is updated

* handle boolean inputs

* update openapi

* update openapi

Author: jdkent

compose/neurosynth-frontend/src/neurosynth-compose-typescript-sdk

@@ -16,6 +16,8 @@
 from .auth import User
 
 __all__ = [
+    "Condition",
+    "SpecificationCondition",
     "Specification",
     "Studyset",
     "StudysetReference",

compose/neurosynth_compose/models/__init__.py

@@ -1,6 +1,7 @@
 """TODO: PLACE INTO THE NEUROSYNTH APP"""
 from sqlalchemy.orm import relationship, backref
 from sqlalchemy.sql import func
+from sqlalchemy.ext.associationproxy import association_proxy
 import shortuuid
 import secrets
 
@@ -31,16 +32,35 @@ class BaseMixin(object):
     #     relationship("User", backref=cls.__tablename__, uselist=False)
 
 
+class Condition(BaseMixin, db.Model):
+    __tablename__ = "conditions"
+    name = db.Column(db.Text)
+    description = db.Column(db.Text)
+
+
+class SpecificationCondition(BaseMixin, db.Model):
+    __tablename__ = "specification_conditions"
+    weight = db.Column(db.Float)
+    specification_id = db.Column(
+        db.Text, db.ForeignKey("specifications.id"), index=True, primary_key=True
+    )
+    condition_id = db.Column(
+        db.Text, db.ForeignKey("conditions.id"), index=True, primary_key=True
+    )
+    condition = relationship("Condition", backref=backref("specification_conditions"))
+    specification = relationship("Specification", backref=backref("specification_conditions"))
+
+
 class Specification(BaseMixin, db.Model):
     __tablename__ = "specifications"
 
     type = db.Column(db.Text)
     estimator = db.Column(db.JSON)
     filter = db.Column(db.Text)
-    contrast = db.Column(db.JSON)
+    weights = association_proxy("specification_conditions", "weight")
+    conditions = association_proxy("specification_conditions", "condition")
     corrector = db.Column(db.JSON)
     user_id = db.Column(db.Text, db.ForeignKey("users.external_id"))
-
     user = relationship("User", backref=backref("specifications"))
 
 

compose/neurosynth_compose/models/analysis.py

@@ -1,4 +1,6 @@
 from .analysis import (
+    ConditionsResource,
+    SpecificationConditionsResource,
     MetaAnalysesView,
     MetaAnalysisResultsView,
     NeurovaultCollectionsView,
@@ -15,6 +17,8 @@
 from .users import UsersView
 
 __all__ = [
+    "ConditionsResource",
+    "SpecificationConditionsResource",
     "MetaAnalysesView",
     "MetaAnalysisResultsView",
     "NeurovaultCollectionsView",

compose/neurosynth_compose/openapi

@@ -1,4 +1,7 @@
+
+from collections import ChainMap
 import pathlib
+from operator import itemgetter
 
 import connexion
 from flask import abort, request, jsonify, current_app
@@ -13,6 +16,8 @@
 
 from ..database import db
 from ..models.analysis import (  # noqa E401
+    Condition,
+    SpecificationCondition,
     Studyset,
     Annotation,
     MetaAnalysis,
@@ -29,6 +34,8 @@
 from ..models.auth import User
 
 from ..schemas import (  # noqa E401
+    ConditionSchema,
+    SpecificationConditionSchema,
     MetaAnalysisSchema,
     AnnotationSchema,
     StudysetSchema,
@@ -87,6 +94,7 @@ class ClassView(cls):
 class BaseView(MethodView):
     _model = None
     _nested = {}
+    _attribute_name = None
 
     @classmethod
     def _external_request(cls, data, record, id):
@@ -110,6 +118,8 @@ def update_or_create(cls, data, id=None, commit=True):
 
         only_ids = set(data.keys()) - set(["id"]) == set()
 
+        if cls._model is Condition:
+            record = cls._model.query.filter_by(name=data.get('name')).first() or cls._model()
         if id is None:
             record = cls._model()
             record.user = current_user
@@ -137,29 +147,44 @@ def update_or_create(cls, data, id=None, commit=True):
         # check if external request updated the data already
         committed = cls._external_request(data, record, id)
 
+        # get nested attributes
+        nested_keys = [
+            item for key in cls._nested.keys()
+            for item in (key if isinstance(key, tuple) else (key,))
+        ]
+
         # Update all non-nested attributes
         if not committed:
             for k, v in data.items():
-                if k not in cls._nested and k not in ["id", "user"]:
+                if k not in nested_keys and k not in ["id", "user"]:
                     setattr(record, k, v)
 
             to_commit.append(record)
 
         # Update nested attributes recursively
         for field, res_name in cls._nested.items():
+            field = (field,) if not isinstance(field, tuple) else field
+            try:
+                rec_data = itemgetter(*field)(data)
+            except KeyError:
+                rec_data = None
+
             ResCls = globals()[res_name]
-            if data.get(field) is not None:
-                if isinstance(data.get(field), list):
+            if rec_data is not None:
+                if isinstance(rec_data, tuple):
+                    rec_data = [dict(ChainMap(*rc)) for rc in zip(*rec_data)]
+                if isinstance(rec_data, list):
                     nested = [
                         ResCls.update_or_create(rec, commit=False)
-                        for rec in data.get(field)
+                        for rec in rec_data
                     ]
                     to_commit.extend(nested)
                 else:
-                    nested = ResCls.update_or_create(data.get(field), commit=False)
+                    nested = ResCls.update_or_create(rec_data, commit=False)
                     to_commit.append(nested)
-
-                setattr(record, field, nested)
+                update_field = field if len(field) == 1 else (cls._attribute_name,)
+                for f in update_field:
+                    setattr(record, f, nested)
 
         if commit:
             db.session.add_all(to_commit)
@@ -374,7 +399,10 @@ class StudysetsView(ObjectView, ListView):
 
 @view_maker
 class SpecificationsView(ObjectView, ListView):
-    pass
+    _nested = {
+        ("conditions", "weights"): "SpecificationConditionsResource",
+    }
+    _attribute_name = "specification_conditions"
 
 
 @view_maker
@@ -387,6 +415,16 @@ class AnnotationReferencesResource(ObjectView):
     pass
 
 
+@view_maker
+class ConditionsResource(ObjectView):
+    pass
+
+
+@view_maker
+class SpecificationConditionsResource(ObjectView):
+    _nested = {"condition": "ConditionsResource"}
+
+
 @view_maker
 class MetaAnalysisResultsView(ObjectView, ListView):
     _nested = {

compose/neurosynth_compose/resources/__init__.py

@@ -1,4 +1,6 @@
 from .analysis import (
+    ConditionSchema,
+    SpecificationConditionSchema,
     MetaAnalysisSchema,
     MetaAnalysisResultSchema,
     NeurovaultCollectionSchema,
@@ -17,6 +19,8 @@
 
 
 __all__ = [
+    "ConditionSchema",
+    "SpecificationConditionSchema",
     "MetaAnalysisSchema",
     "MetaAnalysisResultSchema",
     "ResultInitSchema",

compose/neurosynth_compose/resources/analysis.py

@@ -1,4 +1,4 @@
-from marshmallow import fields, Schema, utils, post_load, post_dump
+from marshmallow import fields, Schema, utils, post_load, post_dump, pre_load
 
 
 # neurovault api base URL
@@ -122,6 +122,22 @@ class BaseSchema(Schema):
     username = fields.String(attribute="user.name", dump_only=True)
 
 
+class ConditionSchema(Schema):
+    id = PGSQLString()
+    created_at = fields.DateTime()
+    updated_at = fields.DateTime(allow_none=True)
+    name = PGSQLString()
+    description = PGSQLString()
+
+
+class SpecificationConditionSchema(Schema):
+    id = PGSQLString()
+    created_at = fields.DateTime()
+    updated_at = fields.DateTime(allow_none=True)
+    condition = fields.Pluck(ConditionSchema, "name")
+    weight = fields.Number()
+
+
 class EstimatorSchema(Schema):
     type = fields.String()
     args = fields.Dict()
@@ -152,11 +168,69 @@ class SpecificationSchema(BaseSchema):
     contrast = PGSQLString(allow_none=True)
     filter = PGSQLString(allow_none=True)
     corrector = fields.Dict(allow_none=True)
+    _conditions = fields.Pluck(
+        SpecificationConditionSchema,
+        "condition",
+        many=True,
+        allow_none=True,
+        load_only=True,
+        attribute="conditions",
+        data_key="conditions",
+    )
+    conditions = fields.Pluck(
+        ConditionSchema,
+        "name",
+        many=True,
+        allow_none=True,
+        dump_only=True
+    )
+    weights = fields.List(
+        fields.Float(),
+        allow_none=True,
+        dump_only=True,
+    )
+    _weights = fields.Pluck(
+        SpecificationConditionSchema,
+        "weight",
+        many=True,
+        allow_none=True,
+        load_only=True,
+        data_key="weights",
+        attribute="weights",
+    )
 
     class Meta:
         additional = ("name", "description")
         allow_none = ("name", "description")
 
+    @post_dump
+    def to_bool(self, data, **kwargs):
+        conditions = data.get("conditions", None)
+        if conditions:
+            output_conditions = conditions[:]
+            for i, cond in enumerate(conditions):
+                if cond.lower() == "true":
+                    output_conditions[i] = True
+                elif cond.lower() == "false":
+                    output_conditions[i] = False
+            data['conditions'] = conditions
+
+        return data
+
+    @pre_load
+    def to_string(self, data, **kwargs):
+        conditions = data.get("conditions", None)
+        if conditions:
+            output_conditions = conditions[:]
+            for i, cond in enumerate(conditions):
+                if cond is True:
+                    output_conditions[i] = 'true'
+                elif cond is False:
+                    output_conditions[i] = 'false'
+            data['conditions'] = output_conditions
+
+        return data
+
 
 class StudysetSchema(BaseSchema):
     snapshot = fields.Dict()

compose/neurosynth_compose/schemas/__init__.py

@@ -1,3 +1,37 @@
+import pytest
+
+
 def test_get_specification(session, app, auth_client, user_data):
     get = auth_client.get("/api/specifications")
     assert get.status_code == 200
+
+
+@pytest.mark.parametrize(
+    "specification_data",
+    [
+        {
+            "estimator": {"type": "ALE"},
+            "type": "cbma",
+            "conditions": ["open", "closed"],
+            "weights": [1, -1],
+            "corrector": {"type": "FDRCorrector"},
+            "filter": "eyes",
+        },
+        {
+            "estimator": {"type": "ALE"},
+            "type": "cbma",
+            "conditions": [True],
+            "weights": [1],
+            "corrector": {"type": "FDRCorrector"},
+            "filter": "eyes",
+        },
+    ]
+)
+def test_create_and_get_spec(session, app, auth_client, user_data, specification_data):
+    create_spec = auth_client.post("/api/specifications", data=specification_data)
+
+    assert create_spec.status_code == 200
+
+    view_spec = auth_client.get(f"/api/specifications/{create_spec.json['id']}")
+
+    assert create_spec.json == view_spec.json