Esempio n. 1
0
 def setUp(self):
     self.maxDiff = None
     self.sequence = TreatmentSequence()
     self.agent = StudyFactor(name=BASE_FACTORS[0]['name'],
                              factor_type=BASE_FACTORS[0]['type'])
     self.intensity = StudyFactor(name=BASE_FACTORS[1]['name'],
                                  factor_type=BASE_FACTORS[1]['type'])
     self.duration = StudyFactor(name=BASE_FACTORS[2]['name'],
                                 factor_type=BASE_FACTORS[2]['type'])
     self.test_treatment = Treatment(
         treatment_type=INTERVENTIONS['CHEMICAL'],
         factor_values=(FactorValue(factor_name=self.agent, value='crack'),
                        FactorValue(factor_name=self.intensity,
                                    value='low'),
                        FactorValue(factor_name=self.duration,
                                    value='short')))
Esempio n. 2
0
def create_descriptor():
    """Returns a ISA-Tab descriptor using a simple sample plan for
    illustration."""
    investigation = Investigation(identifier='I1')
    plan = SampleAssayPlan()
    plan.add_sample_type('liver')
    plan.add_sample_plan_record('liver', 5)
    plan.add_sample_type('blood')
    plan.add_sample_plan_record('blood', 3)
    plan.group_size = 2
    f1 = StudyFactor(name='AGENT',
                     factor_type=OntologyAnnotation(term='pertubation agent'))
    f2 = StudyFactor(name='INTENSITY',
                     factor_type=OntologyAnnotation(term='intensity'))
    f3 = StudyFactor(name='DURATION',
                     factor_type=OntologyAnnotation(term='time'))
    treatment_factory = TreatmentFactory(factors=[f1, f2, f3])
    treatment_factory.add_factor_value(f1, {'cocaine', 'crack', 'aether'})
    treatment_factory.add_factor_value(f2, {'low', 'medium', 'high'})
    treatment_factory.add_factor_value(f3, {'short', 'long'})
    ffactorial_design_treatments = treatment_factory\
        .compute_full_factorial_design()
    treatment_sequence = TreatmentSequence(
        ranked_treatments=ffactorial_design_treatments)
    # treatment_factory.add_factor_value('intensity', 1.05)
    study = IsaModelObjectFactory(plan, treatment_sequence)\
        .create_study_from_plan()
    study.filename = 's_study.txt'
    investigation.studies = [study]
    print(isatab.dumps(investigation))
Esempio n. 3
0
 def test_create_study_from_plan(self):
     plan = SampleAssayPlan()
     plan.add_sample_type('liver')
     plan.add_sample_plan_record('liver', 5)
     plan.add_sample_type('blood')
     plan.add_sample_plan_record('blood', 3)
     plan.group_size = 2
     treatment_factory = TreatmentFactory(
         factors=[self.f1, self.f2, self.f3])
     treatment_factory.add_factor_value(self.f1,
                                        {'cocaine', 'crack', 'aether'})
     treatment_factory.add_factor_value(self.f2, {'low', 'medium', 'high'})
     treatment_factory.add_factor_value(self.f3, {'short', 'long'})
     ffactorial_design_treatments = \
         treatment_factory.compute_full_factorial_design()
     treatment_sequence = TreatmentSequence(
         ranked_treatments={(x, i)
                            for i, x in enumerate(
                                ffactorial_design_treatments)})
     # makes each study group ranked in sequence
     study = IsaModelObjectFactory(
         plan, treatment_sequence).create_study_from_plan()
     study.filename = 's_study.txt'
     self.investigation.studies = [study]
     self.assertEqual(36, len(study.sources))
     self.assertEqual(288, len(study.samples))
Esempio n. 4
0
 def setUp(self):
     self.design = InterventionStudyDesign()
     self.agent = StudyFactor(name=BASE_FACTORS[0]['name'],
                              factor_type=BASE_FACTORS[0]['type'])
     self.intensity = StudyFactor(name=BASE_FACTORS[1]['name'],
                                  factor_type=BASE_FACTORS[1]['type'])
     self.duration = StudyFactor(name=BASE_FACTORS[2]['name'],
                                 factor_type=BASE_FACTORS[2]['type'])
     self.first_treatment = Treatment(
         treatment_type=INTERVENTIONS['CHEMICAL'],
         factor_values=(FactorValue(factor_name=self.agent, value='crack'),
                        FactorValue(factor_name=self.intensity,
                                    value='low'),
                        FactorValue(factor_name=self.duration,
                                    value='medium')))
     self.second_treatment = Treatment(
         treatment_type=INTERVENTIONS['CHEMICAL'],
         factor_values=(FactorValue(factor_name=self.agent, value='crack'),
                        FactorValue(factor_name=self.intensity,
                                    value='high'),
                        FactorValue(factor_name=self.duration,
                                    value='medium')))
     self.test_sequence = TreatmentSequence(
         ranked_treatments=[(self.first_treatment,
                             1), (self.second_treatment, 2)])
     self.sample_plan = SampleAssayPlan(group_size=10,
                                        sample_plan={},
                                        assay_plan=None)
Esempio n. 5
0
 def test_init_with_single_treatment(self):
     treatment = Treatment(
         treatment_type=INTERVENTIONS['CHEMICAL'],
         factor_values=(FactorValue(factor_name=self.agent, value='crack'),
                        FactorValue(factor_name=self.intensity,
                                    value='low'),
                        FactorValue(factor_name=self.duration,
                                    value='short')))
     new_sequence = TreatmentSequence(ranked_treatments=treatment)
     self.assertTrue((treatment, 1) in new_sequence.ranked_treatments)
Esempio n. 6
0
 def test_sequences_plan_property(self):
     other_test_sequence = TreatmentSequence(
         ranked_treatments=[(self.first_treatment,
                             2), (self.second_treatment, 1)])
     other_sample_plan = SampleAssayPlan(group_size=12)
     sequences_plan = {
         self.test_sequence: self.sample_plan,
         other_test_sequence: other_sample_plan
     }
     self.design.sequences_plan = sequences_plan
     self.assertEqual(self.design.sequences_plan, sequences_plan)
Esempio n. 7
0
 def test_eq(self):
     treatments = [
         (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                    factor_values=(FactorValue(factor_name=self.agent,
                                               value='crack'),
                                   FactorValue(factor_name=self.intensity,
                                               value='low'),
                                   FactorValue(factor_name=self.duration,
                                               value='short'))), 1),
         (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                    factor_values=(FactorValue(factor_name=self.agent,
                                               value='crack'),
                                   FactorValue(factor_name=self.intensity,
                                               value='low'),
                                   FactorValue(factor_name=self.duration,
                                               value='long'))), 2)
     ]
     first_sequence = TreatmentSequence(treatments)
     second_sequence = TreatmentSequence(reversed(treatments))
     self.assertEqual(first_sequence, second_sequence)
     self.assertEqual(hash(first_sequence), hash(second_sequence))
Esempio n. 8
0
 def test_repr(self):
     treatments = [
         (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                    factor_values=(FactorValue(factor_name=self.agent,
                                               value='crack'),
                                   FactorValue(factor_name=self.intensity,
                                               value='low'),
                                   FactorValue(factor_name=self.duration,
                                               value='short'))), 1),
         (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                    factor_values=(FactorValue(factor_name=self.agent,
                                               value='crack'),
                                   FactorValue(factor_name=self.intensity,
                                               value='low'),
                                   FactorValue(factor_name=self.duration,
                                               value='long'))), 2)
     ]
     new_sequence = TreatmentSequence(ranked_treatments=treatments)
     self.assertEqual(
         'TreatmentSequence([(Treatment(factor_type=chemical '
         'intervention, factor_values=(FactorValue(factor_name='
         'StudyFactor(name="AGENT", factor_type='
         'OntologyAnnotation(term="perturbation agent", '
         'term_source=None, term_accession="", comments=[]), '
         'comments=[]), value=crack, unit=None), FactorValue('
         'factor_name=StudyFactor(name="INTENSITY", '
         'factor_type=OntologyAnnotation(term="intensity", '
         'term_source=None, term_accession="", comments=[]), '
         'comments=[]), value=low, unit=None), FactorValue('
         'factor_name=StudyFactor(name="DURATION", '
         'factor_type=OntologyAnnotation(term="time", '
         'term_source=None, term_accession="", comments=[]), '
         'comments=[]), value=short, unit=None))), 1), ('
         'Treatment(factor_type=chemical intervention, '
         'factor_values=(FactorValue(factor_name=StudyFactor('
         'name="AGENT", factor_type=OntologyAnnotation('
         'term="perturbation agent", term_source=None, '
         'term_accession="", comments=[]), comments=[]), '
         'value=crack, unit=None), FactorValue(factor_name='
         'StudyFactor(name="INTENSITY", factor_type='
         'OntologyAnnotation(term="intensity", '
         'term_source=None, term_accession="", comments=[]), '
         'comments=[]), value=low, unit=None), FactorValue('
         'factor_name=StudyFactor(name="DURATION", '
         'factor_type=OntologyAnnotation(term="time", '
         'term_source=None, term_accession="", comments=[]), '
         'comments=[]), value=long, unit=None))), 2)])', repr(new_sequence))
Esempio n. 9
0
 def test_init_with_treatments_list_no_rank(self):
     treatments = [
         Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                   factor_values=(FactorValue(factor_name=self.agent,
                                              value='crack'),
                                  FactorValue(factor_name=self.intensity,
                                              value='low'),
                                  FactorValue(factor_name=self.duration,
                                              value='short'))),
         Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                   factor_values=(FactorValue(factor_name=self.agent,
                                              value='crack'),
                                  FactorValue(factor_name=self.intensity,
                                              value='low'),
                                  FactorValue(factor_name=self.duration,
                                              value='long')))
     ]
     new_sequence = TreatmentSequence(ranked_treatments=treatments)
     self.assertTrue((treatments[0], 1) in new_sequence.ranked_treatments)
     self.assertTrue((treatments[1], 1) in new_sequence.ranked_treatments)
Esempio n. 10
0
    def test_create_study_from_plan_with_qc(self):
        plan = SampleAssayPlan()
        plan.add_sample_type('liver')
        plan.add_sample_plan_record('liver', 5)
        plan.add_sample_type('blood')
        plan.add_sample_plan_record('blood', 3)
        plan.group_size = 2
        plan.add_sample_type('solvent')
        plan.add_sample_qc_plan_record('solvent', 8)

        treatment_factory = TreatmentFactory(
            factors=[self.f1, self.f2, self.f3])
        treatment_factory.add_factor_value(self.f1,
                                           {'cocaine', 'crack', 'aether'})
        treatment_factory.add_factor_value(self.f2, {'low', 'medium', 'high'})
        treatment_factory.add_factor_value(self.f3, {'short', 'long'})
        ffactorial_design_treatments = \
            treatment_factory.compute_full_factorial_design()
        treatment_sequence = TreatmentSequence(
            ranked_treatments={(x, i)
                               for i, x in enumerate(
                                   ffactorial_design_treatments)})
        # makes each study group ranked in sequence
        study = IsaModelObjectFactory(
            plan, treatment_sequence).create_study_from_plan()
        study.filename = 's_study.txt'
        # print(isatab.dumps(self.investigation))
        self.investigation.studies = [study]
        # 36 sources, 36 QC sources
        self.assertEqual(72, len(study.sources))
        self.assertEqual(
            36,
            len([
                x for x in study.sources
                if x.get_char('Material Type').value.term == 'solvent'
            ]))
        # 288 samples plus 36 QC samples
        self.assertEqual(324, len(study.samples))
Esempio n. 11
0
def create_from_plan_parameters(galaxy_parameters_file,
                                sample_assay_plans_file, study_info_file,
                                treatment_plans_file, target_dir):
    decoder = SampleAssayPlanDecoder()
    if galaxy_parameters_file:
        galaxy_parameters = json.load(galaxy_parameters_file)
        sample_and_assay_plans, study_info, treatment_plan_params = \
            map_galaxy_to_isa_create_json(galaxy_parameters)
        plan = decoder.load(io.StringIO(json.dumps(sample_and_assay_plans)))
    elif sample_assay_plans_file and study_info_file and treatment_plans_file:
        plan = decoder.load(sample_assay_plans_file)
        study_info = json.load(study_info_file)
        treatment_plan_params = json.load(treatment_plans_file)
    else:
        raise IOError('Wrong parameters provided')

    study_type = treatment_plan_params['study_type_cond']['study_type']
    if study_type != 'intervention':
        raise NotImplementedError('Only supports Intervention studies')

    single_or_multiple = treatment_plan_params['study_type_cond'][
        'one_or_more']['single_or_multiple']
    if single_or_multiple == 'multiple':
        raise NotImplementedError(
            'Multiple treatments not yet implemented. Please select Single')

    intervention_type = treatment_plan_params['study_type_cond'][
        'one_or_more']['intervention_type']['select_intervention_type']
    if intervention_type != 'chemical intervention':
        raise NotImplementedError(
            'Only Chemical Interventions supported at this time')

    treatment_factory = TreatmentFactory(
        intervention_type=INTERVENTIONS['CHEMICAL'], factors=BASE_FACTORS)
    agent_levels = treatment_plan_params['study_type_cond']['one_or_more'][
        'intervention_type']['agent'].split(',')
    for agent_level in agent_levels:
        treatment_factory.add_factor_value(BASE_FACTORS[0],
                                           agent_level.strip())
    dose_levels = treatment_plan_params['study_type_cond']['one_or_more'][
        'intervention_type']['intensity'].split(',')
    for dose_level in dose_levels:
        treatment_factory.add_factor_value(BASE_FACTORS[1], dose_level.strip())
    duration_of_exposure_levels = treatment_plan_params['study_type_cond'][
        'one_or_more']['intervention_type']['duration'].split(',')
    for duration_of_exposure_level in duration_of_exposure_levels:
        treatment_factory.add_factor_value(BASE_FACTORS[2],
                                           duration_of_exposure_level.strip())
    treatment_sequence = TreatmentSequence(
        ranked_treatments=treatment_factory.compute_full_factorial_design())
    isa_object_factory = IsaModelObjectFactory(plan, treatment_sequence)
    s = isa_object_factory.create_assays_from_plan()
    contact = Person()
    contact.affiliation = study_info['study_pi_affiliation']
    contact.last_name = study_info['study_pi_last_name']
    contact.email = study_info['study_pi_email']
    contact.first_name = study_info['study_pi_first_name']
    s.contacts = [contact]
    s.description = study_info['study_description']
    s.filename = 's_study.txt'
    s.title = 'ISA created {}'.format(datetime.datetime.now().isoformat())
    s.identifier = 'ISA-{}'.format(uuid.uuid4().hex[:8])

    i = Investigation()
    i.contacts = [contact]
    i.description = s.description
    i.title = s.title
    i.identifier = s.identifier

    i.studies = [s]
    isatab.dump(isa_obj=i,
                output_path=target_dir,
                i_file_name='i_investigation.txt')

    for assay in s.assays:
        for data_file in assay.data_files:
            data_file_path = os.path.join(target_dir, data_file.filename)
            with open(data_file_path, 'a'):
                os.utime(data_file_path, None)
Esempio n. 12
0
class TreatmentSequenceTest(unittest.TestCase):
    def setUp(self):
        self.maxDiff = None
        self.sequence = TreatmentSequence()
        self.agent = StudyFactor(name=BASE_FACTORS[0]['name'],
                                 factor_type=BASE_FACTORS[0]['type'])
        self.intensity = StudyFactor(name=BASE_FACTORS[1]['name'],
                                     factor_type=BASE_FACTORS[1]['type'])
        self.duration = StudyFactor(name=BASE_FACTORS[2]['name'],
                                    factor_type=BASE_FACTORS[2]['type'])
        self.test_treatment = Treatment(
            treatment_type=INTERVENTIONS['CHEMICAL'],
            factor_values=(FactorValue(factor_name=self.agent, value='crack'),
                           FactorValue(factor_name=self.intensity,
                                       value='low'),
                           FactorValue(factor_name=self.duration,
                                       value='short')))

    def test_init_with_single_treatment(self):
        treatment = Treatment(
            treatment_type=INTERVENTIONS['CHEMICAL'],
            factor_values=(FactorValue(factor_name=self.agent, value='crack'),
                           FactorValue(factor_name=self.intensity,
                                       value='low'),
                           FactorValue(factor_name=self.duration,
                                       value='short')))
        new_sequence = TreatmentSequence(ranked_treatments=treatment)
        self.assertTrue((treatment, 1) in new_sequence.ranked_treatments)

    def test_init_with_treatments_list_no_rank(self):
        treatments = [
            Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                      factor_values=(FactorValue(factor_name=self.agent,
                                                 value='crack'),
                                     FactorValue(factor_name=self.intensity,
                                                 value='low'),
                                     FactorValue(factor_name=self.duration,
                                                 value='short'))),
            Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                      factor_values=(FactorValue(factor_name=self.agent,
                                                 value='crack'),
                                     FactorValue(factor_name=self.intensity,
                                                 value='low'),
                                     FactorValue(factor_name=self.duration,
                                                 value='long')))
        ]
        new_sequence = TreatmentSequence(ranked_treatments=treatments)
        self.assertTrue((treatments[0], 1) in new_sequence.ranked_treatments)
        self.assertTrue((treatments[1], 1) in new_sequence.ranked_treatments)

    def test_init_with_treatments_list_with_rank(self):
        treatments = [
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='short'))), 1),
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='long'))), 2)
        ]
        new_sequence = TreatmentSequence(ranked_treatments=treatments)
        self.assertTrue(isinstance(new_sequence.ranked_treatments, set))
        self.assertTrue(treatments[0] in new_sequence.ranked_treatments)
        self.assertTrue(treatments[1] in new_sequence.ranked_treatments)

    def test_add_treatment_single(self):
        self.sequence.add_treatment(self.test_treatment)
        self.assertEqual(self.sequence.ranked_treatments,
                         {(self.test_treatment, 1)})

    def test_repr(self):
        treatments = [
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='short'))), 1),
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='long'))), 2)
        ]
        new_sequence = TreatmentSequence(ranked_treatments=treatments)
        self.assertEqual(
            'TreatmentSequence([(Treatment(factor_type=chemical '
            'intervention, factor_values=(FactorValue(factor_name='
            'StudyFactor(name="AGENT", factor_type='
            'OntologyAnnotation(term="perturbation agent", '
            'term_source=None, term_accession="", comments=[]), '
            'comments=[]), value=crack, unit=None), FactorValue('
            'factor_name=StudyFactor(name="INTENSITY", '
            'factor_type=OntologyAnnotation(term="intensity", '
            'term_source=None, term_accession="", comments=[]), '
            'comments=[]), value=low, unit=None), FactorValue('
            'factor_name=StudyFactor(name="DURATION", '
            'factor_type=OntologyAnnotation(term="time", '
            'term_source=None, term_accession="", comments=[]), '
            'comments=[]), value=short, unit=None))), 1), ('
            'Treatment(factor_type=chemical intervention, '
            'factor_values=(FactorValue(factor_name=StudyFactor('
            'name="AGENT", factor_type=OntologyAnnotation('
            'term="perturbation agent", term_source=None, '
            'term_accession="", comments=[]), comments=[]), '
            'value=crack, unit=None), FactorValue(factor_name='
            'StudyFactor(name="INTENSITY", factor_type='
            'OntologyAnnotation(term="intensity", '
            'term_source=None, term_accession="", comments=[]), '
            'comments=[]), value=low, unit=None), FactorValue('
            'factor_name=StudyFactor(name="DURATION", '
            'factor_type=OntologyAnnotation(term="time", '
            'term_source=None, term_accession="", comments=[]), '
            'comments=[]), value=long, unit=None))), 2)])', repr(new_sequence))

    def test_eq(self):
        treatments = [
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='short'))), 1),
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='long'))), 2)
        ]
        first_sequence = TreatmentSequence(treatments)
        second_sequence = TreatmentSequence(reversed(treatments))
        self.assertEqual(first_sequence, second_sequence)
        self.assertEqual(hash(first_sequence), hash(second_sequence))

    def test_neq(self):
        treatments = [
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='short'))), 1),
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='long'))), 2)
        ]
        other_treatments = [
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='spirit'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='short'))), 1),
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='spirit'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='long'))), 2)
        ]
        first_sequence = TreatmentSequence(treatments)
        second_sequence = TreatmentSequence(other_treatments)
        self.assertNotEqual(first_sequence, second_sequence)
        self.assertNotEqual(hash(first_sequence), hash(second_sequence))

    def test_ranked_treatments_setter(self):
        treatments = [
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='short'))), 2),
            (Treatment(treatment_type=INTERVENTIONS['CHEMICAL'],
                       factor_values=(FactorValue(factor_name=self.agent,
                                                  value='crack'),
                                      FactorValue(factor_name=self.intensity,
                                                  value='low'),
                                      FactorValue(factor_name=self.duration,
                                                  value='long'))), 1)
        ]
        self.sequence.ranked_treatments = treatments
        self.assertTrue(isinstance(self.sequence.ranked_treatments, set))
        self.assertTrue(treatments[0] in self.sequence.ranked_treatments)
        self.assertTrue(treatments[1] in self.sequence.ranked_treatments)

    def test_subject_count_setter(self):
        subject_count = 20
        self.sequence.subject_count = subject_count
        self.assertTrue(self.sequence.subject_count, subject_count)