variantgrid-api 1.5.0__tar.gz → 1.7.0__tar.gz

{variantgrid_api-1.5.0/src/variantgrid_api.egg-info → variantgrid_api-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.5.0
+Version: 1.7.0
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License: MIT License

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0}/pyproject.toml

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

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0}/src/variantgrid_api/api_client.py

@@ -14,7 +14,7 @@ import requests
 from variantgrid_api.data_models import EnrichmentKit, SequencingRun, SampleSheet, JointCalledVCF, \
     SampleSheetLookup, SequencingFile, QCGeneList, QCExecStats, QCGeneCoverage, SequencerModel, Sequencer, \
     SequencingSampleLookup, Patient, Specimen, Extraction, SpecimenMeasure, ExternalReference, ReferenceLike, \
-    reference_json, ServerCapabilities
+    reference_json, ServerCapabilities, ServerFeature, UploadFileType
 
 
 _UNSET = object()
@@ -161,11 +161,11 @@ class VariantGridAPI:
                 self._capabilities = ServerCapabilities.from_json(data)
         return self._capabilities
 
-    def supports(self, feature: str) -> bool:
+    def supports(self, feature: Union[ServerFeature, str]) -> bool:
         return feature in self.capabilities.features
 
-    def accepts_upload(self, file_type: str) -> bool:
-        """ file_type is the server's UploadedFileTypes name in lower case, eg 'dragen_tso500_combined_variant_output' """
+    def accepts_upload(self, file_type: Union[UploadFileType, str]) -> bool:
+        """ file_type is an UploadFileType, or the server's UploadedFileTypes name in lower case """
         return file_type in self.capabilities.upload_file_types
 
     def _unsupported(self, message: str) -> bool:
@@ -177,11 +177,11 @@ class VariantGridAPI:
             return False
         raise UnsupportedFeatureError(message, capabilities)
 
-    def _require(self, feature: str) -> bool:
+    def _require(self, feature: Union[ServerFeature, str]) -> bool:
         """ True if the server supports feature, otherwise applies unsupported_feature_policy """
         return self.supports(feature) or self._unsupported(f"server doesn't support feature '{feature}'")
 
-    def _require_upload(self, file_type: str) -> bool:
+    def _require_upload(self, file_type: Union[UploadFileType, str]) -> bool:
         return self.accepts_upload(file_type) or self._unsupported(f"server doesn't accept upload file type '{file_type}'")
 
     def create_experiment(self, experiment: str):
@@ -241,7 +241,22 @@ class VariantGridAPI:
         self._validate_list("sequencing_files", sequencing_files)
         records = []
         for sf in sequencing_files:
+            # The server requires both paths - catch it here, naming the record, rather than a 400 for the batch
+            self._validate_string(f"SequencingFile '{sf.sample_name}' bam_file.path", sf.bam_file and sf.bam_file.path)
+            vcf_files = sf.get_vcf_files()
+            self._validate_list(f"SequencingFile '{sf.sample_name}' vcf_files", vcf_files)
+            for i, vcf_file in enumerate(vcf_files):
+                self._validate_string(f"SequencingFile '{sf.sample_name}' vcf_files[{i}].path",
+                                      vcf_file and vcf_file.path)
+            # The server keeps one VCF per BAM and caller - a repeated caller would silently replace a path
+            callers = [f"{vc.name} {vc.version}" for vcf_file in vcf_files
+                       if vcf_file and (vc := vcf_file.variant_caller)]
+            if repeated := {c for c in callers if callers.count(c) > 1}:
+                raise ValueError(f"SequencingFile '{sf.sample_name}' has more than one VCF from variant caller(s) "
+                                 f"{', '.join(sorted(repeated))} - each VCF off a BAM needs its own caller")
             data = sf.to_dict()
+            data.pop("vcf_file", None)
+            data.pop("vcf_files", None)
             # put into hierarchial JSON DRF expects
             fastq_r1 = data.pop("fastq_r1", None)
             fastq_r2 = data.pop("fastq_r2", None)
@@ -252,8 +267,10 @@ class VariantGridAPI:
                 data["unaligned_reads"] = unaligned_reads
             elif fastq_r2:
                 raise ValueError(f"SequencingFile '{sf.sample_name}' has fastq_r2 without fastq_r1")
-            # No FastQs (BAM-first run) - server resolves the sample from sample_name
-            records.append(data)
+            # No FastQs (BAM-first run) - server resolves the sample from sample_name.
+            # The server takes one VCF per record, so each is a record sharing the BAM and FastQs
+            for vcf_file in vcf_files:
+                records.append({**data, "vcf_file": vcf_file.to_dict() if vcf_file else None})
 
         json_data = {
             "sample_sheet": sample_sheet_lookup.to_dict(),
@@ -310,28 +327,28 @@ class VariantGridAPI:
     ## Creates are upserts keyed on the identifiers sent, so re-posting returns the same rows
 
     def create_patient(self, patient: Patient):
-        if not self._require("patients"):
+        if not self._require(ServerFeature.PATIENTS):
             return None
         self._validate_object("patient", patient)
         return self._post("patients/api/v1/patient/", patient.to_dict())
 
     def create_specimen(self, specimen: Specimen):
         """ The specimen's patient must already exist on the server, otherwise this is a 400 """
-        if not self._require("patients"):
+        if not self._require(ServerFeature.PATIENTS):
             return None
         self._validate_object("specimen", specimen)
         return self._post("patients/api/v1/specimen/", specimen.to_dict())
 
     def create_extraction(self, extraction: Extraction):
         """ The extraction's specimen must already exist on the server, otherwise this is a 400 """
-        if not self._require("patients"):
+        if not self._require(ServerFeature.PATIENTS):
             return None
         self._validate_object("extraction", extraction)
         return self._post("patients/api/v1/extraction/", extraction.to_dict())
 
     def create_specimen_measure(self, specimen_reference: ReferenceLike, measure: SpecimenMeasure):
         """ An unknown specimen is a 400. Replaces any existing measure of the same type for the specimen """
-        if not self._require("specimen_measures"):
+        if not self._require(ServerFeature.SPECIMEN_MEASURES):
             return None
         self._validate_reference("specimen_reference", specimen_reference)
         self._validate_object("measure", measure)
@@ -340,7 +357,7 @@ class VariantGridAPI:
 
     def create_specimen_measures(self, specimen_reference: ReferenceLike, measures: List[SpecimenMeasure]):
         """ A run's measures (TMB, MSI, GIS etc) against one specimen in one call """
-        if not self._require("specimen_measures"):
+        if not self._require(ServerFeature.SPECIMEN_MEASURES):
             return None
         self._validate_reference("specimen_reference", specimen_reference)
         self._validate_list("measures", measures)
@@ -360,7 +377,7 @@ class VariantGridAPI:
             sequencing sample is a 400, but an extraction the server doesn't have yet is not an error:
             the response is a 202 with match_status 'Pending', and the link attaches itself once the
             extraction is created - there's no need to re-send. """
-        if not self._require("link_extraction"):
+        if not self._require(ServerFeature.LINK_EXTRACTION):
             return None
         self._validate_object("sequencing_sample_lookup", sequencing_sample_lookup)
         self._validate_reference("extraction_reference", extraction_reference)
@@ -371,7 +388,7 @@ class VariantGridAPI:
         return self._post("seqauto/api/v1/sequencing_sample/link_extraction", json_data)
 
     def upload_file(self, filename: str, path=_UNSET, metadata: Optional[dict] = None,
-                    file_type: Optional[str] = None):
+                    file_type: Optional[Union[UploadFileType, str]] = None):
         """ Upload a file via multipart POST to upload/api/v1/file_upload.
 
             Returns {"uploaded_file_id": <id>, "sha256_hash": <hash>, ...}; identify the upload by
@@ -393,10 +410,10 @@ class VariantGridAPI:
                   Needs the server feature 'upload_metadata'. Without it, SKIP uploads the file without the
                   metadata (as older clients did) rather than not at all, and ERROR raises
 
-            file_type: the server's name for what this file is, eg 'dragen_tso500_combined_variant_output'.
+            file_type: the server's name for what this file is, eg UploadFileType.DRAGEN_TSO500_COMBINED_VARIANT_OUTPUT.
                   Not sent (the server decides from the filename) - if given, the upload only happens when
                   accepts_upload(file_type), so an older server doesn't mis-import it as something else """
-        if metadata and not self.supports("upload_metadata"):
+        if metadata and not self.supports(ServerFeature.UPLOAD_METADATA):
             self._unsupported(f"upload metadata for '{filename}' (server doesn't support feature 'upload_metadata')")
             metadata = None
         if file_type and not self._require_upload(file_type):
@@ -473,7 +490,7 @@ class VariantGridAPI:
 
             Keyed by uploaded_file_id (returned from upload_file) or the SHA-256 of the uploaded file.
             See wait_for_annotation to block until annotation is complete. Needs server feature 'upload_status' """
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         segment = self._upload_key_segment(uploaded_file_id, sha256)
         return self._get(f"upload/api/v1/upload_status/{segment}")
@@ -490,7 +507,7 @@ class VariantGridAPI:
             server is still creating the upload record) are tolerated: up to 'max_transient_errors' *consecutive*
             failures are retried before giving up. A 4xx response is treated as a real error and raised immediately.
             The success counter resets whenever a poll succeeds. Needs server feature 'upload_status' """
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         deadline = time.monotonic() + timeout
         transient_errors = 0
@@ -542,7 +559,7 @@ class VariantGridAPI:
             otherwise it is treated as the full destination path. Returns the Path written.
 
             Raises TimeoutError if the file isn't ready within 'timeout' seconds. Needs server feature 'upload_status' """
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         if export_type not in ("vcf", "csv"):
             raise ValueError(f"export_type must be 'vcf' or 'csv', got {export_type!r}")
@@ -590,7 +607,7 @@ class VariantGridAPI:
 
             Chains upload_file -> wait_for_annotation -> download_annotated and returns the Path written.
             Needs server feature 'upload_status' - checked before uploading """
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         # path is SeqAuto-only and makes ad-hoc uploads fail the import - omit it for the annotate flow
         upload = self.upload_file(filename, path=None)

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0}/src/variantgrid_api/data_models.py

@@ -196,12 +196,33 @@ class VCFFile(SingleSampleVCF):
 @dataclass_json
 @dataclass
 class SequencingFile:
-    """ FastQs are optional - BAM-first runs (sequencer emits BAM, or FastQs not kept) send just BAM + VCF """
+    """ FastQs are optional - BAM-first runs (sequencer emits BAM, or FastQs not kept) send just BAM + VCF
+
+        vcf_files: the VCFs called off this BAM, one per variant caller, eg DRAGEN TSO 500's small variant VCF and
+        its gene-level CNV VCF. The server keeps one VCF per BAM and caller, so a second with the same caller
+        would replace the first - create_sequencing_data() raises instead.
+
+        vcf_file is deprecated - use vcf_files. It still works (set it and it is sent, read it back as before),
+        and get_vcf_files() gives both """
     sample_name: str
     bam_file: BamFile
-    vcf_file: SingleSampleVCF
+    vcf_file: Optional[SingleSampleVCF] = field(default=None, metadata=config(exclude=lambda x: x is None))
     fastq_r1: Optional[str] = field(default=None, metadata=config(exclude=lambda x: x is None))
     fastq_r2: Optional[str] = field(default=None, metadata=config(exclude=lambda x: x is None))
+    vcf_files: Optional[List[SingleSampleVCF]] = field(default=None, metadata=config(exclude=lambda x: x is None))
+
+    def __post_init__(self):
+        if self.vcf_file is not None:
+            warnings.warn(
+                "SequencingFile.vcf_file is deprecated; use vcf_files instead.",
+                DeprecationWarning,
+                stacklevel=3,
+            )
+
+    def get_vcf_files(self) -> List[SingleSampleVCF]:
+        """ vcf_file (deprecated) then vcf_files """
+        vcf_files = [self.vcf_file] if self.vcf_file is not None else []
+        return vcf_files + list(self.vcf_files or [])
 
 
 @dataclass_json
@@ -442,6 +463,47 @@ class SpecimenMeasure:
     extraction: Optional[ReferenceLike] = _reference_field(default=None)  # the arm that produced it
 
 
+############################################################
+## Server capabilities (SACGF/variantgrid_api#22)
+
+class _ServerName(str, Enum):
+    """ A name from the server's vocabulary. Subclasses str so plain strings and these are interchangeable,
+        and formats as its value so messages read 'patients' rather than 'ServerFeature.PATIENTS' """
+
+    def __str__(self):
+        return self.value
+
+    def __format__(self, format_spec):
+        return format(self.value, format_spec)
+
+
+class ServerFeature(_ServerName):
+    """ Features a server reports in capabilities (API_FEATURES in the variantgrid repo's
+        variantgrid/views_rest.py). Names are never removed - an older server just doesn't list a newer one """
+    PATIENTS = "patients"
+    SPECIMEN_MEASURES = "specimen_measures"
+    LINK_EXTRACTION = "link_extraction"
+    UPLOAD_STATUS = "upload_status"
+    JOINT_CALLED_VCF_CROSS_RUN = "joint_called_vcf_cross_run"
+    UPLOAD_METADATA = "upload_metadata"
+
+
+class UploadFileType(_ServerName):
+    """ File types a server imports from an upload - the server's upload.models.UploadedFileTypes names in
+        lower case, less the internal ones it drives itself. A server only reports those it has an importer for """
+    BED = "bed"
+    DRAGEN_TSO500_ALL_FUSIONS = "dragen_tso500_all_fusions"
+    DRAGEN_TSO500_COMBINED_VARIANT_OUTPUT = "dragen_tso500_combined_variant_output"
+    GENE_COVERAGE = "gene_coverage"
+    GENE_LIST = "gene_list"
+    GENE_LEVEL_CNV_VCF = "gene_level_cnv_vcf"
+    GENE_LEVEL_INSERT_VARIANTS_ONLY = "gene_level_insert_variants_only"
+    PATIENT_RECORDS = "patient_records"
+    PED = "ped"
+    VCF = "vcf"
+    VCF_INSERT_VARIANTS_ONLY = "vcf_insert_variants_only"
+
+
 @dataclass(frozen=True)
 class ServerCapabilities:
     """ What a server accepts, from GET api/v1/capabilities (SACGF/variantgrid_sapath#443).

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0}/src/variantgrid_api/mock_variantgrid_api.py

@@ -16,20 +16,21 @@ import copy
 import logging
 import warnings
 from pathlib import Path
-from typing import Any, List, Optional, Tuple
+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
+from variantgrid_api.data_models import reference_json, ServerCapabilities, ServerFeature, UploadFileType
 
 _UNSET = object()
 
 # Every feature and upload file type the real client gates on - the shape of a current (VG4) server
 MOCK_CAPABILITIES = ServerCapabilities(
     version="mock",
-    features=frozenset({"patients", "specimen_measures", "link_extraction", "upload_status",
-                        "joint_called_vcf_cross_run", "upload_metadata"}),
-    upload_file_types=frozenset({"vcf", "gene_coverage", "dragen_tso500_all_fusions",
-                                 "dragen_tso500_combined_variant_output", "gene_level_cnv_vcf"}),
+    features=frozenset(ServerFeature),
+    upload_file_types=frozenset({UploadFileType.VCF, UploadFileType.GENE_COVERAGE,
+                                 UploadFileType.DRAGEN_TSO500_ALL_FUSIONS,
+                                 UploadFileType.DRAGEN_TSO500_COMBINED_VARIANT_OUTPUT,
+                                 UploadFileType.GENE_LEVEL_CNV_VCF}),
 )
 
 
@@ -86,10 +87,10 @@ class MockVariantGridAPI:
     # Capabilities — same gating as VariantGridAPI                        #
     # ------------------------------------------------------------------ #
 
-    def supports(self, feature: str) -> bool:
+    def supports(self, feature: Union[ServerFeature, str]) -> bool:
         return feature in self.capabilities.features
 
-    def accepts_upload(self, file_type: str) -> bool:
+    def accepts_upload(self, file_type: Union[UploadFileType, str]) -> bool:
         return file_type in self.capabilities.upload_file_types
 
     def _unsupported(self, message: str) -> bool:
@@ -99,10 +100,10 @@ class MockVariantGridAPI:
             return False
         raise UnsupportedFeatureError(message, self.capabilities)
 
-    def _require(self, feature: str) -> bool:
+    def _require(self, feature: Union[ServerFeature, str]) -> bool:
         return self.supports(feature) or self._unsupported(f"server doesn't support feature '{feature}'")
 
-    def _require_upload(self, file_type: str) -> bool:
+    def _require_upload(self, file_type: Union[UploadFileType, str]) -> bool:
         return self.accepts_upload(file_type) or self._unsupported(f"server doesn't accept upload file type '{file_type}'")
 
     # ------------------------------------------------------------------ #
@@ -181,39 +182,39 @@ class MockVariantGridAPI:
         return self._ret("create_multiple_qc_gene_coverage", {"created": len(qc_gene_coverage_list)})
 
     def create_patient(self, patient):
-        if not self._require("patients"):
+        if not self._require(ServerFeature.PATIENTS):
             return None
         self._record("create_patient", patient)
         return self._ret("create_patient", {"id": 1, **patient.to_dict()})
 
     def create_specimen(self, specimen):
-        if not self._require("patients"):
+        if not self._require(ServerFeature.PATIENTS):
             return None
         self._record("create_specimen", specimen)
         return self._ret("create_specimen", {"id": 1, **specimen.to_dict()})
 
     def create_extraction(self, extraction):
-        if not self._require("patients"):
+        if not self._require(ServerFeature.PATIENTS):
             return None
         self._record("create_extraction", extraction)
         return self._ret("create_extraction", {"id": 1, **extraction.to_dict()})
 
     def create_specimen_measure(self, specimen_reference, measure):
-        if not self._require("specimen_measures"):
+        if not self._require(ServerFeature.SPECIMEN_MEASURES):
             return None
         self._record("create_specimen_measure", specimen_reference, measure)
         return self._ret("create_specimen_measure", {"id": 1, "specimen": reference_json(specimen_reference),
                                                      **measure.to_dict()})
 
     def create_specimen_measures(self, specimen_reference, measures):
-        if not self._require("specimen_measures"):
+        if not self._require(ServerFeature.SPECIMEN_MEASURES):
             return None
         self._record("create_specimen_measures", specimen_reference, measures)
         return self._ret("create_specimen_measures", {"specimen": reference_json(specimen_reference),
                                                       "measures": [m.to_dict() for m in measures]})
 
     def link_sequencing_sample_extraction(self, sequencing_sample_lookup, extraction_reference):
-        if not self._require("link_extraction"):
+        if not self._require(ServerFeature.LINK_EXTRACTION):
             return None
         self._record("link_sequencing_sample_extraction", sequencing_sample_lookup, extraction_reference)
         return self._ret("link_sequencing_sample_extraction", {
@@ -224,7 +225,7 @@ class MockVariantGridAPI:
         })
 
     def upload_file(self, filename, path=_UNSET, metadata=None, file_type=None):
-        if metadata and not self.supports("upload_metadata"):
+        if metadata and not self.supports(ServerFeature.UPLOAD_METADATA):
             self._unsupported(f"upload metadata for '{filename}' (server doesn't support feature 'upload_metadata')")
             metadata = None
         if file_type and not self._require_upload(file_type):
@@ -240,7 +241,7 @@ class MockVariantGridAPI:
                                          "path": path, "status": "ok"})
 
     def poll_upload_status(self, uploaded_file_id=None, sha256=None):
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         self._record("poll_upload_status", uploaded_file_id, sha256)
         return self._ret("poll_upload_status", {
@@ -252,7 +253,7 @@ class MockVariantGridAPI:
 
     def wait_for_annotation(self, uploaded_file_id=None, sha256=None,
                             timeout=3600, poll_interval=10, sleep=None, max_transient_errors=5):
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         self._record("wait_for_annotation", uploaded_file_id, sha256,
                      timeout=timeout, poll_interval=poll_interval, sleep=sleep,
@@ -265,7 +266,7 @@ class MockVariantGridAPI:
 
     def download_annotated(self, uploaded_file_id=None, sha256=None, export_type="vcf",
                            dest_path=None, timeout=3600, poll_interval=10, sleep=None):
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         self._record("download_annotated", uploaded_file_id, sha256, export_type=export_type,
                      dest_path=dest_path, timeout=timeout, poll_interval=poll_interval, sleep=sleep)
@@ -274,7 +275,7 @@ class MockVariantGridAPI:
 
     def annotate_vcf(self, filename, export_type="vcf", dest_path=None,
                      timeout=3600, poll_interval=10, sleep=None):
-        if not self._require("upload_status"):
+        if not self._require(ServerFeature.UPLOAD_STATUS):
             return None
         self._record("annotate_vcf", filename, export_type=export_type, dest_path=dest_path,
                      timeout=timeout, poll_interval=poll_interval, sleep=sleep)

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0/src/variantgrid_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.5.0
+Version: 1.7.0
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License: MIT License

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0}/tests/test_api_client.py

@@ -6,7 +6,8 @@ import logging
 import pytest
 import responses
 
-from variantgrid_api.api_client import VariantGridAPI, DateTimeEncoder
+from variantgrid_api.api_client import VariantGridAPI, DateTimeEncoder, EmptyInputPolicy
+from variantgrid_api.data_models import BamFile, SequencingFile, SingleSampleVCF, VariantCaller
 
 
 def _last_json():
@@ -66,6 +67,80 @@ def test_create_sequencing_data_fastq_r2_without_r1_raises(api, vg_objects):
     with pytest.raises(ValueError):
         api.create_sequencing_data(vg_objects["sample_sheet_lookup"], [sf])
 
+@pytest.mark.parametrize("changes, name", [
+    ({"vcf_files": None}, "vcf_files"),
+    ({"vcf_files": []}, "vcf_files"),
+    ({"vcf_files": [None]}, r"vcf_files\[0\].path"),
+    ({"vcf_files": [SingleSampleVCF(path=None)]}, r"vcf_files\[0\].path"),
+    ({"vcf_files": [SingleSampleVCF(path="")]}, r"vcf_files\[0\].path"),
+    ({"bam_file": None}, "bam_file.path"),
+    ({"bam_file": BamFile(path=None)}, "bam_file.path"),
+])
+@responses.activate
+def test_create_sequencing_data_missing_path_names_record(api, vg_objects, changes, name):
+    """ SACGF/variantgrid_api#23 - caught before sending, naming the record, rather than a 400 for the batch """
+    sequencing_files = list(vg_objects["sequencing_files"])
+    sequencing_files[1] = dataclasses.replace(sequencing_files[1], **changes)
+    with pytest.raises(ValueError, match=f"SequencingFile 'fake_sample_2' {name}"):
+        api.create_sequencing_data(vg_objects["sample_sheet_lookup"], sequencing_files)
+    assert len(responses.calls) == 0
+
+@responses.activate
+def test_create_sequencing_data_missing_vcf_path_warns_and_posts(server, api_token, vg_objects, caplog):
+    api = VariantGridAPI(server, api_token, empty_input_policy=EmptyInputPolicy.WARN)
+    url = f"{server}/seqauto/api/v1/sequencing_files/bulk_create"
+    responses.add(responses.POST, url, json={"created": 2}, status=200)
+    sequencing_files = list(vg_objects["sequencing_files"])
+    sequencing_files[0] = dataclasses.replace(sequencing_files[0], vcf_files=[SingleSampleVCF(path=None)])
+    api.create_sequencing_data(vg_objects["sample_sheet_lookup"], sequencing_files)
+    assert len(responses.calls) == 1
+    assert any("SequencingFile 'fake_sample_1' vcf_files[0].path" in r.message for r in caplog.records)
+
+@responses.activate
+def test_create_sequencing_data_vcf_files_share_the_bam(api, server, vg_objects):
+    """ eg DRAGEN TSO 500's CNV VCF beside its small variant VCF - one record per VCF, same BAM and FastQs """
+    url = f"{server}/seqauto/api/v1/sequencing_files/bulk_create"
+    responses.add(responses.POST, url, json={"created": 3}, status=200)
+    cnv_vcf = SingleSampleVCF(path="/data/fake_sample_1.cnv.vcf", variant_caller=VariantCaller(name="cnv", version="1"))
+    sequencing_files = list(vg_objects["sequencing_files"])
+    sf = sequencing_files[0]
+    sequencing_files[0] = dataclasses.replace(sf, vcf_files=sf.vcf_files + [cnv_vcf])
+    api.create_sequencing_data(vg_objects["sample_sheet_lookup"], sequencing_files)
+
+    records = _last_json()["records"]
+    assert [r["sample_name"] for r in records] == ["fake_sample_1", "fake_sample_1", "fake_sample_2"]
+    first, second = records[0], records[1]
+    assert "vcf_files" not in first
+    assert first["vcf_file"]["path"] == sf.vcf_files[0].path
+    assert second["vcf_file"]["path"] == "/data/fake_sample_1.cnv.vcf"
+    assert second["bam_file"] == first["bam_file"]
+    assert second["unaligned_reads"] == first["unaligned_reads"]
+
+def test_create_sequencing_data_vcf_files_same_caller_raises(api, vg_objects):
+    """ The server keeps one VCF per BAM and caller, so the second would silently replace the first's path """
+    sf = vg_objects["sequencing_files"][0]
+    same_caller = SingleSampleVCF(path="/data/other.vcf", variant_caller=sf.vcf_files[0].variant_caller)
+    sf = dataclasses.replace(sf, vcf_files=sf.vcf_files + [same_caller])
+    with pytest.raises(ValueError, match="fake_sample_1.*more than one VCF"):
+        api.create_sequencing_data(vg_objects["sample_sheet_lookup"], [sf])
+
+@responses.activate
+def test_create_sequencing_data_deprecated_vcf_file_still_sent(api, server, vg_objects):
+    """ vcf_file is deprecated for vcf_files, but a client still using it sends the same records as before """
+    url = f"{server}/seqauto/api/v1/sequencing_files/bulk_create"
+    responses.add(responses.POST, url, json={"created": 2}, status=200)
+    old_style = []
+    for sf in vg_objects["sequencing_files"]:
+        with pytest.warns(DeprecationWarning, match="vcf_file is deprecated"):
+            old_style.append(SequencingFile(sample_name=sf.sample_name, bam_file=sf.bam_file,
+                                            vcf_file=sf.vcf_files[0], fastq_r1=sf.fastq_r1, fastq_r2=sf.fastq_r2))
+    api.create_sequencing_data(vg_objects["sample_sheet_lookup"], old_style)
+    old_records = _last_json()["records"]
+
+    api.create_sequencing_data(vg_objects["sample_sheet_lookup"], vg_objects["sequencing_files"])
+    assert old_records == _last_json()["records"]
+    assert old_style[0].vcf_file.path == old_style[0].get_vcf_files()[0].path
+
 def assert_post(api_call, url):
     responses.add(responses.POST, url, json={"ok": True}, status=200)
     out = api_call()

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0}/tests/test_api_client_capabilities.py

@@ -6,7 +6,7 @@ import requests
 import responses
 
 from variantgrid_api.api_client import VariantGridAPI, UnsupportedFeaturePolicy, UnsupportedFeatureError
-from variantgrid_api.data_models import ServerCapabilities
+from variantgrid_api.data_models import ServerCapabilities, ServerFeature, UploadFileType
 
 CVO = "dragen_tso500_combined_variant_output"
 
@@ -53,6 +53,33 @@ def test_capabilities_parsed_and_fetched_once(api, capabilities_url, capabilitie
     assert len(_capabilities_calls(capabilities_url)) == 1
 
 
+@responses.activate
+def test_capabilities_accept_enums(api, capabilities_url, capabilities_json):
+    """ SACGF/variantgrid_api#22 - the enums are str, so they match the plain names the server sends """
+    responses.add(responses.GET, capabilities_url, json=capabilities_json, status=200)
+
+    assert all(api.supports(feature) for feature in ServerFeature)
+    assert api.accepts_upload(UploadFileType.DRAGEN_TSO500_COMBINED_VARIANT_OUTPUT)
+    assert not api.accepts_upload(UploadFileType.GENE_LIST)
+
+
+def test_enums_are_their_server_names():
+    assert ServerFeature.PATIENTS == "patients"
+    assert str(UploadFileType.DRAGEN_TSO500_COMBINED_VARIANT_OUTPUT) == CVO
+    assert f"'{ServerFeature.UPLOAD_METADATA}'" == "'upload_metadata'"
+    for enum_class in (ServerFeature, UploadFileType):
+        for member in enum_class:
+            assert member.value == member.name.lower()
+
+
+@responses.activate
+def test_unsupported_message_names_feature_value(api, capabilities_url, vg_objects):
+    responses.add(responses.GET, capabilities_url, json={"detail": "Not found."}, status=404)
+
+    with pytest.raises(UnsupportedFeatureError, match="feature 'patients'"):
+        api.create_patient(vg_objects["patient"])
+
+
 @responses.activate
 def test_capabilities_404_is_legacy(api, capabilities_url):
     responses.add(responses.GET, capabilities_url, json={"detail": "Not found."}, status=404)

{variantgrid_api-1.5.0 → variantgrid_api-1.7.0}/tests/test_mock_variantgrid_api.py

@@ -3,7 +3,7 @@ overrides, and assertion helpers work correctly."""
 import pytest
 
 from variantgrid_api.api_client import UnsupportedFeaturePolicy, UnsupportedFeatureError
-from variantgrid_api.data_models import ServerCapabilities
+from variantgrid_api.data_models import ServerCapabilities, ServerFeature, UploadFileType
 from variantgrid_api.mock_variantgrid_api import MockVariantGridAPI
 
 
@@ -240,6 +240,15 @@ def test_mock_default_capabilities_support_everything_gated(mock_api, vg_objects
         (("cvo.tsv",), {"path": None, "file_type": "dragen_tso500_combined_variant_output"})]
 
 
+def test_mock_default_capabilities_accept_enums(mock_api):
+    assert all(mock_api.supports(feature) for feature in ServerFeature)
+    assert mock_api.supports("upload_status")
+    assert mock_api.accepts_upload(UploadFileType.DRAGEN_TSO500_COMBINED_VARIANT_OUTPUT)
+    assert not mock_api.accepts_upload(UploadFileType.PED)
+    mock_api.upload_file("cvo.tsv", path=None, file_type=UploadFileType.DRAGEN_TSO500_COMBINED_VARIANT_OUTPUT)
+    mock_api.assert_called_once("upload_file")
+
+
 def test_mock_legacy_skips_under_skip(vg_objects):
     mock_api = MockVariantGridAPI(capabilities=ServerCapabilities.LEGACY,
                                   unsupported_feature_policy=UnsupportedFeaturePolicy.SKIP)