hoo boy

Author: jsstevenson

src/anyvlm/anyvar/base_client.py

@@ -1,6 +1,7 @@
 """Provide abstraction for a AnyVLM-to-AnyVar connection."""
 
 import abc
+from collections.abc import Iterable
 
 from anyvar.utils.types import VrsVariation
 
@@ -9,23 +10,26 @@ class AnyVarClientError(Exception):
     """Generic client-related exception."""
 
 
-class UnidentifiedObjectError(AnyVarClientError):
-    """Raise if input object lacks an ID property"""
+class AnyVarClientConnectionError(AnyVarClientError):
+    """Raise for failure to connect to AnyVar client.
+
+    Likely relevant only for HTTP-based implementation.
+    """
 
 
 class BaseAnyVarClient(abc.ABC):
     """Interface elements for an AnyVar client"""
 
     @abc.abstractmethod
-    def put_objects(self, objects: list[VrsVariation]) -> None:
-        """Register objects with AnyVar
-
-        All input objects must have a populated ID field. A validation check for this is
-        performed before any variants are registered.
-
-        :param objects: variation objects to register
-        :raise AnyVarClientError: for errors relating to specifics of client interface
-        :raise UnidentifiedObjectError: if *any* provided object lacks a VRS ID
+    def put_allele_expressions(
+        self, expressions: Iterable[str], assembly: str = "GRCh38"
+    ) -> list[str | None]:
+        """Submit allele expressions to an AnyVar instance and retrieve corresponding VRS IDs
+
+        :param expressions: variation expressions to register
+        :param assembly: reference assembly used in variation expressions
+        :return: list where the i'th item is either the VRS ID if translation succeeds,
+            else `None`, for the i'th expression
         """
 
     @abc.abstractmethod
@@ -38,7 +42,7 @@ def search_by_interval(
         :param start: start position for genomic region
         :param end: end position for genomic region
         :return: list of matching variant objects
-        :raise AnyVarClientError: if connection is unsuccessful during search query
+        :raise AnyVarClientConnectionError: if connection is unsuccessful during search query
         """
 
     @abc.abstractmethod

src/anyvlm/anyvar/http_client.py

@@ -1,15 +1,16 @@
 """Provide abstraction for a VLM-to-AnyVar connection."""
 
 import logging
+from collections.abc import Iterable
 
 import requests
 from anyvar.utils.types import VrsVariation
 from ga4gh.vrs import models
 
 from anyvlm.anyvar.base_client import (
+    AnyVarClientConnectionError,
     AnyVarClientError,
     BaseAnyVarClient,
-    UnidentifiedObjectError,
 )
 
 _logger = logging.getLogger(__name__)
@@ -26,38 +27,61 @@ def __init__(
         :param hostname: service API root
         :param request_timeout: timeout value, in seconds, for HTTP requests
         """
+        _logger.info("Initializing HTTP-based AnyVar client with hostname %s", hostname)
         self.hostname = hostname
         self.request_timeout = request_timeout
 
-    def put_objects(self, objects: list[VrsVariation]) -> None:
-        """Register objects with AnyVar
+    def put_allele_expressions(
+        self, expressions: Iterable[str], assembly: str = "GRCh38"
+    ) -> list[str | None]:
+        """Submit allele expressions to an AnyVar instance and retrieve corresponding VRS IDs
 
-        All input objects must have a populated ID field. A validation check for this is
-        performed before any variants are registered.
-
-        :param objects: variation objects to register
-        :return: completed VRS objects
-        :raise AnyVarClientError: if connection is unsuccessful during registration request
-        :raise UnidentifiedObjectError: if *any* provided object lacks a VRS ID
+        :param expressions: variation expressions to register
+        :param assembly: reference assembly used in expressions
+        :return: list where the i'th item is either the VRS ID if translation succeeds,
+            else `None`, for the i'th expression
+        :raise AnyVarClientError: for unexpected errors relating to specifics of client interface
         """
-        objects_to_submit = []
-        for vrs_object in objects:
-            if not vrs_object.id:
-                _logger.error("Provided variant %s has no VRS ID", vrs_object)
-                raise UnidentifiedObjectError
-            objects_to_submit.append(
-                vrs_object.model_dump(exclude_none=True, mode="json")
-            )
-        for vrs_object in objects_to_submit:
-            response = requests.put(
-                f"{self.hostname}/vrs_variation",
-                json=vrs_object,
-                timeout=self.request_timeout,
-            )
+        results = []
+        for expression in expressions:
+            url = f"{self.hostname}/variation"
+            payload = {
+                "definition": expression,
+                "assembly_name": assembly,
+                "input_type": "Allele",
+            }
+            try:
+                response = requests.put(
+                    url,
+                    json=payload,
+                    timeout=self.request_timeout,
+                )
+            except requests.ConnectionError as e:
+                _logger.exception(
+                    "Unable to establish connection using AnyVar configured at %s",
+                    self.hostname,
+                )
+                raise AnyVarClientConnectionError from e
             try:
                 response.raise_for_status()
             except requests.HTTPError as e:
+                _logger.exception(
+                    "Encountered HTTP exception submitting payload %s to %s",
+                    payload,
+                    url,
+                )
                 raise AnyVarClientError from e
+            response_json = response.json()
+            if messages := response_json.get("messages"):
+                _logger.warning(
+                    "Variant expression `%s` seems to have failed to translate: %s",
+                    expression,
+                    messages,
+                )
+                results.append(None)
+            else:
+                results.append(response_json["object_id"])
+        return results
 
     def search_by_interval(
         self, accession: str, start: int, end: int
@@ -89,3 +113,6 @@ def close(self) -> None:
 
         This is a no-op for this class.
         """
+        _logger.info(
+            "Closing HTTP-based AnyVar client class. This requires no further action."
+        )

src/anyvlm/anyvar/python_client.py

@@ -1,13 +1,14 @@
 """Implement AnyVar client interface for direct Python-based access."""
 
 import logging
+from collections.abc import Iterable
 
 from anyvar import AnyVar
 from anyvar.storage.base_storage import Storage
-from anyvar.translate.translate import Translator
+from anyvar.translate.translate import TranslationError, Translator
 from anyvar.utils.types import VrsVariation
 
-from anyvlm.anyvar.base_client import BaseAnyVarClient, UnidentifiedObjectError
+from anyvlm.anyvar.base_client import BaseAnyVarClient
 
 _logger = logging.getLogger(__name__)
 
@@ -23,20 +24,28 @@ def __init__(self, translator: Translator, storage: Storage) -> None:
         """
         self.av = AnyVar(translator, storage)
 
-    def put_objects(self, objects: list[VrsVariation]) -> None:
-        """Register objects with AnyVar
+    def put_allele_expressions(
+        self, expressions: Iterable[str], assembly: str = "GRCh38"
+    ) -> list[str | None]:
+        """Submit allele expressions to an AnyVar instance and retrieve corresponding VRS IDs
 
-        All input objects must have a populated ID field. A validation check for this is
-        performed before any variants are registered.
-
-        :param objects: variation objects to register
-        :raise UnidentifiedObjectError: if *any* provided object lacks a VRS ID
+        :param expressions: variation expressions to register
+        :param assembly: reference assembly used in expressions
+        :return: list where the i'th item is either the VRS ID if translation succeeds,
+            else `None`, for the i'th expression
         """
-        for variant in objects:
-            if not variant.id:
-                _logger.error("Provided variant %s has no VRS ID", variant)
-                raise UnidentifiedObjectError
-        self.av.put_objects(objects)  # type: ignore[reportArgumentType]
+        results = []
+        for expression in expressions:
+            translated_variation = None
+            try:
+                translated_variation = self.av.translator.translate_variation(
+                    expression, assembly=assembly
+                )
+            except TranslationError:
+                _logger.exception("Failed to translate expression: %s", expression)
+                self.av.put_objects([translated_variation])  # type: ignore
+            results.append(translated_variation.id)  # type: ignore
+        return results
 
     def search_by_interval(
         self, accession: str, start: int, end: int

src/anyvlm/functions/ingest_vcf.py

@@ -1,56 +1,48 @@
 """Get a VCF, register its contained variants, and add cohort frequency data to storage"""
 
 import logging
-import os
+from collections import namedtuple
 from collections.abc import Iterator
 from pathlib import Path
 
 import pysam
-from anyvar.translate.vrs_python import AlleleTranslator
-from anyvar.utils.types import VrsVariation
-from ga4gh.vrs.dataproxy import create_dataproxy
+from ga4gh.va_spec.base import CohortAlleleFrequencyStudyResult
 
 from anyvlm.anyvar.base_client import BaseAnyVarClient
-from anyvlm.schemas.domain import AlleleFrequencyAnnotation
 
 _logger = logging.getLogger(__name__)
 
 
-_Var_Af_Pair = tuple[VrsVariation, AlleleFrequencyAnnotation]
+AfData = namedtuple("AfData", ("ac", "an", "ac_het", "ac_hom", "ac_hemi"))
 
 
-def _yield_var_af_batches(
-    vcf: pysam.VariantFile,
-    translator: AlleleTranslator,
-    assembly: str,
-    batch_size: int = 1000,
-) -> Iterator[_Var_Af_Pair]:
-    """Generate a variant-allele frequency data pairing, one at a time
+def _yield_expression_af_batches(
+    vcf: pysam.VariantFile, batch_size: int = 1000
+) -> Iterator[list[tuple[str, CohortAlleleFrequencyStudyResult]]]:
+    """Generate a variant expression-allele frequency data pairing, one at a time
 
     :param vcf: VCF to pull variants from
     :param translator: VRS-Python variant translator for converting VCF expressions to VRS
     :param assembly: name of reference assembly used by VCF
     :param batch_size: size of return batches
+    :return: iterator of lists of pairs of variant expressions and AF data classes
     """
-    batch: list[_Var_Af_Pair] = []
+    batch = []
 
     for record in vcf:
         for i, alt in enumerate(record.alts or []):
             if record.ref is None or "*" in record.ref or "*" in alt:
                 _logger.warning("Skipping missing allele at %s", record)
                 continue
             expression = f"{record.chrom}-{record.pos}-{record.ref}-{alt}"
-            vrs_variation = translator.translate_from(
-                expression, "gnomad", assembly_name=assembly
-            )
-            af = AlleleFrequencyAnnotation(
+            af = AfData(
                 ac=record.info["AC"][i],
                 an=record.info["AN"],
                 ac_het=record.info["AC_Het"][i],
                 ac_hom=record.info["AC_Hom"][i],
                 ac_hemi=record.info["AC_Hemi"][i],
             )
-            batch.append((vrs_variation, af))
+            batch.append((expression, af))
             if len(batch) >= batch_size:
                 yield batch
                 batch = []
@@ -74,14 +66,12 @@ def ingest_vcf(vcf_path: Path, av: BaseAnyVarClient, assembly: str = "GRCh38") -
     :param av: AnyVar client
     :param assembly: reference assembly used by VCF
     """
-    dataproxy = create_dataproxy(
-        os.environ.get("SEQREPO_DATAPROXY_URI", "seqrepo+http://localhost:5000/seqrepo")
-    )
-    translator = AlleleTranslator(dataproxy)
     vcf = pysam.VariantFile(filename=vcf_path.absolute().as_uri(), mode="r")
 
-    for batch in _yield_var_af_batches(vcf, translator, assembly):
-        variants = [v for v, _ in batch]
-        av.put_objects(variants)
-        for variant, af in batch:  # noqa: B007
-            pass  # make a call to a storage class to store frequency data -- see issue 23
+    for batch in _yield_expression_af_batches(vcf):
+        expressions, afs = zip(*batch, strict=True)
+        variant_ids = av.put_allele_expressions(expressions, assembly)
+        for variant_id, af in zip(variant_ids, afs, strict=True):  # noqa: B007
+            if variant_id is None:
+                continue
+            # put af object here

tests/data/variations.json

@@ -43,7 +43,8 @@
         },
         "state": { "type": "LiteralSequenceExpression", "sequence": "T" }
       },
-      "comment": "BRAF V600E (genomic)"
+      "comment": "BRAF V600E (genomic)",
+      "vcf_expression": "7-140753336-A-T"
     },
     "ga4gh:VA.ruQCmfXJrEylHmOQF-1PG6bLwQesDU2g": {
       "variation": {
@@ -66,30 +67,30 @@
           "sequence": "G"
         }
       },
-      "comment": "Y-2781704-G-G"
+      "vcf_expression": "Y-2781704-G-G"
     },
     "ga4gh:VA.IM4QyU9D2kTJzeftUBBD4Vcd1peq0dn1": {
       "variation": {
-        "id": "ga4gh:VA.IM4QyU9D2kTJzeftUBBD4Vcd1peq0dn1",
-        "digest": "IM4QyU9D2kTJzeftUBBD4Vcd1peq0dn1",
+        "id": "ga4gh:VA.xbX035HgURWIUAjn6x3cS26jafP8Q_bk",
         "type": "Allele",
+        "digest": "xbX035HgURWIUAjn6x3cS26jafP8Q_bk",
         "location": {
-          "id": "ga4gh:SL.sWfeTXwGUkfIuYRAkiFGPjkSk_mIDuXG",
-          "digest": "sWfeTXwGUkfIuYRAkiFGPjkSk_mIDuXG",
+          "id": "ga4gh:SL.sYiBcbbgF-1CANNCTfQ6zwZOU0iHhymR",
           "type": "SequenceLocation",
-          "start": 2781760,
-          "end": 2781762,
+          "digest": "sYiBcbbgF-1CANNCTfQ6zwZOU0iHhymR",
           "sequenceReference": {
             "type": "SequenceReference",
             "refgetAccession": "SQ.8_liLu1aycC0tPQPFmUaGXJLDs5SbPZ5"
-          }
+          },
+          "start": 2781760,
+          "end": 2781761
         },
         "state": {
           "type": "LiteralSequenceExpression",
-          "sequence": "CA"
+          "sequence": "C"
         }
       },
-      "comment": "Y-2781761-C-C"
+      "vcf_expression": "Y-2781761-C-C"
     },
     "ga4gh:VA.xbX035HgURWIUAjn6x3cS26jafP8Q_bk": {
       "variation": {
@@ -109,7 +110,7 @@
         },
         "state": { "type": "LiteralSequenceExpression", "sequence": "C" }
       },
-      "comment": "Y-2781761-C-C"
+      "vcf_expression": "Y-2781761-C-C"
     },
     "ga4gh:VA.9VDxL0stMBOZwcTKw3yb3UoWQkpaI9OD": {
       "variation": {
@@ -129,7 +130,7 @@
         },
         "state": { "type": "LiteralSequenceExpression", "sequence": "A" }
       },
-      "comment": "Y-2781761-C-A"
+      "vcf_expression": "Y-2781761-C-A"
     },
     "ga4gh:VA.yi7A2l0uIUMaInQaJnHU_B2Cf_OuZRJg": {
       "variation": {
@@ -154,7 +155,7 @@
           "repeatSubunitLength": 1
         }
       },
-      "comment": "Y-2781761-CA-C"
+      "vcf_expression": "Y-2781761-CA-C"
     }
   }
 }