[ENH] add ability to update study upon cloning (#682)

* add ability to update study upon cloning

* update function signatures

Author: jdkent

store/neurostore/resources/base.py

@@ -529,13 +529,15 @@ def post(self):
         args = parser.parse(self._user_args, request, location="query")
         source_id = args.get("source_id")
         source = args.get("source") or "neurostore"
+
+        unknown = self.__class__._schema.opts.unknown
+        data = parser.parse(
+            self.__class__._schema(exclude=("id",)), request, unknown=unknown
+        )
+
         if source_id:
-            data = self._load_from_source(source, source_id)
-        else:
-            unknown = self.__class__._schema.opts.unknown
-            data = parser.parse(
-                self.__class__._schema(exclude=("id",)), request, unknown=unknown
-            )
+            data = self._load_from_source(source, source_id, data)
+
         args["nested"] = bool(args.get("nested") or request.args.get("source_id"))
 
         with db.session.no_autoflush:

store/neurostore/resources/data.py

@@ -53,7 +53,6 @@
     "nested": fields.Boolean(load_default=False),
 }
 
-
 # Individual resource views
 
 
@@ -191,12 +190,12 @@ def insert_data(self, id, data):
         return data
 
     @classmethod
-    def _load_from_source(cls, source, source_id):
+    def _load_from_source(cls, source, source_id, data=None):
         if source == "neurostore":
-            return cls.load_from_neurostore(source_id)
+            return cls.load_from_neurostore(source_id, data)
 
     @classmethod
-    def load_from_neurostore(cls, source_id):
+    def load_from_neurostore(cls, source_id, data=None):
         annotation = cls._model.query.filter_by(id=source_id).first_or_404()
         parent_source_id = annotation.source_id
         parent_source = annotation.source
@@ -418,16 +417,16 @@ def serialize_records(self, records, args, exclude=tuple()):
         return super().serialize_records(records, args, exclude)
 
     @classmethod
-    def _load_from_source(cls, source, source_id):
+    def _load_from_source(cls, source, source_id, data=None):
         if source == "neurostore":
-            return cls.load_from_neurostore(source_id)
+            return cls.load_from_neurostore(source_id, data)
         elif source == "neurovault":
-            return cls.load_from_neurovault(source_id)
+            return cls.load_from_neurovault(source_id, data)
         elif source == "pubmed":
-            return cls.load_from_pubmed(source_id)
+            return cls.load_from_pubmed(source_id, data)
 
     @classmethod
-    def load_from_neurostore(cls, source_id):
+    def load_from_neurostore(cls, source_id, data=None):
         study = cls._model.query.filter_by(id=source_id).first_or_404()
         parent_source_id = study.source_id
         parent_source = study.source
@@ -437,22 +436,26 @@ def load_from_neurostore(cls, source_id):
             parent_source = parent.source
             parent_source_id = parent.source_id
 
-        context = {"clone": True, "nested": True}
-        schema = cls._schema(context=context)
-        dump_study = schema.dump(study)
-        data = schema.load(dump_study)
-        data["source"] = "neurostore"
-        data["source_id"] = source_id
-        data["source_updated_at"] = study.updated_at or study.created_at
-        data["base_study"] = {"id": study.base_study_id}
-        return data
+        update_schema = cls._schema(context={"nested": True})
+        clone_data = update_schema.load(update_schema.dump(study))
+        # update data with new source
+        clone_data.update(data)
+
+        context = {"nested": True, "clone": True}
+        return_schema = cls._schema(context=context)
+        clone_data = return_schema.load(return_schema.dump(clone_data))
+        clone_data["source"] = "neurostore"
+        clone_data["source_id"] = source_id
+        clone_data["source_updated_at"] = study.updated_at or study.created_at
+        clone_data["base_study"] = {"id": study.base_study_id}
+        return clone_data
 
     @classmethod
-    def load_from_neurovault(cls, source_id):
+    def load_from_neurovault(cls, source_id, data=None):
         pass
 
     @classmethod
-    def load_from_pubmed(cls, source_id):
+    def load_from_pubmed(cls, source_id, data=None):
         pass
 
     def pre_nested_record_update(record):

store/neurostore/schemas/data.py

@@ -209,15 +209,16 @@ class PointSchema(BaseDataSchema):
     cluster_size = fields.Float(allow_none=True)
     subpeak = fields.Boolean(allow_none=True)
     order = fields.Integer()
+    coordinates = fields.List(fields.Float(), dump_only=True)
 
     # deserialization
     x = fields.Float(load_only=True)
     y = fields.Float(load_only=True)
     z = fields.Float(load_only=True)
 
     class Meta:
-        additional = ("kind", "space", "coordinates", "image", "label_id")
-        allow_none = ("kind", "space", "coordinates", "image", "label_id")
+        additional = ("kind", "space", "image", "label_id")
+        allow_none = ("kind", "space", "image", "label_id")
 
     @pre_load
     def process_values(self, data, **kwargs):
@@ -227,6 +228,14 @@ def process_values(self, data, **kwargs):
             data["x"], data["y"], data["z"] = coords
         return data
 
+    @pre_dump
+    def pre_dump_process(self, data, **kwargs):
+        if getattr(data, "coordinates", None) or data.get("coordinates"):
+            return data
+        if isinstance(data, dict):
+            data["coordinates"] = [data["x"], data["y"], data["z"]]
+        return data
+
 
 class AnalysisConditionSchema(BaseDataSchema):
     weight = fields.Float()

store/neurostore/tests/api/test_base_studies.py

@@ -58,7 +58,7 @@ def test_info_base_study(auth_client, ingest_neurosynth, session):
     assert single_reg_resp.status_code == 200
     info_fields = ["has_coordinates", "has_images", "studysets"]
     for field in info_fields:
-        assert field in single_info_resp.json()['versions'][0]
+        assert field in single_info_resp.json()["versions"][0]
     assert "id" in single_info_resp.json()["versions"][0]
     assert isinstance(single_reg_resp.json()["versions"][0], str)
 

store/neurostore/tests/api/test_studies.py

@@ -1,6 +1,7 @@
 import pytest
 
 from ...models import Studyset, Study, User, Analysis
+from ...schemas import StudySchema
 
 
 def test_create_study_as_user_and_analysis_as_bot(auth_clients, session):
@@ -111,6 +112,34 @@ def test_clone_studies(auth_client, ingest_neurosynth, session):
     )
 
 
+def test_clone_studies_with_data(auth_client, ingest_neurosynth, session):
+    study_entry = Study.query.first()
+    schema = StudySchema(context={"nested": True})
+    study_data = schema.dump(study_entry)
+    half_points = len(study_data["analyses"][0]["points"]) // 2
+
+    first_analysis_points = study_data["analyses"][0]["points"][0:half_points]
+    second_analysis_points = study_data["analyses"][0]["points"][half_points:]
+    first_analysis_points[0]["coordinates"] = [0, 0, 0]
+    second_analysis_points[0]["coordinates"] = [0, 0, 0]
+    study_data["analyses"][0]["points"] = first_analysis_points
+    study_data["analyses"].append(
+        {"name": "new analysis", "points": second_analysis_points}
+    )
+
+    resp = auth_client.post(
+        f"/api/studies/?source_id={study_entry.id}",
+        data=study_data,
+    )
+    data = resp.json()
+    assert data["name"] == study_entry.name
+    assert data["source_id"] == study_entry.id
+    assert data["source"] == "neurostore"
+    assert data["analyses"][0]["points"][0]["coordinates"] == [0, 0, 0]
+    assert data["analyses"][1]["points"][0]["coordinates"] == [0, 0, 0]
+    assert "new analysis" in [a["name"] for a in data["analyses"]]
+
+
 def test_private_studies(user_data, auth_clients, session):
     from ...resources.users import User