commit

Author: kloudtrader-github

back.py

@@ -0,0 +1,32 @@
+from libkloudtrader.algorithm import *
+import libkloudtrader.analysis as analysis
+import pandas as pd
+import numpy as np
+
+
+
+def ba(backtest,data):
+
+    data['high']=data.close.shift(1).rolling(window=5).max()
+    data['low']=data.close.shift(1).rolling(window=5).min()
+    data['avg']=analysis.ma(data.close,5)
+    buy=(data.close>data.high)
+    sell=(data.close<data.avg)
+    #short=(data.close<data.low)
+    #cover=(data.close>data.avg)
+    if buy.tail(1).bool():
+        backtest.buy(5)
+    elif sell.tail(1).bool():
+        backtest.sell(5)
+    else:
+        print('No trade')
+   
+    #rets=analysis.daily_returns(data.close)
+    #data['volatility']=analysis.moving_volatility(rets,1)
+    #data['slip']=data.high-data.close
+   
+
+
+    
+
+run_backtest(ba,['AAPL'],data="US_STOCKS_daily",start_date='2018-01-01',end_date='2019-01-01')

sma_live.py renamed to backtest.md

@@ -1,6 +1,7 @@
 from typing import Any, List
 import random
 import time
+import datetime
 import numpy as np
 import pandas as pd
 import libkloudtrader.stocks as stocks
@@ -10,15 +11,18 @@
 from libkloudtrader.logs import start_logger
 import libkloudtrader.backtest as bt
 import libkloudtrader.crypto as crypto
-import asyncio
+import libkloudtrader.analysis as analysis
+
+
+
 #pd.set_option('display.max_columns', None)  # or 1000
 #pd.set_option('display.max_rows', None)  # or 1000
 #pd.set_option('display.max_colwidth', -1)  # or 199
 
 logger = start_logger(__name__, ignore_module='libkloudtrader.analysis')
 
 
-def backtest(strategy: str,
+def run_backtest(strategy: str,
              symbol_bucket: List[str],
              data: str,
              start_date: Any,
@@ -27,23 +31,42 @@ def backtest(strategy: str,
              preferred_benchmark: str = 'SPY',
              data_interval: str = '1d',
              initial_capital: float = 100000,
-             commission: float = 0):
+             commission: float = 0,
+             slippage=True):
     """Backtester function"""
     try:
         logger.info(
             'Starting Backtest for {} from {} to {} with initial capital = {}'.
             format(strategy.__name__, start_date, end_date, initial_capital))
         data_to_backtest_on = Data_Types[data].value
+        for symbol in symbol_bucket:
+            data_batch = data_to_backtest_on(symbol,
+                                             start_date,
+                                             end_date
+                                             )
+            batch = processing.Buffer(len(data_batch), dtype=object)
+            backtest=bt.Backtest(capital=100000,commission=1,enable_slippage=True)
+            for index, bar in data_batch.iterrows():
+                batch.append(bar)
+                backtest.update_bar(index,bar)
+                data_batch = pd.DataFrame(batch)
+                
+                locals()['strategy'](backtest,data_batch)
+            print(backtest.get_trade_log)
+        
+        '''
         for symbol in symbol_bucket:
             data_batch = data_to_backtest_on(symbol,
                                              start_date,
                                              end_date,
                                              interval=data_interval)
             for symbol in symbol_bucket:
+
+              
                 a = bt.Backtest(locals()['strategy'](data_batch),
                                 preferred_price_point)
                 print(a.preferred_price_point)
-                '''
+                
                 signals=locals()['strategy'](data_batch)
                 df=pd.DataFrame()
                 df['buy']=signals['buy']
@@ -62,7 +85,7 @@ def backtest(strategy: str,
                 #df['positions in '+symbol]=100*df['positions']
                 #print(bt.trades)
 
-            logger.info("Received Signals from {}".format(strategy.__name__))
+        logger.info("Received Signals from {}".format(strategy.__name__))
 
     except (KeyboardInterrupt, SystemExit):
         print('\n')
@@ -80,29 +103,33 @@ def backtest(strategy: str,
     #print(locals()[a](symbol, start_date, end_date))
 
 
-def live_trade(strategy: str,
+def run_live(strategy: str,
                symbol_bucket: list,
                data_feed_type: str,
-               exempted_states: list = ['close'],
+               exempted_states: list = [''],
+               exempted_days:list=[''],
+               exempted_dates:list=[''],
                batch_size: int = 1000,
-               data_feed_delay: float = 0.0,
+               data_feed_delay: float = 1.0,
                fake_feed: bool = False):
     try:
         logger.info("{} is now entering the live markets. 📈\n".format(
             strategy.__name__))
+        [x.lower() for x in exempted_states]
+        [x.lower() for x in exempted_days]
         if isinstance(symbol_bucket, list):
             symbol_bucket = np.array(symbol_bucket)
         elif type(symbol_bucket) not in (numpy.ndarray, list):
             raise TypeError('Symbol bucket must be a list or numpy array')
         if data_feed_type not in ('CRYPTO_live_feed', 'US_STOCKS_live_feed',
                                   'CRYPTO_live_feed_level2'):
             raise InvalidDataFeedType(
-                'This Data Feed is not available for live trading. Please use libkloudtrader.algorithm.backtest() for backtesting or using hisotrical data.'
+                'This Data Feed is not available for live trading.'
             )
         if data_feed_type in ("CRYPTO_live_feed", 'CRYPTO_live_feed_level2'):
             data_feed_delay = crypto.exchange_attribute('rateLimit')
         data_feed = Data_Types[data_feed_type].value
-        while stocks.intraday_status()['state'] not in exempted_states:
+        while stocks.intraday_status()['state'] not in exempted_states: #and datetime.datetime.now().strftime("%A").lower() not in exempted_days:
             batch = processing.Buffer(batch_size, dtype=object)
             while len(batch) < batch_size:
                 for symbol in symbol_bucket:

libkloudtrader/algorithm.py

@@ -1,3 +1,4 @@
+'''
 import pandas as pd
 from libkloudtrader.exceptions import InvalidPricePoint
 
@@ -31,3 +32,91 @@ def data(self):
     @property
     def preferred_price_point(self):
         return self.default_price
+'''
+import numpy as np
+import pandas as pd
+
+class Backtest():
+    def __init__(self,capital:float,commission:float,enable_slippage:bool):
+        """Init backtest"""
+        self.capital=capital
+        self.bar=0
+        self.position=0
+        self.commission=commission
+        self.enable_slippage=enable_slippage
+        self.slippage=0
+        self.trades_log=pd.DataFrame(columns=['datetime','trade type','price','fill price','order cost'])
+
+    
+    def buy(self,quantity):
+        '''emulates a buy order'''
+        self.capital-=self.order_cost
+        self.update_positions(quantity)
+        self.update_trade_logs(datetime=self.bar.datetime,trade_type='Buy',price=self.bar.close,fill_price=self.fill_price,order_cost=self.order_cost)
+        print('Bought {} of stocks @ {} but price is {}'.format(quantity,self.order_cost,self.bar.close))
+
+    
+    def sell(self,quantity):
+        '''emulates a sell order'''
+        if self.position!=0:
+            self.capital+=self.order_cost
+            self.update_positions(-1*quantity)
+            self.update_trade_logs(datetime=self.bar.datetime,trade_type='Sell',price=self.bar.close,fill_price=self.fill_price,order_cost=-1*self.order_cost)
+            print('Sold {} of stocks @ {} but price is {}'.format(quantity,self.order_cost,self.bar.close))
+        else:
+            print('No position to close')
+
+    def update_trade_logs(self,datetime,trade_type,price,fill_price,order_cost):
+        df=pd.DataFrame([{'datetime':datetime,'trade type':trade_type,'price':price,'fill price':fill_price,'order cost':order_cost}])
+        self.trades_log=self.trades_log.append(df)
+
+
+    @property
+    def get_trade_log(self):
+        self.trades_log.set_index('datetime',inplace=True)
+        return self.trades_log
+
+    def update_bar(self,index,bar):
+        self.bar=bar
+        self.bar.datetime=index
+
+    def update_positions(self,quantity):
+        self.position+=quantity
+
+    @property
+    def calculate_commission(self):
+        commiss=(self.commission/100)*self.bar.close
+        return commiss
+
+    @property
+    def calculate_slippage(self):
+        '''how is slippage calculated?'''
+        '''slippage should not be more than 2% in most of the trades. so we generate a random percentage b/w 0-2.use that number as %age'''
+        if self.enable_slippage:
+            slippage_percent= np.random.uniform(low=0, high=0.02)
+            slippage=slippage_percent*self.bar.close
+            return slippage
+        return 0.0
+    
+    @property   
+    def fill_price(self):
+        return self.bar.close+self.calculate_slippage
+        
+
+    @property   
+    def order_cost(self):
+        return self.fill_price+self.calculate_commission
+         
+    
+    @property
+    def getcapital(self):
+        return self.capital
+
+    @property
+    def getbar(self):
+        return self.bar
+
+    @property
+    def getposition(self):
+        return self.position
+

libkloudtrader/backtest.py

@@ -776,6 +776,7 @@ def incoming_tick_data_handler(symbol: str,
                                fake_feed: bool = False):
     latest_orderbook_entry = order_book(symbol, number_of_data_points=1)
     latest_trades = trades(symbol, number_of_data_points=1)
+    latest_price=latest_price_info(symbol)
     latest_orderbook_entry_dict = {}
     latest_orderbook_entry_dict['symbol'] = symbol
     latest_orderbook_entry_dict['ask'] = latest_orderbook_entry['asks'][0][
@@ -792,6 +793,10 @@ def incoming_tick_data_handler(symbol: str,
     latest_orderbook_entry_dict['price'] = latest_trades[0]['price']
     latest_orderbook_entry_dict['tradesize'] = latest_trades[0]['amount']
     latest_orderbook_entry_dict['tradedate'] = latest_trades[0]['datetime']
+    latest_orderbook_entry_dict['open']=latest_price['open']
+    latest_orderbook_entry_dict['high']=latest_price['high']
+    latest_orderbook_entry_dict['low']=latest_price['low']
+    latest_orderbook_entry_dict['close']=latest_price['close']
     return latest_orderbook_entry_dict
 
 

libkloudtrader/crypto.py

@@ -0,0 +1,23 @@
+from libkloudtrader.algorithm import *
+import pandas as pd
+import libkloudtrader.analysis as analysis
+
+def crypto_turtle(data):
+    data['high']=data.price.shift(1).rolling(window=5).max()
+    data['low']=data.price.shift(1).rolling(window=5).min()
+    data['avg']=analysis.ma(data.price,5)
+    buy=data.price>data.high
+    sell=data.price<data.avg
+    short=data.price<data.low
+    cover=data.price>data.avg
+    if buy.tail(1).bool():
+        logger.info('Buy signal')
+    if sell.tail(1).bool():
+        logger.info('Sell signal')
+    if short.tail(1).bool():
+        logger.info('Short signal')
+    if cover.tail(1).bool():
+        logger.info('Cover signal')
+
+
+live_trade(crypto_turtle,symbol_bucket=['BTC/USD'],data_feed_type="CRYPTO_live_feed")