Ejemplo n.º 1
0
    def test_overlap_experiment_annotation(self):
        epidb = DeepBlueClient(address="localhost", port=31415)
        self.init_base(epidb)

        sample_id = self.sample_ids[0]

        self.insert_experiment(epidb, "hg19_chr1_1", sample_id)
        self.insert_annotation(epidb, "Cpg Islands")

        # TODO: Is this test actually check anything?

        res, qid_1 = epidb.select_regions("hg19_chr1_1", "hg19", "Methylation",
                                          sample_id, "tech1", "ENCODE", "chr1",
                                          760000, 860000, self.admin_key)
        self.assertSuccess(res, qid_1)
        res, req = epidb.count_regions(qid_1, self.admin_key)
        self.assertSuccess(res, req)
        count = self.count_request(req)

        res, qid_2 = epidb.select_annotations("Cpg Islands", "hg19", "chr1",
                                              None, None, self.admin_key)
        self.assertSuccess(res, qid_2)
        res, req = epidb.count_regions(qid_2, self.admin_key)
        self.assertSuccess(res, req)
        count = self.count_request(req)

        res, qid_3 = epidb.merge_queries(qid_1, qid_2, self.admin_key)
        self.assertSuccess(res, qid_3)
        res, req = epidb.count_regions(qid_3, self.admin_key)
        self.assertSuccess(res, req)
        count = self.count_request(req)
  def test_merge_tiling(self):
    epidb = DeepBlueClient(address="localhost", port=31415)
    self.init_full(epidb)

    res, qid1 = epidb.tiling_regions(10000, "hg19", "chr1", self.admin_key)
    self.assertSuccess(res, qid1)

    res, qid2 = epidb.select_regions("hg19_chr1_1", "hg19", None, None, None, None, None, None, None, self.admin_key)
    self.assertSuccess(res, qid2)

    # limit the tilings on the range of the experiment
    res, qid3 = epidb.filter_regions(qid1, "START",  ">=", "713240", "number", self.admin_key)
    self.assertSuccess(res, qid3)
    res, qid4 = epidb.filter_regions(qid3, "END",  "<=", "876330", "number", self.admin_key)
    self.assertSuccess(res, qid4)

    res, qid5 = epidb.merge_queries(qid4, qid2, self.admin_key)
    self.assertSuccess(res, qid5)

    res, req = epidb.get_regions(qid5, "CHROMOSOME,START,END", self.admin_key)
    self.assertSuccess(res, req)
    regions = self.get_regions_request(req)

    expected_regions = helpers.get_result("merge_tiling")
    self.assertEqual(regions, expected_regions)
Ejemplo n.º 3
0
    def test_experiment_name_metacolumn2(self):
        epidb = DeepBlueClient(address="localhost", port=31415)
        self.init_base()

        self.insert_experiment(epidb, "hg19_chr1_1")
        self.insert_experiment(epidb, "hg19_chr1_2")

        res, qid1 = epidb.select_regions("hg19_chr1_2", "hg19", None, None,
                                         None, None, None, 750000, 770000,
                                         self.admin_key)
        self.assertSuccess(res, qid1)
        res, qid2 = epidb.select_regions("hg19_chr1_1", "hg19", None, None,
                                         None, None, None, 750000, 770000,
                                         self.admin_key)
        self.assertSuccess(res, qid2)

        res, qid3 = epidb.merge_queries(qid1, qid2, self.admin_key)
        self.assertSuccess(res, qid3)

        expected = helpers.get_result("experiment_name_multiple_experiments")
        res, req = epidb.get_regions(qid3, "CHROMOSOME,START,END,@NAME",
                                     self.admin_key)
        self.assertSuccess(res, req)
        regions = self.get_regions_request(req)
        l_regions = regions.split("\n")
        l_expected = expected.split("\n")
        self.assertEqual(set(l_regions), set(l_expected))
Ejemplo n.º 4
0
    def test_multiple_merge(self):
        epidb = DeepBlueClient(address="localhost", port=31415)
        self.init_base(epidb)

        sizes = [10000, 20000, 25000, 30000, 35000, 40000, 50000]
        qs = []

        for s in sizes:
            res, q_t = epidb.tiling_regions(s, "hg19", "chr21", self.admin_key)
            qs.append(q_t)

        res, qid_3 = epidb.merge_queries(qs[0], qs[1:], self.admin_key)
        self.assertSuccess(res, qid_3)

        res, req = epidb.count_regions(qid_3, self.admin_key)

        self.assertSuccess(res, req)
        count = self.count_request(req)
        self.assertEqual(count, 14287)
Ejemplo n.º 5
0
    def test_complex1(self):
        epidb = DeepBlueClient(address="localhost", port=31415)
        self.init_full(epidb)

        res, qid_1_1 = epidb.select_regions("hg19_chr1_1", "hg19", None, None,
                                            None, None, None, None, None,
                                            self.admin_key)
        #server.get_regions(qid_1_1, )

        self.assertSuccess(res, qid_1_1)
        res, qid_1_2 = epidb.select_regions("hg19_chr1_2", "hg19", None, None,
                                            None, None, None, None, None,
                                            self.admin_key)
        self.assertSuccess(res, qid_1_2)

        res, qid_2 = epidb.merge_queries(qid_1_1, qid_1_2, self.admin_key)
        self.assertSuccess(res, qid_2)

        res, regions = epidb.get_regions(qid_2, "CHROMOSOME,START,END",
                                         self.admin_key)
        self.assertSuccess(res, regions)

        res, qid_1_3 = epidb.select_regions("hg19_chr1_3", "hg19", None, None,
                                            None, None, None, None, None,
                                            self.admin_key)
        self.assertSuccess(res, qid_1_3)

        res, qid_5 = epidb.intersection(qid_2, qid_1_3, self.admin_key)
        self.assertSuccess(res, qid_5)

        res, req = epidb.get_regions(
            qid_5,
            "CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK",
            self.admin_key)
        self.assertSuccess(res, req)
        regions = self.get_regions_request(req)

        expected_regions = helpers.get_result("complex1")
        self.assertEqual(
            regions.split("\n").sort(),
            expected_regions.split("\n").sort())
Ejemplo n.º 6
0
    def test_merge_queries(self):
        epidb = DeepBlueClient(address="localhost", port=31415)
        self.init_full(epidb)

        res, qid_1 = epidb.select_experiments("hg19_chr1_1", None, 760000,
                                              860000, self.admin_key)
        self.assertSuccess(res, qid_1)

        res, qid_2 = epidb.select_regions("hg19_chr1_2", "hg19", None, None,
                                          None, None, None, 760000, 860000,
                                          self.admin_key)
        self.assertSuccess(res, qid_2)

        res, qid_3 = epidb.merge_queries(qid_1, qid_2, self.admin_key)
        self.assertSuccess(res, qid_3)

        expected_regions = helpers.get_result("merge_760k_860k")

        res, req = epidb.get_regions(qid_3, "CHROMOSOME,START,END",
                                     self.admin_key)
        self.assertSuccess(res, req)
        regions = self.get_regions_request(req)
        self.assertEqual(regions, expected_regions)
Ejemplo n.º 7
0
    def test_complex2(self):
        epidb = DeepBlueClient(address="localhost", port=31415)
        self.init_full(epidb)

        self.insert_experiment(epidb, "hg19_big_1")
        self.insert_experiment(epidb, "hg19_big_2")

        res, qid_1_1 = epidb.select_regions("hg19_big_1", "hg19", None, None,
                                            None, None, None, 1000000, 3000000,
                                            self.admin_key)
        self.assertSuccess(res, qid_1_1)
        res, req = epidb.count_regions(qid_1_1, self.admin_key)
        self.assertSuccess(res, req)
        c = self.count_request(req)

        res, qid_1_2 = epidb.select_regions(
            "hg19_big_1", "hg19", None, None, None, None,
            ["chr1", "chr3", "chr11", "chrX", "chr9"], None, None,
            self.admin_key)
        self.assertSuccess(res, qid_1_2)
        res, req = epidb.count_regions(qid_1_2, self.admin_key)
        self.assertSuccess(res, req)
        c = self.count_request(req)

        # this gives us regions from 1,000,000 to 3,000,000 on chromosomes chr1, chr3, chr9, chr11, chrY
        res, qid_2_1 = epidb.intersection(qid_1_1, qid_1_2, self.admin_key)
        self.assertSuccess(res, qid_2_1)
        res, req = epidb.count_regions(qid_2_1, self.admin_key)
        self.assertSuccess(res, req)
        c = self.count_request(req)
        self.assertEqual(c, 247)

        res, qid_2_2 = epidb.tiling_regions(1000, "hg19",
                                            ["chr1", "chr2", "chr15", "chrX"],
                                            self.admin_key)
        self.assertSuccess(res, qid_2_2)
        res, req = epidb.count_regions(qid_2_2, self.admin_key)
        self.assertSuccess(res, req)
        c = self.count_request(req)

        res, qid_3_1 = epidb.merge_queries(qid_2_1, qid_2_2, self.admin_key)
        self.assertSuccess(res, qid_3_1)
        res, req = epidb.count_regions(qid_3_1, self.admin_key)
        self.assertSuccess(res, req)
        c = self.count_request(req)

        res, qid_4_1 = epidb.filter_regions(qid_3_1, "START", ">=", "2000000",
                                            "number", self.admin_key)
        self.assertSuccess(res, qid_4_1)
        res, req = epidb.count_regions(qid_4_1, self.admin_key)
        self.assertSuccess(res, req)
        c = self.count_request(req)

        res, qid_4_2 = epidb.select_regions("hg19_big_2", "hg19", None, None,
                                            None, None, ["chr1", "chrX"], None,
                                            None, self.admin_key)
        self.assertSuccess(res, qid_4_2)
        (res, qid_4_2_cached) = epidb.query_cache(qid_4_2, True,
                                                  self.admin_key)
        res, req = epidb.count_regions(qid_4_2_cached, self.admin_key)
        self.assertSuccess(res, req)
        c = self.count_request(req)
        self.assertEqual(c, 8961)

        res, qid_5_1 = epidb.intersection(qid_4_1, qid_4_2_cached,
                                          self.admin_key)
        self.assertSuccess(res, qid_5_1)
        res, req = epidb.count_regions(qid_5_1, self.admin_key)
        self.assertSuccess(res, req)
        count = self.count_request(req)

        self.assertEqual(count, 14356)

        res, qid_6_1 = epidb.filter_regions(qid_5_1, "END", "<", "2200000",
                                            "number", self.admin_key)
        self.assertSuccess(res, qid_6_1)

        (res, qid_6_1_cached) = epidb.query_cache(qid_6_1, True,
                                                  self.admin_key)
        res, req = epidb.count_regions(qid_6_1, self.admin_key)
        self.assertSuccess(res, req)
        count = self.count_request(req)
        self.assertEqual(count, 52)

        res, req = epidb.get_regions(
            qid_6_1,
            "CHROMOSOME,START,END,NAME,SCORE,STRAND,SIGNAL_VALUE,P_VALUE,Q_VALUE,PEAK,@NAME",
            self.admin_key)
        self.assertSuccess(res, req)
        regions = self.get_regions_request(req)

        expected_regions = helpers.get_result("complex2")
        self.assertEqual(regions, expected_regions)