Пример #1
0
    def testDeleteLinkedDataSets(self):
        ds = testdata.createSimpleDataSet()
        ds2 = transform(ds, 'select', { 'descriptorNames': [ 'a*', 'b*' ] })

        ds2.setReferenceDataSet(ds)

        del ds2
        del ds

        ds = testdata.createSimpleDataSet()
        ds2 = transform(ds, 'select', { 'descriptorNames': [ 'a*', 'b*' ] })

        ds2.setReferenceDataSet(ds)

        del ds
        del ds2
Пример #2
0
    def testDeleteLinkedDataSets(self):
        ds = testdata.createSimpleDataSet()
        ds2 = transform(ds, 'select', {'descriptorNames': ['a*', 'b*']})

        ds2.setReferenceDataSet(ds)

        del ds2
        del ds

        ds = testdata.createSimpleDataSet()
        ds2 = transform(ds, 'select', {'descriptorNames': ['a*', 'b*']})

        ds2.setReferenceDataSet(ds)

        del ds
        del ds2
Пример #3
0
    def testHistory(self):
        # add a point in a transformed dataset
        d = testdata.createSimpleDataSet()
        ds = transform(d, 'select', { 'descriptorNames': [ 'a*', 'b*' ] })

        p = Point()
        p.setName('ptest')
        p.setLayout(testdata.createSimpleLayout())

        ds.addPoint(p)
Пример #4
0
    def testHistory(self):
        # add a point in a transformed dataset
        d = testdata.createSimpleDataSet()
        ds = transform(d, 'select', {'descriptorNames': ['a*', 'b*']})

        p = Point()
        p.setName('ptest')
        p.setLayout(testdata.createSimpleLayout())

        ds.addPoint(p)
Пример #5
0
    def testParserStillInValidStateAfterParserError(self):
        '''ticket #20: parser is in invalid state after parser error'''
        ds = testdata.createSimpleDataSet()
        dist = MetricFactory.create('null', ds.layout())
        v = View(ds)

        result = v.nnSearch(ds.samplePoint(), dist, 'WHERE true').get(1)
        clause = 'WHERE label.tonal_key_mode.value = \\"major"'
        try: result = v.nnSearch(ds.samplePoint(), dist, clause).get(1)
        except: pass # filter correctly failed to compile
        result = v.nnSearch(ds.samplePoint(), dist, 'WHERE true').get(1)
Пример #6
0
    def testParserStillInValidStateAfterParserError(self):
        '''ticket #20: parser is in invalid state after parser error'''
        ds = testdata.createSimpleDataSet()
        dist = MetricFactory.create('null', ds.layout())
        v = View(ds)

        result = v.nnSearch(ds.samplePoint(), dist, 'WHERE true').get(1)
        clause = 'WHERE label.tonal_key_mode.value = \\"major"'
        try:
            result = v.nnSearch(ds.samplePoint(), dist, clause).get(1)
        except:
            pass  # filter correctly failed to compile
        result = v.nnSearch(ds.samplePoint(), dist, 'WHERE true').get(1)
Пример #7
0
    def testLinkedViews(self):
        ds = testdata.createSimpleDataSet()
        ds.point('p')['a.1'] = 23.0

        for i in range(5):
            p = Point()
            p.setName('p%d' % i)
            p.setLayout(ds.originalLayout())
            p['a.1'] = float(i)
            ds.addPoint(p)

        ds = transform(ds, 'fixlength')
        dist = MetricFactory.create('euclidean', ds.layout())
        v = View(ds)

        query = Point(ds.point('p'))
        query['a.1'] = 23.0

        self.assertEqual((('p', 0.), ('p4', 19.), ('p3', 20.), ('p2', 21.)),
                         v.nnSearch(query, dist).get(4))

        ds.removePoint('p')
        self.assertEqual((('p4', 19.), ('p3', 20.), ('p2', 21.), ('p1', 22.)),
                         v.nnSearch(query, dist).get(4))

        ds.removePoint('p3')
        self.assertEqual((('p4', 19.), ('p2', 21.), ('p1', 22.), ('p0', 23.)),
                         v.nnSearch(query, dist).get(4))

        # get original query point to add in dataset
        testdata.resetSettings()
        dsq = testdata.createSimpleDataSet()
        orig_query = Point(dsq.point('p'))
        orig_query['a.1'] = 23.0

        ds.addPoint(orig_query)
        self.assertEqual((('p', 0.), ('p4', 19.), ('p2', 21.), ('p1', 22.)),
                         v.nnSearch(query, dist).get(4))
Пример #8
0
    def testLinkedViews(self):
        ds = testdata.createSimpleDataSet()
        ds.point('p')['a.1'] = 23.0

        for i in range(5):
            p = Point()
            p.setName('p%d' % i)
            p.setLayout(ds.originalLayout())
            p['a.1'] = float(i)
            ds.addPoint(p)

        ds = transform(ds, 'fixlength')
        dist = MetricFactory.create('euclidean', ds.layout())
        v = View(ds)

        query = Point(ds.point('p'))
        query['a.1'] = 23.0

        self.assertEqual((('p', 0.), ('p4', 19.), ('p3', 20.), ('p2', 21.)),
                         v.nnSearch(query, dist).get(4))

        ds.removePoint('p')
        self.assertEqual((('p4', 19.), ('p3', 20.), ('p2', 21.), ('p1', 22.)),
                         v.nnSearch(query, dist).get(4))

        ds.removePoint('p3')
        self.assertEqual((('p4', 19.), ('p2', 21.), ('p1', 22.), ('p0', 23.)),
                         v.nnSearch(query, dist).get(4))

        # get original query point to add in dataset
        testdata.resetSettings()
        dsq = testdata.createSimpleDataSet()
        orig_query = Point(dsq.point('p'))
        orig_query['a.1'] = 23.0

        ds.addPoint(orig_query)
        self.assertEqual((('p', 0.), ('p4', 19.), ('p2', 21.), ('p1', 22.)),
                         v.nnSearch(query, dist).get(4))
Пример #9
0
    def testWeightedPearson(self):
        ds = testdata.createSimpleDataSet()
        ds.point('p')['a.1'] = [ 0, 0 ] # need to have 2 values before fixing length
        p1 = transform(ds, 'fixlength').point('p')
        p2 = Point(p1)

        dist = MetricFactory.create('WeightedPearson', p1.layout(), { 'weights': { '1': 0.3,
                                                                                   'c': 0.7 }
                                                                      })
        p1['a.1'] = [ 0.12, 2.71 ]
        p1['c'] = 4.32
        p2['1'] = [ 0.46, 1.12 ]
        p2['c'] = 2.4242

        self.assertAlmostEqual(dist(p1, p2), 0.038222129799, 6)
Пример #10
0
    def testWeightedPearson(self):
        ds = testdata.createSimpleDataSet()
        ds.point('p')['a.1'] = [ 0, 0 ] # need to have 2 values before fixing length
        p1 = transform(ds, 'fixlength').point('p')
        p2 = Point(p1)

        dist = MetricFactory.create('WeightedPearson', p1.layout(), { 'weights': { '1': 0.3,
                                                                                   'c': 0.7 }
                                                                      })
        p1['a.1'] = [ 0.12, 2.71 ]
        p1['c'] = 4.32
        p2['1'] = [ 0.46, 1.12 ]
        p2['c'] = 2.4242

        self.assertAlmostEqual(dist(p1, p2), 0.038222129799, 6)
Пример #11
0
    def testLinkedDataSets(self):
        d = testdata.createSimpleDataSet()
        d2 = transform(d, 'select', { 'descriptorNames': [ 'a*', 'b*' ] })

        d2.setReferenceDataSet(d)

        p = Point()
        p.setName('ptest')
        p.setLayout(d.originalLayout())
        p['a.1'] = 23

        d.addPoint(p)

        self.assertEqual(d2.point('ptest').value('a.1'), 23)
        self.assertRaises(Exception, d2.point('ptest').value, 'c')

        d2.removePoint('ptest')
        self.assertRaises(Exception, d.point, 'ptest')
Пример #12
0
    def testLinkedDataSets(self):
        d = testdata.createSimpleDataSet()
        d2 = transform(d, 'select', {'descriptorNames': ['a*', 'b*']})

        d2.setReferenceDataSet(d)

        p = Point()
        p.setName('ptest')
        p.setLayout(d.originalLayout())
        p['a.1'] = 23

        d.addPoint(p)

        self.assertEqual(d2.point('ptest').value('a.1'), 23)
        self.assertRaises(Exception, d2.point('ptest').value, 'c')

        d2.removePoint('ptest')
        self.assertRaises(Exception, d.point, 'ptest')
Пример #13
0
    def testRhythmDistance(self):
        p1 = testdata.createSimpleDataSet().point('p')
        p2 = Point(p1)

        dist = MetricFactory.create('Rhythm', p1.layout(), { 'descriptorName': 'a.1',
                                                             'indexRange': [ 1, 2, 4, 8 ],
                                                             'alpha': 0.8 })

        p1['a.1'] = 3
        p2['a.1'] = 2
        self.assertAlmostEqual(dist(p1, p1), 0.0)
        self.assertAlmostEqual(dist(p1, p2), 0.4)
        self.assertAlmostEqual(dist(p2, p1), 0.4)

        p1['a.1'] = 3.14
        self.assertAlmostEqual(dist(p1, p2), 0.344)

        p1['a.1'] = 6.23
        self.assertAlmostEqual(dist(p1, p2), 0.45312)
Пример #14
0
    def testRhythmDistance(self):
        p1 = testdata.createSimpleDataSet().point('p')
        p2 = Point(p1)

        dist = MetricFactory.create('Rhythm', p1.layout(), { 'descriptorName': 'a.1',
                                                             'indexRange': [ 1, 2, 4, 8 ],
                                                             'alpha': 0.8 })

        p1['a.1'] = 3
        p2['a.1'] = 2
        self.assertAlmostEqual(dist(p1, p1), 0.0)
        self.assertAlmostEqual(dist(p1, p2), 0.4)
        self.assertAlmostEqual(dist(p2, p1), 0.4)

        p1['a.1'] = 3.14
        self.assertAlmostEqual(dist(p1, p2), 0.344)

        p1['a.1'] = 6.23
        self.assertAlmostEqual(dist(p1, p2), 0.45312)
Пример #15
0
    def testSimple(self):
        ds = testdata.createSimpleDataSet()
        p2 = Point(ds.point('p')); p2.setName('p2')
        p3 = Point(ds.point('p')); p3.setName('p3')
        p3['a.1'] = 1
        p4 = Point(ds.point('p')); p4.setName('p4')
        p4['a.1'] = 1
        p4['a.2'] = 1
        ds.addPoint(p2)
        ds.addPoint(p3)
        ds.addPoint(p4)

        ds = transform(ds, 'fixlength')
        dist = MetricFactory.create('euclidean', ds.layout())
        v = View(ds)

        results = v.nnSearch('p', dist).get(10)
        self.assertEqual(results[0][1], 0.0)
        self.assertEqual(results[1][1], 0.0)
        self.assertSearchResultEqual(results[2], ('p3', 1.0))
        self.assertSearchResultEqual(results[3], ('p4', math.sqrt(2)))
Пример #16
0
    def testCreatedInputSpace(self):
        ds = testdata.createSimpleDataSet()
        ds.point('p')['a.1'] = 23.0

        for i in range(5):
            p = Point()
            p.setName('p%d' % i)
            p.setLayout(ds.originalLayout())
            p['a.1'] = float(i)
            ds.addPoint(p)

        ds = transform(ds, 'fixlength')
        dist = MetricFactory.create('euclidean', ds.layout())
        v = View(ds)

        p = ds.point('p')

        RS_remove = v.nnSearch(p, dist)
        RS_remove.removePoints(['p2', 'p4'])

        RS_create = InputSpace()
        RS_create.addPoints(ds, ['p', 'p0', 'p1', 'p3'])

        rsc = v.nnSearch(p, RS_remove, dist)
        rsa = v.nnSearch(p, RS_create, dist)

        self.assertEqual((('p', 0.), ('p3', 20.), ('p1', 22.), ('p0', 23.)),
                         v.nnSearch(p, rsc, dist).get(10))

        self.assertEqual((('p', 0.), ('p3', 20.), ('p1', 22.), ('p0', 23.)),
                         v.nnSearch(p, rsa, dist).get(10))

        # test thresholdLimit method
        self.assertEqual((('p', 0.), ),
                         v.nnSearch(p, rsa, dist).thresholdLimit(10).get(10))
        self.assertEqual((('p', 0.), ('p3', 20.)),
                         v.nnSearch(p, rsa, dist).thresholdLimit(20).get(10))
        self.assertEqual((('p', 0.), ('p3', 20.), ('p1', 22.)),
                         v.nnSearch(p, rsa,
                                    dist).thresholdLimit(22.01).get(10))
Пример #17
0
    def testCreatedInputSpace(self):
        ds = testdata.createSimpleDataSet()
        ds.point('p')['a.1'] = 23.0

        for i in range(5):
            p = Point()
            p.setName('p%d' % i)
            p.setLayout(ds.originalLayout())
            p['a.1'] = float(i)
            ds.addPoint(p)

        ds = transform(ds, 'fixlength')
        dist = MetricFactory.create('euclidean', ds.layout())
        v = View(ds)

        p = ds.point('p')

        RS_remove = v.nnSearch(p, dist)
        RS_remove.removePoints([ 'p2', 'p4' ])

        RS_create = InputSpace()
        RS_create.addPoints(ds, [ 'p', 'p0', 'p1', 'p3' ])

        rsc = v.nnSearch(p, RS_remove, dist)
        rsa = v.nnSearch(p, RS_create, dist)

        self.assertEqual((('p', 0.), ('p3', 20.), ('p1', 22.), ('p0', 23.)),
                         v.nnSearch(p, rsc, dist).get(10))

        self.assertEqual((('p', 0.), ('p3', 20.), ('p1', 22.), ('p0', 23.)),
                         v.nnSearch(p, rsa, dist).get(10))

        # test thresholdLimit method
        self.assertEqual((('p', 0.),),
                         v.nnSearch(p, rsa, dist).thresholdLimit(10).get(10))
        self.assertEqual((('p', 0.), ('p3', 20.)),
                         v.nnSearch(p, rsa, dist).thresholdLimit(20).get(10))
        self.assertEqual((('p', 0.), ('p3', 20.), ('p1', 22.)),
                         v.nnSearch(p, rsa, dist).thresholdLimit(22.01).get(10))
Пример #18
0
    def testVariables(self):
        d = testdata.createSimpleDataSet()

        def test(clause, expected):
            self.assertEqual(testValidPoint(d, clause), expected)

        d.point('p')['d'] = 'Hello'
        test('label.d = "Hello"', True)
        test('label.d = "goodbye"', False)

        d.point('p')['b'] = 23.
        test('value.b < 23', False)
        test('value.b <= 23', True)
        test('value.b != 23', False)
        test('value.b > 23', False)
        test('value.b == 23', True)
        test('value.b = 23', True)
        test('value.b <= 23', True)
        
        d.point('p')['e'] = [23.0, 24.0, 25.0]
        test('value.e[0] < 23', False)
        test('value.e[1] > 23', True)
        test('value.e[2] > 24.3 and value.e[2] <= 25', True)

        test('value.b = 23.0 and label.d = "Hello"', True)
        test('value.b = 23.0 or label.d = "Ho ho"', True)
        test('value.b < 23.0 and label.d = "Hello"', False)
        test('value.b = 23.0 and label.d = "Hell"', False)
       
        d.point('p')['a.1'] = 17
        test('value.a.1 == 17', True)
        test('value.a.1 < 20 and value.b > 20 and label.d != "ooh yeah"', True)

        test('point.id IN ("c", "a", "t")', False)
        test('point.id NOT IN ("a", "p", "u")', False)
        test('point.id NOT IN ("s", "u", "n")', True)
        test('point.id == "p"', True)
        test('point.id != "rock\'n\'roll"', True)
Пример #19
0
    def testVariables(self):
        d = testdata.createSimpleDataSet()

        def test(clause, expected):
            self.assertEqual(testValidPoint(d, clause), expected)

        d.point('p')['d'] = 'Hello'
        test('label.d = "Hello"', True)
        test('label.d = "goodbye"', False)

        d.point('p')['b'] = 23.
        test('value.b < 23', False)
        test('value.b <= 23', True)
        test('value.b != 23', False)
        test('value.b > 23', False)
        test('value.b == 23', True)
        test('value.b = 23', True)
        test('value.b <= 23', True)

        d.point('p')['e'] = [23.0, 24.0, 25.0]
        test('value.e[0] < 23', False)
        test('value.e[1] > 23', True)
        test('value.e[2] > 24.3 and value.e[2] <= 25', True)

        test('value.b = 23.0 and label.d = "Hello"', True)
        test('value.b = 23.0 or label.d = "Ho ho"', True)
        test('value.b < 23.0 and label.d = "Hello"', False)
        test('value.b = 23.0 and label.d = "Hell"', False)

        d.point('p')['a.1'] = 17
        test('value.a.1 == 17', True)
        test('value.a.1 < 20 and value.b > 20 and label.d != "ooh yeah"', True)

        test('point.id IN ("c", "a", "t")', False)
        test('point.id NOT IN ("a", "p", "u")', False)
        test('point.id NOT IN ("s", "u", "n")', True)
        test('point.id == "p"', True)
        test('point.id != "rock\'n\'roll"', True)
Пример #20
0
    def testCenter(self):
        ds = testdata.createSimpleDataSet()
        l = testdata.createSimpleLayout()
        for i in range(4):
            p = Point()
            p.setName("p%d" % i)
            p.setLayout(l)
            ds.addPoint(p)
        ds.removePoint("p")

        ds.point("p0")["a.1"] = [0, 1]
        ds.point("p1")["a.1"] = [4, 3]
        ds.point("p2")["a.1"] = [6, 9]
        ds.point("p3")["a.1"] = [2, 27]
        # mean = [ 3, 10 ]

        ds = transform(ds, "fixlength")
        dsc = transform(ds, "center", {"descriptorNames": "a.1"})

        self.assertEqual(dsc.point("p0")["a.1"], (-3, -9))
        self.assertEqual(dsc.point("p1")["a.1"], (1, -7))
        self.assertEqual(dsc.point("p2")["a.1"], (3, -1))
        self.assertEqual(dsc.point("p3")["a.1"], (-1, 17))
Пример #21
0
    def testCenter(self):
        ds = testdata.createSimpleDataSet()
        l = testdata.createSimpleLayout()
        for i in range(4):
            p = Point()
            p.setName('p%d' % i)
            p.setLayout(l)
            ds.addPoint(p)
        ds.removePoint('p')

        ds.point('p0')['a.1'] = [ 0, 1 ]
        ds.point('p1')['a.1'] = [ 4, 3 ]
        ds.point('p2')['a.1'] = [ 6, 9 ]
        ds.point('p3')['a.1'] = [ 2, 27 ]
        # mean = [ 3, 10 ]

        ds = transform(ds, 'fixlength')
        dsc = transform(ds, 'center', { 'descriptorNames': 'a.1' })

        self.assertEqual(dsc.point('p0')['a.1'], (-3, -9))
        self.assertEqual(dsc.point('p1')['a.1'], ( 1, -7))
        self.assertEqual(dsc.point('p2')['a.1'], ( 3, -1))
        self.assertEqual(dsc.point('p3')['a.1'], (-1, 17))
Пример #22
0
def testClause(clause):
    ds = testdata.createSimpleDataSet()
    return testValidPoint(ds, clause)
Пример #23
0
    def testSimplifyHistory(self):
        ds = testdata.createSimpleDataSet()
        p = Point()
        p.setName('p2')
        p.setLayout(ds.layout())
        p['a.2'] = [ 1.2, 2.3 ]
        ds.addPoint(p)
        ds0 = ds.copy()

        ds1 = ds.copy()
        ds1.simplifyHistory()
        self.assertEqual(ds1.history().size(), 0)

        ds = transform(ds, 'removevl')
        ds2 = ds.copy()
        ds2.simplifyHistory()

        self.assertEqual(ds2.history().toPython(),
                         [{ 'Analyzer name': 'remove',
                            'Analyzer parameters': { 'descriptorNames': [ '.a.2' ] },
                            'Applier name': 'removedesc',
                            'Applier parameters': {'descriptorNames': [ '.a.2' ] },
                            'Additional info': {}
                            }])

        ds = transform(ds, 'fixlength')
        ds3 = ds.copy()
        ds3.simplifyHistory()

        self.assertEqual(ds3.history().toPython(),
                         [{ 'Analyzer name': 'remove',
                            'Analyzer parameters': { 'descriptorNames': [ '.a.2' ] },
                            'Applier name': 'removedesc',
                            'Applier parameters': {'descriptorNames': [ '.a.2' ] },
                            'Additional info': {}
                            },
                          { 'Analyzer name': 'fixlength',
                            'Analyzer parameters': { 'descriptorNames': [ '.a.1', '.b', '.c', '.d' ] },
                            'Applier name': 'fixlengthapplier',
                            'Applier parameters': {'descriptorNames': [ '.a.1', '.b', '.c', '.d' ] },
                            'Additional info': {}
                            }])

        ds = transform(ds, 'remove', { 'descriptorNames': 'a.*' })
        ds4 = ds.copy()
        ds4.simplifyHistory()

        self.assertEqual(ds4.history().toPython(),
                         [{ 'Analyzer name': 'remove',
                            'Analyzer parameters': { 'descriptorNames': [ '.a.1', '.a.2' ] },
                            'Applier name': 'removedesc',
                            'Applier parameters': {'descriptorNames': [ '.a.1', '.a.2' ] },
                            'Additional info': {}
                            },
                          { 'Analyzer name': 'fixlength',
                            'Analyzer parameters': { 'descriptorNames': [ '.b', '.c', '.d' ] },
                            'Applier name': 'fixlengthapplier',
                            'Applier parameters': {'descriptorNames': [ '.b', '.c', '.d' ] },
                            'Additional info': {}
                            }])

        ds = transform(ds, 'select', { 'descriptorNames': [ 'b', 'c' ] })
        ds5 = ds.copy()
        ds5.simplifyHistory()

        self.assertEqual(ds5.history().toPython(),
                         [{ 'Analyzer name': 'remove',
                            'Analyzer parameters': { 'descriptorNames': [ '.a.1', '.a.2', '.d' ] },
                            'Applier name': 'removedesc',
                            'Applier parameters': {'descriptorNames': [ '.a.1', '.a.2', '.d' ] },
                            'Additional info': {}
                            },
                          { 'Analyzer name': 'fixlength',
                            'Analyzer parameters': { 'descriptorNames': [ '.b', '.c' ] },
                            'Applier name': 'fixlengthapplier',
                            'Applier parameters': {'descriptorNames': [ '.b', '.c' ] },
                            'Additional info': {}
                            }])


        p2 = Point()
        p2.setLayout(ds0.layout())
        p2['b'] = 23
        p2['c'] = 78
        p2['a.2'] = [ 1, 2, 3, 4 ]

        p2m = ds5.history().mapPoint(p2)

        self.assertEqual(p2m.layout().descriptorNames(), ('.b', '.c'))
        self.assertEqual(p2m['b'], 23.)
        self.assertEqual(p2m['c'], 78.)
Пример #24
0
    def testSimplifyHistory(self):
        ds = testdata.createSimpleDataSet()
        p = Point()
        p.setName('p2')
        p.setLayout(ds.layout())
        p['a.2'] = [1.2, 2.3]
        ds.addPoint(p)
        ds0 = ds.copy()

        ds1 = ds.copy()
        ds1.simplifyHistory()
        self.assertEqual(ds1.history().size(), 0)

        ds = transform(ds, 'removevl')
        ds2 = ds.copy()
        ds2.simplifyHistory()

        self.assertEqual(ds2.history().toPython(), [{
            'Analyzer name': 'remove',
            'Analyzer parameters': {
                'descriptorNames': ['.a.2']
            },
            'Applier name': 'removedesc',
            'Applier parameters': {
                'descriptorNames': ['.a.2']
            },
            'Additional info': {}
        }])

        ds = transform(ds, 'fixlength')
        ds3 = ds.copy()
        ds3.simplifyHistory()

        self.assertEqual(ds3.history().toPython(), [{
            'Analyzer name': 'remove',
            'Analyzer parameters': {
                'descriptorNames': ['.a.2']
            },
            'Applier name': 'removedesc',
            'Applier parameters': {
                'descriptorNames': ['.a.2']
            },
            'Additional info': {}
        }, {
            'Analyzer name': 'fixlength',
            'Analyzer parameters': {
                'descriptorNames': ['.a.1', '.b', '.c', '.d']
            },
            'Applier name': 'fixlengthapplier',
            'Applier parameters': {
                'descriptorNames': ['.a.1', '.b', '.c', '.d']
            },
            'Additional info': {}
        }])

        ds = transform(ds, 'remove', {'descriptorNames': 'a.*'})
        ds4 = ds.copy()
        ds4.simplifyHistory()

        self.assertEqual(ds4.history().toPython(), [{
            'Analyzer name': 'remove',
            'Analyzer parameters': {
                'descriptorNames': ['.a.1', '.a.2']
            },
            'Applier name': 'removedesc',
            'Applier parameters': {
                'descriptorNames': ['.a.1', '.a.2']
            },
            'Additional info': {}
        }, {
            'Analyzer name': 'fixlength',
            'Analyzer parameters': {
                'descriptorNames': ['.b', '.c', '.d']
            },
            'Applier name': 'fixlengthapplier',
            'Applier parameters': {
                'descriptorNames': ['.b', '.c', '.d']
            },
            'Additional info': {}
        }])

        ds = transform(ds, 'select', {'descriptorNames': ['b', 'c']})
        ds5 = ds.copy()
        ds5.simplifyHistory()

        self.assertEqual(ds5.history().toPython(), [{
            'Analyzer name': 'remove',
            'Analyzer parameters': {
                'descriptorNames': ['.a.1', '.a.2', '.d']
            },
            'Applier name': 'removedesc',
            'Applier parameters': {
                'descriptorNames': ['.a.1', '.a.2', '.d']
            },
            'Additional info': {}
        }, {
            'Analyzer name': 'fixlength',
            'Analyzer parameters': {
                'descriptorNames': ['.b', '.c']
            },
            'Applier name': 'fixlengthapplier',
            'Applier parameters': {
                'descriptorNames': ['.b', '.c']
            },
            'Additional info': {}
        }])

        p2 = Point()
        p2.setLayout(ds0.layout())
        p2['b'] = 23
        p2['c'] = 78
        p2['a.2'] = [1, 2, 3, 4]

        p2m = ds5.history().mapPoint(p2)

        self.assertEqual(p2m.layout().descriptorNames(), ('.b', '.c'))
        self.assertEqual(p2m['b'], 23.)
        self.assertEqual(p2m['c'], 78.)
Пример #25
0
def testClause(clause):
    ds = testdata.createSimpleDataSet()
    return testValidPoint(ds, clause)