Beispiel #1
0
    def testSecurityValueHolderWithGetItemUseInt(self):

        shift = 2

        benchmark = SecurityShiftedValueHolder(
            SecurityLatestValueHolder(dependency='close'), shift)
        testValueHolder = SecurityLatestValueHolder(dependency='close')[shift]

        for i in range(len(self.datas['aapl']['close'])):
            data = {
                'aapl': {
                    Factors.CLOSE: self.datas['aapl'][Factors.CLOSE][i],
                    Factors.OPEN: self.datas['aapl'][Factors.OPEN][i]
                },
                'ibm': {
                    Factors.CLOSE: self.datas['ibm'][Factors.CLOSE][i],
                    Factors.OPEN: self.datas['ibm'][Factors.OPEN][i]
                }
            }
            benchmark.push(data)
            testValueHolder.push(data)

            if i < shift:
                continue

            calculated = testValueHolder.value
            expected = benchmark.value

            self.assertEqual(calculated.name_mapping, expected.name_mapping)
            np.testing.assert_array_almost_equal(calculated.values,
                                                 expected.values)
    def testShiftedSecurityValueHolderPickle(self):
        tested = SecurityShiftedValueHolder(SecurityLatestValueHolder('close'), 2)

        data = dict(aapl=dict(close=1.0),
                    ibm=dict(close=2.0))
        tested.push(data)

        data = dict(aapl=dict(close=3.0),
                    ibm=dict(close=4.0))
        tested.push(data)

        data = dict(aapl=dict(close=5.0),
                    ibm=dict(close=6.0))
        tested.push(data)

        with tempfile.NamedTemporaryFile('w+b', delete=False) as f:
            pickle.dump(tested, f)

        with open(f.name, 'rb') as f2:
            pickled = pickle.load(f2)

        expected = tested.value
        calcualted = pickled.value
        for name in expected.index():
            self.assertAlmostEqual(expected[name], calcualted[name])
Beispiel #3
0
    def testShiftedSecurityValueHolderDeepcopy(self):
        tested = SecurityShiftedValueHolder(SecurityLatestValueHolder('close'),
                                            2)

        data = dict(aapl=dict(close=1.0), ibm=dict(close=2.0))
        tested.push(data)

        data = dict(aapl=dict(close=3.0), ibm=dict(close=4.0))
        tested.push(data)

        data = dict(aapl=dict(close=5.0), ibm=dict(close=6.0))
        tested.push(data)

        copied = copy.deepcopy(tested)

        expected = tested.value
        calcualted = copied.value
        for name in expected.index():
            self.assertAlmostEqual(expected[name], calcualted[name])
Beispiel #4
0
def SHIFT(x, n):
    return SecurityShiftedValueHolder(x, n)
Beispiel #5
0
def SHIFT(dependency, n):
    return SecurityShiftedValueHolder(dependency, n)