Add new endpoint: "/gwa-compute/<k_filename>/loco/maf/<maf>/<token>"

2 files changed, 101 insertions, 0 deletions

diff --git a/gn3/api/gemma.py b/gn3/api/gemma.py
index acaec68..7fcf2a2 100644
--- a/gn3/api/gemma.py
+++ b/gn3/api/gemma.py
@@ -7,10 +7,12 @@ from flask import current_app
 from flask import jsonify
 from flask import request
 
+from gn3.commands import compose_gemma_cmd
 from gn3.commands import queue_cmd
 from gn3.commands import run_cmd
 from gn3.file_utils import get_hash_of_files
 from gn3.file_utils import jsonfile_to_dict
+from gn3.computations.gemma import do_paths_exist
 from gn3.computations.gemma import generate_hash_of_string
 from gn3.computations.gemma import generate_pheno_txt_file
 from gn3.computations.gemma import generate_gemma_computation_cmd
@@ -252,3 +254,50 @@ def compute_gwa_with_covar(k_filename, token):
         return jsonify(status=128,
                        # use better message
                        message="Metadata file non-existent!")
+
+
+@gemma.route("/gwa-compute/<k_filename>/loco/maf/<maf>/<token>",
+             methods=["POST"])
+def compute_gwa_with_loco_maf(k_filename, maf, token):
+    """Compute GWA values. No Covariates provided. Only loco and maf vals given.
+
+    """
+    working_dir = os.path.join(current_app.config.get("TMPDIR"),
+                               token)
+    _dict = jsonfile_to_dict(os.path.join(working_dir,
+                                          "metadata.json"))
+    try:
+        genofile, phenofile, snpsfile = [
+            os.path.join(working_dir,
+                         _dict.get(x))
+            for x in ["geno", "pheno", "snps"]]
+        if not do_paths_exist([genofile, phenofile, snpsfile]):
+            raise FileNotFoundError
+        gemma_kwargs = {"g": genofile, "p": phenofile,
+                        "a": snpsfile, "lmm": _dict.get("lmm", 9),
+                        'maf': float(maf)}
+        _hash = get_hash_of_files([genofile, phenofile, snpsfile])
+        _output_filename = f"{_hash}-gwa-output.json"
+        return jsonify(
+            unique_id=queue_cmd(
+                conn=redis.Redis(),
+                email=(request.get_json() or {}).get('email'),
+                job_queue=current_app.config.get("REDIS_JOB_QUEUE"),
+                cmd=compose_gemma_cmd(
+                    gemma_wrapper_cmd=current_app.config.get("GEMMA_"
+                                                             "WRAPPER_CMD"),
+                    gemma_wrapper_kwargs={
+                        "loco": ("--input "
+                                 f"{os.path.join(working_dir, k_filename)}")
+                    },
+                    gemma_kwargs=gemma_kwargs,
+                    gemma_args=["-gk", ">",
+                                (f"{current_app.config.get('TMPDIR')}/"
+                                 f"{token}/{_output_filename}")])),
+            status="queued",
+            output_file=_output_filename)
+    # pylint: disable=W0703
+    except Exception:
+        return jsonify(status=128,
+                       # use better message
+                       message="Metadata file non-existent!")
diff --git a/tests/integration/test_gemma.py b/tests/integration/test_gemma.py
index 0c2afdc..45c9148 100644
--- a/tests/integration/test_gemma.py
+++ b/tests/integration/test_gemma.py
@@ -290,3 +290,55 @@ class GemmaAPITest(unittest.TestCase):
             "status": "queued",
             "output_file": "hash-gwa-output.json"
         })
+
+    # pylint: disable=R0913
+    @mock.patch("gn3.api.gemma.queue_cmd")
+    @mock.patch("gn3.api.gemma.compose_gemma_cmd")
+    @mock.patch("gn3.api.gemma.get_hash_of_files")
+    @mock.patch("gn3.api.gemma.jsonfile_to_dict")
+    @mock.patch("gn3.api.gemma.do_paths_exist")
+    def test_gwa_compute_with_loco_only(self, mock_path_exist,
+                                        mock_json, mock_hash,
+                                        mock_cmd,
+                                        mock_queue_cmd):
+        """Test /gemma/gwa-compute/<k-inputfile>/loco/maf/<maf>/<token>
+
+        """
+        mock_path_exist.return_value = True
+        mock_queue_cmd.return_value = "my-unique-id"
+        mock_json.return_value = {
+            "geno": "genofile.txt",
+            "pheno": "phenofile.txt",
+            "snps": "snpfile.txt",
+            "covar": "covarfile.txt",
+        }
+        mock_hash.return_value = "hash"
+        mock_cmd.return_value = ("gemma-wrapper --json -- "
+                                 "-debug -g "
+                                 "genotype_name.txt "
+                                 "-p traitfilename.txt "
+                                 "-a genotype_snps.txt "
+                                 "-gk > k_output_filename.json")
+        response = self.app.post(("/api/gemma/gwa-compute/"
+                                  "hash-k-output.json/loco/"
+                                  "maf/21/my-token"))
+        mock_hash.assert_called_once_with(['/tmp/my-token/genofile.txt',
+                                           '/tmp/my-token/phenofile.txt',
+                                           '/tmp/my-token/snpfile.txt'])
+        mock_cmd.assert_called_once_with(
+            gemma_wrapper_cmd='gemma-wrapper',
+            gemma_wrapper_kwargs={
+                'loco': '--input /tmp/my-token/hash-k-output.json'
+            },
+            gemma_kwargs={'g': '/tmp/my-token/genofile.txt',
+                          'p': '/tmp/my-token/phenofile.txt',
+                          'a': '/tmp/my-token/snpfile.txt',
+                          'lmm': 9,
+                          'maf': 21},
+            gemma_args=["-gk", ">",
+                        '/tmp/my-token/hash-gwa-output.json'])
+        self.assertEqual(response.get_json(), {
+            "unique_id": "my-unique-id",
+            "status": "queued",
+            "output_file": "hash-gwa-output.json"
+        })