Ejemplo n.º 1
0
    def test_iris(self):
        f = open('tests/iris.txt')
        csv_reader = SmartCSVReader(f, header=True, separator='\t')
        relation = Relation()
        relation.read(csv_reader)
        f.close()
        self.assertEqual(len(relation), 150)
        self.assertEqual(len(relation.attributes), 9)
        self.assertEqual(len(relation.header), 9)
        self.assertEqual(len(relation.header.attributes), 9)

        self.assertTrue(relation.attributes[0].numeric)
        self.assertEqual(relation.attributes[4].name, 'Species')
        for attribute in relation.attributes:
            if attribute.name == 'Species':
                self.assertFalse(attribute.numeric)
                self.assertTrue(attribute.discrete)
                self.assertSetEqual(attribute.values,
                                    set(["setosa", "versicolor", "virginica"]))
            else:
                self.assertTrue(attribute.numeric)
                self.assertFalse(attribute.discrete)

        self.assertTrue(relation.attributes[8].numeric)

        self.assertEqual(relation.header, Header(relation.attributes))
        self.assertEqual(relation.header[:], relation.header)

        self.assertEqual(relation.header[4], relation.attributes[4])
        self.assertEqual(relation.header.attributes[4], relation.attributes[4])

        self.assertRaises(ValidationError, lambda: relation.header.validate(()))

        try:
            relation.header.validate(relation[0])
            relation.header.validate(relation[1])
            relation.header.validate(relation[2])
        except ValidationError:
            self.assertFalse(True, msg='record validation failed')

        for i, (cond_rec, dec_rec) in enumerate(
                                relation.iter_conditional_decisional_records()):
            self.assertEqual(cond_rec, relation[i])
            self.assertEqual(dec_rec, ())

        #
        #setting decision index
        #
        relation.set_decision_index(4)

        self.assertEqual(relation.get_decision_index(), 4)

        relation.set_decision_index(-5)

        self.assertEqual(relation.get_decision_index(), 4)

        #equality shoud fail because second param has decision_index=None
        self.assertNotEqual(relation.header, Header(relation.attributes))

        self.assertEqual(relation.header, Header(attributes=relation.attributes,
                                                decision_index=4))

        cond_relation = relation.conditional_part
        dec_relation = relation.decisional_part

        self.assertEqual(len(cond_relation), 150)
        self.assertEqual(len(cond_relation.attributes), 8)
        self.assertEqual(len(dec_relation), 150)
        self.assertEqual(len(dec_relation.attributes), 1)

        for attribute in cond_relation.attributes:
            self.assertTrue(attribute.numeric)
            self.assertFalse(attribute.discrete)

        for attribute in dec_relation.attributes:
            self.assertFalse(attribute.numeric)
            self.assertTrue(attribute.discrete)
            self.assertSetEqual(attribute.values,
                                set(["setosa", "versicolor", "virginica"]))

        self.assertNotEqual(cond_relation.header, 1)
        self.assertNotEqual(cond_relation.header, relation._header)

        for i, (cond_rec, dec_rec) in enumerate(
                                relation.iter_conditional_decisional_records()):
            self.assertEqual(cond_rec, cond_relation[i])
            self.assertEqual(dec_rec, dec_relation[i])

        relation.set_decision_index(None)

        self.assertEqual(relation.get_decision_index(), None)

        cond_relation2 = relation.conditional_part
        dec_relation2 = relation.decisional_part

        self.assertEqual(len(cond_relation2), 150)
        self.assertEqual(len(cond_relation2.attributes), 9)
        self.assertEqual(len(dec_relation2), 150)
        self.assertEqual(len(dec_relation2.attributes), 0)

        self.assertEqual(cond_relation2.attributes[4].name, 'Species')
        for attribute in cond_relation2.attributes:
            if attribute.name == 'Species':
                self.assertFalse(attribute.numeric)
                self.assertTrue(attribute.discrete)
                self.assertSetEqual(attribute.values,
                                    set(["setosa", "versicolor", "virginica"]))
            else:
                self.assertTrue(attribute.numeric)
                self.assertFalse(attribute.discrete)

        self.assertEqual(cond_relation2.header, relation._header)