Merge pull request #14 from ressy/release-0.0.6

Release 0.0.6

Author: ressy

CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.0.6 - 2021-03-12
+
+### Changed
+
+ * Refactored top-level code into separate modules ([#13])
+
+### Fixed
+
+ * Avoid trying to import dependencies at install time ([#13])
+
+[#13]: https://github.com/ressy/vquest/pull/13
+
 ## 0.0.5 - 2021-03-10
 
 ### Added

test_vquest/test_vquest.py

@@ -15,8 +15,9 @@
 from contextlib import redirect_stdout, redirect_stderr
 from pathlib import Path
 from io import StringIO
-import vquest
-import vquest.__main__
+from vquest.request import vquest
+from vquest.util import VquestError
+from vquest.__main__ import main
 
 class TestVquestBase(unittest.TestCase):
     """Base class for supporting code.  No actual tests here."""
@@ -85,7 +86,7 @@ def test_vquest(self):
 GAGCCTCTTGGATAGTGACGGGTACACCTGTTTGGACTGGTACCTGCAGAAGCCAGGCCAGTCTCCACAGCTCCTGATCT
 ATGAGGTTTCCAACCGGGTCTCTGGAGTCCCTGACAGGTTCAGTGGCAGTGGGTCAGNCACTGATTTCACACTGAAAATC
 AGCCGGGTGGAAGCTGAGGATGTTGGGGTGTATTACTGTATGCAAAGTATAGAGTTTCCTCC"""}
-        result = vquest.vquest(config)
+        result = vquest(config)
         # requests.post should have been called once, with this input.
         self.assertEqual(self.post.call_count, 1)
         self.assertEqual(
@@ -145,7 +146,7 @@ def test_vquest_main(self):
         config_path = str((self.path / "config.yml").resolve())
         with tempfile.TemporaryDirectory() as tempdir:
             os.chdir(tempdir)
-            vquest.__main__.main([config_path])
+            main([config_path])
             self.assertTrue(Path("vquest_airr.tsv").exists())
             self.assertTrue(Path("Parameters.txt").exists())
 
@@ -164,7 +165,7 @@ def test_vquest_main_alignment(self):
         with redirect_stdout(out), redirect_stderr(err):
             with tempfile.TemporaryDirectory() as tempdir:
                 os.chdir(tempdir)
-                vquest.__main__.main([config_path, "--align"])
+                main([config_path, "--align"])
                 self.assertFalse(Path("vquest_airr.tsv").exists())
                 self.assertFalse(Path("Parameters.txt").exists())
         self.assertEqual(out.getvalue(), expected)
@@ -177,7 +178,7 @@ class TestVquestEmpty(TestVquestSimple):
     def test_vquest(self):
         """Test that an empty config fails as expected."""
         with self.assertRaises(ValueError):
-            vquest.vquest({})
+            vquest({})
 
     def test_vquest_main(self):
         """Test how the command-line interface handles no arguments.
@@ -191,7 +192,7 @@ def test_vquest_main(self):
             with self.assertRaises(SystemExit):
                 with tempfile.TemporaryDirectory() as tempdir:
                     os.chdir(tempdir)
-                    vquest.__main__.main([])
+                    main([])
         self.assertNotEqual(out.getvalue(), "")
         self.assertEqual(err.getvalue(), "")
 
@@ -206,7 +207,7 @@ def test_vquest_main_alignment(self):
             with self.assertRaises(SystemExit):
                 with tempfile.TemporaryDirectory() as tempdir:
                     os.chdir(tempdir)
-                    vquest.__main__.main(["--align"])
+                    main(["--align"])
         self.assertNotEqual(out.getvalue(), "")
         self.assertEqual(err.getvalue(), "")
 
@@ -233,7 +234,7 @@ def test_vquest(self):
 GAGCCTCTTGGATAGTGACGGGTACACCTGTTTGGACTGGTACCTGCAGAAGCCAGGCCAGTCTCCACAGCTCCTGATCT
 ATGAGGTTTCCAACCGGGTCTCTGGAGTCCCTGACAGGTTCAGTGGCAGTGGGTCAGNCACTGATTTCACACTGAAAATC
 AGCCGGGTGGAAGCTGAGGATGTTGGGGTGTATTACTGTATGCAAAGTATAGAGTTTCCTCC"""}
-        result = vquest.vquest(config)
+        result = vquest(config)
         parameters = [("Date", "Wed Dec 02 19:18:14 CET 2020"),
         ("IMGT/V-QUEST program version", "3.5.21"),
         ("IMGT/V-QUEST reference directory release", "202049-2"),
@@ -272,7 +273,7 @@ def test_vquest_main(self):
         config_path = str((self.path / "config.yml").resolve())
         with tempfile.TemporaryDirectory() as tempdir:
             os.chdir(tempdir)
-            vquest.__main__.main(["--imgtrefdirset", "1", config_path])
+            main(["--imgtrefdirset", "1", config_path])
             self.assertTrue(Path("vquest_airr.tsv").exists())
             self.assertTrue(Path("Parameters.txt").exists())
 
@@ -296,8 +297,8 @@ def test_vquest(self):
 GAGCCTCTTGGATAGTGACGGGTACACCTGTTTGGACTGGTACCTGCAGAAGCCAGGCCAGTCTCCACAGCTCCTGATCT
 ATGAGGTTTCCAACCGGGTCTCTGGAGTCCCTGACAGGTTCAGTGGCAGTGGGTCAGNCACTGATTTCACACTGAAAATC
 AGCCGGGTGGAAGCTGAGGATGTTGGGGTGTATTACTGTATGCAAAGTATAGAGTTTCCTCC"""}
-        with self.assertRaises(vquest.VquestError) as context:
-            vquest.vquest(config)
+        with self.assertRaises(VquestError) as context:
+            vquest(config)
         self.assertEqual(
             context.exception.server_messages,
             ["The receptor type or locus is not available for this species"])

vquest/__init__.py

@@ -4,141 +4,8 @@
 http://www.imgt.org/IMGT_vquest/analysis
 """
 
-import sys
-import csv
 import logging
-import time
-from io import StringIO, BytesIO
-from pathlib import Path
-import yaml
-import requests
-from requests_html import HTML
-from Bio import SeqIO
-from .util import unzip, chunker
-
-__version__ = "0.0.5"
-URL = "http://www.imgt.org/IMGT_vquest/analysis"
-DELAY = 1 # for rate-limiting multiple requests
-CHUNK_SIZE = 50 # to stay within V-QUEST's limit on sequences in one go
+from .version import __version__
 LOGGER = logging.getLogger(__name__)
 LOGGER.propagate = False
 LOGGER.addHandler(logging.StreamHandler())
-
-class VquestError(Exception):
-    """Vquest-related errors.  These can have one or more messages provided by the server."""
-
-    def __init__(self, message, server_messages=None):
-        self.message = message
-        self.server_messages = server_messages
-        super().__init__(self.message)
-
-def _parse_records(config):
-    """Extract Seq records for sequences given in config"""
-    records = []
-    if "sequences" in config and config["sequences"]:
-        with StringIO(config["sequences"]) as seqs_stream:
-            records.extend(list(SeqIO.parse(seqs_stream, "fasta")))
-    if "fileSequences" in config and config["fileSequences"]:
-        with open(config["fileSequences"]) as f_in:
-            records.extend(list(SeqIO.parse(f_in, "fasta")))
-    return records
-
-def vquest(config):
-    """Submit a request to V-QUEST"""
-    if not all([
-        config.get("species"),
-        config.get("receptorOrLocusType"),
-        config.get("fileSequences") or config.get("sequences")]):
-        raise ValueError(
-            "species, receptorOrLocusType, and fileSequences "
-            "and/or sequences are required options")
-    # species, receptorOrLocusType, and either fileSequences or sequences
-    supported = [("resultType", "excel"), ("xv_outputtype", 3)]
-    if all([config.get(pair[0]) == pair[1] for pair in supported]):
-        output = {}
-        records = _parse_records(config)
-        if not records:
-            raise ValueError("No sequences supplied")
-        LOGGER.info("Starting request batch for %d sequences total", len(records))
-        for chunk in chunker(records, CHUNK_SIZE):
-            if output:
-                time.sleep(DELAY)
-            LOGGER.info("Sending request with %d sequences...", len(chunk))
-            out_handle = StringIO()
-            SeqIO.write(chunk, out_handle, "fasta")
-            config_chunk = config.copy()
-            config_chunk["sequences"] = out_handle.getvalue()
-            config_chunk["inputType"] = "inline"
-            response = requests.post(URL, data = config_chunk)
-            ctype = response.headers.get("Content-Type")
-            LOGGER.debug("Received data of type %s", ctype)
-            if ctype and "text/html" in ctype:
-                html = HTML(html=response.content)
-                errors = [div.text for div in html.find("div.form_error")]
-                if errors:
-                    raise VquestError("; ".join(errors), errors)
-            response = unzip(response.content)
-            # Only keep one copy of the Parameters.txt data, but append rows
-            # (minus header) of vquest_airr.tsv together
-            if "Parameters.txt" not in output:
-                output["Parameters.txt"] = response["Parameters.txt"].decode()
-            if "vquest_airr.tsv" not in output:
-                output["vquest_airr.tsv"] = response["vquest_airr.tsv"].decode()
-            else:
-                airr = response["vquest_airr.tsv"].decode()
-                output["vquest_airr.tsv"] += "\n".join(airr.splitlines()[1:])
-        return output
-    needed = " ".join([pair[0] + "=" + str(pair[1]) for pair in supported])
-    observed = " ".join([pair[0] + "=" + str(config.get(pair[0])) for pair in supported])
-    raise NotImplementedError(("Only " + needed + " currently supported, not " + observed))
-
-def airr_to_fasta(
-        airr_txt,
-        seqid_col="sequence_id", aln_col="sequence_alignment", fallback_col="sequence"):
-    """Convert AIRR TSV table to FASTA, both as strings.
-
-    If the alignment column is empty for a given row, the sequence will be
-    taken from fallback_col, if provided.
-    """
-    reader = csv.DictReader(StringIO(airr_txt), delimiter="\t")
-    fasta = ""
-    for row in reader:
-        seq = row[aln_col]
-        if fallback_col:
-            seq = seq or row[fallback_col]
-        fasta += ">%s\n%s\n" % (row[seqid_col], seq)
-    return fasta
-
-def load_config(path):
-    """Load YAML config file."""
-    LOGGER.debug("Loading config file: %s", path)
-    with open(path) as f_in:
-        config = yaml.load(f_in, Loader=yaml.SafeLoader)
-    return config
-
-def layer_configs(*configs):
-    """Merge dictionaries one after the other.
-
-    The result is a shallow copy of the pairs in each input dictionary.
-    """
-    config_full = configs[0].copy()
-    for config in configs[1:]:
-        config_full.update(config)
-    return config_full
-
-def __load_options():
-    data = load_config(Path(__file__).parent / "data" / "options.yml")
-    mapping = {"int": int, "bool": bool, "str": str}
-    for opt_section in data:
-        for val in opt_section["options"].values():
-            try:
-                val["values"] = mapping.get(val["values"], val["values"])
-            except TypeError:
-                pass
-    return data
-
-def __load_default_config():
-    return load_config(Path(__file__).parent / "data" / "defaults.yml")
-
-DEFAULTS = __load_default_config()
-OPTIONS = __load_options()

vquest/__main__.py

@@ -6,9 +6,11 @@
 import logging
 import argparse
 import vquest
-from . import LOGGER, DEFAULTS, OPTIONS
-from . import load_config
-from . import layer_configs
+from vquest import LOGGER
+from . import request
+from .config import DEFAULTS, OPTIONS, load_config, layer_configs
+from .util import airr_to_fasta
+from .version import __version__
 
 def main(arglist=None):
     """Command-line interface for V-QUEST requests"""
@@ -46,10 +48,10 @@ def main(arglist=None):
     LOGGER.debug("final config: %s",
         " ".join(["%s=%s" % (key, val) for key, val in config_full.items()]))
     LOGGER.info("Configuration prepared")
-    output = vquest.vquest(config_full)
+    output = request.vquest(config_full)
     if args.align:
         LOGGER.info("Writing FASTA to stdout")
-        print(vquest.airr_to_fasta(output["vquest_airr.tsv"]), end="")
+        print(airr_to_fasta(output["vquest_airr.tsv"]), end="")
     else:
         LOGGER.info("Writing vquest_airr.tsv")
         with open("vquest_airr.tsv", "wt") as f_out:
@@ -68,7 +70,7 @@ def __setup_arg_parser():
         "--verbose", "-v", action="count", default=0,
         help="increase logging verbosity")
     parser.add_argument(
-        "--version", "-V", action="version", version=vquest.__version__)
+        "--version", "-V", action="version", version=__version__)
     parser.add_argument(
         "--align", "-a", action="store_true",
         help=("Instead of writing results to files, "

vquest/config.py

@@ -0,0 +1,43 @@
+"""
+Tools to manage configurations and default options.
+"""
+
+from pathlib import Path
+import logging
+import yaml
+
+LOGGER = logging.getLogger(__name__)
+
+def load_config(path):
+    """Load YAML config file."""
+    LOGGER.debug("Loading config file: %s", path)
+    with open(path) as f_in:
+        config = yaml.load(f_in, Loader=yaml.SafeLoader)
+    return config
+
+def layer_configs(*configs):
+    """Merge dictionaries one after the other.
+
+    The result is a shallow copy of the pairs in each input dictionary.
+    """
+    config_full = configs[0].copy()
+    for config in configs[1:]:
+        config_full.update(config)
+    return config_full
+
+def __load_options():
+    data = load_config(Path(__file__).parent / "data" / "options.yml")
+    mapping = {"int": int, "bool": bool, "str": str}
+    for opt_section in data:
+        for val in opt_section["options"].values():
+            try:
+                val["values"] = mapping.get(val["values"], val["values"])
+            except TypeError:
+                pass
+    return data
+
+def __load_default_config():
+    return load_config(Path(__file__).parent / "data" / "defaults.yml")
+
+DEFAULTS = __load_default_config()
+OPTIONS = __load_options()