feat: deployed pypi test package

MANIFEST.in

@@ -0,0 +1,2 @@
+recursive-exclude tests *
+recursive-exclude plugins *

README.md

@@ -5,5 +5,5 @@
 Run test:
 
 ```bash
-python3 -m unittest discover -s test
+python3 -m unittest discover -s tests
 ```

src/annotation/annotation.py → openvariant/annotation/annotation.py

@@ -5,12 +5,12 @@
 from typing import List
 from yaml import safe_load, YAMLError
 
-from src.annotation.builder import AnnotationTypesBuilders
-from src.config.config_annotation import (AnnotationGeneralKeys,
-                                          AnnotationKeys,
-                                          AnnotationTypes,
-                                          ExcludesKeys,
-                                          DEFAULT_FORMAT)
+from openvariant.annotation.builder import AnnotationTypesBuilders
+from openvariant.config.config_annotation import (AnnotationGeneralKeys,
+                                                  AnnotationKeys,
+                                                  AnnotationTypes,
+                                                  ExcludesKeys,
+                                                  DEFAULT_FORMAT)
 
 
 def _read_annotation_file(path: str) -> dict:

src/annotation/builder.py → openvariant/annotation/builder.py

@@ -3,7 +3,7 @@
 from functools import partial
 from typing import List, Tuple, Callable, Any
 
-from src.config.config_annotation import AnnotationTypes, AnnotationKeys
+from openvariant.config.config_annotation import AnnotationTypes, AnnotationKeys
 
 
 class Builder:

src/annotation/parser.py → openvariant/annotation/parser.py

@@ -3,7 +3,7 @@
 from os.path import basename, dirname
 from typing import Tuple, Any, List, Optional, Union, Callable
 
-from src.annotation.builder import Builder
+from openvariant.annotation.builder import Builder
 
 
 def _get_text_by_field(x: List, line: List, original_header: List, func: Builder or None):

src/task/cat.py → openvariant/task/cat.py

@@ -1,7 +1,7 @@
-from src.annotation.annotation import Annotation
-from src.utils.format_line import format_line
-from src.utils.where import parse_where, skip
-from src.variant.variant import Variant
+from openvariant.annotation.annotation import Annotation
+from openvariant.utils.format_line import format_line
+from openvariant.utils.where import parse_where, skip
+from openvariant.variant.variant import Variant
 
 
 def cat(base_path: str, annotation_path: str, where=None) -> None:

src/task/count.py → openvariant/task/count.py

@@ -5,10 +5,10 @@
 
 from tqdm import tqdm
 
-from src.annotation.annotation import Annotation
-from src.task.find import find_files
-from src.utils.where import parse_where, skip
-from src.variant.variant import Variant
+from openvariant.annotation.annotation import Annotation
+from openvariant.task.find import find_files
+from openvariant.utils.where import parse_where, skip
+from openvariant.variant.variant import Variant
 
 
 def _count_task(selection: Tuple[str, Annotation], group_by: str, where: str) -> Tuple[int, Union[dict, None]]:

src/task/find.py → openvariant/task/find.py

@@ -5,9 +5,9 @@
 from typing import Generator
 from copy import deepcopy
 
-from src.annotation.annotation import Annotation, merge_annotations_structure
+from openvariant.annotation.annotation import Annotation, merge_annotations_structure
 
-from src.config.config_annotation import ANNOTATION_EXTENSION, DEFAULT_RECURSIVE
+from openvariant.config.config_annotation import ANNOTATION_EXTENSION, DEFAULT_RECURSIVE
 
 
 def _get_annotation_file(annotation: Annotation, file_name: str, file_path: str, base_path: str) -> \

src/task/groupby.py → openvariant/task/groupby.py

@@ -6,11 +6,11 @@
 
 from tqdm import tqdm
 
-from src.annotation.annotation import Annotation
-from src.task.find import find_files
-from src.utils.logger import log
-from src.utils.where import skip, parse_where
-from src.variant.variant import Variant
+from openvariant.annotation.annotation import Annotation
+from openvariant.task.find import find_files
+from openvariant.utils.logger import log
+from openvariant.utils.where import skip, parse_where
+from openvariant.variant.variant import Variant
 
 
 def _get_unique_values(file_path, annotation, key) -> Set:

src/utils/format_line.py → openvariant/utils/format_line.py

@@ -1,6 +1,6 @@
 from typing import List
 
-from src.config.config_annotation import AnnotationFormat
+from openvariant.config.config_annotation import AnnotationFormat
 
 
 def format_line(line: List[str], out_format: str) -> str:

src/variant/variant.py → openvariant/variant/variant.py

@@ -4,10 +4,10 @@
 import re
 from typing import Generator, TextIO, List
 
-from src.annotation.annotation import Annotation
-from src.annotation.parser import AnnotationTypesParsers
-from src.config.config_annotation import AnnotationFormat, AnnotationGeneralKeys, ExcludesKeys
-from src.utils.logger import log
+from openvariant.annotation.annotation import Annotation
+from openvariant.annotation.parser import AnnotationTypesParsers
+from openvariant.config.config_annotation import AnnotationFormat, AnnotationGeneralKeys, ExcludesKeys
+from openvariant.utils.logger import log
 
 
 def _base_parser(lines: TextIO) -> Generator[int, str, None]:

plugins/liftover/liftover.py

@@ -1,9 +1,9 @@
-from liftover import get_lifter
+#from liftover import get_lifter
 
 
 def liftover(text: str) -> str:
-    converter = get_lifter('hg19', 'hg38')
-    chrom = '1'
-    pos = int(text)
+    #converter = get_lifter('hg19', 'hg38')
+    #chrom = '1'
+    #pos = int(text)
 
-    return converter[chrom][pos][0][1]
+    return text #converter[chrom][pos][0][1]

setup.py

@@ -0,0 +1,10 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="open-variant",
+    version="0.0.2",
+    author="BBGLab - Barcelona Biomedical Genomics Lab",
+    packages=find_packages(exclude=['*.tests', '*.tests.*', 'tests.*', 'tests', 'plugins']),
+    include_package_data=True,
+    install_requires=['pyyaml'],
+)

test/data/example3/example3.yaml → tests/data/example3/example3.yaml

@@ -18,7 +18,7 @@ annotation:
   #    - 'Data'
   #- type: 'mapping'
   #  field: 'F'
-  #  mappingFile: 'test/data/ex.tsv'
+  #  mappingFile: 'tests/data/ex.tsv'
   #  mappingField: 'DONOR'
 
 exclude:

tests/data/meta.bbginfo

@@ -0,0 +1,16 @@
+pattern = "*.maf"
+recursive = True
+
+[annotations]
+GENOMEREF = "hg19"
+#FILTERS = "('internal', 'FILTER')"
+#SAMPLE = "('filename', '([^.*]+)\.purple.somatic.vcf.gz')"
+#SAMPLE = "('mapping', 'SETNAME', 'metadata_intogen.tsv', 'setName', 'sampleId')"
+#DONOR = "('mapping', 'SAMPLE', 'metadata_intogen.tsv', 'sampleId', 'patientId')"
+PLATFORM = "WGS"
+YEAR = "2020"
+#CANCER = "('mapping', 'SAMPLE', 'metadata_intogen.tsv', 'sampleId', 'TUMOR_TYPE')"
+#DATASET = "HARTWIG_{PLATFORM}_{CANCER}_{YEAR}"
+
+[excludes]
+# Exclude variants that didn't pass the quality control checks

test/test_task/test_count.py → tests/test_task/test_count.py

@@ -1,69 +1,69 @@
 import unittest
 
-from src.task.count import count
+from openvariant.task.count import count
 
 
 class TestCount(unittest.TestCase):
 
     # Count functionality
     def test_count(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', quite=True)
         self.assertEqual(res[0], 42130, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_invalid_count(self):
         with self.assertRaises(FileNotFoundError):
-            res = count('test/data/no-exist', 'test/data/no-exist.yaml', quite=True)
+            res = count('tests/data/no-exist', 'tests/data/no-exist.yaml', quite=True)
 
     # Using where attribute
     def test_count_equal_where(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', where="DATASET == \"acc\"", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', where="DATASET == \"acc\"", quite=True)
         self.assertEqual(res[0], 11660, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_count_non_equal_where(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', where="DATASET != \"acc\"", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', where="DATASET != \"acc\"", quite=True)
         self.assertEqual(res[0], 30470, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_count_little_than_where(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', where="A < 52366244", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', where="A < 52366244", quite=True)
         self.assertEqual(res[0], 17734, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_count_leq_than_where(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', where="A <= 52366244", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', where="A <= 52366244", quite=True)
         self.assertEqual(res[0], 17735, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_count_great_than_where(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', where="A > 52366244", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', where="A > 52366244", quite=True)
         self.assertEqual(res[0], 24395, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_count_geq_than_where(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', where="A >= 52366244", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', where="A >= 52366244", quite=True)
         self.assertEqual(res[0], 24396, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_count_no_exist_where(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', where="NO_EXIST == \"no_exist\"", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', where="NO_EXIST == \"no_exist\"", quite=True)
         self.assertEqual(res[0], 0, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 
     def test_count_bad_syntax_where(self):
         with self.assertRaises(ValueError):
-            count('./test/data/', 'test/data/task_test.yaml', where="NO_EXIST = \"no_exist\"", quite=True)
+            count('./tests/data/', 'tests/data/task_test.yaml', where="NO_EXIST = \"no_exist\"", quite=True)
 
     # Using group by attribute
     def test_count_group_by(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', group_by="DATASET", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', group_by="DATASET", quite=True)
         self.assertEqual(res[0], 42130, "Count number not matching")
         self.assertEqual(res[1], {'kich': 3268, 'chol': 4500, 'meso': 3980, 'laml': 8313, 'acc': 11660, 'ucs': 10409},
                          "Count groups not matching")
 
     def test_count_invalid_group_by(self):
-        res = count('./test/data/', 'test/data/task_test.yaml', group_by="NO_EXIST", quite=True)
+        res = count('./tests/data/', 'tests/data/task_test.yaml', group_by="NO_EXIST", quite=True)
         self.assertEqual(res[0], 0, "Count number not matching")
         self.assertEqual(res[1], {}, "Count groups not matching")
 

tests/test_task/test_find.py

@@ -0,0 +1,25 @@
+import unittest
+from os import getcwd
+
+from openvariant.annotation.annotation import Annotation
+from openvariant.task.find import find_files
+
+
+class TestFind(unittest.TestCase):
+
+    def test_find_files(self):
+        res_expect = {'tests/data/example2/KICH.maf', 'tests/data/example2/LAML.maf', 'tests/data/example1/ACC.maf',
+                      'tests/data/example1/CHOL.maf', 'tests/data/example3/MESO.maf', 'tests/data/example3/UCS.maf'}
+
+        annotation = Annotation('tests/data/example.yaml')
+        res = set([f for f, a in list(find_files('tests/data', annotation))])
+        self.assertEqual(res, res_expect)
+
+    def test_invalid_find_files(self):
+        annotation = Annotation('tests/data/example.yaml')
+        with self.assertRaises(FileNotFoundError):
+            set([f for f, a in list(find_files('tests/data/no-exist', annotation))])
+
+
+if __name__ == '__main__':
+    unittest.main()