Пример #1
0
    def test_export_wsp(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS.wsp"
        sample_grp = 'DEN'

        # use a leaf gate to test if the new WSP session is created correctly
        gate_name = 'TNFa+'
        gate_path = ('root', 'Time', 'Singlets', 'aAmine-', 'CD3+', 'CD4+')

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        out_file = BytesIO()
        fks.export_wsp(out_file, sample_grp)
        out_file.seek(0)

        fks_out = Session(copy.deepcopy(test_samples_8c_full_set))
        fks_out.import_flowjo_workspace(out_file, ignore_missing_files=True)

        self.assertIsInstance(fks_out, Session)

        fks_gate = fks.get_gate(sample_grp, gate_name, gate_path)
        fks_out_gate = fks_out.get_gate(sample_grp, gate_name, gate_path)

        self.assertIsInstance(fks_gate, gates.RectangleGate)
        self.assertIsInstance(fks_out_gate, gates.RectangleGate)

        self.assertEqual(fks_gate.gate_name, gate_name)
        self.assertEqual(fks_out_gate.gate_name, gate_name)
Пример #2
0
    def test_load_wsp_single_quad(self):
        wsp_path = "examples/data/simple_diamond_example/simple_diamond_example_quad_gate.wsp"
        fcs_path = "examples/data/simple_diamond_example/test_data_diamond_01.fcs"

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path)

        # FlowJo quadrant gates are not true quadrant gates, rather a collection of rectangle gates
        self.assertIsInstance(
            fks.get_gate('All Samples',
                         'Q1: channel_A- , channel_B+',
                         sample_id='test_data_diamond_01.fcs'),
            gates.RectangleGate)

        fks.analyze_samples(group_name='All Samples')
        results = fks.get_gating_results('All Samples',
                                         'test_data_diamond_01.fcs')

        gate_count_q1 = results.get_gate_count('Q1: channel_A- , channel_B+')
        gate_count_q2 = results.get_gate_count('Q2: channel_A+ , channel_B+')
        gate_count_q3 = results.get_gate_count('Q3: channel_A+ , channel_B-')
        gate_count_q4 = results.get_gate_count('Q4: channel_A- , channel_B-')
        self.assertEqual(gate_count_q1, 49671)
        self.assertEqual(gate_count_q2, 50596)
        self.assertEqual(gate_count_q3, 50330)
        self.assertEqual(gate_count_q4, 49403)
Пример #3
0
    def test_wsp_export_simple_poly50(self):
        wsp_path = "examples/data/simple_line_example/simple_poly_and_rect_v2_poly50.wsp"
        fcs_path = "examples/data/simple_line_example/data_set_simple_line_100.fcs"
        sample_group = 'my_group'
        sample_id = 'data_set_simple_line_100.fcs'

        fks = Session(fcs_path)
        fks.import_flowjo_workspace(wsp_path)

        with BytesIO() as fh_out:
            fks.export_wsp(fh_out, sample_group)
            fh_out.seek(0)

            fks2 = Session(fcs_path)
            fks2.import_flowjo_workspace(fh_out)

        fks.analyze_samples(sample_group)
        fks_results = fks.get_gating_results(sample_group, sample_id)

        fks2.analyze_samples(sample_group)
        fks2_results = fks2.get_gating_results(sample_group, sample_id)

        gate_refs = fks.get_gate_ids(sample_group)

        self.assertEqual(len(gate_refs), 2)

        fks_rect1_count = fks_results.get_gate_count('rect1')
        fks2_rect1_count = fks2_results.get_gate_count('rect1')
        fks_poly1_count = fks_results.get_gate_count('poly1')
        fks2_poly1_count = fks2_results.get_gate_count('poly1')

        self.assertEqual(fks_rect1_count, 0)
        self.assertEqual(fks2_rect1_count, 0)
        self.assertEqual(fks_poly1_count, 50)
        self.assertEqual(fks2_poly1_count, 50)
Пример #4
0
    def test_get_sample_gate_events(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS_simple.wsp"
        sample_grp = 'DEN'
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'
        gate_name = 'CD3+'

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        fks.analyze_samples(sample_grp, sample_id)

        sample_comp = fks.get_sample_comp_matrices(sample_grp, sample_id)[0]
        sample_xform = transforms.LogicleTransform('my_logicle',
                                                   param_t=262144.0,
                                                   param_w=1.0,
                                                   param_m=4.418539922,
                                                   param_a=0.0)

        df_gated_events = fks.get_gate_events(sample_grp,
                                              sample_id,
                                              gate_name,
                                              matrix=sample_comp,
                                              transform=sample_xform)

        self.assertIsInstance(df_gated_events, pd.DataFrame)
        self.assertEqual(len(df_gated_events), 133670)
Пример #5
0
    def test_get_group_transforms(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS_simple.wsp"
        sample_grp = 'DEN'

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        xforms = fks.get_group_transforms(sample_grp)

        self.assertEqual(len(xforms), 23)
        for cm in xforms:
            self.assertIsInstance(cm, Transform)
Пример #6
0
    def test_load_wsp_single_poly(self):
        wsp_path = "examples/simple_line_example/simple_poly_and_rect.wsp"
        fcs_path = "examples/simple_line_example/data_set_simple_line_100.fcs"

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path)

        self.assertIsInstance(
            fks.get_gate('my_group', 'data_set_simple_line_100.fcs', 'poly1'),
            gates.PolygonGate)

        gate_ids = {'rect1', 'poly1'}
        self.assertSetEqual(set(fks.get_gate_ids('my_group')), gate_ids)
Пример #7
0
    def test_get_sample_comp_matrices(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS_simple.wsp"
        sample_grp = 'DEN'
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        comp_matrices = fks.get_sample_comp_matrices(sample_grp, sample_id)

        self.assertEqual(len(comp_matrices), 1)
        for cm in comp_matrices:
            self.assertIsInstance(cm, Matrix)
Пример #8
0
    def test_analyze_single_sample(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS_simple.wsp"
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'
        sample_grp = 'DEN'

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        sample_ids = fks.get_group_sample_ids(sample_grp)
        self.assertEqual(len(sample_ids), 3)

        fks.analyze_samples(sample_grp, sample_id=sample_id)
        report = fks.get_group_report(sample_grp)

        self.assertEqual(report['sample'].nunique(), 1)
Пример #9
0
    def test_analyze_samples_multiproc(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS_simple.wsp"
        sample_grp = 'DEN'
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'
        gate_name = 'CD3+'

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        fks.analyze_samples(sample_grp)

        gate_membership = fks.get_gate_membership(sample_grp, sample_id,
                                                  gate_name)

        self.assertEqual(gate_membership.sum(), 133670)
Пример #10
0
    def test_get_wsp_gated_events(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS_simple.wsp"
        sample_grp = 'DEN'
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'
        gate_name = 'CD3+'

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        fks.analyze_samples(sample_grp, sample_id)

        df_gated_events = fks.get_wsp_gated_events(sample_grp, [sample_id],
                                                   gate_name)

        self.assertIsInstance(df_gated_events, list)
        self.assertEqual(len(df_gated_events[0]), 133670)
Пример #11
0
    def test_load_wsp_single_ellipse(self):
        wsp_path = "examples/simple_line_example/single_ellipse_51_events.wsp"
        fcs_path = "examples/simple_line_example/data_set_simple_line_100.fcs"

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path)

        self.assertIsInstance(
            fks.get_gate('All Samples', 'data_set_simple_line_100.fcs',
                         'ellipse1'), gates.EllipsoidGate)

        fks.analyze_samples(sample_group='All Samples')
        results = fks.get_gating_results('All Samples',
                                         'data_set_simple_line_100.fcs')
        gate_count = results.get_gate_count('ellipse1')
        self.assertEqual(gate_count, 48)
Пример #12
0
    def test_analyze_single_sample(self):
        wsp_path = "examples/8_color_data_set/8_color_ICS_simple.wsp"
        fcs_path = "examples/8_color_data_set/fcs_files"
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'
        sample_grp = 'DEN'

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        sample_ids = fks.get_group_sample_ids(sample_grp)
        self.assertEqual(len(sample_ids), 3)

        fks.analyze_samples(sample_grp, sample_id=sample_id)
        report = fks.get_group_report(sample_grp)

        self.assertEqual(report.index.get_level_values('sample').nunique(), 1)
Пример #13
0
    def test_load_wsp_single_poly(self):
        wsp_path = "examples/data/simple_line_example/simple_poly_and_rect.wsp"
        fcs_path = "examples/data/simple_line_example/data_set_simple_line_100.fcs"

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path)

        self.assertIsInstance(
            fks.get_gate('my_group',
                         'poly1',
                         sample_id='data_set_simple_line_100.fcs'),
            gates.PolygonGate)

        gate_names = {'rect1', 'poly1'}
        wsp_gates_tuple = fks.get_gate_ids('my_group')
        wsp_gate_names = set([g[0] for g in wsp_gates_tuple])
        self.assertSetEqual(wsp_gate_names, gate_names)
Пример #14
0
    def test_get_sample_groups(self):
        wsp_path = "examples/simple_line_example/simple_poly_and_rect.wsp"
        fcs_path = "examples/simple_line_example/data_set_simple_line_100.fcs"

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path)

        groups = fks.get_sample_groups()
        groups_truth = ['default', 'my_group']

        self.assertListEqual(groups, groups_truth)

        fks.add_sample_group('group2')
        groups_truth.append('group2')
        groups = fks.get_sample_groups()

        self.assertListEqual(groups, groups_truth)
Пример #15
0
    def test_parse_wsp_reused_gate_with_child(self):
        wsp_path = "examples/data/8_color_data_set/reused_quad_gate_with_child.wsp"

        fks = Session(copy.deepcopy(test_samples_8c_full_set))
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)
        group_name = 'All Samples'
        gate_name = 'some_child_gate'

        gate_ids = fks.get_gate_ids(group_name)

        gate_id_1 = (gate_name, ('root', 'good cells', 'cd4+',
                                 'Q2: CD107a+, IL2+'))
        gate_id_2 = (gate_name, ('root', 'good cells', 'cd8+',
                                 'Q2: CD107a+, IL2+'))

        self.assertIn(gate_id_1, gate_ids)
        self.assertIn(gate_id_2, gate_ids)
Пример #16
0
    def test_wsp_fasinh_transform(self):
        wsp_path = "examples/data/simple_diamond_example/test_data_diamond_asinh_rect.wsp"
        fcs_path = "examples/data/simple_diamond_example/test_data_diamond_01.fcs"

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path)

        self.assertIsInstance(
            fks.get_gate('All Samples',
                         'upper_right',
                         sample_id='test_data_diamond_01.fcs'),
            gates.RectangleGate)

        fks.analyze_samples(group_name='All Samples')
        results = fks.get_gating_results('All Samples',
                                         'test_data_diamond_01.fcs')
        gate_count = results.get_gate_count('upper_right')
        self.assertEqual(gate_count, 50559)
Пример #17
0
    def test_parse_wsp_with_ellipse(self):
        wsp_path = "examples/data/8_color_data_set/8_color_ICS_with_ellipse.wsp"
        fcs_path = "examples/data/8_color_data_set/fcs_files/101_DEN084Y5_15_E01_008_clean.fcs"
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'
        sample_grp = 'DEN'
        gate_name = 'ellipse1'
        gate_path = ('root', 'Time', 'Singlets', 'aAmine-', 'CD3+')

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        fks.analyze_samples(sample_grp, sample_id=sample_id)
        gate_indices = fks.get_gate_membership(sample_grp,
                                               sample_id,
                                               gate_name,
                                               gate_path=gate_path)

        self.assertIsInstance(gate_indices, np.ndarray)
        self.assertEqual(np.sum(gate_indices), 7018)
Пример #18
0
    def test_get_ambiguous_gate_objects(self):
        wsp_path = "examples/8_color_data_set/8_color_ICS.wsp"
        fcs_path = "examples/8_color_data_set/fcs_files/101_DEN084Y5_15_E01_008_clean.fcs"
        sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'
        sample_grp = 'DEN'
        gate_id = 'TNFa+'
        gate_path = ['root', 'Time', 'Singlets', 'aAmine-', 'CD3+', 'CD4+']

        fks = Session(fcs_samples=fcs_path)
        fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)

        fks.analyze_samples(sample_grp)
        gate_indices = fks.get_gate_indices(sample_grp,
                                            sample_id,
                                            gate_id,
                                            gate_path=gate_path)

        self.assertIsInstance(gate_indices, np.ndarray)
        self.assertEqual(np.sum(gate_indices), 21)
Пример #19
0
"""
Tests for GatingResults class
"""
import copy
import unittest
from flowkit import Session
from .session_tests import test_samples_8c_full_set

wsp_path = "examples/data/8_color_data_set/reused_quad_gate_with_child.wsp"
group_name = 'All Samples'
sample_id = '101_DEN084Y5_15_E01_008_clean.fcs'

fks = Session(copy.deepcopy(test_samples_8c_full_set))
fks.import_flowjo_workspace(wsp_path, ignore_missing_files=True)
fks.analyze_samples(group_name=group_name, sample_id=sample_id)
results_8c_sample_008 = fks.get_gating_results(group_name=group_name,
                                               sample_id=sample_id)


class GatingResultsTestCase(unittest.TestCase):
    def test_get_gate_count_ambiguous_raises_value_error(self):
        gate_name = 'some_child_gate'

        self.assertRaises(ValueError, results_8c_sample_008.get_gate_count,
                          gate_name)

    def test_get_gate_count_with_gate_path(self):
        gate_name = 'some_child_gate'
        gate_path_1 = ('root', 'good cells', 'cd4+', 'Q2: CD107a+, IL2+')

        gate_count = results_8c_sample_008.get_gate_count(