Trading in Python: Part 2

In the previous post, we wrote the basics of stock trading in Python. We saw how to make a small wallet to record transactions, how to fetch data from investing.com in a python object and we wrote some generic classes to buy and sell when a security crosses a thresold.

Now we will continue our exercise writing a program to run several strategias over a period of time.

As we are going to run different scenarios, it is a good idea to use parallelisation in our design.

Here is the code:

%cat Simulation.py

import multiprocessing
import time
import json
from datetime import datetime, timedelta

import numpy as np
import pandas as pd

from Security import Security
from Wallet import Wallet
from Strategies import *
from Global import *

from tqdm.notebook import tqdm, trange

def simulate(portfolio_excel, years, p_bar=None):

    date_format='%Y-%m-%d'
    today = datetime.today()
    time_ago = datetime.today() - timedelta(days=365*years)
    today_str = today.strftime(date_format)
    time_ago_str = time_ago.strftime(date_format)


    portfolio = pd.read_excel(portfolio_excel, engine='openpyxl').astype(str) 

    cases = []
    
    if p_bar is not None:
        p_bar.reset(total=len(portfolio))
        p_bar.set_description('Fetching information for scenario: {} year(s)'.format(years))
        
    for index, row in portfolio.iterrows():
        try:
            isin = row['ISIN']
            country = row['Country'] if row['Country'] != 'nan' else None
            exchange = row['Exchange'] if row['Exchange'] != 'nan' else None
            currency = row['Currency'] if row['Currency'] != 'nan' else 'EUR'

            stock = Security(isin, currency, country, exchange)

            case = Strategy_Hold_And_Sell(stock)
            cases.append(case)
          
            magic_numbers = [20, 50, 100, 200]
            for i in magic_numbers:
                for j in magic_numbers:
                    if i != j:
                        for k in ['SMA', 'EMA']:
                                case = Strategy_Buy_Value0_LT_Value1(stock, (k, i, j))
                                cases.append(case)

            for i in [0.0, 0.25, 0.5]:
                case = Strategy_Buy_dSMA20(stock, i)
                cases.append(case)


        except Exception as e:
            print(e)
            continue
        
        if p_bar is not None:
            p_bar.update()

    running_jobs = []

    manager = multiprocessing.Manager()
    results = manager.list()

    jobs_todo = [ multiprocessing.Process(target=case.simulate,
                                          args=(time_ago_str, today_str, 5.0, results,),
                                          name=case.security.name
                                         ) for case in cases ]
    if p_bar is not None:
        p_bar.reset(total=len(jobs_todo))
        p_bar.set_description('Running simulation of scenario: {} year(s)'.format(years))
    
    while jobs_todo or running_jobs:
        while len(running_jobs) < 4 and len(jobs_todo) > 0:
            job = jobs_todo.pop()
            job.start()
            running_jobs.append(job)

        counter=0
        for job in running_jobs:
            if not job.is_alive():
                job.join()
                running_jobs.remove(job)
                counter = counter + 1
        
        if p_bar is not None:
            p_bar.update(counter)

        time.sleep(0.1)

    dataframe=pd.DataFrame(results[:])  
    dataframe_result=pd.DataFrame()

    for isin in dataframe['ISIN'].drop_duplicates().values:
        isin_dataframe = dataframe[dataframe['ISIN'] == isin]
        yield_hold = isin_dataframe[isin_dataframe['Strategy'] == 'Buy, Hold and Sell']['Yield'].sum()
        sorted_dataframe = isin_dataframe.sort_values(by='Yield', ascending=False)
        yield_winner_strategy = sorted_dataframe.iloc[0]['Yield']
        if yield_winner_strategy > yield_hold:
            winner_dataframe = isin_dataframe[isin_dataframe['Yield'] >= yield_winner_strategy].copy()
            winner_dataframe['Strategy Yield Increment'] = yield_winner_strategy - yield_hold
        else:
            winner_dataframe = isin_dataframe[isin_dataframe['Strategy'] == 'Buy, Hold and Sell'].copy()
            winner_dataframe['Strategy Yield Increment'] = 0
        dataframe_result = dataframe_result.append(winner_dataframe)
    
    return dataframe_result

Now that we have our files in place, we can start playing.

First, let’s do the imports

from Simulation import simulate
import pandas as pd

from tqdm.notebook import tqdm, trange

We also need to provide information about the ETFs and Stocks we want to simulate.

We do that in an excel file, that should like:

pd.read_excel('excel/portfolio.xlsx', engine='openpyxl').astype(str) 

Any column after currency is not required in the first run. Those columns are the results of running the simulation with the best perfoming strategy.

Now we can perform the simulation in several scenarios. Please ignore any warnings regarding some currency exchange or data missing. The program will make the best assumption taking previous data and interpolating. Also in some securities, no dividends are available — which is expected.

final_dataframe = pd.DataFrame()

YEARS = [1, 3]

p_bar = tqdm()

for years in tqdm(YEARS, desc='Processing scenarios'):
    print('Processing Simulation for period of {} year(s)'.format(years))
    dataframe_result = simulate('./excel/portfolio.xlsx', years, p_bar)
    
    dataframe_result['Simulation Period'] = '{} year(s)'.format(years)
    dataframe_result['Yield per Year'] = round(dataframe_result['Yield']/years,2)
    dataframe_result['Strategy Yield Increment Per Year'] = round(dataframe_result['Strategy Yield Increment']/years,2)
    dataframe_result = dataframe_result[['Security Name', 'Security Type', 'Country', 'Exchange', 'Strategy', 'Simulation Period', \
                                         'Yield per Year', 'Strategy Yield Increment Per Year', 'Strategy Class Name', 'Strategy Config']]
    final_dataframe = final_dataframe.append(dataframe_result)

p_bar.close()

Now we can see the best strategy and save the results:

final_dataframe.to_csv('./excel/_simulations.csv',index=False)
display.display(final_dataframe)

In the future, I will focus on investing with python. From the results, I am not convinced that trading is the best approach. I will focus my efforts about selection of securities and balancing a portfolio.

Until next time