virgo-modules 0.6.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

virgo_modules/src/edge_utils/edge_utils.py

@@ -11,7 +11,14 @@ from feature_engine.imputation import  MeanMedianImputer
 from feature_engine.discretisation import EqualWidthDiscretiser
 from feature_engine.datetime import DatetimeFeatures
 
-from ..transformer_utils import VirgoWinsorizerFeature, InverseHyperbolicSine, FeaturesEntropy, FeatureSelector, InteractionFeatures
+from ..transformer_utils import (
+    VirgoWinsorizerFeature,
+    InverseHyperbolicSine,
+    FeaturesEntropy,
+    FeatureSelector,
+    InteractionFeatures,
+    SplineMarketReturnJumpWaves
+)
 
 from plotly.subplots import make_subplots
 import plotly.graph_objects as go
@@ -223,6 +230,7 @@ def data_processing_pipeline_classifier(
         date_features_list = False,
         entropy_set_list = False,
         interaction_features_cont = False,
+        spline_regression_config = False,
         pipeline_order = 'selector//winzorizer//discretizer//median_inputer//drop//correlation'
         ):
 
@@ -254,7 +262,12 @@ def data_processing_pipeline_classifier(
     invhypersin_pipe = [('invhypervolsin scaler', InverseHyperbolicSine(features = invhypervolsin_features))] if invhypervolsin_features else []
     datetimeFeatures_pipe = [('date features', DatetimeFeatures(features_to_extract = date_features_list, variables = 'Date', drop_original = False))] if date_features_list else []
     interaction_features = [("interaction features", InteractionFeatures(interaction_features_cont[0], interaction_features_cont[1]))] if interaction_features_cont else []
-    
+    spline_features = [("spline features", SplineMarketReturnJumpWaves(
+        return_feature_names=spline_regression_config.get("return_feature_names"),
+        target_variables=spline_regression_config.get("target_variables"),
+        feature_label=spline_regression_config.get("feature_label"),
+    ))] if spline_regression_config else []
+
     entropy_pipe = list()
     if entropy_set_list:
         for setx_ in entropy_set_list:
@@ -274,6 +287,7 @@ def data_processing_pipeline_classifier(
         'date_features': datetimeFeatures_pipe,
         'interaction_features': interaction_features,
         'entropy_features' : entropy_pipe,
+        "spline_features": spline_features,
     }
 
     pipeline_steps = pipeline_order.split('//')

virgo_modules/src/edge_utils/feature_selection.py

@@ -0,0 +1,54 @@
+import random
+
+from numpy.random import choice
+import numpy as np
+from scipy import stats
+from sklearn.feature_selection import RFE
+
+class StackRFE:
+    def __init__(self, model, n_features, batch_elim, step_elim, cv, max_iterations):
+        self.model = model
+        self.n_features = n_features
+        self.batch_elim = batch_elim
+        self.step_elim = step_elim
+        self.cv = cv
+        self.max_iterations = max_iterations
+
+    def _suggest_elimination(self, uniform=False):
+        """
+        suggest based on mean ranking, lower the mean rank higher the prob to be selected
+        """
+        ds = self.feature_rankings
+        ds_mean = {k:np.mean(ds.get(k)) for k in ds}
+        max_ = np.max([x for x in ds_mean.values()])
+        ds_weight = {k: (max_-v+1) for k,v in ds_mean.items()}
+        sum_ = np.sum([x for x in ds_weight.values()])
+        ds_prob = {k: v/sum_ for k,v in ds_weight.items()}
+        result = list(choice(list(ds_prob.keys()), self.batch_elim,p=list(ds_prob.values()), replace=False))
+        if uniform:
+            features = list(ds_prob.keys())
+            random.shuffle(features)            
+            result = features[0:self.batch_elim]
+        return result
+        
+    def fit(self, X, y):
+        features = list(X.columns).copy()
+        self.feature_rankings = {f:[1] for f in features}
+        for iteration in range(self.max_iterations):
+            # shuffling
+            if random.random() > 0.5:
+                batch_features = self._suggest_elimination()
+            else:
+                batch_features = self._suggest_elimination()
+            # selector and elimination
+            tmp_feature_ranking = {k: list() for k in batch_features}
+            selector = RFE(self.model, n_features_to_select=self.n_features, step=self.step_elim)
+            for train_index, test_index in self.cv.split(X, y):
+                X_ = X[X.index.get_level_values('i').isin(train_index)][batch_features]
+                y_ = y[y.index.get_level_values('i').isin(train_index)]
+                selector = selector.fit(X_, y_)
+                for k,r in zip(tmp_feature_ranking.keys(), selector.ranking_):
+                    tmp_feature_ranking[k].append(r)
+            rankings = [stats.mode(v).mode for v in tmp_feature_ranking.values()]
+            for f,r in zip(batch_features, rankings):
+                self.feature_rankings[f].append(r)

virgo_modules/src/market/market_tools.py

@@ -0,0 +1,189 @@
+import gc
+
+import pandas as pd
+import numpy as np
+
+from sklearn.linear_model import HuberRegressor
+from scipy import stats
+
+import matplotlib.pyplot as plt
+import seaborn as sns; sns.set()
+
+from matplotlib import cm
+import matplotlib.colors as mcolors
+
+class MarketAnalysis:
+    """
+    Class that perform market analysis using robust linear regression
+
+    Attributes
+    ----------
+    data : pd.DataFrame
+        input data
+    market_features : list
+        list of market feature (log returns) to apply analysis
+    return_cols: str
+        main log return feature
+    col_map: dict
+        dictionary containing rename of market features
+
+    Methods
+    -------
+    compute_beta(data=pd.DataFrame, feature_x=str, feature_y=str):
+        compute betas given x and y using robust linear regression
+    get_correlation(data=pd.DataFrame, feature_x=str, feature_y=str):
+        compute correlation given x and y
+    produce_beta_report(data=pd.DataFrame):
+        produce beta report
+    compute_general_report(sample_size=int, offset=int, index=str, subsample_ts=int, show_plot=bool):
+        compute full report, global and latest window
+    """
+
+    def __init__(self, data, market_features, return_col, col_map=None):
+        self.data = data.dropna()
+        self.market_features = market_features
+        self.return_cols = return_col
+        self.col_map=col_map
+        
+    def compute_beta(self, data, feature_x, feature_y):
+        """
+        compute betas given x and y using robust linear regression
+
+        Parameters
+        ----------
+        data (pd.DataFrame): input data containing analysis features
+        feature_x (str): name of the feature x
+        feature_y (str): name of the feature y
+
+        Returns
+        -------
+        (beta(str), alpha(str))
+        """
+        x = data[feature_x].values.reshape(-1,1)
+        y = data[feature_y].values.reshape(-1,1)
+        huber_regr = HuberRegressor(fit_intercept = True)
+        huber_regr.fit(x, y)
+        beta, alpha = huber_regr.coef_[0], huber_regr.intercept_
+        return beta, alpha
+
+    def get_correlation(self, data, feature_x, feature_y):
+        """
+        compute correlation given x and y
+
+        Parameters
+        ----------
+        data (pd.DataFrame): input data containing analysis features
+        feature_x (str): name of the feature x
+        feature_y (str): name of the feature y
+
+        Returns
+        -------
+        r (float)
+        """
+        x = data[feature_x]
+        y = data[feature_y]
+        r = stats.mstats.pearsonr(x, y)[0]
+        return r
+
+    def produce_beta_report(self, data):
+        """
+        produce beta report
+
+        Parameters
+        ----------
+        data (pd.DataFrame): input data containing analysis features
+
+        Returns
+        -------
+        report (pd.DataFrame)
+        """
+        result = {
+            "market_index": list(),
+            "beta": list(),
+            "alpha": list(),
+            "r": list()
+        }
+        for index in self.market_features:
+            beta, alpha = self.compute_beta( data, self.return_cols, index)
+            r = self.get_correlation( data, self.return_cols, index)
+            result["market_index"].append(index)
+            result["beta"].append(beta)
+            result["alpha"].append(alpha)
+            result["r"].append(r)
+        pd_result = pd.DataFrame(result)
+        pd_result = pd_result.sort_values("r", ascending=False)
+        if self.col_map:
+            pd_result["map_market_index"] = pd_result.market_index.map(self.col_map)
+        return pd_result
+        
+    def compute_general_report(self, sample_size, offset, index=False, subsample_ts=False, show_plot=True):
+        """
+        compute full report, global and latest window
+
+        Parameters
+        ----------
+        sample_size (int): sample size for every beta computation
+        offset (int): offset or overlap between samples
+        index (str): if provided, bet fit index is taken
+        subsample_ts (int): subsample for iterative beta calculation
+        show_plot (bool): whether to show plot
+
+        Returns
+        -------
+        (report (pd.DataFrame), latest_report (pd.DataFrame), figure (mtpl.plt))
+        """
+        general_report = self.produce_beta_report(self.data)
+        current_report = self.produce_beta_report(self.data.iloc[sample_size:,:])
+        if not index:
+            index = general_report.head(1).market_index.values[0]
+        b = general_report[general_report.market_index == index].beta.values
+        a = general_report[general_report.market_index == index].alpha.values
+
+        figure, ax = plt.subplot_mosaic(
+            [["scatter_total", "scatter_sample",'ts','ts']],
+            layout="constrained",
+            figsize=(18, 5)
+        )
+        x = self.data[self.return_cols]
+        y = self.data[index]
+        ax['scatter_total'].scatter(x, y)
+        ax['scatter_total'].plot(x, b*x+a, color='red')
+
+        if subsample_ts:
+            merger_df = self.data.iloc[-subsample_ts:,:].copy()
+        else:
+            merger_df = self.data.copy()
+        ax['ts'].plot(merger_df.Date, merger_df.Close, color = 'grey', alpha = 0.3)
+        b_array = list()
+        for i in range(0,len(merger_df)-sample_size,offset):
+            merger_ = merger_df.sort_values('Date', ascending = False).iloc[i:i+sample_size,:]
+            b, a = self.compute_beta(merger_, self.return_cols, index)
+            x = merger_[self.return_cols]
+            y = merger_[index]
+            normalize_ = mcolors.Normalize(vmin=-2.0, vmax=2.0)
+            colormap_ = cm.jet
+            ax['scatter_sample'].plot(x, y,'o', color = 'blue', alpha = 0.1)
+            ax['scatter_sample'].plot(x, b*x+a, color=colormap_(normalize_(b)))
+            ax['scatter_sample'].set_xlim(-0.08, 0.08)
+            ax['scatter_sample'].set_ylim(-0.08, 0.08)
+            plot = ax['ts'].scatter(merger_.Date, merger_.Close, color=colormap_(normalize_(b)), s = 10)
+            b_array.append(b)
+        normalize_ = mcolors.Normalize(vmin=np.min(b_array), vmax=np.max(b_array))
+        colormap_ = cm.jet
+        x_global = self.data[self.return_cols]
+        scalarmappaple = cm.ScalarMappable(norm=normalize_, cmap=colormap_)
+        scalarmappaple.set_array(x_global)
+        if self.col_map:
+            map_index = self.col_map.get(index)
+            title = f'market analysis of {map_index}'
+        else:
+            title = f'market analysis'
+        plt.title(title)
+        plt.colorbar(scalarmappaple)
+        del merger_df
+        gc.collect()
+        if show_plot:
+            plt.show()
+        else:
+            plt.close() 
+        return general_report, current_report, figure

virgo_modules/src/re_utils.py

@@ -1421,6 +1421,12 @@ def extract_data_traintest(object_stock,features_to_search,configs, target_confi
                 last_signal_featlist = last_signal_featlist.split('//')
                 if feature_name in last_signal_featlist:
                     object_stock.compute_last_signal(feature_name, False)
+    market_interaction_features = configs.get('custom_transformations',{}).get('market_interaction_features', False)
+    if market_interaction_features:
+        for stage in market_interaction_features.keys():
+            method_to_use = market_interaction_features.get(stage).get("method")
+            arguments_to_use = market_interaction_features.get(stage).get("parameters")
+            getattr(object_stock, method_to_use)(**arguments_to_use)
     # geting targets
     object_stock.get_categorical_targets(**target_params_up)
     object_stock.df = object_stock.df.drop(columns = ['target_down']).rename(columns = {'target_up':'target_up_save'})

virgo_modules/src/ticketer_source.py

@@ -1,7 +1,7 @@
 import yfinance as yf
 import pandas as pd
 import numpy as np
-import json
+import gc
 
 import matplotlib.pyplot as plt
 import matplotlib.gridspec as gridspec
@@ -138,6 +138,10 @@ class stock_eda_panel(object):
         perform analysis of lags of the mean rolling log return
     compute_clip_bands(feature_name=str,threshold=float):
         compute outlier detection for a given signal, Note that this follows mean reversion procedure and feature has to be stationary. Also botton and roof resulting signals is attached to the dataframe
+    extract_sec_data(symbol=str, base_columns=list(str), rename_columns=dict):
+        extract new asset data and merge it to the main asset data
+    lag_log_return(lags=int, feature=str, feature_name=str):
+        compute log return given some lags
     signal_plotter(feature_name=str):
         display analysis plot of a feature with high and low signals
     log_features_standard(feature_name=str):
@@ -667,6 +671,63 @@ class stock_eda_panel(object):
         self.df[f'signal_low_{feature_name}'] = np.where( (self.df[f'norm_{feature_name}'] < self.df[f'lower_{feature_name}'] ), 1, 0)
         self.df[f'signal_up_{feature_name}'] = np.where( (self.df[f'norm_{feature_name}'] > self.df[f'upper_{feature_name}'] ), 1, 0)
 
+    def extract_sec_data(self, symbol, base_columns, rename_columns=None):
+        """
+        extract new asset data and merge it to the main asset data
+
+        Parameters
+        ----------
+        symbol (str): symbol to extract data
+        base_columns (list): list of columns to persist
+        rename_columns (dict): map of the new column names using pd.DataFrame.rename()
+
+        Returns
+        -------
+        None
+        """
+        begin_date = self.today - relativedelta(days = self.n_days)
+        begin_date_str = begin_date.strftime('%Y-%m-%d')
+        
+        stock = yf.Ticker(symbol)
+        df = stock.history(period=self.data_window)
+        df = df.sort_values('Date')
+        df.reset_index(inplace=True)
+        df['Date'] = pd.to_datetime(df['Date'], format='mixed',utc=True).dt.date
+        df['Date'] = pd.to_datetime(df['Date'])
+        df = df[df.Date >= begin_date_str ]
+        df = df[base_columns]
+        if rename_columns:
+            df = df.rename(columns=rename_columns)
+        right_df = df.copy()
+        
+        dates_vector = self.df.Date.to_frame()
+        right_df = dates_vector.merge(right_df, on ='Date',how = 'left')
+        right_df = right_df.fillna(method = 'bfill')
+        right_df = right_df.fillna(method = 'ffill')
+
+        self.df = self.df.merge(right_df, on ='Date',how = 'left')
+        self.df = self.df.sort_values("Date")
+        del right_df
+        gc.collect()
+
+    def lag_log_return(self, lags, feature, feature_name=False):
+        """
+        compute log return given some lags
+
+        Parameters
+        ----------
+        lags (int): lag to apply log return
+        feature (str): feature to apply log return
+        feature_name (str): rename resuling name
+
+        Returns
+        -------
+        None
+        """
+
+        feature_name = feature_name if feature_name else f"{feature}_log_return"
+        self.df[feature_name] = np.log(self.df[feature]/self.df[feature].shift(lags))
+
     def signal_plotter(self, feature_name):
 
         """
@@ -748,13 +809,11 @@ class stock_eda_panel(object):
             .transform(lambda x: x.rolling(ma2, min_periods=1).mean())
         )
 
-        print('--------------------------------------------------------------------')
         if save_features:
             self.log_features_standard(feature_name)
             self.settings_relative_spread_ma = {'ma1':ma1, 'ma2':ma2, 'threshold':threshold}
 
         if plot:
-
             self.signal_plotter(feature_name)
 
     def pair_feature(self, pair_symbol, plot = False):
@@ -810,6 +869,24 @@ class stock_eda_panel(object):
             plt.legend()
             plt.show()
 
+    def smooth_logrets_interaction_term(self, feature_interact_with, resulting_feature_name="persisted_clip_diff_smooths", rollmean_window = 5, ext_threhold=0.015, persist_days = 3, save_features=False):
+        """
+        create an interaction term that is going to compare the distance of asset wolling window mean and market rolling window mean.
+        then get the outliers or high values using abs and this value persist for some days
+        goal persist big differences of market and asset returns
+
+        feature_interact_with: name of the market return
+        rollmean_window: rolling window or smoothing number of days
+        ext_threhold: threshold
+        persist_days: number of days to persis the signal
+        """
+        self.df["smooth_log_return"] = self.df['log_return'].rolling(rollmean_window).mean().values
+        self.df["smooth_market_log_return"] = self.df[feature_interact_with].rolling(rollmean_window).mean().values
+        self.df["diff_smooths"] = self.df["smooth_market_log_return"]-self.df["smooth_log_return"]
+        self.df["clip_diff_smooths"] = np.where(np.abs(self.df["diff_smooths"]) > ext_threhold, self.df["diff_smooths"] , 0)
+        self.df[resulting_feature_name] = self.df['clip_diff_smooths'].rolling(persist_days).mean().values
+        self.df = self.df.drop(columns=["smooth_log_return","smooth_market_log_return","diff_smooths","clip_diff_smooths"])
+
     def calculate_cointegration(self,series_1, series_2):
         """
         calculate cointegration score for two time series
@@ -2304,33 +2381,3 @@ class analyse_index(stock_eda_panel):
     
         self.states_result = result
 
-def get_relevant_beta(data_market, ticket_name,  show_plot = True, save_path = False, save_aws = False, aws_credentials = False):
-    '''
-    select relevant beta result data of a given asset
-
-            Parameters:
-                    data_market (pd.DataFrame): dataframe of the market results 
-                    ticket_name (str): name of the asset
-                    show_plot (bool): If tru, plot results
-                    save_path (str): local path for saving e.g r'C:/path/to/the/file/'
-                    save_aws (str):  remote key in s3 bucket path e.g. 'path/to/file/'
-                    aws_credentials (dict): dict of the aws credentials
-
-            Returns:
-                    selection (pd.DataFrame): dataframe of the most relevant beta
-    '''
-    all_betas = data_market[data_market.asset == ticket_name].sort_values('general_r', ascending = False)
-    all_betas['gen_r2'] = all_betas.general_r ** 2
-    all_betas['sampl_r2'] = all_betas.sample_r ** 2
-    selection = all_betas.sort_values('gen_r2',ascending =False).head(2).sort_values('sampl_r2',ascending =False).head(1).drop(columns = ['gen_r2','sampl_r2'])
-
-    if show_plot:
-        print(selection)
-    if save_path:
-        result_plot_name = f'market_best_fit.csv'
-        selection.to_csv(save_path+result_plot_name)
-
-    if save_path and save_aws:
-        # 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

virgo_modules/src/transformer_utils.py

@@ -1,6 +1,11 @@
+import gc
+
 from sklearn.base import BaseEstimator, TransformerMixin
 import pandas as pd
 import numpy as np
+import statsmodels.api as sm
+from patsy import dmatrix
+import matplotlib.pyplot as plt
 
 class InverseHyperbolicSine(BaseEstimator, TransformerMixin):
 
@@ -289,3 +294,108 @@ class InteractionFeatures(BaseEstimator, TransformerMixin):
                 fn = 'iterm_'+f1.replace("norm_","")+"_"+f2.replace("norm_","")
                 X = self.simple_div_interaction(X, f1, f2, fn)
         return X
+    
+
+class SplineMarketReturnJumpWaves(BaseEstimator, TransformerMixin):
+    """
+    Class that gets a feature returns and performs countings so that a spline regression model can be fitted
+
+    Attributes
+    ----------
+    return_feature_names : list
+        list of the name of the features to apply spline regresion
+    target_variables : list
+        list of target features
+    feature_label : str
+        prefix for the new features.
+    sample_perc : float
+        sample size of the traninig data taking into consideration time
+
+    Methods
+    -------
+    fit(additional="", X=DataFrame, y=DataFrame):
+        fit transformation.
+    transform(X=DataFrame, y=None):
+        apply feature transformation
+    """
+
+    def __init__(self, return_feature_names, target_variables, feature_label,
+                  sample_perc=0.5,parts = 6, e_floor=-0.001,e_top=0.0001, d=3):
+        self.sample_perc = sample_perc
+        self.return_feature_names=return_feature_names
+        self.target_variables = target_variables
+        self.glms = dict()
+        self.feature_label = feature_label
+        self.parts = parts
+        self.e_floor = e_floor
+        self.e_top = e_top
+        self.d = d
+    def fit(self, X, y, plot = False):
+        #complete dataset with y
+        X_set=X.copy()
+        X_set[self.target_variables] = y
+        #sampling
+        if plot:
+            fig, ax = plt.subplots(len(self.return_feature_names),1)
+        for i,return_feature_name in enumerate(self.return_feature_names):
+            X_aggregated = (
+                X_set
+                .groupby("Date",as_index=False)
+                .agg(
+                    count_target_up = ("target_up","sum"),
+                    count_target_down = ("target_down","sum"),
+                    return_feature = (return_feature_name,"max"),
+                )
+                .sort_values("Date",ascending=True)
+                .dropna()
+                .copy()
+            )
+            del X
+            gc.collect()
+            nlines = X_aggregated.shape[0]
+            threshold = int(round((1-nlines*self.sample_perc),0))
+            train_ = X_aggregated.iloc[:threshold,:]
+            self.glms[return_feature_name] = dict()
+            for target in self.target_variables:
+                X = train_[["return_feature"]].round(4).values.reshape(-1, 1)
+                y = np.log(train_.dropna()[f"count_{target}"].values + 1)
+                knot_str = self._get_knot(X)
+                transformed_x = dmatrix(f"bs(train, knots=({knot_str}), degree=3, include_intercept=False)", {"train": X}, return_type='dataframe')
+                model = sm.GLM(y, transformed_x).fit()
+                self.glms[return_feature_name][target] = {
+                    "model":model,
+                }
+                if plot:
+                    x_transfomed = dmatrix(f"bs(valid, knots=({knot_str}), degree={self.d}, include_intercept=False)", {"valid":X}, return_type='dataframe')
+                    pred = model.predict(x_transfomed)
+                    ax[i].scatter(X, np.exp(y),s=2,alpha=0.2)
+                    ax[i].scatter(X, np.exp(pred), alpha=0.2, s=1)
+            #self.X_aggregated = X_aggregated
+        return self
+
+    def transform(self, X, y=None, plot =False):
+        if plot:
+            fig, ax = plt.subplots(len(self.return_feature_names),1)
+        for i, return_feature_name in enumerate(self.return_feature_names):
+            for target in self.target_variables:
+                model = self.glms[return_feature_name][target].get("model")
+                vect = X[return_feature_name]
+                knot_str = self._get_knot(vect)
+                X_transformed = dmatrix(f"bs(valid, knots=({knot_str}), degree={self.d}, include_intercept=False)",
+                    {"valid":vect.fillna(0)},
+                    return_type='dataframe')
+                X[f"{self.feature_label}_{return_feature_name}_{target}"] = model.predict(
+                    X_transformed
+                )
+                if plot:
+                    pred = model.predict(X_transformed)
+                    ax[i].scatter(X, np.exp(pred), alpha=0.2, s=1)
+        return X
+    
+    def _get_knot(self, input):
+        min_, max_ = np.min(input)-self.e_floor, np.max(input)+self.e_top
+        r = (max_ - min_)/self.parts
+        knot_tuple = [str(i*r+min_) for i,_ in enumerate(range(self.parts),start=0)]
+        knot_str = ",".join(knot_tuple)
+        knot_str = f"({knot_str})"
+        return knot_str

{virgo_modules-0.6.1.dist-info → virgo_modules-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: virgo-modules
-Version: 0.6.1
+Metadata-Version: 2.4
+Name: virgo_modules
+Version: 0.8.0
 Summary: data processing and statistical modeling using stock market data
 Home-page: https://github.com/miguelmayhem92/virgo_module
 Author: Miguel Mayhuire
@@ -13,7 +13,18 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
-Requires-Dist: pytest >=7.0 ; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-python
+Dynamic: summary
 
 # Virgo Package
 

virgo_modules-0.8.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+virgo_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+virgo_modules/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+virgo_modules/src/aws_utils.py,sha256=q0l7D7ofo09Lu1QQjv-esheQ06uiSy1Pdq3xMul8zvk,2571
+virgo_modules/src/backtester.py,sha256=OhiWyzDX0PthXGuhChyWUmDN3cLkzVYe95zS4nGtia8,22106
+virgo_modules/src/hmm_utils.py,sha256=D7axAnCdSe1_1EgRyli2PAnM2f6699hTY9GcxjPXG-o,21221
+virgo_modules/src/pull_artifacts.py,sha256=5OPrgR7pcMSdpbevDRhf0ebk7g7ZRjff4NpTIIWAKjE,1989
+virgo_modules/src/re_utils.py,sha256=GZCkAfgw2tVJRJ_Gw5Yewc14ebiE9wSImPiYQN8FsW0,75095
+virgo_modules/src/ticketer_source.py,sha256=528WhGoANOm4IKnxGSWsbQxxUh3-qlZfvGRNAafMMcE,103883
+virgo_modules/src/transformer_utils.py,sha256=SnYdtsFPnSF6u4UFIat0-X3-qVuUWvv_T46kiB-H0Sk,13682
+virgo_modules/src/edge_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+virgo_modules/src/edge_utils/conformal_utils.py,sha256=cKm4KSM261Eu1FJn4oowKYiKIesW81VbqITIvopGSVk,5410
+virgo_modules/src/edge_utils/edge_utils.py,sha256=4uXVWthzJDzkJ4Uq19ZYL9aPcA6CDUS3xYD4FY-a2AM,20018
+virgo_modules/src/edge_utils/feature_selection.py,sha256=HYbQ0JLPDiRYhn-5-C438YEKbuNduDmuvboFC_VkHww,2453
+virgo_modules/src/edge_utils/shap_utils.py,sha256=FgcHkfddvdFSeUqEubYa2ExRGVAWSthqK4b-eKagEmo,2333
+virgo_modules/src/edge_utils/stack_model.py,sha256=QqE91uLo2KauGEj91AVNANB1xE7J4Fa49YOX7k5mFng,4257
+virgo_modules/src/market/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+virgo_modules/src/market/market_tools.py,sha256=vBt66_7E3ANz7avzfeNw_RHMGvG9lh5PRhxmcf_Oyjc,6880
+virgo_modules-0.8.0.dist-info/licenses/LICENSE,sha256=pNgFyCYgmimaw0o6V20JupZLROycAnOA_HDDh1tX2V4,1097
+virgo_modules-0.8.0.dist-info/METADATA,sha256=sCkdOmbxrEEXvGUIwh6vIl_vIcue5C0BbvRtvP9yows,1122
+virgo_modules-0.8.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+virgo_modules-0.8.0.dist-info/top_level.txt,sha256=ZjI-qEkDtT-8mFwGAWnXfqPOKEGlIhWRW1es1VyXc60,14
+virgo_modules-0.8.0.dist-info/RECORD,,

{virgo_modules-0.6.1.dist-info → virgo_modules-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

virgo_modules-0.6.1.dist-info/RECORD

@@ -1,19 +0,0 @@
-virgo_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-virgo_modules/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-virgo_modules/src/aws_utils.py,sha256=q0l7D7ofo09Lu1QQjv-esheQ06uiSy1Pdq3xMul8zvk,2571
-virgo_modules/src/backtester.py,sha256=OhiWyzDX0PthXGuhChyWUmDN3cLkzVYe95zS4nGtia8,22106
-virgo_modules/src/hmm_utils.py,sha256=D7axAnCdSe1_1EgRyli2PAnM2f6699hTY9GcxjPXG-o,21221
-virgo_modules/src/pull_artifacts.py,sha256=5OPrgR7pcMSdpbevDRhf0ebk7g7ZRjff4NpTIIWAKjE,1989
-virgo_modules/src/re_utils.py,sha256=DBY_VBB1wKm5D7znutpF_66CTLZhJfx54h8Ws0YzdN4,74641
-virgo_modules/src/ticketer_source.py,sha256=jxP-OOeoyN2JxRQg-mX6t6WNJXiIrhWKDywDxpYANxU,101977
-virgo_modules/src/transformer_utils.py,sha256=ysCUp3cB3_7Jr9OHDqhg2_6Vu0k1YVjfqbvQNbxpbhI,8990
-virgo_modules/src/edge_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-virgo_modules/src/edge_utils/conformal_utils.py,sha256=cKm4KSM261Eu1FJn4oowKYiKIesW81VbqITIvopGSVk,5410
-virgo_modules/src/edge_utils/edge_utils.py,sha256=7nYPLDNyKqeKIuOOwQi4wsBibzs9gP1HgYMISXJX1Y8,19522
-virgo_modules/src/edge_utils/shap_utils.py,sha256=FgcHkfddvdFSeUqEubYa2ExRGVAWSthqK4b-eKagEmo,2333
-virgo_modules/src/edge_utils/stack_model.py,sha256=QqE91uLo2KauGEj91AVNANB1xE7J4Fa49YOX7k5mFng,4257
-virgo_modules-0.6.1.dist-info/LICENSE,sha256=pNgFyCYgmimaw0o6V20JupZLROycAnOA_HDDh1tX2V4,1097
-virgo_modules-0.6.1.dist-info/METADATA,sha256=9EtSQrm2xy6-S4wGgWwWbL5V7yz-8BV6TlK3G18LyoM,876
-virgo_modules-0.6.1.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-virgo_modules-0.6.1.dist-info/top_level.txt,sha256=ZjI-qEkDtT-8mFwGAWnXfqPOKEGlIhWRW1es1VyXc60,14
-virgo_modules-0.6.1.dist-info/RECORD,,