コード例 #1
0
def output_feeds(instrument: str, st: datetime, et: datetime, short_win: int,
                 long_win: int, ema_period: int,
                 save_dir: str) -> pd.DataFrame:
    """
    Output ohlc price feeds to csv for strategy back testing
    :param instrument: ccy_pair
    :param st: start date
    :param et: end date
    :param short_win:
    :param long_win:
    :param ema_period:
    :param save_dir:
    :return:
    """
    pd_h1 = read_price_df(instrument=instrument,
                          granularity='H1',
                          start=st,
                          end=et)
    pd_h1[f'last_{long_win}_high'] = pd_h1['high'].rolling(window=long_win *
                                                           24).max()
    pd_h1[f'last_{short_win}_high'] = pd_h1['high'].rolling(window=short_win *
                                                            24).max()
    pd_h1[f'last_{long_win}_low'] = pd_h1['low'].rolling(window=long_win *
                                                         24).min()
    pd_h1[f'last_{short_win}_low'] = pd_h1['low'].rolling(window=short_win *
                                                          24).min()

    pd_h1.to_csv(f'{save_dir}/{instrument.lower()}_h1.csv')

    pd_d = read_price_df(instrument=instrument,
                         granularity='D',
                         start=st,
                         end=et)
    pd_d[f'last_{long_win}_high'] = pd_d['high'].rolling(window=long_win).max()
    pd_d[f'last_{short_win}_high'] = pd_d['high'].rolling(
        window=short_win).max()
    pd_d[f'last_{long_win}_low'] = pd_d['low'].rolling(window=long_win).min()
    pd_d[f'last_{short_win}_low'] = pd_d['low'].rolling(window=short_win).min()
    pd_d['atr'] = TA.ATR(pd_d, period=14)
    pd_d['adx'] = TA.ADX(pd_d, period=14)
    pd_d['rsi'] = TA.RSI(pd_d, period=14)
    pd_d[f'ema_{ema_period}'] = TA.EMA(pd_d, period=ema_period)

    pd_d.to_csv(f'{save_dir}/{instrument.lower()}_d.csv')

    pd_h1.reset_index(level=0, inplace=True)
    pd_merged = pd_h1.apply(partial(enrich, pd_d, ema_period),
                            axis=1).set_index('time')

    logger.info(pd_merged.info())
    pd_merged.to_csv(f"{save_dir}/{instrument.lower()}_h1_enrich.csv")
    logger.info(f'output feeds complete for [{instrument}]!')
    return pd_merged
コード例 #2
0
    def check_for_signals(self, instrument: str) -> pd.DataFrame:
        param = {"count": 240, "granularity": "H1"}
        resp = api_request(instrument=instrument, p=param)
        df = pd.DataFrame(transform(resp['candles'])).set_index('time')
        df['ema_short'] = TA.EMA(df, period=self.short_win)
        df['ema_long'] = TA.EMA(df, period=self.long_win)
        df['atr'] = TA.ATR(df, 14)
        df['signal'] = 0.0
        # Create a 'signal' (invested or not invested) when the short moving average crosses the long
        # moving average, but only for the period greater than the shortest moving average window
        df['signal'][self.short_win:] = np.where(
            df['ema_short'][self.short_win:] > df['ema_long'][self.short_win:],
            1.0, 0.0)
        # Take the difference of the signals in order to generate actual trading orders
        df['position'] = df['signal'].diff()

        # df.to_csv(r'C:\temp\signals.csv')
        return df
コード例 #3
0
def sample_data(instrument: str,
                start: datetime,
                end: datetime,
                short_window: int = 100,
                long_window: int = 350) -> pd.DataFrame:
    price_feed = read_price_df(instrument=instrument,
                               granularity='D',
                               start=start,
                               end=end)
    price_feed[f'smma_{short_window}'] = TA.SMMA(price_feed,
                                                 period=short_window,
                                                 adjust=False)
    price_feed[f'smma_{long_window}'] = TA.SMMA(price_feed,
                                                period=long_window,
                                                adjust=False)
    price_feed['atr'] = TA.ATR(price_feed[['high', 'low', 'close']])
    price_feed['signal'] = price_feed.apply(partial(signal, short_window,
                                                    long_window),
                                            axis=1)
    return price_feed
コード例 #4
0
def generate_price_feed(instrument: str,
                        start: datetime = None,
                        end: datetime = None,
                        persist_dir: str = 'c:/temp'):
    start = start or datetime(2005, 1, 1)  # earliest date support by Oanda
    end = end or datetime.today() - timedelta(days=1)
    pd_h1 = read_price_df(instrument=instrument,
                          granularity='H1',
                          start=start,
                          end=end)
    pd_d = read_price_df(instrument=instrument,
                         granularity='D',
                         start=start,
                         end=end)
    pd_h1[['macd', 'signal']] = TA.MACD(pd_h1)
    pd_h1['ema_200'] = TA.EMA(pd_h1, period=200)
    pd_h1['atr'] = TA.ATR(pd_h1)
    pd_h1['rsi'] = TA.RSI(pd_h1)
    pd_d['atr'] = TA.ATR(pd_d)
    pd_d['rsi'] = TA.RSI(pd_d)

    pd_h1.reset_index(level=0, inplace=True)
    pd_h1 = pd_h1.apply(partial(_enrich, pd_d), axis=1).set_index('time')

    print(pd_h1)
    pd_h1.to_csv(f'{persist_dir}/{instrument.lower()}_macd.csv')
コード例 #5
0
def output_feeds(instrument: str,
                 short_win: int,
                 long_win: int,
                 ema_period: int,
                 save_dir: str,
                 st: datetime,
                 et: datetime = None) -> pd.DataFrame:
    """
    Output daily ohlc price feeds to csv
    :param instrument: ccy_pair
    :param st: start date
    :param et: end date
    :param short_win:
    :param long_win:
    :param ema_period:
    :param save_dir:
    :return:
    """

    pd_d = read_price_df(instrument=instrument,
                         granularity='D',
                         start=st,
                         end=et)
    pd_d[f'last_{long_win}_high'] = pd_d['high'].rolling(window=long_win).max()
    pd_d[f'last_{short_win}_high'] = pd_d['high'].rolling(
        window=short_win).max()
    pd_d[f'last_{long_win}_low'] = pd_d['low'].rolling(window=long_win).min()
    pd_d[f'last_{short_win}_low'] = pd_d['low'].rolling(window=short_win).min()
    pd_d['atr'] = TA.ATR(pd_d, period=14)
    pd_d['adx'] = TA.ADX(pd_d, period=14)
    pd_d['rsi'] = TA.RSI(pd_d, period=14)
    pd_d[f'ema_{ema_period}'] = TA.EMA(pd_d, period=ema_period)

    pd_d.to_csv(f'{save_dir}/{instrument.lower()}_d.csv')
    logger.info(f'output feeds complete for [{instrument}]!')
    return pd_d