Example #1
0
File: models.py Project: pgwthf/TSB
    def _run_once(self):
        '''
        Run a single backtest for which all parameters have already been set.
        '''
        self._reset()
        signals = Signals()
        for today in self.pool.index.price.close.get_dates(self.startdate, 
                self.enddate):
            print 'TODAY: ', today
            todays_trades = signals.trade(today, self.positions, self.equity)
            self.trades.extend(todays_trades)
            ordered_method_list = self.markettype.get_methods(date=today,
                    method_list=self.methods)
            # generate exit signals for tomorrow:
            signals.set_exits(today, self.positions, self.pool, 
                    ordered_method_list)
            # generate entry signals for tomorrow:
            for method in ordered_method_list:
                signals.set_entries(today, method, self.pool, self.positions)
            # set position size of entry signals:
            signals.set_volume(today, self.allocation, self.equity, 
                    self.equitymodel, self.positions)

#            for signal in signals.entries:
#                print signal.stock, signal.volume
#            raise SystemExit()

        self.trades.extend(self.positions.close_all(today))
        self.trades.calc_performance(self.startdate, self.enddate, 
                                                self.positions.max_positions)
        data = self.trades.data
        sysdata = {'metasystem': self, 'active': False, 
                'params': repr(self._get_variable_parameters()),
                'enddate': self.enddate}
        data.update(sysdata)
        data.update(self.equity.calc_results())

#debugging
#        system = System.objects.create(**data) #keep only this
#the following replaces the previous line for debugging
        try:
            system = System.objects.create(**data)
        except:
            print data
            raise ValueError('ERROR saving system')
#/debugging

        self.equity.write_thumbnail_to_db(system)
        if eval_conditions(self.conditions, data):
            self.trades.write_to_db(system)
            self.equity.save(system)
        self._del_variable_parameters()
Example #2
0
    def test_eval_conditions(self):
        self.assertTrue(mu.eval_conditions(None))
        self.assertRaises(TypeError, mu.eval_conditions, 'a')
        self.assertRaises(TypeError, mu.eval_conditions, (1,2,3,4))

        # simple conditions
        for conditions in ( (2, 'gt', 1), 
                            ('a', 'eq', 'a'),
                            ('a', 'lt', 'b'),
                            (2., 'gt', 1),
                            (1, 'eq', 1.),
                            (True, 'eq', True),
                            (True, 'or', False),
                            ):
            self.assertTrue(mu.eval_conditions(conditions), conditions)
        for conditions in ( (2, 'lt', 1), 
                            ('a', 'eq', 'b'),
                            (3, 'gt', 4.2),
                            (True, 'eq', False),
                            (True, 'and', False),
                            ):
            self.assertFalse(mu.eval_conditions(conditions), conditions)

        for conditions in ( 
                ('a', 'eq', 1),
                (True, 'eq', 3),
                (3, 'and', True),
                ):
            self.assertRaises(TypeError, mu.eval_conditions, conditions)

        for conditions in (
                (1, 'abc', 2),
                (1, 3, 2),
                ):
            self.assertRaises(ValueError, mu.eval_conditions, conditions)

        # simple conditions with data
        for conditions, data in ( (('x', 'lt', 2), {'x': 1}),
                                  (('y', 'eq', 1.3), {'y': 1.3}),
                                  (('y', 'and', True), {'y': True}),
                                 ):
            self.assertTrue(mu.eval_conditions(conditions, data), conditions)
        for conditions, data in ( (('x', 'lt', 1), {'x': 2}),
                                  (('x', 'eq', 1), {'x': 1.1}),
                                  ((True, 'and', 'abc'), {'abc': False}),
                                 ):
            self.assertFalse(mu.eval_conditions(conditions, data), conditions)
        for conditions, data in (
                (('x', 'gt', 1), {'y': 2}),
                ):
            self.assertRaises(TypeError, mu.eval_conditions, conditions, data)

        for conditions, data in (
                (('x', 'abc', 1), {'abc': 'and'}),
                ):
            self.assertRaises(ValueError, mu.eval_conditions, conditions, data)

        # complex conditions
        for conditions, data in (
                ((True, 'and', ('x', 'eq', 2)), {'x': 2}),
                (('x', 'eq', (1, 'ne', 'y')), {'x': True, 'y': 2}),
                                 ):
            self.assertTrue(mu.eval_conditions(conditions, data), conditions)
        for conditions, data in (
                ((('x', 'lt', 1), 'and', (2, 'lt', 'y')), {'x': 2, 'y': 1}),
                                 ):
            self.assertFalse(mu.eval_conditions(conditions, data), conditions)
        for conditions, data in (
                ((2, ('lt' , 'or', 'gt'), 1), {}),
                (('x', 'abc', 1), {'abc': 'and'}),
                                 ):
            self.assertRaises(ValueError, mu.eval_conditions, conditions, data)