Beispiel #1
0
    def setUp(self):
        super().setUp()
        # We need to init the ribo object in write mode
        # Because we are going to add tnaseq data to it.
        self.sample_ribo = Ribo(self.merged_io, file_mode="r+")

        self.rnaseq_file_1 = StringIO(RNASEQ_READS)
        self.rnaseq_file_2 = StringIO(RNASEQ_READS_2)

        set_rnaseq(ribo_handle=self.sample_ribo._handle,
                   name="merzifon",
                   rnaseq_reads=self.rnaseq_file_1,
                   format="bed",
                   rnaseq_counts=None)

        set_rnaseq(ribo_handle=self.sample_ribo._handle,
                   name="ankara",
                   rnaseq_reads=self.rnaseq_file_2,
                   format="bed",
                   rnaseq_counts=None)

        # We need to re-initialize the ribo object
        # so that the changes take effect.
        self.sample_ribo._handle.close()
        self.sample_ribo = Ribo(self.merged_io, file_mode="r+")
Beispiel #2
0
class TestRNASEQ_2(ApiTestBase):
    def setUp(self):
        super().setUp()
        # We need to init the ribo object in write mode
        # Because we are going to add tnaseq data to it.
        self.sample_ribo = Ribo(self.merged_io, file_mode="r+")

        self.rnaseq_file_1 = StringIO(RNASEQ_READS)
        self.rnaseq_file_2 = StringIO(RNASEQ_READS_2)

        set_rnaseq(ribo_handle=self.sample_ribo._handle,
                   name="merzifon",
                   rnaseq_reads=self.rnaseq_file_1,
                   format="bed",
                   rnaseq_counts=None)

        set_rnaseq(ribo_handle=self.sample_ribo._handle,
                   name="ankara",
                   rnaseq_reads=self.rnaseq_file_2,
                   format="bed",
                   rnaseq_counts=None)

        # We need to re-initialize the ribo object
        # so that the changes take effect.
        self.sample_ribo._handle.close()
        self.sample_ribo = Ribo(self.merged_io, file_mode="r+")

    def test_has_rnaseq(self):
        self.assertTrue(self.sample_ribo.has_rnaseq("merzifon"))

        self.assertTrue(self.sample_ribo.has_rnaseq("ankara"))

    def test_get_rnaseq_multiple(self):
        rnaseq_df = self.sample_ribo.get_rnaseq()

        self.assertTrue(
            np.allclose([1, 0, 2, 1, 3], rnaseq_df.loc["merzifon", "GAPDH"]))
        self.assertTrue(
            np.allclose([0, 1, 3, 0, 1], rnaseq_df.loc["merzifon", "VEGFA"]))
        self.assertTrue(
            np.allclose([0, 1, 0, 0, 2], rnaseq_df.loc["merzifon", "MYC"]))

        self.assertTrue(
            np.isclose(rnaseq_df.loc["merzifon", "GAPDH"][CDS_name], 2))

        self.assertTrue(
            np.allclose([0, 0, 0, 0, 0], rnaseq_df.loc["ankara", "GAPDH"]))
        self.assertTrue(
            np.allclose([0, 0, 0, 2, 0], rnaseq_df.loc["ankara", "VEGFA"]))
        self.assertTrue(
            np.allclose([0, 0, 0, 0, 0], rnaseq_df.loc["ankara", "MYC"]))

        self.assertTrue(
            np.isclose(rnaseq_df.loc["ankara", "VEGFA"][UTR3_JUNCTION_name],
                       2))
Beispiel #3
0
class TestRNASEQ(ApiTestBase):
    def setUp(self):
        super().setUp()
        # We need to init the ribo object in write mode
        # Because we are going to add tnaseq data to it.
        self.sample_ribo = Ribo(self.merged_io, file_mode="r+")

        self.rnaseq_file_1 = StringIO(RNASEQ_READS)
        self.rnaseq_file_2 = StringIO(RNASEQ_READS_2)

        set_rnaseq(ribo_handle=self.sample_ribo._handle,
                   name="merzifon",
                   rnaseq_reads=self.rnaseq_file_1,
                   format="bed",
                   rnaseq_counts=None)

        # We need to re-initialize the ribo object
        # so that the changes take effect.
        self.sample_ribo._handle.close()
        self.sample_ribo = Ribo(self.merged_io, file_mode="r+")

    def test_has_rnaseq(self):
        self.assertTrue(self.sample_ribo.has_rnaseq("merzifon"))

        self.assertTrue(not self.sample_ribo.has_rnaseq("ankara"))

    def test_rnaseq_info(self):
        self.assertTrue(self.sample_ribo.\
                info["experiments"]["merzifon"]["RNA-Seq"])
        self.assertTrue(not self.sample_ribo.\
               info["experiments"]["ankara"]["RNA-Seq"])

    def test_get_rnaseq_single(self):
        rnaseq_df = self.sample_ribo.get_rnaseq("merzifon")

        self.assertTrue(
            np.allclose([1, 0, 2, 1, 3], rnaseq_df.loc["merzifon", "GAPDH"]))
        self.assertTrue(
            np.allclose([0, 1, 3, 0, 1], rnaseq_df.loc["merzifon", "VEGFA"]))
        self.assertTrue(
            np.allclose([0, 1, 0, 0, 2], rnaseq_df.loc["merzifon", "MYC"]))

        self.assertTrue(
            np.isclose(rnaseq_df.loc["merzifon", "GAPDH"][CDS_name], 2))

    def test_get_rnaseq_from_nornaseq_exp(self):
        with self.assertRaises(NORNASEQ) as exception_context:
            rnaseq_df = self.sample_ribo.get_rnaseq("ankara")
class TestGetCoverage(ApiTestBase):
    def setUp(self):
        super().setUp()
        self.file_handle_3 = BytesIO()
        self.ribo_handle_3 = h5py.File(self.file_handle_3, "w")

        create.create_ribo(ribo=self.ribo_handle_3,
                           experiment_name="adana",
                           alignment_file=self.alignment_file_1,
                           reference_name="hg38",
                           lengths_file=self.ref_len_file,
                           annotation_file=self.annotation_file,
                           metagene_radius=METAGENE_RADIUS,
                           left_span=LEFT_SPAN,
                           right_span=RIGHT_SPAN,
                           length_min=2,
                           length_max=5,
                           store_coverage=True,
                           nprocess=1,
                           tmp_file_prefix="")

        self.ribo_handle_3.close()
        self.adana_ribo = Ribo(self.file_handle_3)

    def test_get_coverage(self):
        coverage = self.adana_ribo.get_coverage("adana")
        self.assertEqual(coverage["GAPDH"][4], 7)
        self.assertEqual(coverage["VEGFA"][15], 0)
        self.assertEqual(coverage["MYC"][10], 13)
        self.assertEqual(coverage["MYC"][0], 2)

    def test_get_coverage_nonexising_exp(self):
        with self.assertRaises(ExperimentDoesntExist) as exception_context:
            has_coverage = self.sample_ribo.get_coverage("nonexisting")
    def setUp(self, rename_func=None):
        self.tmp_files = list()

        self.ref_len_file = StringIO(TRANSCRIPT_LENGTHS)
        self.annotation_file = StringIO(TRANSCRIPT_ANNOTATION)
        self.alignment_file_1 = StringIO(READ_SET_1)
        self.alignment_file_2 = StringIO(READ_SET_2)

        self.handle = h5py.File(BytesIO(), "w")
        self.handle_2 = h5py.File(BytesIO(), "w")

        create.create_ribo(ribo=self.handle,
                           experiment_name="merzifon",
                           alignment_file=self.alignment_file_1,
                           reference_name="hg38",
                           lengths_file=self.ref_len_file,
                           annotation_file=self.annotation_file,
                           metagene_radius=METAGENE_RADIUS,
                           left_span=LEFT_SPAN,
                           right_span=RIGHT_SPAN,
                           length_min=2,
                           length_max=5,
                           store_coverage=False,
                           nprocess=NPROCESS,
                           tmp_file_prefix="")
        self.ref_len_file.seek(0)
        self.annotation_file.seek(0)
        self.alignment_file_1 = StringIO(READ_SET_1)

        set_metadata(self.handle, "merzifon", METADATA_EXPERIMENT_DICT)

        create.create_ribo(ribo=self.handle_2,
                           experiment_name="ankara",
                           alignment_file=self.alignment_file_2,
                           reference_name="hg38",
                           lengths_file=self.ref_len_file,
                           annotation_file=self.annotation_file,
                           metagene_radius=METAGENE_RADIUS,
                           left_span=LEFT_SPAN,
                           right_span=RIGHT_SPAN,
                           length_min=2,
                           length_max=5,
                           store_coverage=True,
                           nprocess=NPROCESS,
                           tmp_file_prefix="")
        self.ref_len_file.seek(0)
        self.annotation_file.seek(0)
        self.alignment_file_2 = StringIO(READ_SET_2)

        self.merged_io = BytesIO()
        self.merged_ribo = h5py.File(self.merged_io, "w")
        merge_ribos(self.merged_ribo, [self.handle, self.handle_2])
        set_metadata(self.merged_ribo, name=None, metadata=RIBO_METADATA_STR_1)
        self.merged_ribo.close()

        self.sample_ribo = Ribo(self.merged_io, alias=rename_func)
    def setUp(self):
        super().setUp()
        self.file_handle_3 = BytesIO()
        self.ribo_handle_3 = h5py.File(self.file_handle_3, "w")

        create.create_ribo(ribo=self.ribo_handle_3,
                           experiment_name="adana",
                           alignment_file=self.alignment_file_1,
                           reference_name="hg38",
                           lengths_file=self.ref_len_file,
                           annotation_file=self.annotation_file,
                           metagene_radius=METAGENE_RADIUS,
                           left_span=LEFT_SPAN,
                           right_span=RIGHT_SPAN,
                           length_min=2,
                           length_max=5,
                           store_coverage=True,
                           nprocess=1,
                           tmp_file_prefix="")

        self.ribo_handle_3.close()
        self.adana_ribo = Ribo(self.file_handle_3)
Beispiel #7
0
    def setUp(self):

        self.tmp_files = list()

        self.ref_len_file = StringIO(GENERIC_TRANSCRIPT_LENGTHS)
        self.annotation_file = StringIO(GENERIC_TRANSCRIPT_ANNOTATION)
        self.alignment_file_1 = StringIO(READ_SET_1)
        self.alignment_file_2 = StringIO(READ_SET_2)

        self.handle_io = BytesIO()
        self.handle = h5py.File(self.handle_io, "w")
        self.handle_2 = h5py.File(BytesIO(), "w")
        self.h5_handle = h5py.File(BytesIO(), "w")

        initialize(self.h5_handle,
                   experiment_name="dummy",
                   reference_name="test_ref")

        (ref_names, ref_lengths) = \
           set_reference_names_and_lengths(self.h5_handle , self.ref_len_file)
        self.ref_len_file.seek(0)

        self.annotation_lines = GENERIC_TRANSCRIPT_ANNOTATION.split("\n")

        create.create_ribo(ribo=self.handle,
                           experiment_name="experiment-1",
                           alignment_file=self.alignment_file_1,
                           reference_name="hg38",
                           lengths_file=self.ref_len_file,
                           annotation_file=self.annotation_file,
                           metagene_radius=METAGENE_RADIUS,
                           left_span=LEFT_SPAN,
                           right_span=RIGHT_SPAN,
                           length_min=LENGTH_MIN,
                           length_max=LENGTH_MAX,
                           store_coverage=True,
                           nprocess=NPROCESS,
                           tmp_file_prefix="")

        self.handle.close()
        self.sample_ribo = Ribo(self.handle_io)

        # Get the  region counts

        self.cds_counts = \
           self.sample_ribo.get_region_counts( region_name    = CDS_name,
                                               sum_references = False)

        self.utr5_counts = \
           self.sample_ribo.get_region_counts( region_name    = UTR5_name,
                                               sum_references = False)

        self.utr3_counts = \
           self.sample_ribo.get_region_counts( region_name    = UTR3_name,
                                               sum_references = False)

        self.utr5j_counts = \
           self.sample_ribo.get_region_counts( region_name    = UTR5_JUNCTION_name,
                                               sum_references = False)

        self.utr3j_counts = \
           self.sample_ribo.get_region_counts( region_name    = UTR3_JUNCTION_name,
                                               sum_references = False)