added assay, analysis mutations

Author: nevoodoo

api/graphql/mutations/__init__.py

@@ -1,5 +1,8 @@
 import strawberry
 
+from api.graphql.mutations.analysis import AnalysisMutations
+from api.graphql.mutations.analysis_runner import AnalysisRunnerMutations
+from api.graphql.mutations.assay import AssayMutations
 from api.graphql.mutations.family import FamilyMutations
 from api.graphql.mutations.participant import ParticipantMutations
 from api.graphql.mutations.project import ProjectMutations
@@ -40,3 +43,21 @@ def sample(self) -> SampleMutations:
     def sequencing_groups(self) -> SequencingGroupsMutations:
         """Sequencing group mutations"""
         return SequencingGroupsMutations()
+
+    # Analysis
+    @strawberry.field
+    def analysis(self) -> AnalysisMutations:
+        """Analysis mutations"""
+        return AnalysisMutations()
+
+    # Assay
+    @strawberry.field
+    def assay(self) -> AssayMutations:
+        """Assay mutations"""
+        return AssayMutations()
+
+    # Analysis Runner
+    @strawberry.field
+    def analysis_runner(self) -> AnalysisRunnerMutations:
+        """Analysis Runner mutations"""
+        return AnalysisRunnerMutations()

api/graphql/mutations/analysis.py

@@ -0,0 +1,54 @@
+import strawberry
+from strawberry.types import Info
+
+from api.graphql.types import AnalysisInput, AnalysisUpdateInput
+from db.python.layers.analysis import AnalysisLayer
+from models.models.analysis import AnalysisInternal
+
+
+@strawberry.type
+class AnalysisMutations:
+    """Analysis mutations"""
+
+    @strawberry.mutation
+    async def create_analysis(
+        self,
+        analysis: AnalysisInput,
+        info: Info,
+    ) -> int:
+        """Create a new analysis"""
+        # TODO: Reconfigure connection permissions as per `routes`
+        connection = info.context['connection']
+        atable = AnalysisLayer(connection)
+
+        if analysis.author:
+            # special tracking here, if we can't catch it through the header
+            connection.on_behalf_of = analysis.author
+
+        if not analysis.sequencing_group_ids and not analysis.cohort_ids:
+            raise ValueError('Must specify "sequencing_group_ids" or "cohort_ids"')
+
+        analysis_id = await atable.create_analysis(
+            AnalysisInternal.from_dict(strawberry.asdict(analysis)),
+        )
+
+        return analysis_id
+
+    @strawberry.mutation
+    async def update_analysis(
+        self,
+        analysis_id: int,
+        analysis: AnalysisUpdateInput,
+        info: Info,
+    ) -> bool:
+        """Update status of analysis"""
+        # TODO: Reconfigure connection permissions as per `routes`
+        connection = info.context['connection']
+        atable = AnalysisLayer(connection)
+        await atable.update_analysis(
+            analysis_id,
+            status=analysis.status,
+            output=analysis.output,
+            meta=analysis.meta,
+        )
+        return True

api/graphql/mutations/analysis_runner.py

@@ -0,0 +1,65 @@
+import datetime
+
+import strawberry
+from strawberry.types import Info
+
+from db.python.layers.analysis_runner import AnalysisRunnerLayer
+from models.models.analysis_runner import AnalysisRunnerInternal
+
+
+@strawberry.type
+class AnalysisRunnerMutations:
+    """Analysis Runner mutations"""
+
+    @strawberry.mutation
+    async def create_analysis_runner_log(  # pylint: disable=too-many-arguments
+        self,
+        ar_guid: str,
+        access_level: str,
+        repository: str,
+        commit: str,
+        script: str,
+        description: str,
+        driver_image: str,
+        config_path: str,
+        environment: str,
+        batch_url: str,
+        submitting_user: str,
+        meta: strawberry.scalars.JSON,
+        output_path: str,
+        hail_version: str | None,
+        cwd: str | None,
+        info: Info,
+    ) -> str:
+        """Create a new analysis runner log"""
+        # TODO Reconfigure connection permissions as per `routes`
+        connection = info.context['connection']
+        alayer = AnalysisRunnerLayer(connection)
+
+        if not connection.project:
+            raise ValueError('Project not set')
+
+        analysis_id = await alayer.insert_analysis_runner_entry(
+            AnalysisRunnerInternal(
+                ar_guid=ar_guid,
+                timestamp=datetime.datetime.now(),
+                access_level=access_level,
+                repository=repository,
+                commit=commit,
+                script=script,
+                description=description,
+                driver_image=driver_image,
+                config_path=config_path,
+                cwd=cwd,
+                environment=environment,
+                hail_version=hail_version,
+                batch_url=batch_url,
+                submitting_user=submitting_user,
+                meta=meta,
+                project=connection.project,
+                audit_log_id=None,
+                output_path=output_path,
+            )
+        )
+
+        return analysis_id

api/graphql/mutations/assay.py

@@ -0,0 +1,44 @@
+import strawberry
+from strawberry.types import Info
+
+from api.graphql.types import AssayUpsertInput, AssayUpsertType
+from db.python.layers.assay import AssayLayer
+from models.models.assay import AssayUpsertInternal
+
+
+@strawberry.type
+class AssayMutations:
+    """Assay mutations"""
+
+    @strawberry.mutation
+    async def create_assay(
+        self, assay: AssayUpsertInput, info: Info
+    ) -> AssayUpsertType:
+        """Create new assay, attached to a sample"""
+        # TODO: Reconfigure connection permissions as per `routes`
+        connection = info.context['connection']
+        seq_table = AssayLayer(connection)
+        return AssayUpsertType.from_upsert_internal(
+            await seq_table.upsert_assay(
+                AssayUpsertInternal.from_dict(strawberry.asdict(assay))
+            )
+        )
+
+    @strawberry.mutation
+    async def update_assay(
+        self,
+        assay: AssayUpsertInput,
+        info: Info,
+    ) -> int:
+        """Update assay for ID"""
+        # TODO: Reconfigure connection permissions as per `routes`
+
+        if not assay.id:
+            raise ValueError('Assay must have an ID to update')
+        connection = info.context['connection']
+        assay_layer = AssayLayer(connection)
+        await assay_layer.upsert_assay(
+            AssayUpsertInternal.from_dict(strawberry.asdict(assay))
+        )
+
+        return assay.id

api/graphql/types/__init__.py

@@ -2,6 +2,7 @@
 
 import strawberry
 
+from models.enums.analysis import AnalysisStatus
 from models.models.assay import AssayUpsert, AssayUpsertInternal
 from models.models.cohort import NewCohortInternal
 from models.models.participant import ParticipantUpsertInternal
@@ -24,8 +25,37 @@
     parse_value=lambda v: v,
 )
 
+AnalysisStatusType = strawberry.enum(AnalysisStatus)
 
-@strawberry.experimental.pydantic.input(model=AssayUpsert)  # type: ignore [misc]
+
+@strawberry.input
+class AnalysisInput:
+    """Analysis input"""
+
+    type: str
+    status: AnalysisStatusType
+    id: int | None
+    output: str | None
+    sequencing_group_ids: list[str] | None
+    cohort_ids: list[str] | None
+    author: str | None
+    timestamp_completed: str | None
+    project: int | None
+    active: bool | None
+    meta: strawberry.scalars.JSON
+
+
+@strawberry.input
+class AnalysisUpdateInput:
+    """Analysis update input"""
+
+    status: AnalysisStatusType
+    output: str | None
+    meta: strawberry.scalars.JSON | None
+    active: bool | None
+
+
+@strawberry.input  # type: ignore [misc]
 class AssayUpsertInput:
     """Assay upsert input"""