new version

Author: philippe-ostiguy

exit/exit_fibo.py

@@ -1,3 +1,5 @@
+"""Module that will try to exit the market when we are in """
+
 import entry.entry_fibo as ef
 import sys
 import operator as op
@@ -6,24 +8,12 @@
 import pandas as pd
 
 class ExitFibo(ef.EntFibo):
+    """ Class that uses Fibonnacci strategy to exit the market.
 
+        It first uses the `EntFibo()` class in `entry_fibo.py` to enter in the market.
+        """
 
     def __init__(self,init_):
-        """
-        Class that uses Fibonnacci strategy to exit the market.
-
-        It first uses the EntFibo to enter the market (inheritance)
-        Then it tries to exit the market with Fibonacci retracement and extension. 1 type at the moment:
-            1- Extension from a previous wave (largest one in the last trend)
-
-        Notes
-        -----
-        Need to use also Fibonnacci retracements to exit the market
-
-        No slippage included in `try_exit()`. If the price reached the desired level, we just exit at either the
-            current price or the next desired price
-
-        """
 
         new_obj = init_
         self.__dict__.update(new_obj.__dict__) #replacing self object with Initialise object
@@ -32,15 +22,25 @@ def __init__(self,init_):
                                                   self.trade_return])
 
     def __call__(self,curr_row,buy_signal=False,sell_signal=False):
-
+        """ Method that will first try to enter the market with `self.ent_fibo` then it will try to exit with
+        `self.try_exit()` whenever we have a position
+        """
         super().__init__()
         self.ent_fibo(curr_row=curr_row, buy_signal=buy_signal, sell_signal=sell_signal)
         return self.try_exit()
-
 
     def try_exit(self):
         """
-        Method which try to exit the market.
+        This is the ethod that tries to exit the market when wr have a position with `entry_fibo.py`
+
+        Then it tries to exit
+        the market using Fibonacci retracement and extension. 1 type at the moment:
+            1- Largest extension `self.largest_extension_` from the current trend
+
+        There is no slippage included in `try_exit()`. If the price reached the desired level, we just exit at
+        either the current price or the next desired price
+
+
 
         This method will make the system exit the market when a close or a stop loss signal is triggered
 

indicator.py

@@ -25,6 +25,20 @@ def calcul_indicator(self):
         The function iterate through the indicators in `self.indicator` and through the range of `self.series`,defined
         in `init_operations.py` and function `init_series()`. Then it calculates the value of the indicator using
         the subseries `self.sous_series`.
+
+
+        Parameters
+        ----------
+        `self.series` : pandas Dataframe
+            It contains the series used to build the model.
+        `self.indicator` : dictionary
+            It contains the indicator we are using for the strategy.
+
+        Return
+        ------
+        The function doesn't return anything in itself, but it calculates and stores the value of the desired indicator
+        in `self.indicator` with new columns in `self.series` (pandas Dataframe)
+
         """
 
         super().__call__()

indicators/regression/linear_regression.py

@@ -1,18 +1,22 @@
+"""Module that evaluates the slope and r_square of a serie"""
+
 from scipy import stats
 from initialize import Initialize
 from manip_data import ManipData as md
 from init_operations import InitOp as io
 import copy
 
 class RegressionSlopeStrenght(Initialize):
-    """
-    Indicateur qui évalue si la "slope" est différente de 0 pour une régression linéaire
-    Valeurs retournées sont 1 (pente positive), -1 (pente négative) et 0 (neutre)
-    Prendre en considération que cette technique viole des principes statistiques, ie l'autocorrélation des données qui fait
-    que les erreurs ne suivent pas une loi normale
-    + la trend (saisonnalité aussi dans certains cas) qui font que les données ne sont pas indépendantes
-    """
+    """Class that evaluates the slope and r2 value of a serie
 
+    Take into consideration that we use r2 to see if one variable can explain movement in the other.
+    We are not trying to forecast using the r2 value.
+
+    Parameters
+    ----------
+    `self.sous_series` : pandas Dataframe
+        Contains the subseries on which we calculate the slope and r2 value
+    """
 
     def __init__(self,series_,self_):
         super().__init__()
@@ -21,21 +25,16 @@ def __init__(self,series_,self_):
         self.__dict__.update(new_obj.__dict__)
         io.init_series(self)
         del new_obj, self_
-
-        #init_ = init.Initialize()
         self.sous_series=md.sous_series_(series_,self.nb_data)
 
     def __store_stat(self):
-
-        """
-        Function to return stat in a list
-        """
+        """Function that returns stat in a list"""
 
         return stats.linregress(self.sous_series[self.date_ordinal_name],
                                 self.sous_series[self.default_data])
 
     def slope(self):
-        """
+        """ Function that return the slope of a serie.
         La pente est la 1ième valeur retournée dans cette stats.linregress, d'où le [0]
         """
 

indicators/regression/mann_kendall.py

@@ -13,11 +13,9 @@
 from init_operations import InitOp as io
 import copy
 
-
 class MannKendall(Initialize):
     """
-    Mann-Kendall is a non-parametric test to determine if a trend is present over time (using monotonic function)
-
+    Mann-Kendall is a non-parametric test to determine if there is a trend in a time-series
     """
 
     def __init__(self,series_,self_,alpha=0.01,iteration=True):
@@ -41,6 +39,10 @@ def mk(self):
 
         https://github.com/mps9506/Mann-Kendall-Trend/blob/master/mk_test.py
 
+        The goal here is to calculate the Mann Kendall value at data point, so to
+        save time, we just substract the first value and add the last value when
+        we go to a new data point.
+
         This function is derived from code originally posted by Sat Kumar Tomer
         (satkumartomer@gmail.com)
         See also: http://vsp.pnnl.gov/help/Vsample/Design_Trend_Mann_Kendall.htm

init_operations.py

@@ -13,16 +13,21 @@ def __init__(self):
     def __call__(self):
         self.reset_value()
 
-
     def reset_value(self):
-        """Function to reset the dictionary that contains the trading journal (entry, exit, return).
+        """Function to reset the dictionary that contains the trading journal (entry, exit, return) in
+        `self.trades_track`
+
+         We need to do that when we optimize, ie when `self.is_walkfoward` is `True`
+
+         """
 
-         We need to do that when we optimize, ie when `self.is_walkfoward` is `True` """
         self.trades_track = pd.DataFrame(columns=[self.entry_row, self.entry_level, self.exit_row, self.exit_level, \
                                                   self.trade_return])
 
     def init_series(self):
-        """Function that extract data from csv to a pandas Dataframe"""
+        """Function that extract the data from csv to a pandas Dataframe `self.series`
+
+        It actually is the data that we are using for the strategy """
 
         self.series = md.csv_to_pandas(self.date_name, self.start_date, self.end_date, self.name, self.directory,
                             self.asset, ordinal_name=self.date_ordinal_name, is_fx=self.is_fx, dup_col = self.dup_col)

initialize.py

@@ -97,13 +97,13 @@ def __init__(self):
         self.is_fx = True
         self.asset = "EURUSD"
         self.start_date = datetime.strptime('2015-10-15', "%Y-%m-%d")
-        self.end_date = datetime.strptime('2020-10-18', "%Y-%m-%d")
+        self.end_date = datetime.strptime('2016-02-18', "%Y-%m-%d")
 
         self.is_walkfoward = True
         self.training_name_ = '_training'
         self.test_name_ =  '_test'
-        self.training_ = 18 #Lenght in months of training period (put 18)
-        self.test_ = 9 #Lenght in months of testing period (put 9)
+        self.training_ = 2 #Lenght in months of training period (put 18)
+        self.test_ = 1 #Lenght in months of testing period (put 9)
         self.dict_name_ = {self.training_name_:self.training_,self.test_name_:self.test_}
         self.train_param= [] #Optimized training parameters used for the test period
 

manip_data.py

@@ -5,6 +5,7 @@
 from functools import wraps
 from statsmodels.tsa.stattools import adfuller
 import os.path
+import numpy as np
 
 
 def ordinal_date(function):
@@ -94,7 +95,7 @@ def sous_series_(cls,series_,nb_data,point_data=0):
 
         cls.sous_series=series_.iloc[point_data:point_data + nb_data,:]
         if nb_data > len(series_):
-            raise Exception("Number of necessary data to calculate the indicator lower than available data")
+            raise Exception("Not enough necessary data to calculate the indicator")
         return cls.sous_series
 
     @classmethod
@@ -109,4 +110,27 @@ def de_trend(cls, series, period, p_value, date_name, date_ordinal_name, default
         series_diff[date_ordinal_name] = series[date_ordinal_name]
         if adfuller(series_diff[default_data])[1] > p_value:
             raise Exception("The differentiated series is not stationary")
-        return series_diff
+        return series_diff
+
+    @classmethod
+    def nan_list(cls,list_):
+        """Check if a list has one empty value
+
+        Return
+        ------
+        Bool : `True` or `False`
+            Return `True` if at least one value in the list is `nan` and `False otherwise
+        """
+
+        return True if True in np.isnan(list_) else False
+
+    @classmethod
+    def pd_tolist(cls,pd_, row_name):
+        """Transform a pandas column to a list. It makes sure it is an integer"""
+        pd__ = pd_.loc[:, row_name].tolist()
+        try:
+           t = [int(i) for i in pd__]
+        except:
+            raise Exception("Mistake happened in pd_tolist")
+        else :
+            return [int(i) for i in pd__]

math_op.py

@@ -1,5 +1,5 @@
 """
-Basic math operations
+Module for mathematical operation support
 """
 from scipy.signal import argrelextrema
 import matplotlib.pyplot as plt
@@ -33,16 +33,13 @@ def local_extremum(cls,start_point,end_point,window = 6,min_= 'min',max_='max',i
         max_ : str
             Name given to max data column
 
-
         Return
         ------
         DataFrame list : Return a pandas dataframe `cls.series` with the none empty min or max value
             (if both are empty, nothing is returned. If one of
             them has a value, return the local min or max with index no)
         """
 
-
-
         cls.series=cls.series.loc[start_point:end_point,cls.default_col]
         cls.series=pd.DataFrame({cls.default_col: cls.series})
 
@@ -66,27 +63,4 @@ def local_extremum(cls,start_point,end_point,window = 6,min_= 'min',max_='max',i
         #Filter nan value for min or max out
         cls.series=cls.series.loc[(cls.series[min_].isna())==False | (cls.series[max_].isna() == False)]
 
-        return cls.series
-
-    @classmethod
-    def nan_list(cls,list_):
-        """Check if a list has one empty value
-
-        Return
-        ------
-        Bool : `True` or `False`
-            Return `True` if at least one value in the list is `nan` and `False otherwise
-        """
-
-        return True if True in np.isnan(list_) else False
-
-    @classmethod
-    def pd_tolist(cls,pd_, row_name):
-        """Transform a pandas column to a list. It makes sure it is an integer"""
-        pd__ = pd_.loc[:, row_name].tolist()
-        try:
-           t = [int(i) for i in pd__]
-        except:
-            raise Exception("Mistake happened in pd_tolist")
-        else :
-            return [int(i) for i in pd__]
+        return cls.series

optimize_.py

@@ -1,37 +1,52 @@
-"""Module to run the program - use optimization tool if asked"""
+"""Module to run the program - use optimization tools if desired"""
+
 from pnl import PnL
 from manip_data import ManipData as md
 from date_manip import DateManip as dm
 from optimize.genetic_algorithm import GenAlgo as ga
-from indicator import Indicator
 
 class Optimize(PnL):
 
     def __init__(self):
+        """Function that initializes stuff.
+
+        It resets the `self.series` with `self.init_series()` and dictionary that track the pnl
+        `self.trades_track` with `reset_value()` when we optimize.
+        """
         super().__init__()
         self.init_series()
         self.reset_value()
         self.params = {}
 
     def __call__(self):
+        """Function do different things dependent if we optimize or not"""
 
-        # If we optimize
         if self.is_walkfoward:
             self.walk_foward()
         else :
-            Indicator.calcul_indicator(self)
+            self.calcul_indicator()
             self.pnl_()
-            self.first_write = md.write_csv_(self.dir_output, self.name_out, self.first_write, add_doc="",
-                                             is_walkfoward=self.is_walkfoward, **self.pnl_dict)
+            md.write_csv_(self.dir_output, self.name_out, add_doc="", is_walkfoward=self.is_walkfoward, **self.pnl_dict)
 
-    def execute_(self,add_doc=""):
-        """ Just runs the whole program without optimization
+    def walk_foward(self):
+        """Function that do the walk-foward analysis (optimization).
 
-         Load data (and clean), calculate indicators, check for signal, calculate pnl + write results to file
-         """
+        First it runs through the divided period (1 period interval for training and testing). We have to choose
+        properly `self.start_date` and `self.end_date` as they set the numbers of period.
 
+        Then the program runs through each training and testing period (in `self.dict_name_`). The program optimizes
+        only in the training period `self.training_name_`. The results are store in the folder results and
+        results_training for the training period and results_test for the testing period.
+
+        Parameters
+        ----------
+        `self.start_date` : datetime object
+            Set in `initialize.py`. Beginning date of training and testing.
+        `self.end_date` : datetime object
+            Set in `initialize.py`. End date of training and testing.
+
+        """
 
-    def walk_foward(self):
         md_ = md
 
         _first_time = True
@@ -48,7 +63,7 @@ def walk_foward(self):
                 if _first_time :
                     md_(self.dir_output,self.name_out,extension = key_).erase_content()
                 self.init_series()
-                Indicator.calcul_indicator(self)
+                self.calcul_indicator()
                 if key_ == self.training_name_: #we only optimize for the training period
                     self.optimize_param()
                     self.pnl_dict,self.params = ga(self).__call__()
@@ -64,11 +79,13 @@ def walk_foward(self):
             _first_time = False
 
     def assign_value(self):
-        """ Function to assign the value to each optimized parameters obtained in the optimization function"""
+        """ Function to assign the value to each optimized parameters obtained in the optimization module.
+
+        The `genetic_algorithm.py` return the dictionary with the value and when we test in `r_square_tr.py` they are
+        in a different format"""
 
         for item in range(len(self.op_param)):
             if len(self.op_param[item]) > 1:
                 self.op_param[item][0][self.op_param[item][1]] = self.params[self.op_param[item][1]]
             else:
-                setattr(self, self.op_param[item][0], self.params[self.op_param[item][0]])
-        t =5
+                setattr(self, self.op_param[item][0], self.params[self.op_param[item][0]])