virgo-modules 0.0.72__py3-none-any.whl → 0.9.0__py3-none-any.whl

virgo_modules/src/transformer_utils.py

@@ -0,0 +1,401 @@
+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):
+
+    """
+    Class that applies inverse hyperbolic sine for feature transformation.
+    this class is compatible with scikitlearn pipeline
+
+    Attributes
+    ----------
+    features : list
+        list of features to apply the transformation
+    prefix : str
+        prefix for the new features. is '' the features are overwrite
+
+    Methods
+    -------
+    fit(additional="", X=DataFrame, y=None):
+        fit transformation.
+    transform(X=DataFrame, y=None):
+        apply feature transformation
+    """
+
+    def __init__(self, features, prefix = ''):
+        self.features = features
+        self.prefix = prefix
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X, y=None):
+        for feature in self.features:
+            X[f'{self.prefix}{feature}'] = np.arcsinh(X[feature])
+        return X
+
+class VirgoWinsorizerFeature(BaseEstimator, TransformerMixin):
+
+    """
+    Class that applies winsorirization of a feature for feature transformation.
+    this class is compatible with scikitlearn pipeline
+
+    Attributes
+    ----------
+    feature_configs : dict
+        dictionary of features and configurations. the configuration has high and low limits per feature
+
+    Methods
+    -------
+    fit(additional="", X=DataFrame, y=None):
+        fit transformation.
+    transform(X=DataFrame, y=None):
+        apply feature transformation
+    """
+
+    def __init__(self, feature_configs):
+        self.feature_configs = feature_configs
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X, y=None):
+        for feature in self.feature_configs:
+            lower = self.feature_configs[feature]['min']
+            upper = self.feature_configs[feature]['max']
+            X[feature] = np.where( lower > X[feature], lower, X[feature])
+            X[feature] = np.where( upper < X[feature], upper, X[feature])
+        return X
+
+class FeatureSelector(BaseEstimator, TransformerMixin):
+
+    """
+    Class that applies selection of features.
+    this class is compatible with scikitlearn pipeline
+
+    Attributes
+    ----------
+    columns : list
+        list of features to select
+
+    Methods
+    -------
+    fit(additional="", X=DataFrame, y=None):
+        fit transformation.
+    transform(X=DataFrame, y=None):
+        apply feature transformation
+    """
+
+    def __init__(self, columns):
+        self.columns = columns
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X, y=None):
+        return X[self.columns]
+
+class FeaturesEntropy(BaseEstimator, TransformerMixin):
+    """
+    Class that creates a feature that calculate entropy for a given feature classes, but it might get some leackeage in the training set.
+    this class is compatible with scikitlearn pipeline
+
+    Attributes
+    ----------
+    columns : list
+        list of features to select
+    entropy_map: pd.DataFrame
+        dataframe of the map with the entropies per class
+    perc: float
+        percentage of the dates using for calculate the entropy map
+    
+    Methods
+    -------
+    fit(additional="", X=DataFrame, y=None):
+        fit transformation.
+    transform(X=DataFrame, y=None):
+        apply feature transformation
+    """
+    
+    def __init__(self, features, target, feature_name = None, feature_type = 'discrete', perc = 0.5, default_null = 0.99):
+        
+        self.features = features
+        self.feature_type = feature_type
+        self.target = target
+        self.perc = perc
+        self.default_null = default_null
+        
+        if not feature_name:
+            self.feature_name = '_'.join(features)
+            self.feature_name = self.feature_name + '_' + target + '_' + feature_type
+        else:
+            self.feature_name = feature_name
+            
+    def fit(self, X, y=None):
+
+        unique_dates = list(X['Date'].unique())
+        unique_dates.sort()
+        
+        total_length = len(unique_dates)
+        cut = int(round(total_length*self.perc,0))
+        train_dates = unique_dates[:cut]
+        max_train_date = max(train_dates)
+        
+        X_ = X[X['Date'] <= max_train_date].copy()
+        df = X_.join(y, how = 'left')
+
+        column_list = [f'{self.feature_type}_signal_{colx}' for colx in self.features]
+        
+        df_aggr = (
+            df
+            .groupby(column_list, as_index = False)
+            .apply(
+                lambda x: pd.Series(
+                    dict(
+                        counts = x[self.target].count(),
+                        trues=(x[self.target] == 1).sum(),
+                        falses=(x[self.target] == 0).sum(),
+                    )
+                )
+            )
+            .assign(
+                trues_rate=lambda x: x['trues'] / x['counts']
+            )
+            .assign(
+                falses_rate=lambda x: x['falses'] / x['counts']
+            )
+            .assign(
+                log2_trues = lambda x: np.log2(1/x['trues_rate'])
+            )
+            .assign(
+                log2_falses = lambda x: np.log2(1/x['falses_rate'])
+            )
+            .assign(
+                comp1 = lambda x: x['trues_rate']*x['log2_trues']
+            )
+            .assign(
+                comp2 = lambda x: x['falses_rate']*x['log2_falses']
+            )
+            .assign(
+                class_entropy = lambda x: np.round(x['comp1']+x['comp2'],3)
+            )
+        )
+        
+        self.column_list = column_list
+        self.entropy_map = (
+            df_aggr
+            [column_list+['class_entropy']]
+            .rename(columns = {'class_entropy': self.feature_name})
+            .copy()
+        )
+        
+        del df, df_aggr, X_
+        return self
+
+    def transform(self, X, y=None):
+
+        X = X.join(self.entropy_map.set_index(self.column_list), on=self.column_list, how = 'left')
+        X[self.feature_name] = X[self.feature_name].fillna(self.default_null)
+        return X
+
+class signal_combiner(BaseEstimator, TransformerMixin):
+
+    """
+    Class that applies feature combination of binary signals.
+    this class is compatible with scikitlearn pipeline
+
+    ...
+
+    Attributes
+    ----------
+    columns : list
+        list of features to select
+    drop : boolean
+        drop combining features
+    prefix_up : str
+        up prefix of the base feature
+    prefix_low : str
+        low prefix of the base feature
+
+    Methods
+    -------
+    fit(additional="", X=DataFrame, y=None):
+        fit transformation.
+    transform(X=DataFrame, y=None):
+        apply feature transformation
+    """
+
+    def __init__(self, columns, drop = True, prefix_up = 'signal_up_', prefix_low = 'signal_low_'):
+        self.columns = columns
+        self.drop = drop
+        self.prefix_up = prefix_up
+        self.prefix_low = prefix_low
+
+    def fit(self, X, y=None):
+        return self
+
+    def transform(self, X, y=None):
+        for column in self.columns:
+            X['CombSignal_'+column] = np.where(
+                X[self.prefix_up + column] == 1,
+                1,
+                np.where(
+                    X[self.prefix_low + column] == 1,
+                    1,
+                    0
+                )
+            )
+            if self.drop:
+                X = X.drop(columns = [self.prefix_up + column, self.prefix_low + column])
+        return X
+    
+class InteractionFeatures(BaseEstimator, TransformerMixin):
+
+    """
+    Class that applies feature interaction.
+    this class is compatible with scikitlearn pipeline
+
+    Attributes
+    ----------
+    feature_list1 : list
+        list of features to combine
+    feature_list2 : list
+        list of features to combine
+
+    Methods
+    -------
+    fit(additional="", X=DataFrame, y=None):
+        fit transformation.
+    transform(X=DataFrame, y=None):
+        apply feature transformation
+    """
+
+    def __init__(self, feature_list1, feature_list2):
+        self.feature_list1 = feature_list1
+        self.feature_list2 = feature_list2
+
+    def fit(self, X, y=None):
+        return self
+    
+    def simple_div_interaction(self, data, feature1, feature2, feature_name):
+        data[feature_name] = data[feature1]*data[feature2]
+        data[feature_name] = data[feature_name].replace([np.inf, -np.inf], 0)
+        data[feature_name] = data[feature_name].fillna(0)
+        return data
+
+    def transform(self, X, y=None):
+        for f1 in self.feature_list1:
+            for f2 in self.feature_list2:
+                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.0.72.dist-info → virgo_modules-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
-Name: virgo-modules
-Version: 0.0.72
+Metadata-Version: 2.4
+Name: virgo_modules
+Version: 0.9.0
 Summary: data processing and statistical modeling using stock market data
 Home-page: https://github.com/miguelmayhem92/virgo_module
 Author: Miguel Mayhuire
@@ -9,28 +9,22 @@ License: MIT
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9, <3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: feature-engine ==1.6.1
-Requires-Dist: matplotlib ==3.6.3
-Requires-Dist: mlflow ==2.1.1
-Requires-Dist: numpy ==1.23.5
-Requires-Dist: optuna ==3.1.0
-Requires-Dist: pandas ==1.5.3
-Requires-Dist: plotly ==5.15.0
-Requires-Dist: rsa ==4.9
-Requires-Dist: scikit-learn ==1.2.1
-Requires-Dist: scipy ==1.10.0
-Requires-Dist: seaborn ==0.12.2
-Requires-Dist: starlette ==0.22.0
-Requires-Dist: statsmodels ==0.13.5
-Requires-Dist: ta ==0.10.2
-Requires-Dist: yfinance ==0.2.9
-Requires-Dist: hmmlearn ==0.3.0
-Requires-Dist: boto3
 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.9.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+virgo_modules/__init__.py,sha256=7NrzGOSBvO9S73thMlxEh5aNYKS5SYKLgTxC1YIIPRk,21
+virgo_modules/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+virgo_modules/src/aws_utils.py,sha256=QCyxJwZ6bNCkMpuuxzxkNxejj-hJf4kj2arb1SQPNug,2582
+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=AQlhyO0cvU-G42dolhedz5E-sniRzeFhf40RD5QVYpo,75506
+virgo_modules/src/ticketer_source.py,sha256=nGjQdZRDWto8cGKhMQCyAqYwvqYy1m6djkCpffiX3Dk,107747
+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=FuqEyvVYPhMy39uhxqD6bIVSMVcT-P3Pzuim0FS8u7A,20324
+virgo_modules/src/edge_utils/feature_selection.py,sha256=VSjGsC9bivuRuGDZiykX1_LIM0C0q2el3HEmujWZ4qs,3097
+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/src/markowitz/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+virgo_modules/src/markowitz/markowitz_utils.py,sha256=2bsnk_QlfWB5QytSNZ5n8elto9hhsEiukcEJBqWEYX4,1970
+virgo_modules-0.9.0.dist-info/licenses/LICENSE,sha256=pNgFyCYgmimaw0o6V20JupZLROycAnOA_HDDh1tX2V4,1097
+virgo_modules-0.9.0.dist-info/METADATA,sha256=z7zb755kS0k15I2FddBWXbFzrTaSmEqUiPvxvtEEzIM,1122
+virgo_modules-0.9.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+virgo_modules-0.9.0.dist-info/top_level.txt,sha256=ZjI-qEkDtT-8mFwGAWnXfqPOKEGlIhWRW1es1VyXc60,14
+virgo_modules-0.9.0.dist-info/RECORD,,

{virgo_modules-0.0.72.dist-info → virgo_modules-0.9.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/src/edge_utils.py

@@ -1,178 +0,0 @@
-import numpy as np
-import itertools
-
-from sklearn.metrics import roc_auc_score, precision_score, recall_score
-from sklearn.pipeline import Pipeline
-
-from feature_engine.selection import DropFeatures, DropCorrelatedFeatures
-from feature_engine.imputation import  MeanMedianImputer
-from virgo_modules.src.ticketer_source import FeatureSelector
-from feature_engine.discretisation import EqualWidthDiscretiser
-
-from .ticketer_source import VirgoWinsorizerFeature, InverseHyperbolicSine
-
-class produce_model_wrapper:
-    def __init__(self,data):
-        self.data = data.copy()
-    
-    def preprocess(self, validation_size, target):
-        
-        val_date = self.data.groupby('Date', as_index = False).agg(target_down = (target[0],'count')).sort_values('Date').iloc[-validation_size:,].head(1)['Date'].values[0]
-        
-        train_data = self.data[self.data['Date'] < val_date].dropna()
-        val_data = self.data[self.data['Date'] >= val_date].dropna()
-
-        columns = [ x for x in train_data.columns if x not in target ]
-        X_train, y_train = train_data[columns], train_data[target]
-        X_val, y_val = val_data[columns], val_data[target]
-        self.X_train = X_train
-        self.y_train = y_train
-        self.X_val = X_val
-        self.y_val = y_val
-    
-    def train_model(self, pipe, model, cv_ = False):
-        self.model = model
-        self.pipe_transform = pipe
-        self.pipeline = Pipeline([('pipe_transform',self.pipe_transform), ('model',self.model)])
-        self.features_to_model = self.pipe_transform.fit_transform(self.X_train).columns
-        self.pipeline.fit(self.X_train, self.y_train)
-
-class register_results():
-    def __init__(self, model_name):
-        self.model_name = model_name
-        self.metric_logger = dict()
-    def eval_metrics(self, pipeline, X, y, type_data, phase):
-        
-        preds_proba = pipeline.predict_proba(X)
-        preds = pipeline.predict(X)
-    
-        if type(preds_proba) == list:
-            preds_proba = np.array([ x[:,1]  for x in preds_proba]).T
-
-        roc = roc_auc_score(y,preds_proba, average=None)
-        precision = precision_score(y,preds, average=None)
-        recall = recall_score(y,preds, average=None)
-        
-        self.metric_logger[f'{phase}//{self.model_name}//{type_data}'] = {'roc':roc, 'precision':precision, 'recall':recall}
-
-    def print_metric_logger(self):
-        parts = list(self.metric_logger.keys())
-        phase_parts = [ x.split('//')[0] for x in parts]
-    
-        parts = list(self.metric_logger)
-        phase_parts = [ x.split('//')[0] for x in parts]
-        
-        init_phase = phase_parts[0]
-        print(f'---{init_phase}--')
-        for phase,val in zip(phase_parts,self.metric_logger):
-            stage = val.split('//')[2]
-            if init_phase != phase:
-                print(f'---{phase}--')
-                init_phase = phase
-            for metric in self.metric_logger[val]:
-                print(stage, metric,self.metric_logger[val][metric])
-
-
-def eval_metrics(pipeline, X, y, type_data, model_name):
-    
-    preds_proba = pipeline.predict_proba(X)
-    preds = pipeline.predict(X)
-
-    if type(preds_proba) == list:
-        preds_proba = np.array([ x[:,1]  for x in preds_proba]).T
-            
-    print(f'--{type_data} - {model_name}--')
-    print('--target: down, up--')
-    print('--roc-auc--')
-    print(roc_auc_score(y,preds_proba, average=None))
-    print('--precision--')
-    print(precision_score(y,preds, average=None))
-    print('--recall--')
-    print(recall_score(y,preds, average=None))
-
-
-def data_processing_pipeline_classifier(
-        features_base,features_to_drop = False, winsorizer_conf = False, discretize_columns = False,
-        bins_discretize = 10, correlation = 0.85, fillna = True,
-        invhypervolsin_features = False,
-        pipeline_order = 'selector//winzorizer//discretizer//median_inputer//drop//correlation'):
-
-
-    select_pipe = [('selector', FeatureSelector(features_base))] if features_base else []
-    winzorizer_pipe = [('winzorized_features', VirgoWinsorizerFeature(winsorizer_conf))] if winsorizer_conf else []
-    drop_pipe = [('drop_features' , DropFeatures(features_to_drop=features_to_drop))] if features_to_drop else []
-    discretize = [('discretize',EqualWidthDiscretiser(discretize_columns, bins = bins_discretize ))] if discretize_columns else []
-    drop_corr = [('drop_corr', DropCorrelatedFeatures(threshold=correlation, method = 'spearman'))] if correlation else []
-    median_imputer_pipe = [('median_imputer', MeanMedianImputer())] if fillna else []
-    invhypersin_pipe = [('invhypervolsin scaler', InverseHyperbolicSine(features = invhypervolsin_features))] if invhypervolsin_features else []
-
-    pipe_dictionary = {
-        'selector': select_pipe,
-        'winzorizer':winzorizer_pipe,
-        'drop':drop_pipe,
-        'discretizer': discretize,
-        'correlation': drop_corr,
-        'median_inputer':median_imputer_pipe,
-        'arcsinh_scaler': invhypersin_pipe,
-    }
-
-    pipeline_steps = pipeline_order.split('//')
-    ## validation
-    for step in pipeline_steps:
-        if step not in pipe_dictionary.keys():
-            raise Exception(f'{step} step not in list of steps, the list is: {list(pipe_dictionary.keys())}')
-        
-    pipeline_args = [ pipe_dictionary[step] for step in pipeline_steps]
-    pipeline_args = list(itertools.chain.from_iterable(pipeline_args))
-    pipe = Pipeline(pipeline_args)
-
-    return pipe
-
-
-class ExpandingMultipleTimeSeriesKFold:
-    """increasing training window where the test can be overlap"""
-    def __init__(self, df, window_size = 100, number_window=3, overlap_size = 0):
-        self.df = df
-        self.number_window = number_window
-        self.window_size = window_size
-        self.overlap_size = overlap_size
-        
-    def split(self, X, y, groups=None):
-        
-        if 'Date_i' not in self.df.index.names or 'i' not in self.df.index.names:
-            raise Exception('no date and/or index in the index dataframe')
-        
-        if self.overlap_size > self.window_size:
-            raise Exception('overlap can not be higher than the window size')
-
-        unique_dates = list(self.df.index.get_level_values('Date_i').unique())
-        unique_dates.sort()
-    
-        total_test_size = self.window_size * self.number_window
-        total_test_size = total_test_size - (self.number_window - 1)*self.overlap_size
-        
-        if total_test_size > len(unique_dates):
-            raise Exception('test size is higher than the data length')
-
-        cut = total_test_size
-        for fold in range(self.number_window):
-            
-            topcut = cut-self.window_size
-            train_dates = unique_dates[:-cut]
-            test_dates = unique_dates[-cut:-topcut]
-            
-            if topcut == 0:
-                test_dates = unique_dates[-cut:]
-        
-            max_train_date = max(train_dates)
-            min_test_date, max_test_date = min(test_dates), max(test_dates)
-            
-            cut = cut - (self.window_size - self.overlap_size) 
-        
-            train_index = self.df[self.df.index.get_level_values('Date_i') <= max_train_date].index.get_level_values('i')
-            test_index = self.df[(self.df.index.get_level_values('Date_i') >= min_test_date) & (self.df.index.get_level_values('Date_i') <= max_test_date)].index.get_level_values('i')
-        
-            yield train_index, test_index
-
-    def get_n_splits(self, X, y, groups=None):
-        return self.number_window

virgo_modules-0.0.72.dist-info/RECORD

@@ -1,12 +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=GWmVdXM0mIJJPn-X-bEtM4KtNPCHM1D457hnuKxaM7E,1383
-virgo_modules/src/edge_utils.py,sha256=Ihdmq7dyb8gOvG6CrDal7wsa15tqsdsFk6KINwM6578,7691
-virgo_modules/src/pull_artifacts.py,sha256=5OPrgR7pcMSdpbevDRhf0ebk7g7ZRjff4NpTIIWAKjE,1989
-virgo_modules/src/re_utils.py,sha256=LDI3sYAaNm3LO5gRul7PyCVbJrkT3PBihObkdVilVec,52428
-virgo_modules/src/ticketer_source.py,sha256=ciMPObqntAFtnlY1IPt8-Y4mz6yuD1jy6gRQN109D4M,104837
-virgo_modules-0.0.72.dist-info/LICENSE,sha256=pNgFyCYgmimaw0o6V20JupZLROycAnOA_HDDh1tX2V4,1097
-virgo_modules-0.0.72.dist-info/METADATA,sha256=Txin9qouILtGSvPTQYcJPPkWXNry0JjI3sSfAMB0Cjg,1429
-virgo_modules-0.0.72.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-virgo_modules-0.0.72.dist-info/top_level.txt,sha256=ZjI-qEkDtT-8mFwGAWnXfqPOKEGlIhWRW1es1VyXc60,14
-virgo_modules-0.0.72.dist-info/RECORD,,