variantgrid-api 1.9.0__tar.gz → 1.10.0__tar.gz

{variantgrid_api-1.9.0/src/variantgrid_api.egg-info → variantgrid_api-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.9.0
+Version: 1.10.0
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License-Expression: MIT
@@ -90,6 +90,21 @@ api.upload_file("sample.vcf.gz", path=None,
 A bare string names a record by its local reference. Use `ExternalReference(code=..., external_type=...)` to
 name it by a LIMS identifier instead. See `examples/example_tso500.py` for a full run.
 
+Once the sample sheet is registered, link its sequencing samples to their extractions in one call, keyed on
+sample name (what `SequencingSampleLookup.sample_name` holds):
+
+```
+api.link_sequencing_sample_extractions(sample_sheet_lookup, {"sample_1": "2600000001C",
+                                                             "sample_2": "2600000002C"})
+```
+
+It returns a list with one `{"sequencing_sample", "match_status", "match_error", "extraction"}` per sample. An
+extraction the server doesn't have yet is `Pending` for that sample only (HTTP 202) and attaches itself once the
+extraction is created; a sample name that isn't on the sheet is a 400 for the whole batch. On a server from
+before SACGF/variantgrid#2176 (no `link_extractions_bulk` feature) the client makes one
+`link_sequencing_sample_extraction` call per sample instead, so pipelines can use the bulk call unconditionally.
+`link_sequencing_sample_extraction` is still there for a single late link. See `examples/example_haem_20_999.py`.
+
 ## BAMs and CRAMs
 
 A sequencing sample can have several alignment files, eg a BAM and its recalibrated BAM, or a BAM plus a CRAM.
@@ -114,13 +129,15 @@ file as `bam_file`, and a QC's first alignment file as its `bam_file`. A CRAM th
 Servers of different ages accept different calls. The client asks the server which features it has
 (`GET api/v1/capabilities`, fetched once on first use), and each call that needs a newer server
 checks that list first: the patient / specimen / extraction calls, specimen measures,
-`link_sequencing_sample_extraction`, the annotate flow (`poll_upload_status`, `wait_for_annotation`,
-`download_annotated`, `annotate_vcf`), and `upload_file` with `metadata` or `file_type`. A server without the
-capabilities endpoint counts as legacy and reports no features.
+`link_sequencing_sample_extraction` and `link_sequencing_sample_extractions`, the annotate flow
+(`poll_upload_status`, `wait_for_annotation`, `download_annotated`, `annotate_vcf`), and `upload_file` with
+`metadata` or `file_type`. A server without the capabilities endpoint counts as legacy and reports no features.
 
 By default an unsupported call raises `UnsupportedFeatureError`. To run the same code against old and new
-servers, skip those calls instead: they log a warning and return `None`. `upload_file` is the exception: on a
-server without upload metadata it drops the `metadata` and still uploads the file.
+servers, skip those calls instead: they log a warning and return `None`. Two calls downgrade rather than skip
+when the server has the older form of the feature: `upload_file` on a server without upload metadata drops the
+`metadata` and still uploads the file, and `link_sequencing_sample_extractions` on a server with only
+`link_extraction` makes one call per sample.
 
 ```
 from variantgrid_api.api_client import VariantGridAPI, UnsupportedFeaturePolicy
@@ -163,10 +180,10 @@ specimen measures. See `examples/example_tso500.py` for a full run.
 ## Permission to write sequencing data
 
 Posts to the server's `seqauto/api/` endpoints - the sequencing `create_*` calls from `create_experiment` through
-`create_sequencing_data` and the QC calls, and `link_sequencing_sample_extraction` - need a superuser's API token,
-or one belonging to a member of the server's SeqAuto write group (`seqauto_api_write` unless the server's
-`SEQAUTO_API_WRITE_GROUP` setting says otherwise). Anyone else gets a 403 (`requests.HTTPError`). Reads, such as
-`sequencing_run_has_vcf()`, need only a valid token.
+`create_sequencing_data` and the QC calls, and the `link_sequencing_sample_extraction(s)` calls - need a
+superuser's API token, or one belonging to a member of the server's SeqAuto write group (`seqauto_api_write`
+unless the server's `SEQAUTO_API_WRITE_GROUP` setting says otherwise). Anyone else gets a 403
+(`requests.HTTPError`). Reads, such as `sequencing_run_has_vcf()`, need only a valid token.
 
 ## Testing
 

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/README.md

@@ -69,6 +69,21 @@ api.upload_file("sample.vcf.gz", path=None,
 A bare string names a record by its local reference. Use `ExternalReference(code=..., external_type=...)` to
 name it by a LIMS identifier instead. See `examples/example_tso500.py` for a full run.
 
+Once the sample sheet is registered, link its sequencing samples to their extractions in one call, keyed on
+sample name (what `SequencingSampleLookup.sample_name` holds):
+
+```
+api.link_sequencing_sample_extractions(sample_sheet_lookup, {"sample_1": "2600000001C",
+                                                             "sample_2": "2600000002C"})
+```
+
+It returns a list with one `{"sequencing_sample", "match_status", "match_error", "extraction"}` per sample. An
+extraction the server doesn't have yet is `Pending` for that sample only (HTTP 202) and attaches itself once the
+extraction is created; a sample name that isn't on the sheet is a 400 for the whole batch. On a server from
+before SACGF/variantgrid#2176 (no `link_extractions_bulk` feature) the client makes one
+`link_sequencing_sample_extraction` call per sample instead, so pipelines can use the bulk call unconditionally.
+`link_sequencing_sample_extraction` is still there for a single late link. See `examples/example_haem_20_999.py`.
+
 ## BAMs and CRAMs
 
 A sequencing sample can have several alignment files, eg a BAM and its recalibrated BAM, or a BAM plus a CRAM.
@@ -93,13 +108,15 @@ file as `bam_file`, and a QC's first alignment file as its `bam_file`. A CRAM th
 Servers of different ages accept different calls. The client asks the server which features it has
 (`GET api/v1/capabilities`, fetched once on first use), and each call that needs a newer server
 checks that list first: the patient / specimen / extraction calls, specimen measures,
-`link_sequencing_sample_extraction`, the annotate flow (`poll_upload_status`, `wait_for_annotation`,
-`download_annotated`, `annotate_vcf`), and `upload_file` with `metadata` or `file_type`. A server without the
-capabilities endpoint counts as legacy and reports no features.
+`link_sequencing_sample_extraction` and `link_sequencing_sample_extractions`, the annotate flow
+(`poll_upload_status`, `wait_for_annotation`, `download_annotated`, `annotate_vcf`), and `upload_file` with
+`metadata` or `file_type`. A server without the capabilities endpoint counts as legacy and reports no features.
 
 By default an unsupported call raises `UnsupportedFeatureError`. To run the same code against old and new
-servers, skip those calls instead: they log a warning and return `None`. `upload_file` is the exception: on a
-server without upload metadata it drops the `metadata` and still uploads the file.
+servers, skip those calls instead: they log a warning and return `None`. Two calls downgrade rather than skip
+when the server has the older form of the feature: `upload_file` on a server without upload metadata drops the
+`metadata` and still uploads the file, and `link_sequencing_sample_extractions` on a server with only
+`link_extraction` makes one call per sample.
 
 ```
 from variantgrid_api.api_client import VariantGridAPI, UnsupportedFeaturePolicy
@@ -142,10 +159,10 @@ specimen measures. See `examples/example_tso500.py` for a full run.
 ## Permission to write sequencing data
 
 Posts to the server's `seqauto/api/` endpoints - the sequencing `create_*` calls from `create_experiment` through
-`create_sequencing_data` and the QC calls, and `link_sequencing_sample_extraction` - need a superuser's API token,
-or one belonging to a member of the server's SeqAuto write group (`seqauto_api_write` unless the server's
-`SEQAUTO_API_WRITE_GROUP` setting says otherwise). Anyone else gets a 403 (`requests.HTTPError`). Reads, such as
-`sequencing_run_has_vcf()`, need only a valid token.
+`create_sequencing_data` and the QC calls, and the `link_sequencing_sample_extraction(s)` calls - need a
+superuser's API token, or one belonging to a member of the server's SeqAuto write group (`seqauto_api_write`
+unless the server's `SEQAUTO_API_WRITE_GROUP` setting says otherwise). Anyone else gets a 403
+(`requests.HTTPError`). Reads, such as `sequencing_run_has_vcf()`, need only a valid token.
 
 ## Testing
 

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "variantgrid_api"
-version = "1.9.0"
+version = "1.10.0"
 description = "A Python API client for VariantGrid"
 authors = [
     { name = "Dave Lawrence", email = "davmlaw@gmail.com" }

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/src/variantgrid_api/api_client.py

@@ -7,7 +7,7 @@ import urllib
 import warnings
 from enum import Enum
 from pathlib import Path
-from typing import List, Optional, Callable, Union
+from typing import Dict, List, Optional, Callable, Union
 
 import requests
 
@@ -438,6 +438,44 @@ class VariantGridAPI:
         }
         return self._post("seqauto/api/v1/sequencing_sample/link_extraction", json_data)
 
+    def link_sequencing_sample_extractions(self, sample_sheet_lookup: SampleSheetLookup,
+                                           extractions: Dict[str, ReferenceLike]) -> Optional[List[dict]]:
+        """ link_sequencing_sample_extraction() for a whole sample sheet in one call. extractions maps each
+            sequencing sample's name (SequencingSampleLookup.sample_name) to its extraction reference.
+
+            Returns one {"sequencing_sample", "match_status", "match_error", "extraction"} per sample, in the
+            order given. match_status is per sample: an extraction the server doesn't have yet is 'Pending'
+            (the response is a 202) and attaches itself once created, without affecting the others. A sample
+            name that isn't on the sample sheet is a 400 for the whole batch - nothing is linked.
+
+            Needs ServerFeature.LINK_EXTRACTIONS_BULK (SACGF/variantgrid#2176). A server with only
+            ServerFeature.LINK_EXTRACTION gets one link_sequencing_sample_extraction() call per sample and
+            the results are collected, so pipelines can call this unconditionally. unsupported_feature_policy
+            applies only when the server has neither feature. """
+        if not self.supports(ServerFeature.LINK_EXTRACTIONS_BULK) and not self._require(ServerFeature.LINK_EXTRACTION):
+            return None
+        self._validate_object("sample_sheet_lookup", sample_sheet_lookup)
+        if not extractions:
+            self.validation_handler("extractions: empty")
+        for sample_name, extraction_reference in extractions.items():
+            self._validate_string("extractions: sample name", sample_name)
+            self._validate_reference(f"extractions['{sample_name}']", extraction_reference)
+
+        if not self.supports(ServerFeature.LINK_EXTRACTIONS_BULK):
+            self.logger.info("Server doesn't support feature '%s' - linking %d sequencing sample(s) one at a time",
+                             ServerFeature.LINK_EXTRACTIONS_BULK, len(extractions))
+            return [self.link_sequencing_sample_extraction(
+                        SequencingSampleLookup(sample_sheet_lookup=sample_sheet_lookup, sample_name=sample_name),
+                        extraction_reference)
+                    for sample_name, extraction_reference in extractions.items()]
+
+        json_data = {
+            "sample_sheet": sample_sheet_lookup.to_dict(),
+            "links": [{"sample_name": sample_name, "extraction": reference_json(extraction_reference)}
+                      for sample_name, extraction_reference in extractions.items()],
+        }
+        return self._post("seqauto/api/v1/sequencing_sample/link_extractions", json_data)
+
     def upload_file(self, filename: str, path=_UNSET, metadata: Optional[dict] = None,
                     file_type: Optional[Union[UploadFileType, str]] = None):
         """ Upload a file via multipart POST to upload/api/v1/file_upload.

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/src/variantgrid_api/data_models.py

@@ -520,6 +520,7 @@ class ServerFeature(_ServerName):
         variantgrid/views_rest.py). An older server just doesn't list a newer one """
     PATIENTS = "patients"
     LINK_EXTRACTION = "link_extraction"
+    LINK_EXTRACTIONS_BULK = "link_extractions_bulk"  # sequencing_sample/link_extractions (SACGF/variantgrid#2176)
     UPLOAD_STATUS = "upload_status"
     JOINT_CALLED_VCF_CROSS_RUN = "joint_called_vcf_cross_run"
     UPLOAD_METADATA = "upload_metadata"

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/src/variantgrid_api/mock_variantgrid_api.py

@@ -19,7 +19,8 @@ from pathlib import Path
 from typing import Any, List, Optional, Tuple, Union
 
 from variantgrid_api.api_client import UnsupportedFeaturePolicy, UnsupportedFeatureError
-from variantgrid_api.data_models import reference_json, ServerCapabilities, ServerFeature, UploadFileType
+from variantgrid_api.data_models import reference_json, SequencingSampleLookup, ServerCapabilities, \
+    ServerFeature, UploadFileType
 
 _UNSET = object()
 
@@ -219,6 +220,24 @@ class MockVariantGridAPI:
             "extraction": str(reference_json(extraction_reference)),
         })
 
+    def link_sequencing_sample_extractions(self, sample_sheet_lookup, extractions):
+        """ As the real client, a server without 'link_extractions_bulk' gets one
+            link_sequencing_sample_extraction call per sample - those are what's recorded, not this call """
+        if not self.supports(ServerFeature.LINK_EXTRACTIONS_BULK):
+            if not self._require(ServerFeature.LINK_EXTRACTION):
+                return None
+            return [self.link_sequencing_sample_extraction(
+                        SequencingSampleLookup(sample_sheet_lookup=sample_sheet_lookup, sample_name=sample_name),
+                        extraction_reference)
+                    for sample_name, extraction_reference in extractions.items()]
+        self._record("link_sequencing_sample_extractions", sample_sheet_lookup, extractions)
+        return self._ret("link_sequencing_sample_extractions", [{
+            "sequencing_sample": sample_name,
+            "match_status": "Matched",
+            "match_error": None,
+            "extraction": str(reference_json(extraction_reference)),
+        } for sample_name, extraction_reference in extractions.items()])
+
     def upload_file(self, filename, path=_UNSET, metadata=None, file_type=None):
         if metadata and not self.supports(ServerFeature.UPLOAD_METADATA):
             self._unsupported(f"upload metadata for '{filename}' (server doesn't support feature 'upload_metadata')")

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0/src/variantgrid_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.9.0
+Version: 1.10.0
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License-Expression: MIT
@@ -90,6 +90,21 @@ api.upload_file("sample.vcf.gz", path=None,
 A bare string names a record by its local reference. Use `ExternalReference(code=..., external_type=...)` to
 name it by a LIMS identifier instead. See `examples/example_tso500.py` for a full run.
 
+Once the sample sheet is registered, link its sequencing samples to their extractions in one call, keyed on
+sample name (what `SequencingSampleLookup.sample_name` holds):
+
+```
+api.link_sequencing_sample_extractions(sample_sheet_lookup, {"sample_1": "2600000001C",
+                                                             "sample_2": "2600000002C"})
+```
+
+It returns a list with one `{"sequencing_sample", "match_status", "match_error", "extraction"}` per sample. An
+extraction the server doesn't have yet is `Pending` for that sample only (HTTP 202) and attaches itself once the
+extraction is created; a sample name that isn't on the sheet is a 400 for the whole batch. On a server from
+before SACGF/variantgrid#2176 (no `link_extractions_bulk` feature) the client makes one
+`link_sequencing_sample_extraction` call per sample instead, so pipelines can use the bulk call unconditionally.
+`link_sequencing_sample_extraction` is still there for a single late link. See `examples/example_haem_20_999.py`.
+
 ## BAMs and CRAMs
 
 A sequencing sample can have several alignment files, eg a BAM and its recalibrated BAM, or a BAM plus a CRAM.
@@ -114,13 +129,15 @@ file as `bam_file`, and a QC's first alignment file as its `bam_file`. A CRAM th
 Servers of different ages accept different calls. The client asks the server which features it has
 (`GET api/v1/capabilities`, fetched once on first use), and each call that needs a newer server
 checks that list first: the patient / specimen / extraction calls, specimen measures,
-`link_sequencing_sample_extraction`, the annotate flow (`poll_upload_status`, `wait_for_annotation`,
-`download_annotated`, `annotate_vcf`), and `upload_file` with `metadata` or `file_type`. A server without the
-capabilities endpoint counts as legacy and reports no features.
+`link_sequencing_sample_extraction` and `link_sequencing_sample_extractions`, the annotate flow
+(`poll_upload_status`, `wait_for_annotation`, `download_annotated`, `annotate_vcf`), and `upload_file` with
+`metadata` or `file_type`. A server without the capabilities endpoint counts as legacy and reports no features.
 
 By default an unsupported call raises `UnsupportedFeatureError`. To run the same code against old and new
-servers, skip those calls instead: they log a warning and return `None`. `upload_file` is the exception: on a
-server without upload metadata it drops the `metadata` and still uploads the file.
+servers, skip those calls instead: they log a warning and return `None`. Two calls downgrade rather than skip
+when the server has the older form of the feature: `upload_file` on a server without upload metadata drops the
+`metadata` and still uploads the file, and `link_sequencing_sample_extractions` on a server with only
+`link_extraction` makes one call per sample.
 
 ```
 from variantgrid_api.api_client import VariantGridAPI, UnsupportedFeaturePolicy
@@ -163,10 +180,10 @@ specimen measures. See `examples/example_tso500.py` for a full run.
 ## Permission to write sequencing data
 
 Posts to the server's `seqauto/api/` endpoints - the sequencing `create_*` calls from `create_experiment` through
-`create_sequencing_data` and the QC calls, and `link_sequencing_sample_extraction` - need a superuser's API token,
-or one belonging to a member of the server's SeqAuto write group (`seqauto_api_write` unless the server's
-`SEQAUTO_API_WRITE_GROUP` setting says otherwise). Anyone else gets a 403 (`requests.HTTPError`). Reads, such as
-`sequencing_run_has_vcf()`, need only a valid token.
+`create_sequencing_data` and the QC calls, and the `link_sequencing_sample_extraction(s)` calls - need a
+superuser's API token, or one belonging to a member of the server's SeqAuto write group (`seqauto_api_write`
+unless the server's `SEQAUTO_API_WRITE_GROUP` setting says otherwise). Anyone else gets a 403
+(`requests.HTTPError`). Reads, such as `sequencing_run_has_vcf()`, need only a valid token.
 
 ## Testing
 

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/tests/test_api_client_capabilities.py

@@ -140,6 +140,8 @@ def _gated_calls(vg_objects, vcf):
         "create_extraction": lambda api: api.create_extraction(vg_objects["dna_extraction"]),
         "link_sequencing_sample_extraction": lambda api: api.link_sequencing_sample_extraction(
             vg_objects["sequencing_sample_lookup_1"], "2600000001C"),
+        "link_sequencing_sample_extractions": lambda api: api.link_sequencing_sample_extractions(
+            vg_objects["sample_sheet_lookup"], {"fake_sample_1": "2600000001C"}),
         "upload_file_file_type": lambda api: api.upload_file(vcf, path=None, file_type=CVO),
         "poll_upload_status": lambda api: api.poll_upload_status(uploaded_file_id=1),
         "wait_for_annotation": lambda api: api.wait_for_annotation(uploaded_file_id=1, sleep=lambda _: None),
@@ -149,6 +151,7 @@ def _gated_calls(vg_objects, vcf):
 
 
 GATED = ["create_patient", "create_specimen", "create_extraction", "link_sequencing_sample_extraction",
+         "link_sequencing_sample_extractions",
          "upload_file_file_type",
          "poll_upload_status", "wait_for_annotation", "download_annotated", "annotate_vcf"]
 

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/tests/test_api_client_patients.py

@@ -1,12 +1,16 @@
 """Patient / specimen / extraction, specimen measures, extraction links and upload metadata
 (SACGF/variantgrid_api#20)"""
 import json
+import logging
+import re
 from urllib.parse import urlparse, parse_qs
 
 import pytest
 import responses
 
-from variantgrid_api.data_models import ExternalReference, ExternalPK, Extraction
+from variantgrid_api.api_client import VariantGridAPI, UnsupportedFeaturePolicy, UnsupportedFeatureError
+from variantgrid_api.data_models import ExternalReference, ExternalPK, Extraction, ServerCapabilities, \
+    ServerFeature
 
 
 @pytest.fixture
@@ -141,6 +145,126 @@ def test_link_sequencing_sample_extraction_pending_is_not_an_error(api, server,
     assert out == pending
 
 
+# ------------------------------------------------------------------ #
+# Linking a sample sheet's sequencing samples in one call (#32)         #
+# ------------------------------------------------------------------ #
+
+def _bulk_url(server):
+    return f"{server}/seqauto/api/v1/sequencing_sample/link_extractions"
+
+
+def _single_url(server):
+    return f"{server}/seqauto/api/v1/sequencing_sample/link_extraction"
+
+
+def _link_result(sample_name, extraction, match_status="Matched"):
+    return {"sequencing_sample": sample_name, "match_status": match_status, "match_error": None,
+            "extraction": extraction if match_status == "Matched" else None}
+
+
+EXTRACTIONS = {"fake_sample_1": "2600000001C", "fake_sample_2": "2600000002C"}
+
+
+@responses.activate
+def test_link_sequencing_sample_extractions(api, server, vg_objects):
+    result = [_link_result("fake_sample_1", "2600000001C"), _link_result("fake_sample_2", "2600000002C")]
+    responses.add(responses.POST, _bulk_url(server), json=result, status=200)
+
+    out = api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], EXTRACTIONS)
+    assert out == result
+    assert len(responses.calls) == 1
+    assert _last_json() == {
+        "sample_sheet": vg_objects["sample_sheet_lookup"].to_dict(),
+        "links": [
+            {"sample_name": "fake_sample_1", "extraction": "2600000001C"},
+            {"sample_name": "fake_sample_2", "extraction": "2600000002C"},
+        ],
+    }
+
+
+@responses.activate
+def test_link_sequencing_sample_extractions_external_reference(api, server, vg_objects):
+    """ Each link takes the same reference forms as the single call """
+    responses.add(responses.POST, _bulk_url(server), json=[], status=200)
+    lims = ExternalReference(code="LIMS-1", external_type="LabNo")
+    api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], {"fake_sample_1": lims})
+    assert _last_json()["links"] == [{"sample_name": "fake_sample_1", "extraction": lims.to_json_value()}]
+
+
+@responses.activate
+def test_link_sequencing_sample_extractions_pending_is_not_an_error(api, server, vg_objects):
+    """ match_status is per sample - a 202 with one 'Pending' still links the others """
+    result = [_link_result("fake_sample_1", "2600000001C"),
+              _link_result("fake_sample_2", None, match_status="Pending")]
+    responses.add(responses.POST, _bulk_url(server), json=result, status=202)
+    assert api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], EXTRACTIONS) == result
+
+
+@pytest.fixture
+def link_extraction_only_api(server, api_token):
+    """ A server from before the bulk endpoint, with just the single-sample one """
+    api = VariantGridAPI(server, api_token)
+    api._capabilities = ServerCapabilities(version="old", features=frozenset([ServerFeature.LINK_EXTRACTION]))
+    return api
+
+
+@responses.activate
+def test_link_sequencing_sample_extractions_falls_back_to_one_call_per_sample(link_extraction_only_api, server,
+                                                                              vg_objects):
+    """ So pipelines can use the bulk call unconditionally - the results are collected in order """
+    api = link_extraction_only_api
+    responses.add(responses.POST, _single_url(server), json=_link_result("fake_sample_1", "2600000001C"), status=200)
+    responses.add(responses.POST, _single_url(server), json=_link_result("fake_sample_2", None, "Pending"), status=202)
+
+    out = api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], EXTRACTIONS)
+    assert out == [_link_result("fake_sample_1", "2600000001C"), _link_result("fake_sample_2", None, "Pending")]
+    assert [c.request.url for c in responses.calls] == [_single_url(server)] * 2
+    sample_sheet = vg_objects["sample_sheet_lookup"].to_dict()
+    assert [json.loads(c.request.body) for c in responses.calls] == [
+        {"sequencing_sample": {"sample_sheet": sample_sheet, "sample_name": "fake_sample_1"},
+         "extraction": "2600000001C"},
+        {"sequencing_sample": {"sample_sheet": sample_sheet, "sample_name": "fake_sample_2"},
+         "extraction": "2600000002C"},
+    ]
+
+
+@responses.activate
+def test_link_sequencing_sample_extractions_policy_applies_only_without_link_extraction(server, api_token,
+                                                                                        vg_objects, caplog):
+    """ unsupported_feature_policy applies only when the server has neither feature """
+    legacy = ServerCapabilities.LEGACY
+    api = VariantGridAPI(server, api_token)
+    api._capabilities = legacy
+    with pytest.raises(UnsupportedFeatureError):
+        api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], EXTRACTIONS)
+
+    skip_api = VariantGridAPI(server, api_token, unsupported_feature_policy=UnsupportedFeaturePolicy.SKIP)
+    skip_api._capabilities = legacy
+    with caplog.at_level(logging.WARNING):
+        assert skip_api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], EXTRACTIONS) is None
+    assert "Skipping" in caplog.text
+    assert not responses.calls
+
+
+@pytest.mark.parametrize("extractions, message", [
+    ({}, "extractions: empty"),
+    ({"fake_sample_1": "2600000001C", "fake_sample_2": None}, "extractions['fake_sample_2']: is None"),
+    ({"fake_sample_1": ""}, "extractions['fake_sample_1']: empty string"),
+    ({"": "2600000001C"}, "extractions: sample name: empty string"),
+])
+@responses.activate
+def test_link_sequencing_sample_extractions_validation_names_the_sample(api, vg_objects, extractions, message):
+    with pytest.raises(ValueError, match=re.escape(message)):
+        api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], extractions)
+    assert not responses.calls
+
+
+@responses.activate
+def test_link_sequencing_sample_extractions_requires_sample_sheet_lookup(api, vg_objects):
+    with pytest.raises(ValueError, match="sample_sheet_lookup: is None"):
+        api.link_sequencing_sample_extractions(None, EXTRACTIONS)
+
+
 # ------------------------------------------------------------------ #
 # Upload metadata                                                      #
 # ------------------------------------------------------------------ #

{variantgrid_api-1.9.0 → variantgrid_api-1.10.0}/tests/test_mock_variantgrid_api.py

@@ -208,6 +208,34 @@ def test_mock_link_sequencing_sample_extraction_pending_override(mock_api, vg_ob
     mock_api.assert_called_once("link_sequencing_sample_extraction")
 
 
+def test_mock_link_sequencing_sample_extractions(mock_api, vg_objects):
+    extractions = {"fake_sample_1": "2600000001C", "fake_sample_2": "2600000002C"}
+    result = mock_api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], extractions)
+    assert [r["sequencing_sample"] for r in result] == ["fake_sample_1", "fake_sample_2"]
+    assert all(r["match_status"] == "Matched" for r in result)
+    mock_api.assert_called_once("link_sequencing_sample_extractions")
+    mock_api.assert_not_called("link_sequencing_sample_extraction")
+    assert mock_api.get_calls("link_sequencing_sample_extractions") == [
+        ((vg_objects["sample_sheet_lookup"], extractions), {})]
+
+    mock_api.set_return("link_sequencing_sample_extractions", [{"match_status": "Pending"}])
+    assert mock_api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], extractions) == [
+        {"match_status": "Pending"}]
+
+
+def test_mock_link_sequencing_sample_extractions_falls_back_without_bulk_feature(vg_objects):
+    """ A server with only link_extraction gets (and records) one single-sample call per sample """
+    mock_api = MockVariantGridAPI(capabilities=ServerCapabilities(
+        version="old", features=frozenset([ServerFeature.LINK_EXTRACTION])))
+    extractions = {"fake_sample_1": "2600000001C", "fake_sample_2": "2600000002C"}
+    result = mock_api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"], extractions)
+    assert [r["sequencing_sample"] for r in result] == ["fake_sample_1", "fake_sample_2"]
+    mock_api.assert_not_called("link_sequencing_sample_extractions")
+    calls = mock_api.get_calls("link_sequencing_sample_extraction")
+    assert [(lookup.sample_name, extraction) for (lookup, extraction), _ in calls] == list(extractions.items())
+    assert all(lookup.sample_sheet_lookup == vg_objects["sample_sheet_lookup"] for (lookup, _), _ in calls)
+
+
 def test_mock_upload_file_records_metadata_only_when_sent(mock_api):
     mock_api.upload_file("a.vcf")
     mock_api.upload_file("b.vcf", path=None, metadata={"genome_build": "GRCh37"})
@@ -246,9 +274,12 @@ def test_mock_legacy_skips_under_skip(vg_objects):
     assert not mock_api.supports("patients")
     assert mock_api.create_patient(vg_objects["patient"]) is None
     assert mock_api.link_sequencing_sample_extraction(vg_objects["sequencing_sample_lookup_1"], "2600000001C") is None
+    assert mock_api.link_sequencing_sample_extractions(vg_objects["sample_sheet_lookup"],
+                                                       {"fake_sample_1": "2600000001C"}) is None
     assert mock_api.upload_file("cvo.tsv", path=None, file_type="dragen_tso500_combined_variant_output") is None
     mock_api.assert_not_called("create_patient")
     mock_api.assert_not_called("link_sequencing_sample_extraction")
+    mock_api.assert_not_called("link_sequencing_sample_extractions")
     mock_api.assert_not_called("upload_file")
 
     # Metadata is dropped but the file still uploads