virgo-modules 0.1.0__tar.gz → 0.1.2__tar.gz

{virgo_modules-0.1.0 → virgo_modules-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: virgo_modules
-Version: 0.1.0
+Version: 0.1.2
 Summary: data processing and statistical modeling using stock market data
 Home-page: https://github.com/miguelmayhem92/virgo_module
 Author: Miguel Mayhuire

{virgo_modules-0.1.0 → virgo_modules-0.1.2}/setup.py

@@ -5,7 +5,7 @@ with open("virgo_app/README.md", "r") as f:
 
 setup(
     name="virgo_modules",
-    version="0.1.0",
+    version="0.1.2",
     description="data processing and statistical modeling using stock market data",
     package_dir={"": "virgo_app"},
     packages=find_packages(where="virgo_app"),

{virgo_modules-0.1.0 → virgo_modules-0.1.2}/virgo_app/virgo_modules/src/backtester.py

@@ -50,9 +50,11 @@ class SignalAnalyserObject:
     aws_credentials: dict
     signal_position: int
         if available, signal position to open a position
-    df: pd.DataFrame:
+    df: pd.DataFrame
         transformed data of the selected feature to perform back-test
-
+    median_return: float
+        median return after end low signals
+    
     Methods
     -------
     signal_analyser(days_list=list):
@@ -169,12 +171,19 @@ class SignalAnalyserObject:
             
         df['open_long'] = np.where(df.last_in_chain == True, True, np.nan)
         df['open_short'] = np.where(df.first_in_chain == True, True, np.nan)
+        df.signal_type = df.signal_type.map({'up':'go down', 'down': 'go up'})
+        
+        # median return
+        returns_list = [f'return_{days}d' for days in days_list]
+        df_melt = df[df.open_long == True].pivot_table(index=['signal_type'], values=returns_list, aggfunc='median')
+        df_melt['median'] = df_melt[returns_list].median(axis = 1)
+        self.median_return = df_melt.loc['go up', 'median']
         
         # plotting
         fig, axs = plt.subplots(1, 4, figsize = (20,5))
         palette ={"go down": "tomato", "go up": "lightblue"}
         
-        df2 = df[df.signal_type.isin(['up','down'])]
+        df2 = df[df.signal_type.isin(['go down','go up'])]
         df2['lag_Date'] = df2['Date'].shift(1)
         df2['lag_signal_type'] = df2['signal_type'].shift(1)
         df2 = df2[df2.lag_signal_type != df2.signal_type]
@@ -183,7 +192,6 @@ class SignalAnalyserObject:
         sns.stripplot(data=df2, y="span",ax = axs[0], jitter=True, zorder=1)
         axs[0].set_title('span between last signals')
 
-        df.signal_type = df.signal_type.map({'up':'go down', 'down': 'go up'})
         df_ = df[df.last_in_chain == True]
         df_['part'] = '-'
         sns.violinplot(data=df_, y="internal_rn", x='part', ax = axs[1], hue="signal_type", inner="quart",palette = palette,gap=0.1, split=True, linewidth=0.7)
@@ -357,4 +365,110 @@ class SignalAnalyserObject:
         del dft
 
         if self.return_fig:
-            return fig, messages
+            return fig, messages
+        
+class IterateSignalAnalyse(SignalAnalyserObject):
+    """
+    object that is going to iterate backtest given a parameter space
+
+    Attributes
+    ----------
+    test_data_size : int
+    feature_name : str
+    days_list: list
+        list of integers that serve as time horizons
+    arguments_to_test : dict
+        paramter space
+    method: str
+        method to use
+    object_stock: obj
+        object containing data and methods
+    plot: boolean
+        show summary plot of median results
+    best_result: float
+        index of the best result, the index corresponds to the parameter space
+
+    Methods
+    -------
+    execute(show_plot_iter=boolean):
+        display plots for every iteration
+    """
+    def __init__(self, test_data_size, feature_name, days_list, arguments_to_test, method, object_stock, plot = False):
+        """
+        Parameters
+        ----------
+        test_data_size (int): size of the test data
+        feature_name (str): name of the feature
+        days_list (list): list of integers that serve as time horizons
+        arguments_to_test (dict): paramter space
+        method (str): method to use
+        object_stock (obj): object containing data and methods
+        plot (boolean): show summary plot of median results
+
+        Returns
+        -------
+        None
+        """
+        self.test_data_size = test_data_size
+        self.feature_name = feature_name
+        self.days_list = days_list
+        self.arguments_to_test = arguments_to_test
+        self.method = method
+        self.plot = plot
+        self.object_stock = object_stock
+        
+    def execute(self,show_plot_iter = False):
+        """
+        Iterate backtest and compute median result for every iteration
+
+        Parameters
+        ----------
+        show_plot_iter  (boolean): display plots for every iteration
+
+        Returns
+        -------
+        None
+        """
+        results = list()
+        for key in self.arguments_to_test.keys():
+            configuration = self.arguments_to_test.get(key)
+            getattr(self.object_stock, self.method)(**configuration)
+            signal_assess = SignalAnalyserObject(self.object_stock.df, self.object_stock.stock_code, show_plot = show_plot_iter, test_size = self.test_data_size, feature_name = self.feature_name)
+            signal_assess.signal_analyser(days_list = self.days_list)
+            mean_median_return = signal_assess.median_return
+            results.append(mean_median_return)
+            
+        df_result = pd.DataFrame({'keys':self.arguments_to_test.keys(),'results':results})
+        if self.plot:
+            plt.plot(df_result['keys'], df_result['results'])
+            plt.scatter(df_result['keys'], df_result['results'])
+            plt.title('simulation between configurations')
+            plt.ylabel('median expected return')
+            plt.show()
+    
+        best_result = df_result.sort_values('results',ascending = False)['keys'].values[0]
+        self.best_result = best_result
+
+def execute_signal_analyser(test_data_size, feature_name, days_list, configuration, method, object_stock, analyser_object, plot = False, backtest= False, exit_params = {}):
+    '''
+    code snippet that is going run backtest and display analysis messages and plots
+
+            Parameters:
+                    test_data_size (int): test data size
+                    feature_name (str): name of the feature to assess
+                    days_list (list): tome scope to assess the returns
+                    configuration (dict): parameters of the method to run
+                    object_stock (obj): object with data to assess
+                    method (str): method to use
+                    analyser_object (obj): signal_analyser object
+                    plot (boolean): if true, plot results
+                    backtest (boolean): if true, run backtest 
+                    exit_params (dict): parameters of exit returns
+
+            Returns:
+                    None
+    '''
+    getattr(object_stock, method)(**configuration)
+    signal_assess = analyser_object(object_stock.df,object_stock.stock_code,show_plot = plot, feature_name = feature_name, test_size = test_data_size)
+    signal_assess.signal_analyser(days_list = days_list)
+    signal_assess.create_backtest_signal(backtest, open_in_list = ['down','up'], **exit_params )

{virgo_modules-0.1.0 → virgo_modules-0.1.2}/virgo_app/virgo_modules/src/ticketer_source.py

@@ -2790,68 +2790,6 @@ class hmm_feature_selector():
         self.feature_results = feature_results
         self.best_features = pd.DataFrame(self.feature_results).T.sort_values('mean relevance').iloc[-1,:].features
 
-def execute_signal_analyser(test_data_size, feature_name, days_list, configuration, method, object_stock, signal_analyser_object, plot = False, backtest= False, exit_params = {}):
-    '''
-    code snippet that is going run some objects. The analysis is signal analyse which is backtesting
-
-            Parameters:
-                    test_data_size (int): test data size
-                    feature_name (str): name of the feature to assess
-                    days_list (list): tome scope to assess the returns
-                    configuration (dict): parameters of the method to run
-                    object_stock (obj): object with data to assess
-                    signal_analyser_object (obj): signal_analyser object
-                    plot (boolean): if true, plot results
-                    backtest (boolean): if true, run backtest 
-                    exit_params (dict): parameters of exit returns
-
-            Returns:
-                    mean_median_return (float): median return of the backtests
-    '''
-    method(**configuration)
-    signal_assess = signal_analyser_object(object_stock.df,object_stock.stock_code,show_plot = plot)
-    signal_assess.signal_analyser(test_size = test_data_size, feature_name = feature_name, days_list = days_list, threshold = 1)
-
-    if backtest:
-        print('-----------------------back test ---------------------------')
-        signal_assess.create_backtest_signal(backtest, test_data_size, feature_name, **exit_params )
-
-    return signal_assess.mean_median_return
-
-def iterate_signal_analyser(test_data_size,feature_name, days_list, arguments_to_test, method, object_stock, signal_analyser_object, plot = True):
-    '''
-    code snippet is going to iterate signal analyser
-
-            Parameters:
-                    test_data_size (int): test data size
-                    feature_name (str): name of the feature to assess
-                    days_list (list): tome scope to assess the returns
-                    arguments_to_test: parameters to test
-                    method: methods to run
-                    object_stock (obj): object with data to assess
-                    signal_analyser_object (obj): signal_analyser object
-                    plot (boolean): if true, plot results
-
-            Returns:
-                    best_result (int): index from the arguments_to_test with the best result
-    '''
-    results = list()
-    for key in arguments_to_test.keys():
-        configuration = arguments_to_test.get(key)
-        mean_median_return = execute_signal_analyser(test_data_size, feature_name, days_list, configuration, method, object_stock, signal_analyser_object)
-        results.append(mean_median_return)
-
-    df_result = pd.DataFrame({'keys':arguments_to_test.keys(),'results':results})
-    if plot:
-        plt.plot(df_result['keys'], df_result['results'])
-        plt.scatter(df_result['keys'], df_result['results'])
-        plt.title('simulation between configurations')
-        plt.ylabel('median expected return')
-        plt.show()
-
-    best_result = df_result.sort_values('results',ascending = False)['keys'].values[0]
-    return best_result
-
 class analyse_index(stock_eda_panel):
     """
     class that is going to train hmm models to perform feature selection
@@ -3118,389 +3056,3 @@ def get_relevant_beta(data_market, ticket_name,  show_plot = True, save_path = F
         # upload_file_to_aws(bucket = 'VIRGO_BUCKET', key = f'market_plots/{ticket_name}/'+result_plot_name,input_path = save_path+result_plot_name)
         upload_file_to_aws(bucket = 'VIRGO_BUCKET', key = save_aws + result_plot_name, input_path = save_path + result_plot_name, aws_credentials = aws_credentials)
     return selection
-
-#### to deprecate
-
-def sharpe_ratio(return_series):
-
-    '''
-    calculate sharpe ratio for given array.
-
-            Parameters:
-                    return_series (pd.series): pandas series of the asset returns
-
-            Returns:
-                    sharpe (float): sharpe ratio
-    '''
-
-    N = 255 # Trading days in the year (change to 365 for crypto)
-    rf = 0.005 # Half a percent risk free rare
-    mean = return_series.mean() * N -rf
-    sigma = return_series.std() * np.sqrt(N)
-    sharpe = round(mean / sigma, 3)
-    return sharpe
-
-class signal_analyser_object:
-    """
-    class that is going to analyse signals
-
-    Attributes
-    ----------
-    data  : pd.DataFrame
-        symbol of the asset
-    ticket_name :str
-        asset symbol
-    show_plot : boolean
-        if true show plot for every method
-    save_path : str
-        if true, save results in file
-    save_aws : str
-        if true, export results to remote repo
-    aws_credentials : dict
-        credentials for aws
-    return_fig : boolean
-        if true, methods will return objects
-    create_backtest_signal(days_strategy=list, test_size=int, feature_name=str, high_exit=float, low_exit=float):
-        perform backtest signal analysis
-        
-    Methods
-    -------
-    signal_analyser(test_size=int, feature_name=str, days_list=list, threshold=float,verbose=boolean, signal_position=boolean):
-        perform signal analysis and feature extraction
-
-    """
-
-    def __init__(self, data,symbol_name, show_plot = True, save_path = False, save_aws = False, aws_credentials = False, return_fig = False):
-        """
-        Initialize object
-
-        Parameters
-        ----------
-        data (pd.DataFrame): data
-        ticket_name (str): name of the asset
-        show_plot (boolean): if true show plot for every method
-        save_path (str): if true, save results in file e.g r'C:/path/to/the/file/'
-        save_aws (str): if true, export results to remote repo e.g. 'path/to/file/'
-        aws_credentials (dict): credentials for aws
-        return_fig (boolean): if true, methods will return objects
-
-        Returns
-        -------
-        None
-        """
-        self.data = data.copy()
-        self.ticket_name = symbol_name
-        self.show_plot = show_plot
-        self.save_path = save_path
-        self.save_aws = save_aws
-        self.aws_credentials = aws_credentials
-        self.return_fig = return_fig
-
-    def signal_analyser(self, test_size, feature_name, days_list, threshold = 0.05,verbose = False, signal_position = False):
-        """
-        perform signal analysis and feature extraction
-
-        Parameters
-        ----------
-        test_size (int): test data size
-        feature_name (str): name of the feature to assess
-        days_list (list): list of integers [3,8,10] to assess
-        threshold (float): alpha or z threshold
-        verbose (boolean): print metrics
-        signal_position (int): if true, the signal is taken at the given step after the signal end
-
-        Returns
-        -------
-        None
-        """
-        data = self.data
-        self.feature_name = feature_name
-        up_signal, low_signal= f'signal_up_{feature_name}', f'signal_low_{feature_name}'
-        features_base = ['Date', up_signal, low_signal, 'Close']
-
-        df = data[features_base].sort_values('Date').iloc[0:-test_size,:]
-        returns_list = list()
-
-        for days in days_list:
-
-            feature_ = f'return_{days}d'
-            days = days + signal_position if signal_position else days
-            df[feature_] = (df['Close'].shift(-days)/df['Close']-1)*100
-            returns_list.append(feature_)
-
-        df['signal_type'] = np.where(
-            df[up_signal] == 1,
-            'up',
-            np.where(
-                df[low_signal] == 1,
-                'down',
-                None
-            )
-        )
-        df = df[~df.signal_type.isna()]
-        df['lag_Date'] = df['Date'].shift(1)
-        df['lag_signal_type'] = df['signal_type'].shift(1)
-        df['span'] = (pd.to_datetime(df['Date']) - pd.to_datetime(df['lag_Date'])).dt.days - 1
-        df['break'] = np.where((df['span'] > 3) & (df['lag_signal_type'] == df['signal_type']), 1, 0)
-        df['break'] = np.where((df['lag_signal_type'] != df['signal_type']), 1, df['break'])
-
-        df['chain_id'] = df.sort_values(['Date']).groupby(['break']).cumcount() + 1
-        df['chain_id'] = np.where(df['break'] == 1, df['chain_id'], np.nan )
-        df['chain_id'] = df['chain_id'].fillna(method = 'ffill')
-
-        df['internal_rn'] = df.sort_values(['Date']).groupby(['chain_id']).cumcount() + 1
-        df['inv_internal_rn'] = df.sort_values(['Date'],ascending = False).groupby(['chain_id']).cumcount() + 1
-
-        df['first_in_chain'] = np.where(df['internal_rn'] == 1, True, False)
-        df['last_in_chain'] = np.where(df['inv_internal_rn'] == 1, True, False)
-
-        df = df.drop(columns = ['break','span','lag_Date','inv_internal_rn']).sort_values('Date')
-        self.df_signal = df
-
-        n_signals_up = len(list(df[df.signal_type == 'up'].chain_id.unique()))
-        n_signals_down = len(list(df[df.signal_type == 'down'].chain_id.unique()))
-        p_scores = list()
-        medians_down = list()
-        validations = list()
-
-        if signal_position:
-            df['open_long'] = np.where(df.last_in_chain == True, True, np.nan)
-            df['open_long'] = df['open_long'].shift(signal_position)
-        else:
-            df['open_long'] = np.where(df.last_in_chain == True, True, np.nan)
-            
-        # df_melt = df[df.last_in_chain == True].melt(id_vars=['signal_type'], value_vars=returns_list, var_name='time', value_name='value')
-        df_melt = df[df.open_long == True].melt(id_vars=['signal_type'], value_vars=returns_list, var_name='time', value_name='value')
-        df_melt = df_melt.dropna()
-
-        for evalx in returns_list:
-
-            sample1 = df_melt[(df_melt.time == evalx) & (df_melt.signal_type == 'up')].value.values
-            sample2 = df_melt[(df_melt.time == evalx) & (df_melt.signal_type == 'down')].value.values
-            pvalue = stats.ttest_ind(sample1, sample2).pvalue
-            median_down = np.median(sample2)
-            median_up = np.median(sample1)
-            validations.append(median_up < 0)
-            validations.append(median_down > 0)
-            p_scores.append(pvalue)
-            medians_down.append(median_down)
-        self.df_melt = df_melt
-        null_ho_eval = threshold > np.mean(p_scores)
-        mean_median_return = np.median(medians_down)  ## end metric
-        median_signal_type_eval = validations.count(validations[0]) == len(validations)
-
-        if verbose:
-            print('number of signal up:',n_signals_up)
-            print('number of signal down:',n_signals_down)
-            print('reject ho: ', null_ho_eval)
-            print('mean median:', mean_median_return)
-            print('all validations: ', median_signal_type_eval)
-
-        # if median_signal_type_eval == True and null_ho_eval == True:
-        if null_ho_eval == True:
-            if verbose:
-                print('success evals')
-            self.mean_median_return = mean_median_return
-        else:
-            self.mean_median_return = np.nan
-
-        df2 = df.copy()
-        df2 = df2[df2.open_long == True]
-
-
-        df2['lagdate'] = df2.Date.shift(1)
-        df2['span'] = (pd.to_datetime(df2['Date']) - pd.to_datetime(df2['lagdate'])).dt.days
-
-        fig, axs = plt.subplots(1, 3, figsize = (15,5))
-
-        sns.violinplot(data=df2, y="span",ax = axs[0], color = 'lightblue', linewidth=0.7,inner="quart")
-        sns.stripplot(data=df2, y="span",ax = axs[0], jitter=True, zorder=1)
-        axs[0].set_title('span between last signals')
-        del df2
-        sns.violinplot(data=df[df.last_in_chain == True], y="internal_rn",ax = axs[1], color = 'lightblue', linewidth=0.7,inner="quart")
-        sns.stripplot(data=df[df.last_in_chain == True], y="internal_rn",ax = axs[1], jitter=True, zorder=1)
-        axs[1].set_title('signal duration distribution')
-
-        palette ={"go down": "tomato", "go up": "lightblue"}
-        df_melt.signal_type = df_melt.signal_type.map({'up':'go down', 'down': 'go up'})
-        sns.violinplot(data=df_melt, x="time", y="value", hue="signal_type",ax = axs[2], split=True, gap=0.1, inner="quart",palette = palette, linewidth=0.8)
-        axs[2].axhline(y=0, color='grey', linestyle='--')
-        axs[2].set_title('signal type expected returns distribution at different time lapses')
-
-        if self.show_plot:
-            plt.show()
-
-        if self.save_path:
-            result_plot_name = f'signals_strategy_distribution_{feature_name}.png'
-            fig.savefig(self.save_path+result_plot_name)
-            # pickle.dump(axs, open(self.save_path+result_plot_name, 'wb'))
-
-        if self.save_path and self.save_aws:
-            # upload_file_to_aws(bucket = 'VIRGO_BUCKET', key = f'market_plots/{self.ticket_name}/'+result_plot_name, input_path = self.save_path+result_plot_name)
-            upload_file_to_aws(bucket = 'VIRGO_BUCKET', key = self.save_aws + result_plot_name, input_path = self.save_path + result_plot_name, aws_credentials = self.aws_credentials)
-        if not self.show_plot:
-            plt.close()
-
-        del df
-
-        if self.return_fig:
-            return fig
-
-    def create_backtest_signal(self,days_strategy, test_size, feature_name, high_exit = False, low_exit = False, signal_position = False):
-        """
-        perform backtest signal analysis
-
-        Parameters
-        ----------
-        days_strategy (list): list of days to assess returns
-        test_size (str): test data size
-        feature_name (str): name of the feature to assess
-        high_exit (float): high exit thrshold return in backtest
-        low_exit (float): loss exit thrshold return in backtest
-        signal_position (int): if true, the signal is taken at the given step after the signal end
-        
-        Returns
-        -------
-        fig (obj): plots
-        messages (dict): dictionary with key metrics
-        """
-        asset_1 = 'Close'
-        up_signal, low_signal= f'signal_up_{feature_name}', f'signal_low_{feature_name}'
-        df1 = self.data.iloc[-test_size:,:].copy()
-        df2 = df1.copy()
-        df2['signal_type'] = np.where(
-                    df2[up_signal] == 1,
-                    'up',
-                    np.where(
-                        df2[low_signal] == 1,
-                        'down',
-                        None
-                    )
-                )
-        df2 = df2[~df2.signal_type.isna()]
-        df2['lag_Date'] = df2['Date'].shift(1)
-        df2['lag_signal_type'] = df2['signal_type'].shift(1)
-        df2['span'] = (pd.to_datetime(df2['Date']) - pd.to_datetime(df2['lag_Date'])).dt.days - 1
-        df2['break'] = np.where((df2['span'] > 3) & (df2['lag_signal_type'] == df2['signal_type']), 1, 0)
-        df2['break'] = np.where((df2['lag_signal_type'] != df2['signal_type']), 1, df2['break'])
-
-        df2['chain_id'] = df2.sort_values(['Date']).groupby(['break']).cumcount() + 1
-        df2['chain_id'] = np.where(df2['break'] == 1, df2['chain_id'], np.nan )
-        df2['chain_id'] = df2['chain_id'].fillna(method = 'ffill')
-
-        df2['internal_rn'] = df2.sort_values(['Date']).groupby(['chain_id']).cumcount() + 1
-        df2['inv_internal_rn'] = df2.sort_values(['Date'],ascending = False).groupby(['chain_id']).cumcount() + 1
-
-        df2['first_in_chain'] = np.where(df2['internal_rn'] == 1, True, False)
-        df2['last_in_chain'] = np.where(df2['inv_internal_rn'] == 1, True, False)
-
-        df2 = df2.drop(columns = ['break','span','lag_Date','inv_internal_rn']).sort_values('Date')
-
-        df2 = df2[(df2.last_in_chain == True) & (df2.signal_type == 'down')][['last_in_chain']]
-        dft = df1.merge(df2,how = 'left',left_index=True, right_index=True )
-
-        dft['chain_id'] = dft.sort_values(['Date']).groupby(['last_in_chain']).cumcount() + 1
-        dft['chain_id'] = np.where(dft['last_in_chain'] == True, dft['chain_id'], np.nan )
-        dft['chain_id'] = dft['chain_id'].fillna(method = 'ffill')
-
-        dft['internal_rn'] = dft.sort_values(['Date']).groupby(['chain_id']).cumcount() + 1
-        
-        dft['lrets_bench'] = np.log(dft[asset_1]/dft[asset_1].shift(1))
-        dft['bench_prod'] = dft['lrets_bench'].cumsum()
-        dft['bench_prod_exp'] = np.exp(dft['bench_prod']) - 1
-
-        if signal_position:
-            dft['open_long'] = np.where(dft.last_in_chain == True, True, np.nan)
-            dft['open_long'] = dft.groupby(['chain_id'])['open_long'].shift(signal_position)
-            dft['flag'] = np.where(dft['internal_rn'] < days_strategy + signal_position, 1,0)
-            dft['flag'] = dft.groupby(['chain_id'])['flag'].shift(signal_position)
-        else:
-            dft['open_long'] = np.where(dft.last_in_chain == True, True, np.nan)
-            dft['flag'] = np.where(dft['internal_rn'] < days_strategy, 1,0)
-            
-        if high_exit and low_exit:
-            dft['open_strat'] = np.where(dft.open_long == True, dft.Open, np.nan)
-            dft['open_strat'] = dft['open_strat'].fillna(method = 'ffill')
-            dft['open_strat'] = np.where(dft.flag == 1, dft.open_strat, np.nan)
-            dft['high_strat_ret'] = (dft['High']/dft['open_strat']-1)*100
-            dft['low_strat_ret'] = (dft['Low']/dft['open_strat']-1)*100
-            dft['max_step_chain'] = dft.groupby(['chain_id'])['internal_rn'].transform('max')
-            dft['high_exit'] =  np.where(((dft['high_strat_ret'] >= high_exit) | (dft['internal_rn'] == days_strategy) | (dft['max_step_chain'] == dft['internal_rn'])), 1, np.nan)
-            dft['low_exit'] =  np.where((dft['low_strat_ret'] <= low_exit), -1, np.nan)
-
-            dft["exit_type"] = dft[["high_exit", "low_exit"]].max(axis=1)
-            dft['exit_type'] = np.where(dft["exit_type"] == 1, 1, np.where(dft["exit_type"] == -1,-1,np.nan))
-            dft['exit'] = np.where(dft['exit_type'].isnull(), np.nan, 1)
-            dft['exit_order'] = dft.sort_values(['Date']).groupby(['chain_id','exit']).cumcount() + 1
-            dft['exit'] = np.where(dft['exit_order'] == 1, True, np.nan)
-            dft = dft.drop(columns = ['exit_order'])
-            ## if last signal is near
-            max_id = dft.chain_id.max()
-            dft['max_internal_rn'] = dft.sort_values(['Date']).groupby(['chain_id']).internal_rn.transform('max')
-            dft['exit'] = np.where((dft.chain_id == max_id) & (dft.max_internal_rn < days_strategy) & (dft.max_internal_rn == dft.internal_rn), 1, dft['exit'])
-
-            dft['exit_step'] = np.where(dft.exit == 1, dft.internal_rn, np.nan)
-            dft['exit_step'] = dft.sort_values(['Date']).groupby(['chain_id']).exit_step.transform('max')
-
-            if signal_position:
-                dft['flag'] = np.where( (dft.internal_rn >= signal_position + 1) & (dft.internal_rn <= dft.exit_step) , 1,0)
-            else:
-                dft['flag'] = np.where(dft.internal_rn <= dft.exit_step, 1, 0)
-
-        dft['lrets_strat'] = np.log(dft[asset_1].shift(-1)/dft[asset_1]) * dft['flag']
-        dft['lrets_strat'] = np.where(dft['lrets_strat'].isna(),-0.0,dft['lrets_strat'])
-        dft['lrets_prod'] = dft['lrets_strat'].cumsum()
-        dft['strat_prod_exp'] = np.exp(dft['lrets_prod']) - 1
-
-        bench_rets = round(dft['bench_prod_exp'].values[-1]*100,1)
-        strat_rets = round(dft['strat_prod_exp'].values[-1]*100,1)
-
-        bench_sr = round(sharpe_ratio(dft.bench_prod_exp.dropna()),1)
-        strat_sr = round(sharpe_ratio(dft.strat_prod_exp.dropna()),1)
-
-        message1 = f'{bench_rets}%'
-        message2 = f'{strat_rets}%'
-
-        messages = {
-            'benchmark return:':message1,
-            'benchmark sharpe ratio:': bench_sr,
-            'strategy return:':message2,
-            'strategy sharpe ratio:': strat_sr,
-        }
-        if self.show_plot:
-            print('----------------------------')
-            print(messages)
-            print('----------------------------')
-
-        fig = plt.figure(1)
-        plt.plot(dft.bench_prod_exp.values, label = 'benchmark', color = 'steelblue')
-        plt.scatter(range(len(dft)),np.where(dft[low_signal] == 1,dft.bench_prod_exp.values,np.nan),color = 'red', label = 'signal')
-        plt.plot(dft.strat_prod_exp.values, label = 'strategy', color = 'darksalmon')
-        plt.xlabel("index")
-        plt.ylabel("comulative return")
-        plt.legend()
-        plt.title('strategy and cumulative returns based on signal strategy')
-        if self.show_plot:
-            plt.plot()
-
-        if self.save_path:
-            result_json_name = f'signals_strategy_return_{feature_name}.json'
-            result_plot_name = f'signals_strategy_return_{feature_name}.png'
-
-            plt.savefig(self.save_path+result_plot_name)
-
-            with open(self.save_path+result_json_name, "w") as outfile:
-                json.dump(messages, outfile)
-
-        if self.save_path and self.save_aws:
-
-            upload_file_to_aws(bucket = 'VIRGO_BUCKET', key = self.save_aws + result_json_name, input_path = self.save_path + result_json_name, aws_credentials = self.aws_credentials)
-            upload_file_to_aws(bucket = 'VIRGO_BUCKET', key = self.save_aws + result_plot_name, input_path = self.save_path + result_plot_name, aws_credentials = self.aws_credentials)
-
-        if not self.show_plot:
-            plt.close()
-
-        del df1,df2,dft
-
-        if self.return_fig:
-            return fig, messages

{virgo_modules-0.1.0 → virgo_modules-0.1.2}/virgo_app/virgo_modules.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: virgo-modules
-Version: 0.1.0
+Version: 0.1.2
 Summary: data processing and statistical modeling using stock market data
 Home-page: https://github.com/miguelmayhem92/virgo_module
 Author: Miguel Mayhuire