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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.0.0
+Version: 1.1.1
 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.1.1/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.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "variantgrid_api"
-version = "1.0.0"
+version = "1.1.1"
 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.1.1}/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.1.1}/src/variantgrid_api/data_models.py

@@ -13,6 +13,26 @@ 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)
+
+
+@dataclass_json
+@dataclass
+class Sequencer:
+    name: str
+    sequencer_model: SequencerModel
+
+
 @dataclass_json
 @dataclass
 class SequencingRun:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 1.0.0
+Version: 1.1.1
 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.0.0 → variantgrid_api-1.1.1}/src/variantgrid_api.egg-info/SOURCES.txt

@@ -7,4 +7,8 @@ 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
+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

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

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

variantgrid_api-1.1.1/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.1.1/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.1.1/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.1.1/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.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/requires.txt

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