Merge pull request #4 from HarryLudemann/start-script

Adding async to run method

Author: HarryLudemann

setup.py

@@ -7,7 +7,7 @@
 with codecs.open(os.path.join(here, "README.md"), encoding="utf-8") as fh:
     long_description = "\n" + fh.read()
 
-VERSION = '0.0.2'
+VERSION = '0.0.3'
 DESCRIPTION = 'Run/Backtest/Create Easy Python Trading Algorithms'
 LONG_DESCRIPTION = 'A package that allows easy to write, run and backtest algorithms for stocks, forex and crypto from pre-written data sources eg. alpha vantage, yfinance'
 

trader/__init__.py

@@ -1,2 +1,2 @@
 from trader import data
-from trader.start import backtest, standard_backtest, run, StockAlgorithm, ForexAlgorithm
+from trader.start import backtest, run, StockAlgorithm, ForexAlgorithm

trader/start.py

@@ -79,10 +79,10 @@ def set_from_currency(self, to_currency):
 
 
 
-backtest_algorithms = [] # list of algorithms to backtest for async
 async def async_backtest(algorithm):
     """" Async method to backtest given algorithm object, gets data and passes each row to on_data method - dont call"""
     if algorithm.Active == False: return
+    print(f'Getting {algorithm.Name} data, from {algorithm.Data_Source}')
     if hasattr(algorithm, 'Symbol'):                # if algorithm is stock algo
         df = await getattr(data, f'get_{algorithm.Data_Source}_stock')(algorithm)
 
@@ -97,7 +97,7 @@ async def async_backtest(algorithm):
     for i in range(len(df)):
         algorithm.on_data(df.iloc[i])
     print(f'Finished: {algorithm.Name}: {start_date} to, {end_date} interval: {algorithm.Interval} Data-Source: {algorithm.Data_Source}')
-    return algorithm.stats()
+    algorithm.stats()
 
 
 async def create_backtest_tasks():
@@ -106,87 +106,88 @@ async def create_backtest_tasks():
     tasks = [asyncio.ensure_future(async_backtest(algo)) for algo in backtest_algorithms]
     # wait for all tasks to complete
     await asyncio.wait(tasks)
-    return tasks
 
 
 def backtest(algorithms):
     """ Backtest method passed list of algorithms, calls on data for methods"""
-    for algorithm in algorithms:
-        backtest_algorithms.append(algorithm)
+    global backtest_algorithms
+    backtest_algorithms = algorithms
     try:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
         loop = asyncio.get_event_loop()
         #loop.set_debug(1)
-        tasks = loop.run_until_complete(create_backtest_tasks())
-        for algo in tasks:
-            print(algo.result())
+        loop.run_until_complete(create_backtest_tasks())
     except Exception as e:
         print(e)
     finally:
         loop.close()
 
 
-def standard_backtest(algorithm):
-    """ standard Method to backtest given algorithm object, gets data and passes each row to on_data method """
-    if algorithm.Active == False: return
-    if hasattr(algorithm, 'Symbol'):                # if algorithm is stock algo
-        df = getattr(data, f'get_standard_{algorithm.Data_Source}_stock')(algorithm)
-
-    elif hasattr(algorithm, 'From_Currency'):       # if algorithm is forex method
-        df = getattr(data, f'get_standard_{algorithm.Data_Source}_forex')(algorithm)
-        
-    start_date = df.index[0]    # start date of data   
-    end_date = df.index[-1]     # end date of data
-
-    print(f'Back Testing: {algorithm.Name}: {start_date} to, {end_date} interval: {algorithm.Interval} Data-Source: {algorithm.Data_Source}')
-
-    # need alternative, somewhat slow
-    for i in range(len(df)):
-        algorithm.on_data(df.iloc[i])
-
-    print(f'Finished: {algorithm.Name}: {start_date} to, {end_date} interval: {algorithm.Interval} Data-Source: {algorithm.Data_Source}')
 
+async def async_run(algorithm):
+    """ runs given algorithm object if interval time has passed - dont call (used for run method)"""
+    # get algorithms interval in minutes
+    if algorithm.Interval[-1] == 'm':
+        if algorithm.Interval[0] == '1' and algorithm.Interval[1] == '5':   # 15 minute interval
+            algo_interval_minutes = 15
+        elif algorithm.Interval[0] == '1':                                  # 1 minute interval
+            algo_interval_minutes = 1
+        elif algorithm.Interval[0] == '5':                                  # 5 minute interval
+            algo_interval_minutes = 5
+        elif algorithm.Interval[0] == '3':                                  # 30 minute interval
+            algo_interval_minutes = 30
+        elif algorithm.Interval[0] == '6':                                  # 60 minute interval
+            algo_interval_minutes = 60
+    elif algorithm.Interval[-1] == 'd':                                     # 1 day interval
+        algo_interval_minutes = 1440
+    elif algorithm.Interval[-1] == 'w':                                     # 1 week interval
+        algo_interval_minutes = 10080
+    elif algorithm.Interval[-1] == 'm':                                     # 1 month interval
+        algo_interval_minutes = 43200
+    elif algorithm.Interval[-1] == 'y':                                     # 1 year interval
+        algo_interval_minutes = 525600
+    
+    # if time to run algorithm
+    if minutes_ran % algo_interval_minutes == 0:
+        # get appropriate data
+        if hasattr(algorithm, 'Symbol'):                # if algorithm is stock algo
+            df = await getattr(data, f'get_{algorithm.Data_Source}_stock')(algorithm)
+
+        elif hasattr(algorithm, 'From_Currency'):       # if algorithm is forex method
+            df = await getattr(data, f'get_{algorithm.Data_Source}_forex')(algorithm)
+
+        algorithm.on_data(df.iloc[-1]) # call on data with last row in df
+        algorithm.stats()
+    await asyncio.sleep(0)
+
+
+async def create_run_tasks():
+    """ Create of async_run method for all run algorithms"""
+    tasks = [asyncio.ensure_future(async_run(algo)) for algo in run_algorithms]
+    # wait for all tasks to complete
+    await asyncio.wait(tasks)
 
 
 def run(Algorithms):
     """ Pass list of objects runs objects, returns nothing"""
     # currently not setup to be updatable while running
-    start_time = time.time()
-    Algorithms = [x for x in Algorithms if x.Active] 
-    minutes_ran = 0
+    start_time = time.time()    # for scheduling getting rest of of minute
+    global run_algorithms 
+    run_algorithms = [x for x in Algorithms if x.Active] 
+    global minutes_ran 
+    minutes_ran = 0 
     while True:
-        for algorithm in Algorithms:
-            # get algorithms interval in minutes
-            if algorithm.Interval[-1] == 'm':
-                if algorithm.Interval[0] == '1' and algorithm.Interval[1] == '5':   # 15 minute interval
-                    algo_interval_minutes = 15
-                elif algorithm.Interval[0] == '1':                                  # 1 minute interval
-                    algo_interval_minutes = 1
-                elif algorithm.Interval[0] == '5':                                  # 5 minute interval
-                    algo_interval_minutes = 5
-                elif algorithm.Interval[0] == '3':                                  # 30 minute interval
-                    algo_interval_minutes = 30
-                elif algorithm.Interval[0] == '6':                                  # 60 minute interval
-                    algo_interval_minutes = 60
-            elif algorithm.Interval[-1] == 'd':                                     # 1 day interval
-                algo_interval_minutes = 1440
-            elif algorithm.Interval[-1] == 'w':                                     # 1 week interval
-                algo_interval_minutes = 10080
-            elif algorithm.Interval[-1] == 'm':                                     # 1 month interval
-                algo_interval_minutes = 43200
-            elif algorithm.Interval[-1] == 'y':                                     # 1 year interval
-                algo_interval_minutes = 525600
-            
-            # if time to run algorithm
-            if minutes_ran % algo_interval_minutes == 0:
-                # get appropriate data
-                if hasattr(algorithm, 'Symbol'):                # if algorithm is stock algo
-                    df = getattr(data, f'get_{algorithm.Data_Source}_stock')(algorithm)
-
-                elif hasattr(algorithm, 'From_Currency'):       # if algorithm is forex method
-                    df = getattr(data, f'get_{algorithm.Data_Source}_forex')(algorithm)
-
-                algorithm.on_data(df.iloc[-1]) # call on data with last row in df
-                    
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            loop = asyncio.get_event_loop()
+            #loop.set_debug(1)
+            loop.run_until_complete(create_run_tasks())
+        except Exception as e:
+            print(e)
+        finally:
+            loop.close()
 
         # wait for remainder of minute
         time.sleep(60.0 - ((time.time() - start_time) % 60.0))