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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 0.3.0
+Version: 1.1.1
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License: MIT License
@@ -35,5 +35,41 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: dataclasses-json
+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-0.3.0 → variantgrid_api-1.1.1}/pyproject.toml

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

variantgrid_api-1.1.1/src/variantgrid_api/api_client.py

@@ -0,0 +1,251 @@
+import datetime
+import json
+import logging
+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, SequencerModel, Sequencer
+
+
+class DateTimeEncoder(json.JSONEncoder):
+    def default(self,o):
+        if isinstance(o,(datetime.date, datetime.datetime)):
+            return o.isoformat()
+        return super().default(o)
+
+
+class EmptyInputPolicy(Enum):
+    IGNORE = "ignore"
+    WARN = "warn"
+    ERROR = "error"
+
+
+class VariantGridAPI:
+    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 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)
+
+        extra_error_message = f"{url=}, {json_string=}"
+        return self._handle_json_response(response, extra_error_message)
+
+    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:
+                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")
+        json_data["sequencing_run"] = sequencing_run["name"]
+        return self._post("seqauto/api/v1/sample_sheet/",
+                          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()
+            # put into hierarchial JSON DRF expects
+            fastq_r1 = data.pop("fastq_r1")
+            fastq_r2 = data.pop("fastq_r2")
+            data["unaligned_reads"] = {
+                "fastq_r1": {"path": fastq_r1},
+                "fastq_r2": {"path": fastq_r2}
+            }
+            records.append(data)
+
+        json_data = {
+            "sample_sheet": sample_sheet_lookup.to_dict(),
+            "records": records
+        }
+        return self._post("seqauto/api/v1/sequencing_files/bulk_create",
+                          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
+            ]
+        }
+        return self._post("seqauto/api/v1/qc_gene_list/bulk_create",
+                          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
+            ]
+        }
+        return self._post("seqauto/api/v1/qc_exec_summary/bulk_create",
+                          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
+            ]
+        }
+        return self._post("seqauto/api/v1/qc_gene_coverage/bulk_create",
+                          json_data)
+
+    def upload_file(self, filename: str):
+        url = self._get_url("upload/api/v1/file_upload")
+        with open(filename, "rb") as f:
+            kwargs = {
+                "files": {"file": f},
+                "params": {"path": filename}
+            }
+            response = requests.post(url, headers=self.headers, **kwargs)
+            extra_error_message = f"{filename=}"
+            return self._handle_json_response(response, extra_error_message)
+
+    ###############
+    ## Get methods
+
+    def _get(self, path, params=None):
+        url = self._get_url(path)
+        response = requests.get(url,
+                                params,
+                                headers=self.headers)
+
+        extra_error_message = f"{url=}, {params=}"
+        return self._handle_json_response(response, extra_error_message)
+
+    def sequencing_run_has_vcf(self, sequencing_run: SequencingRun, path: Optional[str] = None):
+        """ Returns whether the SequencingRun has a VCF associated with it. If path is set, VCF must match that path
+            otherwise - any VCF present will retur True """
+        return self.sequencing_run_name_has_vcf(sequencing_run.name, path)
+
+    def sequencing_run_name_has_vcf(self, sequencing_run_name: str, path: Optional[str] = None):
+        """ Returns whether the SequencingRun has a VCF associated with it. If path is set, VCF must match that path
+            otherwise - any VCF present will retur True """
+        data = self._get(f"seqauto/api/v1/sequencing_run/{sequencing_run_name}/")
+        found_vcf = False
+        for vcf in data["vcf_set"]:
+            if path is None or path in vcf["path"]:
+                found_vcf = True
+                break
+        return found_vcf
+
+
+
+

{variantgrid_api-0.3.0 → variantgrid_api-1.1.1}/src/variantgrid_api/data_models.py

@@ -1,3 +1,4 @@
+import re
 from datetime import date, datetime
 from dataclasses import dataclass, field
 from typing import Optional, List
@@ -12,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:
@@ -22,15 +43,25 @@ class SequencingRun:
     experiment: str
     enrichment_kit: EnrichmentKit
 
+    @staticmethod
+    def get_date_from_name(name) -> Optional[datetime.date]:
+        date = None
+        if m := re.match(r".*_?([12]\d{5})_", name):
+            date_str = m.group(1)
+            dt = datetime.strptime(date_str, "%y%m%d")
+            date = dt.date()
+        return date
+
+
 
 @dataclass_json
 @dataclass
 class SequencingSample:
     sample_id: str
-    sample_number: int
-    lane: int
+    sample_number: int  # Sample sheet row (to keep in order)
     barcode: str
     enrichment_kit: EnrichmentKit
+    lane: Optional[int] = None
     sample_project: Optional[str] = None
     is_control: bool = False
     failed: bool = False
@@ -42,7 +73,7 @@ class SequencingSample:
 class SampleSheet:
     path: str
     sequencing_run: SequencingRun
-    file_last_modified: datetime
+    file_last_modified: float
     hash: str
     sequencing_samples: List[SequencingSample] = field(metadata=config(field_name="sequencingsample_set"))
 
@@ -144,34 +175,34 @@ class QCExecStats:
     modified: datetime
     hash: str
     is_valid: bool
-    deduplicated_reads: int
-    indels_dbsnp_percent: float
     mean_coverage_across_genes: float
     mean_coverage_across_kit: float
     median_insert: float
-    number_indels: int
-    number_snps: int
-    percent_10x_goi: float
-    percent_20x_goi: float
-    percent_20x_kit: float
-    percent_error_rate: float
-    percent_map_to_diff_chr: float
     percent_read_enrichment: float
-    percent_reads: float
-    percent_softclip: float
     percent_duplication: float
-    reads: int
-    sample_id_lod: float
-    sex_match: str
-    snp_dbsnp_percent: float
-    ts_to_tv_ratio: float
     uniformity_of_coverage: float
+    deduplicated_reads: Optional[int] = None
+    indels_dbsnp_percent: Optional[float] = None
+    number_indels: Optional[int] = None
+    number_snps: Optional[int] = None
+    percent_10x_goi: Optional[float] = None
+    percent_20x_goi: Optional[float] = None
+    percent_20x_kit: Optional[float] = None
     percent_100x_goi: Optional[float] = None
     percent_100x_kit: Optional[float] = None
     percent_250x_goi: Optional[float] = None
     percent_250x_kit: Optional[float] = None
     percent_500x_goi: Optional[float] = None
     percent_500x_kit: Optional[float] = None
+    percent_error_rate: Optional[float] = None
+    percent_map_to_diff_chr: Optional[float] = None
+    percent_reads: Optional[float] = None
+    percent_softclip: Optional[float] = None
+    reads: Optional[int] = None
+    sample_id_lod: Optional[float] = None
+    sex_match: Optional[str] = None
+    snp_dbsnp_percent: Optional[float] = None
+    ts_to_tv_ratio: Optional[float] = None
 
 
 @dataclass_json
@@ -180,4 +211,4 @@ class QCGeneCoverage:
     """ We send this up to associate coverage file path with sequencing sample
         Then, later we upload the coverage file - and match via path """
     qc: QC
-    path: str
+    path: str

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: variantgrid_api
-Version: 0.3.0
+Version: 1.1.1
 Summary: A Python API client for VariantGrid
 Author-email: Dave Lawrence <davmlaw@gmail.com>
 License: MIT License
@@ -35,5 +35,41 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: dataclasses-json
+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-0.3.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-0.3.0/README.md

@@ -1 +0,0 @@
-# variantgrid_api

variantgrid_api-0.3.0/src/variantgrid_api/api_client.py

@@ -1,126 +0,0 @@
-import json
-import logging
-import os
-from typing import List
-
-import requests
-
-from variantgrid_api.data_models import EnrichmentKit, SequencingRun, SampleSheet, SampleSheetCombinedVCFFile, \
-    SampleSheetLookup, SequencingFile, QCGeneList, QCExecStats, QCGeneCoverage
-
-
-class VariantGridAPI:
-    def __init__(self, server, api_token):
-        self.server = server
-        self.headers = {"Authorization": f"Token {api_token}"}
-
-    def _get_url(self, url):
-        return os.path.join(self.server, url)
-
-    def _post(self, path, json_data):
-        url = self._get_url(path)
-        response = requests.post(url, headers=self.headers, json=json_data)
-        try:
-            json_response = response.json()
-        except Exception as e:
-            json_response = f"Couldn't convert JSON: {e}"
-        if not response.ok:
-            logging.info("url='%s', JSON data:", url)
-            logging.info(json.dumps(json_data))
-            logging.info("Response: %s", json_response)
-            response.raise_for_status()
-        return json_response
-
-    def create_experiment(self, experiment: str):
-        json_data = {
-            "name": experiment
-        }
-        return self._post("seqauto/api/v1/experiment/", json_data)
-
-    def create_enrichment_kit(self, enrichment_kit: EnrichmentKit):
-        return self._post("seqauto/api/v1/enrichment_kit/",
-                          enrichment_kit.to_dict())
-
-    def create_sequencing_run(self, sequencing_run: SequencingRun):
-        return self._post("seqauto/api/v1/sequencing_run/",
-                          sequencing_run.to_dict())
-
-    def create_sample_sheet(self, sample_sheet: SampleSheet):
-        json_data = sample_sheet.to_dict()
-        # We don't want all sequencing_run just the name
-        sequencing_run = json_data.pop("sequencing_run")
-        json_data["sequencing_run"] = sequencing_run["name"]
-        return self._post("seqauto/api/v1/sample_sheet/",
-                          json_data)
-
-    def create_sample_sheet_combined_vcf_file(self, sample_sheet_combined_vcf_file: SampleSheetCombinedVCFFile):
-        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]):
-        records = []
-        for sf in sequencing_files:
-            data = sf.to_dict()
-            # put into hierarchial JSON DRF expects
-            fastq_r1 = data.pop("fastq_r1")
-            fastq_r2 = data.pop("fastq_r2")
-            data["unaligned_reads"] = {
-                "fastq_r1": {"path": fastq_r1},
-                "fastq_r2": {"path": fastq_r2}
-            }
-            records.append(data)
-
-        json_data = {
-            "sample_sheet": sample_sheet_lookup.to_dict(),
-            "records": records
-        }
-        return self._post("seqauto/api/v1/sequencing_files/bulk_create",
-                          json_data)
-
-    def create_qc_gene_list(self, qc_gene_list: QCGeneList):
-        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]):
-        json_data = {
-            "records": [
-                qcgl.to_dict() for qcgl in qc_gene_lists
-            ]
-        }
-        return self._post("seqauto/api/v1/qc_gene_list/bulk_create",
-                          json_data)
-
-    def create_qc_exec_stats(self, qc_exec_stats: QCExecStats):
-        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]):
-        json_data = {
-            "records": [
-                qces.to_dict() for qces in qc_exec_stats
-            ]
-        }
-        return self._post("seqauto/api/v1/qc_exec_summary/bulk_create",
-                          json_data)
-
-    def create_multiple_qc_gene_coverage(self, qc_gene_coverage_list: List[QCGeneCoverage]):
-        json_data = {
-            "records": [
-                qcgc.to_dict() for qcgc in qc_gene_coverage_list
-            ]
-        }
-        return self._post("seqauto/api/v1/qc_gene_coverage/bulk_create",
-                          json_data)
-
-    def upload_file(self, filename: str):
-        url = self._get_url("upload/api/v1/file_upload")
-        with open(filename, "rb") as f:
-            kwargs = {
-                "files": {"file": f},
-                "params": {"path": filename}
-            }
-            return requests.post(url, headers=self.headers, **kwargs)

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

@@ -1,2 +0,0 @@
-requests
-dataclasses-json