variantgrid-api 1.0.0__tar.gz → 1.2.0__tar.gz

{variantgrid_api-1.0.0/src/variantgrid_api.egg-info → variantgrid_api-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.0.0
+Version: 1.2.0
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License: MIT License
@@ -35,11 +35,41 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: dataclasses-json
-Requires-Dist: samshee
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-cov>=5; extra == "test"
+Requires-Dist: responses; extra == "test"
 Dynamic: license-file
 
 # variantgrid_api
 
+[![PyPi version](https://img.shields.io/pypi/v/variantgrid_api.svg)](https://pypi.org/project/variantgrid_api/) [![Python versions](https://img.shields.io/pypi/pyversions/variantgrid_api.svg)](https://pypi.org/project/variantgrid_api/)
+
 Python API client for [VariantGrid](https://github.com/SACGF/variantgrid) Open source Variant database and analysis platform
 
 See [changelog](https://github.com/SACGF/variantgrid_api/blob/main/CHANGELOG.md)
+
+## Install
+
+```
+python3 -m pip install variantgrid_api
+```
+
+## Example
+
+```
+from variantgrid_api.api_client import VariantGridAPI
+from variantgrid_api.data_models import EnrichmentKit
+
+api = VariantGridAPI(server="https://variantgrid.com", api_token="YOUR_API_TOKEN")
+enrichment_kit = EnrichmentKit(name="idt_haem", version=1)
+result = api.create_enrichment_kit(enrichment_kit)
+```
+
+## Testing
+
+```
+# Install required testing packages
+python3 -m pip install -e ".[test]"
+python3 -m pytest --cov=variantgrid_api
+```

variantgrid_api-1.2.0/README.md

@@ -0,0 +1,32 @@
+# variantgrid_api
+
+[![PyPi version](https://img.shields.io/pypi/v/variantgrid_api.svg)](https://pypi.org/project/variantgrid_api/) [![Python versions](https://img.shields.io/pypi/pyversions/variantgrid_api.svg)](https://pypi.org/project/variantgrid_api/)
+
+Python API client for [VariantGrid](https://github.com/SACGF/variantgrid) Open source Variant database and analysis platform
+
+See [changelog](https://github.com/SACGF/variantgrid_api/blob/main/CHANGELOG.md)
+
+## Install
+
+```
+python3 -m pip install variantgrid_api
+```
+
+## Example
+
+```
+from variantgrid_api.api_client import VariantGridAPI
+from variantgrid_api.data_models import EnrichmentKit
+
+api = VariantGridAPI(server="https://variantgrid.com", api_token="YOUR_API_TOKEN")
+enrichment_kit = EnrichmentKit(name="idt_haem", version=1)
+result = api.create_enrichment_kit(enrichment_kit)
+```
+
+## Testing
+
+```
+# Install required testing packages
+python3 -m pip install -e ".[test]"
+python3 -m pytest --cov=variantgrid_api
+```

{variantgrid_api-1.0.0 → variantgrid_api-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "variantgrid_api"
-version = "1.0.0"
+version = "1.2.0"
 description = "A Python API client for VariantGrid"
 authors = [
     { name = "Dave Lawrence", email = "davmlaw@gmail.com" }
@@ -21,9 +21,11 @@ classifiers = [
 dependencies = [
     "requests",
     "dataclasses-json",
-    "samshee"
 ]
 
+[project.optional-dependencies]
+test = ["pytest>=8", "pytest-cov>=5", "responses"]
+
 [project.urls]
 "Homepage" = "https://github.com/SACGF/variantgrid_api"
 

{variantgrid_api-1.0.0 → variantgrid_api-1.2.0}/src/variantgrid_api/api_client.py

@@ -1,13 +1,15 @@
 import datetime
 import json
 import logging
-import os
-from typing import List, Optional
+import urllib
+from enum import Enum
+from typing import List, Optional, Callable
 
 import requests
 
 from variantgrid_api.data_models import EnrichmentKit, SequencingRun, SampleSheet, SampleSheetCombinedVCFFile, \
-    SampleSheetLookup, SequencingFile, QCGeneList, QCExecStats, QCGeneCoverage
+    SampleSheetLookup, SequencingFile, QCGeneList, QCExecStats, QCGeneCoverage, SequencerModel, Sequencer
+
 
 class DateTimeEncoder(json.JSONEncoder):
     def default(self,o):
@@ -16,18 +18,35 @@ class DateTimeEncoder(json.JSONEncoder):
         return super().default(o)
 
 
+class EmptyInputPolicy(Enum):
+    IGNORE = "ignore"
+    WARN = "warn"
+    ERROR = "error"
+
 
 class VariantGridAPI:
-    def __init__(self, server, api_token):
+    def __init__(self, server, api_token,
+                 empty_input_policy=EmptyInputPolicy.ERROR,
+                 logger: Optional[logging.Logger] = None,
+                 log_request=False, log_response=False
+    ):
         self.server = server
         self.headers = {"Authorization": f"Token {api_token}"}
+        if logger is None:
+            logger = logging.getLogger(__name__)
+        self.logger = logger
+        self.validation_handler = self._get_validation_handler(empty_input_policy, logger)
+        self.log_request = log_request
+        self.log_response = log_response
 
     def _get_url(self, url):
-        return os.path.join(self.server, url)
+        return urllib.parse.urljoin(self.server, url)
 
     def _post(self, path, json_data):
         url = self._get_url(path)
         json_string = json.dumps(json_data, cls=DateTimeEncoder)
+        if self.log_request:
+            self.logger.info("POST to '%s', JSON: %s", url, json_string)
         response = requests.post(url,
                                  headers={**self.headers, "Content-Type": "application/json"},
                                  data=json_string)
@@ -38,30 +57,78 @@ class VariantGridAPI:
     def _handle_json_response(self, response, extra_error_message: Optional[str] = None):
         try:
             json_response = response.json()
+            if self.log_response:
+                self.logger.info("Response from '%s', JSON: %s", response.url, json_response)
         except Exception as e:
             json_response = f"Couldn't convert JSON: {e}"
         if not response.ok:
             if extra_error_message:
-                logging.error(extra_error_message)
-            logging.error("Response: %s", json_response)
+                self.logger.error(extra_error_message)
+            self.logger.error("Response: %s", json_response)
             response.raise_for_status()
         return json_response
 
+    @staticmethod
+    def _get_validation_handler(empty_input_policy: EmptyInputPolicy, logger: logging.Logger) -> Callable:
+        def _ignore(msg):
+            pass
+
+        def _warn(msg):
+            logger.warning(msg)
+
+        def _error(msg):
+            raise ValueError(msg)
+
+        return {
+            EmptyInputPolicy.IGNORE: _ignore,
+            EmptyInputPolicy.WARN: _warn,
+            EmptyInputPolicy.ERROR: _error,
+        }[empty_input_policy]
+
+    def _validate_string(self, info: str, s: Optional[str]) -> None:
+        if s is None:
+            self.validation_handler(f"{info}: is None")
+        elif s == "":
+            self.validation_handler(f"{info}: empty string")
+
+    def _validate_object(self, info: str, obj):
+        if obj is None:
+            self.validation_handler(f"{info}: is None")
+
+    def _validate_list(self, info: str, list_obj: List):
+        if not list_obj:
+            self.validation_handler(f"{info}: empty list")
+
     def create_experiment(self, experiment: str):
+        self._validate_string("experiment", experiment)
         json_data = {
             "name": experiment
         }
         return self._post("seqauto/api/v1/experiment/", json_data)
 
     def create_enrichment_kit(self, enrichment_kit: EnrichmentKit):
+        self._validate_object("enrichment_kit", enrichment_kit)
         return self._post("seqauto/api/v1/enrichment_kit/",
                           enrichment_kit.to_dict())
 
+
+    def create_sequencer_model(self, sequencer_model: SequencerModel):
+        self._validate_object("sequencer_model", sequencer_model)
+        return self._post("seqauto/api/v1/sequencer_model/",
+                          sequencer_model.to_dict())
+
+    def create_sequencer(self, sequencer: Sequencer):
+        self._validate_object("sequencer", sequencer)
+        return self._post("seqauto/api/v1/sequencer/",
+                          sequencer.to_dict())
+
     def create_sequencing_run(self, sequencing_run: SequencingRun):
+        self._validate_object("sequencing_run", sequencing_run)
         return self._post("seqauto/api/v1/sequencing_run/",
                           sequencing_run.to_dict())
 
     def create_sample_sheet(self, sample_sheet: SampleSheet):
+        self._validate_object("sample_sheet", sample_sheet)
         json_data = sample_sheet.to_dict()
         # We don't want all sequencing_run just the name
         sequencing_run = json_data.pop("sequencing_run")
@@ -70,11 +137,14 @@ class VariantGridAPI:
                           json_data)
 
     def create_sample_sheet_combined_vcf_file(self, sample_sheet_combined_vcf_file: SampleSheetCombinedVCFFile):
+        self._validate_object("sample_sheet_combined_vcf_file", sample_sheet_combined_vcf_file)
         json_data = sample_sheet_combined_vcf_file.to_dict()
         return self._post("seqauto/api/v1/sample_sheet_combined_vcf_file/",
                           json_data)
 
     def create_sequencing_data(self, sample_sheet_lookup: SampleSheetLookup, sequencing_files: List[SequencingFile]):
+        self._validate_object("sample_sheet_lookup", sample_sheet_lookup)
+        self._validate_list("sequencing_files", sequencing_files)
         records = []
         for sf in sequencing_files:
             data = sf.to_dict()
@@ -95,12 +165,14 @@ class VariantGridAPI:
                           json_data)
 
     def create_qc_gene_list(self, qc_gene_list: QCGeneList):
+        self._validate_object("qc_gene_list", qc_gene_list)
         json_data = qc_gene_list.to_dict()
         return self._post("seqauto/api/v1/qc_gene_list/",
                           json_data)
 
 
     def create_multiple_qc_gene_lists(self, qc_gene_lists: List[QCGeneList]):
+        self._validate_list("qc_gene_lists", qc_gene_lists)
         json_data = {
             "records": [
                 qcgl.to_dict() for qcgl in qc_gene_lists
@@ -110,11 +182,13 @@ class VariantGridAPI:
                           json_data)
 
     def create_qc_exec_stats(self, qc_exec_stats: QCExecStats):
+        self._validate_object("qc_exec_stats", qc_exec_stats)
         json_data = qc_exec_stats.to_dict()
         return self._post("seqauto/api/v1/qc_exec_summary/",
                           json_data)
 
     def create_multiple_qc_exec_stats(self, qc_exec_stats: List[QCExecStats]):
+        self._validate_list("qc_exec_stats", qc_exec_stats)
         json_data = {
             "records": [
                 qces.to_dict() for qces in qc_exec_stats
@@ -124,6 +198,7 @@ class VariantGridAPI:
                           json_data)
 
     def create_multiple_qc_gene_coverage(self, qc_gene_coverage_list: List[QCGeneCoverage]):
+        self._validate_list("qc_gene_coverage_list", qc_gene_coverage_list)
         json_data = {
             "records": [
                 qcgc.to_dict() for qcgc in qc_gene_coverage_list

{variantgrid_api-1.0.0 → variantgrid_api-1.2.0}/src/variantgrid_api/data_models.py

@@ -13,6 +13,50 @@ class EnrichmentKit:
     version: int
 
 
+@dataclass_json
+@dataclass
+class Manufacturer:
+    name: str
+
+@dataclass_json
+@dataclass
+class SequencerModel:
+    model: str
+    manufacturer: Manufacturer
+    data_naming_convention: str # 'M' or 'H' for (HiSeq only)
+
+    # (prefix, model_name, data_naming_convention)
+    _ILLUMINA_PREFIXES = [
+        ("LH", "NovaSeq X",    "M"),
+        ("NB", "NextSeq",      "M"),
+        ("NS", "NextSeq",      "M"),
+        ("A",  "NovaSeq 6000", "M"),
+        ("H",  "HiSeq",        "H"),
+        ("M",  "MiSeq",        "M"),
+    ]
+
+    @classmethod
+    def from_sequencer_name(cls, sequencer_name: str) -> 'SequencerModel':
+        """Infer SequencerModel from an Illumina sequencer instrument name.
+
+        Illumina instrument names begin with a letter code that identifies the
+        platform (e.g. ``M02027`` → MiSeq, ``A01234`` → NovaSeq 6000).
+        Returns an Unknown model when no prefix matches.
+        """
+        illumina = Manufacturer(name="Illumina")
+        for prefix, model_name, convention in cls._ILLUMINA_PREFIXES:
+            if sequencer_name.startswith(prefix):
+                return cls(model=model_name, manufacturer=illumina, data_naming_convention=convention)
+        return cls(model="Unknown", manufacturer=illumina, data_naming_convention="U")
+
+
+@dataclass_json
+@dataclass
+class Sequencer:
+    name: str
+    sequencer_model: SequencerModel
+
+
 @dataclass_json
 @dataclass
 class SequencingRun:

variantgrid_api-1.2.0/src/variantgrid_api/mock_variantgrid_api.py

@@ -0,0 +1,134 @@
+"""
+Mock replacement for variantgrid_api.api_client.VariantGridAPI.
+
+Records every call so tests can assert on what was sent without making any
+
+Usage::
+
+    api = MockVariantGridAPI()
+    api.create_experiment("HAEM_25_080")
+    api.assert_called_once("create_experiment")
+    api.assert_not_called("sequencing_run_has_vcf")
+"""
+from __future__ import annotations
+
+import copy
+from typing import Any, List, Optional, Tuple
+
+
+class MockVariantGridAPI:
+    """Drop-in replacement for VariantGridAPI that records all calls."""
+
+    def __init__(self):
+        # List of (method_name, args, kwargs) in call order
+        self.calls: List[Tuple[str, tuple, dict]] = []
+        self._return_values: dict = {}
+
+    # ------------------------------------------------------------------ #
+    # Introspection helpers                                               #
+    # ------------------------------------------------------------------ #
+
+    def _record(self, method: str, *args, **kwargs):
+        self.calls.append((method, args, kwargs))
+
+    def _ret(self, method: str, default: Any) -> Any:
+        return copy.deepcopy(self._return_values.get(method, default))
+
+    def set_return(self, method: str, value: Any) -> None:
+        """Override the default return value for a given method."""
+        self._return_values[method] = value
+
+    def get_calls(self, method: str) -> List[Tuple[tuple, dict]]:
+        """Return all (args, kwargs) pairs recorded for *method*."""
+        return [(a, kw) for name, a, kw in self.calls if name == method]
+
+    def call_count(self, method: str) -> int:
+        return len(self.get_calls(method))
+
+    def assert_called_once(self, method: str) -> None:
+        n = self.call_count(method)
+        assert n == 1, f"Expected {method!r} called once, was called {n} times"
+
+    def assert_not_called(self, method: str) -> None:
+        n = self.call_count(method)
+        assert n == 0, f"Expected {method!r} not called, was called {n} times"
+
+    def reset(self) -> None:
+        self.calls.clear()
+
+    # ------------------------------------------------------------------ #
+    # API surface — mirrors VariantGridAPI public methods exactly         #
+    # ------------------------------------------------------------------ #
+
+    def create_experiment(self, experiment):
+        self._record("create_experiment", experiment)
+        return self._ret("create_experiment", {"name": experiment})
+
+    def create_enrichment_kit(self, enrichment_kit):
+        self._record("create_enrichment_kit", enrichment_kit)
+        return self._ret("create_enrichment_kit", {
+            "name": enrichment_kit.name,
+            "version": enrichment_kit.version,
+            "gene_list": {
+                "genelistgenesymbol_set": [
+                    {"gene_symbol": "BRCA1"},
+                    {"gene_symbol": "BRCA2"},
+                ]
+            },
+        })
+
+    def create_sequencer_model(self, sequencer_model):
+        self._record("create_sequencer_model", sequencer_model)
+        return self._ret("create_sequencer_model", {"model": sequencer_model.model})
+
+    def create_sequencer(self, sequencer):
+        self._record("create_sequencer", sequencer)
+        return self._ret("create_sequencer", {"name": sequencer.name})
+
+    def create_sequencing_run(self, sequencing_run):
+        self._record("create_sequencing_run", sequencing_run)
+        return self._ret("create_sequencing_run", {"name": sequencing_run.name})
+
+    def create_sample_sheet(self, sample_sheet):
+        self._record("create_sample_sheet", sample_sheet)
+        return self._ret("create_sample_sheet", {"path": sample_sheet.path})
+
+    def create_sample_sheet_combined_vcf_file(self, sscvf):
+        self._record("create_sample_sheet_combined_vcf_file", sscvf)
+        return self._ret("create_sample_sheet_combined_vcf_file", {"path": sscvf.path})
+
+    def create_sequencing_data(self, sample_sheet_lookup, sequencing_files):
+        self._record("create_sequencing_data", sample_sheet_lookup, sequencing_files)
+        return self._ret("create_sequencing_data", {"created": len(sequencing_files)})
+
+    def create_qc_gene_list(self, qc_gene_list):
+        self._record("create_qc_gene_list", qc_gene_list)
+        return self._ret("create_qc_gene_list", {})
+
+    def create_multiple_qc_gene_lists(self, qc_gene_lists):
+        self._record("create_multiple_qc_gene_lists", qc_gene_lists)
+        return self._ret("create_multiple_qc_gene_lists", {"created": len(qc_gene_lists)})
+
+    def create_qc_exec_stats(self, qc_exec_stats):
+        self._record("create_qc_exec_stats", qc_exec_stats)
+        return self._ret("create_qc_exec_stats", {})
+
+    def create_multiple_qc_exec_stats(self, qc_exec_stats):
+        self._record("create_multiple_qc_exec_stats", qc_exec_stats)
+        return self._ret("create_multiple_qc_exec_stats", {"created": len(qc_exec_stats)})
+
+    def create_multiple_qc_gene_coverage(self, qc_gene_coverage_list):
+        self._record("create_multiple_qc_gene_coverage", qc_gene_coverage_list)
+        return self._ret("create_multiple_qc_gene_coverage", {"created": len(qc_gene_coverage_list)})
+
+    def upload_file(self, filename):
+        self._record("upload_file", filename)
+        return self._ret("upload_file", {"path": filename, "status": "ok"})
+
+    def sequencing_run_has_vcf(self, sequencing_run, path=None):
+        self._record("sequencing_run_has_vcf", sequencing_run, path)
+        return self._ret("sequencing_run_has_vcf", True)
+
+    def sequencing_run_name_has_vcf(self, sequencing_run_name, path=None):
+        self._record("sequencing_run_name_has_vcf", sequencing_run_name, path)
+        return self._ret("sequencing_run_name_has_vcf", True)

{variantgrid_api-1.0.0 → variantgrid_api-1.2.0/src/variantgrid_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.0.0
+Version: 1.2.0
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License: MIT License
@@ -35,11 +35,41 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: dataclasses-json
-Requires-Dist: samshee
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pytest-cov>=5; extra == "test"
+Requires-Dist: responses; extra == "test"
 Dynamic: license-file
 
 # variantgrid_api
 
+[![PyPi version](https://img.shields.io/pypi/v/variantgrid_api.svg)](https://pypi.org/project/variantgrid_api/) [![Python versions](https://img.shields.io/pypi/pyversions/variantgrid_api.svg)](https://pypi.org/project/variantgrid_api/)
+
 Python API client for [VariantGrid](https://github.com/SACGF/variantgrid) Open source Variant database and analysis platform
 
 See [changelog](https://github.com/SACGF/variantgrid_api/blob/main/CHANGELOG.md)
+
+## Install
+
+```
+python3 -m pip install variantgrid_api
+```
+
+## Example
+
+```
+from variantgrid_api.api_client import VariantGridAPI
+from variantgrid_api.data_models import EnrichmentKit
+
+api = VariantGridAPI(server="https://variantgrid.com", api_token="YOUR_API_TOKEN")
+enrichment_kit = EnrichmentKit(name="idt_haem", version=1)
+result = api.create_enrichment_kit(enrichment_kit)
+```
+
+## Testing
+
+```
+# Install required testing packages
+python3 -m pip install -e ".[test]"
+python3 -m pytest --cov=variantgrid_api
+```

variantgrid_api-1.2.0/src/variantgrid_api.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+src/variantgrid_api/api_client.py
+src/variantgrid_api/data_models.py
+src/variantgrid_api/mock_variantgrid_api.py
+src/variantgrid_api.egg-info/PKG-INFO
+src/variantgrid_api.egg-info/SOURCES.txt
+src/variantgrid_api.egg-info/dependency_links.txt
+src/variantgrid_api.egg-info/requires.txt
+src/variantgrid_api.egg-info/top_level.txt
+tests/test_api_client.py
+tests/test_api_client_bulk.py
+tests/test_api_client_validation.py
+tests/test_data_models.py
+tests/test_mock_variantgrid_api.py
+tests/test_sequencer_model_from_name.py

variantgrid_api-1.2.0/src/variantgrid_api.egg-info/requires.txt

@@ -0,0 +1,7 @@
+requests
+dataclasses-json
+
+[test]
+pytest>=8
+pytest-cov>=5
+responses

variantgrid_api-1.2.0/tests/test_api_client.py

@@ -0,0 +1,228 @@
+import datetime
+import json
+import logging
+
+import pytest
+import responses
+
+from variantgrid_api.api_client import VariantGridAPI, DateTimeEncoder
+
+
+def _last_json():
+    r = responses.calls[-1].request
+    return json.loads(r.body)
+
+@responses.activate
+def test_create_experiment(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/experiment/"
+    responses.add(responses.POST, url, json={"id": 1}, status=200)
+    out = api.create_experiment(vg_objects["experiment"])
+    assert out == {"id": 1}
+    assert responses.calls[-1].request.headers["Authorization"] == "Token TKN"
+
+@responses.activate
+def test_create_sample_sheet_rewrites_sequencing_run_to_name(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/sample_sheet/"
+    responses.add(responses.POST, url, json={"id": 2}, status=200)
+    api.create_sample_sheet(vg_objects["sample_sheet"])
+    body = _last_json()
+    assert isinstance(body["sequencing_run"], str)
+
+@responses.activate
+def test_create_sequencing_data_builds_unaligned_reads(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/sequencing_files/bulk_create"
+    responses.add(responses.POST, url, json={"created": 2}, status=200)
+    api.create_sequencing_data(vg_objects["sample_sheet_lookup"], vg_objects["sequencing_files"])
+    body = _last_json()
+    assert "records" in body and len(body["records"]) == 2
+    r0 = body["records"][0]
+    assert "unaligned_reads" in r0
+    assert "fastq_r1" in r0["unaligned_reads"] and "path" in r0["unaligned_reads"]["fastq_r1"]
+
+def assert_post(api_call, url):
+    responses.add(responses.POST, url, json={"ok": True}, status=200)
+    out = api_call()
+    assert out == {"ok": True}
+    body = json.loads(responses.calls[-1].request.body)
+    assert body
+    return body
+
+@responses.activate
+def test_create_enrichment_kit_posts_json(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/enrichment_kit/"
+    body = assert_post(
+        lambda: api.create_enrichment_kit(vg_objects["enrichment_kit"]),
+        url
+    )
+    assert body["name"] == "idt_haem"
+
+
+@responses.activate
+def test_create_sequencer_model_posts_json(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/sequencer_model/"
+    body = assert_post(
+        lambda: api.create_sequencer_model(vg_objects["sequencer_model"]),
+        url
+    )
+    assert body["model"] == "HiSeq 2500"
+
+
+@responses.activate
+def test_create_sequencer_posts_json(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/sequencer/"
+    body = assert_post(
+        lambda: api.create_sequencer(vg_objects["sequencer"]),
+        url
+    )
+    assert body["name"] == "SN1101"
+
+
+@responses.activate
+def test_create_sequencing_run_posts_json(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/sequencing_run/"
+    body = assert_post(
+        lambda: api.create_sequencing_run(vg_objects["sequencing_run"]),
+        url
+    )
+    assert body["name"] == vg_objects["SEQUENCING_RUN_NAME"]
+
+
+@responses.activate
+def test_create_sample_sheet_combined_vcf_file_posts_json(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/sample_sheet_combined_vcf_file/"
+    body = assert_post(
+        lambda: api.create_sample_sheet_combined_vcf_file(
+            vg_objects["sample_sheet_combined_vcf_file"]
+        ),
+        url
+    )
+    assert body["path"].endswith(".vcf.gz")
+
+
+@responses.activate
+def test_upload_file_calls_expected_url_and_query_param(api, server, vg_objects):
+    filename = vg_objects["qc_gene_coverage_list"][0].path
+    url = f"{server}/upload/api/v1/file_upload"
+    responses.add(responses.POST, url, json={"uploaded": True}, status=200)
+    out = api.upload_file(filename)
+    assert out == {"uploaded": True}
+    assert responses.calls[-1].request.url.startswith(url)
+    assert "path=" in responses.calls[-1].request.url
+
+
+@responses.activate
+def test_sequencing_run_has_vcf(api, server, vg_objects):
+    sequencing_run = vg_objects["sequencing_run"]
+    name = sequencing_run.name
+    url = f"{server}/seqauto/api/v1/sequencing_run/{name}/"
+    responses.add(responses.GET, url, json={"vcf_set":[{"path":"/x/a.vcf.gz"}]}, status=200)
+
+    assert api.sequencing_run_has_vcf(sequencing_run) is True
+    assert api.sequencing_run_has_vcf(sequencing_run, "a.vcf.gz") is True
+    assert api.sequencing_run_has_vcf(sequencing_run, "no_vcf_here") is False
+
+
+@responses.activate
+def test_create_qc_gene_list_posts(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/qc_gene_list/"
+    responses.add(responses.POST, url, json={"ok": True}, status=200)
+
+    out = api.create_qc_gene_list(vg_objects["qc_gene_lists"][0])
+    assert out == {"ok": True}
+    body = _last_json()
+    assert "gene_list" in body and len(body["gene_list"]) > 0
+
+@responses.activate
+def test_create_qc_exec_stats_posts(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/qc_exec_summary/"
+    responses.add(responses.POST, url, json={"ok": True}, status=200)
+
+    out = api.create_qc_exec_stats(vg_objects["qc_exec_stats"][0])
+    assert out == {"ok": True}
+    body = _last_json()
+    assert "reads" in body
+
+import responses
+
+@responses.activate
+def test_log_request_emits_log(server, api_token, vg_objects, caplog):
+    logger = logging.getLogger("variantgrid_api.test")
+    caplog.set_level(logging.INFO, logger=logger.name)
+
+    api = VariantGridAPI(
+        server, api_token,
+        logger=logger,
+        log_request=True
+    )
+    url = f"{server}/seqauto/api/v1/experiment/"
+    responses.add(responses.POST, url, json={"ok": True}, status=200)
+
+    api.create_experiment(vg_objects["experiment"])
+
+    assert any("POST to" in r.message for r in caplog.records)
+
+
+
+@responses.activate
+def test_log_response_emits_log(server, api_token, vg_objects, caplog):
+    logger = logging.getLogger("variantgrid_api.test")
+    caplog.set_level(logging.INFO, logger=logger.name)
+
+    api = VariantGridAPI(
+        server, api_token,
+        logger=logger,
+        log_response=True
+    )
+    url = f"{server}/seqauto/api/v1/experiment/"
+    responses.add(responses.POST, url, json={"ok": True}, status=200)
+
+    api.create_experiment(vg_objects["experiment"])
+
+    assert any("Response from" in r.message for r in caplog.records)
+
+
+@responses.activate
+def test_bad_response_raises_and_logs(server, api_token, vg_objects, caplog):
+    logger = logging.getLogger("variantgrid_api.test")
+    caplog.set_level(logging.INFO, logger=logger.name)
+
+    api = VariantGridAPI(server, api_token, logger=logger)
+    url = f"{server}/seqauto/api/v1/experiment/"
+    responses.add(
+        responses.POST,
+        url,
+        json={"detail": "bad request"},
+        status=400
+    )
+
+    with pytest.raises(Exception):
+        api.create_experiment(vg_objects["experiment"])
+
+    assert any("Response:" in r.message for r in caplog.records)
+
+
+@responses.activate
+def test_bad_response_non_json_body(server, api_token, vg_objects):
+    api = VariantGridAPI(server, api_token)
+    url = f"{server}/seqauto/api/v1/experiment/"
+    responses.add(
+        responses.POST,
+        url,
+        body="not json",
+        status=500,
+        content_type="text/plain"
+    )
+
+    with pytest.raises(Exception):
+        api.create_experiment(vg_objects["experiment"])
+
+
+def test_datetime_encoder_handles_date_and_rejects_unknown():
+    s = json.dumps(
+        {"d": datetime.date(2026, 1, 14)},
+        cls=DateTimeEncoder
+    )
+    assert s == '{"d": "2026-01-14"}'
+
+    with pytest.raises(TypeError):
+        json.dumps({"x": object()}, cls=DateTimeEncoder)

variantgrid_api-1.2.0/tests/test_api_client_bulk.py

@@ -0,0 +1,46 @@
+import json, responses
+
+def assert_bulk_post(api_call, url, n):
+    responses.add(responses.POST, url, json={"ok": True}, status=200)
+    out = api_call()
+    assert out == {"ok": True}
+    body = json.loads(responses.calls[-1].request.body)
+    assert "records" in body
+    assert isinstance(body["records"], list)
+    assert len(body["records"]) == n
+    assert all(isinstance(r, dict) and r for r in body["records"])
+    return body["records"]
+
+
+@responses.activate
+def test_create_multiple_qc_gene_lists(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/qc_gene_list/bulk_create"
+    records = assert_bulk_post(
+        lambda: api.create_multiple_qc_gene_lists(vg_objects["qc_gene_lists"]),
+        url,
+        n=len(vg_objects["qc_gene_lists"])
+    )
+    assert "gene_list" in records[0]
+    assert len(records[0]["gene_list"]) > 0
+
+
+@responses.activate
+def test_create_multiple_qc_exec_stats(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/qc_exec_summary/bulk_create"
+    records = assert_bulk_post(
+        lambda: api.create_multiple_qc_exec_stats(vg_objects["qc_exec_stats"]),
+        url,
+        n=len(vg_objects["qc_exec_stats"])
+    )
+    assert "reads" in records[0]
+
+
+@responses.activate
+def test_create_multiple_qc_gene_coverage(api, server, vg_objects):
+    url = f"{server}/seqauto/api/v1/qc_gene_coverage/bulk_create"
+    records = assert_bulk_post(
+        lambda: api.create_multiple_qc_gene_coverage(vg_objects["qc_gene_coverage_list"]),
+        url,
+        n=len(vg_objects["qc_gene_coverage_list"])
+    )
+    assert "path" in records[0]

variantgrid_api-1.2.0/tests/test_api_client_validation.py

@@ -0,0 +1,75 @@
+import pytest, responses
+from variantgrid_api.api_client import VariantGridAPI, EmptyInputPolicy
+
+import responses
+
+def run_validation_call(api_call, url=None, method=responses.POST, response_json={"ok": True}):
+    if url:
+        responses.add(method, url, json=response_json, status=200)
+    return api_call()
+
+@responses.activate
+def test_error_policy_empty_list_raises(server, api_token):
+    api = VariantGridAPI(server, api_token, empty_input_policy=EmptyInputPolicy.ERROR)
+
+    with pytest.raises(ValueError):
+        run_validation_call(
+            lambda: api.create_multiple_qc_gene_lists([])
+        )
+
+    assert len(responses.calls) == 0
+
+@responses.activate
+def test_warn_policy_empty_list_logs_and_posts(server, api_token, caplog):
+    api = VariantGridAPI(server, api_token, empty_input_policy=EmptyInputPolicy.WARN)
+    url = f"{server}/seqauto/api/v1/qc_gene_list/bulk_create"
+
+    out = run_validation_call(
+        lambda: api.create_multiple_qc_gene_lists([]),
+        url=url
+    )
+
+    assert out == {"ok": True}
+    assert len(responses.calls) == 1
+    assert any("empty list" in r.message for r in caplog.records)
+
+@responses.activate
+def test_ignore_policy_empty_list_posts_silently(server, api_token, caplog):
+    api = VariantGridAPI(server, api_token, empty_input_policy=EmptyInputPolicy.IGNORE)
+    url = f"{server}/seqauto/api/v1/qc_gene_list/bulk_create"
+
+    out = run_validation_call(
+        lambda: api.create_multiple_qc_gene_lists([]),
+        url=url
+    )
+
+    assert out == {"ok": True}
+    assert len(responses.calls) == 1
+    assert not caplog.records
+
+
+import pytest, responses
+from variantgrid_api.api_client import VariantGridAPI, EmptyInputPolicy
+
+@responses.activate
+def test_validate_string_empty_raises(server, api_token):
+    api = VariantGridAPI(server, api_token, empty_input_policy=EmptyInputPolicy.ERROR)
+    with pytest.raises(ValueError):
+        api.create_experiment("")
+    assert len(responses.calls) == 0
+
+
+@responses.activate
+def test_validate_string_none_raises(server, api_token):
+    api = VariantGridAPI(server, api_token, empty_input_policy=EmptyInputPolicy.ERROR)
+    with pytest.raises(ValueError):
+        api.create_experiment(None)
+    assert len(responses.calls) == 0
+
+
+@responses.activate
+def test_validate_object_none_raises(server, api_token):
+    api = VariantGridAPI(server, api_token, empty_input_policy=EmptyInputPolicy.ERROR)
+    with pytest.raises(ValueError):
+        api.create_enrichment_kit(None)
+    assert len(responses.calls) == 0

variantgrid_api-1.2.0/tests/test_data_models.py

@@ -0,0 +1,11 @@
+from variantgrid_api.data_models import SequencingRun, SampleSheetLookup
+
+def test_get_date_from_name(vg_objects):
+    d = SequencingRun.get_date_from_name(vg_objects["SEQUENCING_RUN_NAME"])
+    assert d is not None
+
+def test_sample_sheet_lookup_from_sample_sheet(vg_objects):
+    ss = vg_objects["sample_sheet"]
+    ssl = SampleSheetLookup.from_sample_sheet(ss)
+    d = ssl.to_dict()
+    assert d

variantgrid_api-1.2.0/tests/test_mock_variantgrid_api.py

@@ -0,0 +1,141 @@
+"""Tests for MockVariantGridAPI — verifies call recording, return-value
+overrides, and assertion helpers work correctly."""
+import pytest
+
+from variantgrid_api.mock_variantgrid_api import MockVariantGridAPI
+
+
+@pytest.fixture
+def mock_api():
+    return MockVariantGridAPI()
+
+
+# ------------------------------------------------------------------ #
+# Call recording                                                       #
+# ------------------------------------------------------------------ #
+
+def test_calls_are_recorded(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    assert mock_api.call_count("create_experiment") == 1
+    assert mock_api.call_count("create_sequencing_run") == 0
+
+
+def test_multiple_calls_accumulate(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    mock_api.create_experiment(vg_objects["experiment"])
+    assert mock_api.call_count("create_experiment") == 2
+
+
+def test_get_calls_returns_args(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    calls = mock_api.get_calls("create_experiment")
+    assert len(calls) == 1
+    args, kwargs = calls[0]
+    assert args[0] == vg_objects["experiment"]
+
+
+def test_calls_from_different_methods_are_independent(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    mock_api.create_sequencing_run(vg_objects["sequencing_run"])
+    assert mock_api.call_count("create_experiment") == 1
+    assert mock_api.call_count("create_sequencing_run") == 1
+    assert mock_api.call_count("create_sample_sheet") == 0
+
+
+# ------------------------------------------------------------------ #
+# Assertion helpers                                                    #
+# ------------------------------------------------------------------ #
+
+def test_assert_called_once_passes(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    mock_api.assert_called_once("create_experiment")  # should not raise
+
+
+def test_assert_called_once_fails_when_not_called(mock_api):
+    with pytest.raises(AssertionError):
+        mock_api.assert_called_once("create_experiment")
+
+
+def test_assert_called_once_fails_when_called_twice(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    mock_api.create_experiment(vg_objects["experiment"])
+    with pytest.raises(AssertionError):
+        mock_api.assert_called_once("create_experiment")
+
+
+def test_assert_not_called_passes(mock_api):
+    mock_api.assert_not_called("create_experiment")  # should not raise
+
+
+def test_assert_not_called_fails_when_called(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    with pytest.raises(AssertionError):
+        mock_api.assert_not_called("create_experiment")
+
+
+# ------------------------------------------------------------------ #
+# Default return values                                                #
+# ------------------------------------------------------------------ #
+
+def test_default_return_create_experiment(mock_api, vg_objects):
+    result = mock_api.create_experiment(vg_objects["experiment"])
+    assert result == {"name": vg_objects["experiment"]}
+
+
+def test_default_return_sequencing_run_has_vcf(mock_api, vg_objects):
+    result = mock_api.sequencing_run_has_vcf(vg_objects["sequencing_run"])
+    assert result is True
+
+
+def test_default_return_create_sequencing_data(mock_api, vg_objects):
+    result = mock_api.create_sequencing_data(
+        vg_objects["sample_sheet_lookup"], vg_objects["sequencing_files"]
+    )
+    assert result == {"created": len(vg_objects["sequencing_files"])}
+
+
+def test_default_return_create_multiple_qc_gene_lists(mock_api, vg_objects):
+    result = mock_api.create_multiple_qc_gene_lists(vg_objects["qc_gene_lists"])
+    assert result == {"created": len(vg_objects["qc_gene_lists"])}
+
+
+# ------------------------------------------------------------------ #
+# set_return overrides                                                 #
+# ------------------------------------------------------------------ #
+
+def test_set_return_overrides_default(mock_api, vg_objects):
+    mock_api.set_return("create_experiment", {"name": "overridden", "id": 99})
+    result = mock_api.create_experiment(vg_objects["experiment"])
+    assert result == {"name": "overridden", "id": 99}
+
+
+def test_set_return_is_deep_copied(mock_api, vg_objects):
+    sentinel = {"name": "exp", "extra": []}
+    mock_api.set_return("create_experiment", sentinel)
+    r1 = mock_api.create_experiment(vg_objects["experiment"])
+    r1["extra"].append("mutated")
+    r2 = mock_api.create_experiment(vg_objects["experiment"])
+    assert r2["extra"] == [], "set_return should return independent copies each call"
+
+
+def test_set_return_sequencing_run_has_vcf_false(mock_api, vg_objects):
+    mock_api.set_return("sequencing_run_has_vcf", False)
+    assert mock_api.sequencing_run_has_vcf(vg_objects["sequencing_run"]) is False
+
+
+# ------------------------------------------------------------------ #
+# reset                                                                #
+# ------------------------------------------------------------------ #
+
+def test_reset_clears_calls(mock_api, vg_objects):
+    mock_api.create_experiment(vg_objects["experiment"])
+    mock_api.reset()
+    assert mock_api.call_count("create_experiment") == 0
+
+
+def test_reset_preserves_return_overrides(mock_api, vg_objects):
+    mock_api.set_return("create_experiment", {"id": 7})
+    mock_api.create_experiment(vg_objects["experiment"])
+    mock_api.reset()
+    result = mock_api.create_experiment(vg_objects["experiment"])
+    assert result == {"id": 7}

variantgrid_api-1.2.0/tests/test_sequencer_model_from_name.py

@@ -0,0 +1,32 @@
+import pytest
+from variantgrid_api.data_models import SequencerModel
+
+
+@pytest.mark.parametrize("name,expected_model,expected_convention", [
+    ("M02027",  "MiSeq",        "M"),
+    ("H001",    "HiSeq",        "H"),
+    ("NB551234","NextSeq",      "M"),
+    ("NS500123","NextSeq",      "M"),
+    ("A01234",  "NovaSeq 6000", "M"),
+    ("LH00999", "NovaSeq X",    "M"),
+    ("XYZ999",  "Unknown",      "U"),
+])
+def test_from_sequencer_name(name, expected_model, expected_convention):
+    sm = SequencerModel.from_sequencer_name(name)
+    assert sm.model == expected_model
+    assert sm.data_naming_convention == expected_convention
+    assert sm.manufacturer.name == "Illumina"
+
+
+def test_from_sequencer_name_matches_conftest_example():
+    # The conftest uses sequencer "SN1101" which doesn't match any prefix → Unknown
+    # But the run name contains "M02027" as the instrument — verify MiSeq detection
+    sm = SequencerModel.from_sequencer_name("M02027")
+    assert sm.model == "MiSeq"
+
+
+def test_lh_prefix_not_matched_as_h():
+    """NovaSeq X instruments start with LH — must not be classified as HiSeq."""
+    sm = SequencerModel.from_sequencer_name("LH00187")
+    assert sm.model == "NovaSeq X"
+    assert sm.data_naming_convention == "M"

variantgrid_api-1.0.0/README.md

@@ -1,5 +0,0 @@
-# variantgrid_api
-
-Python API client for [VariantGrid](https://github.com/SACGF/variantgrid) Open source Variant database and analysis platform
-
-See [changelog](https://github.com/SACGF/variantgrid_api/blob/main/CHANGELOG.md)

variantgrid_api-1.0.0/src/variantgrid_api.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-src/variantgrid_api/api_client.py
-src/variantgrid_api/data_models.py
-src/variantgrid_api.egg-info/PKG-INFO
-src/variantgrid_api.egg-info/SOURCES.txt
-src/variantgrid_api.egg-info/dependency_links.txt
-src/variantgrid_api.egg-info/requires.txt
-src/variantgrid_api.egg-info/top_level.txt

variantgrid_api-1.0.0/src/variantgrid_api.egg-info/requires.txt

@@ -1,3 +0,0 @@
-requests
-dataclasses-json
-samshee