metacountregressor 0.1.113__py3-none-any.whl → 0.1.117__py3-none-any.whl

metacountregressor/app_main.py

@@ -69,15 +69,20 @@ def main(args, **kwargs):
     #data_info['data']['Group'][0]
     #data_info['data']['Panel'][0]
     args['decisions'] = data_info['analyst']
-
-    if not np.isnan(data_info['data']['Grouped'][0]):
+    grouped_c = data_info['data']['Grouped'][0]
+    if isinstance(data_info['data']['Grouped'][0],str):
         args['group'] = data_info['data']['Grouped'][0]
-        args['ID'] = data_info['data']['Grouped'][0]
-    if not np.isnan(data_info['data']['Panel'][0]):
+        args['ID'] = data_info['data']['Panel'][0]
+    if isinstance(data_info['data']['Panel'][0],str):
         args['panels'] = data_info['data']['Panel'][0]
 
     df = pd.read_csv(str(data_info['data']['Problem'][0]))
     x_df = df.drop(columns=[data_info['data']['Y'][0]])
+    # drop the columns of x_df where column is string exclude the column stype args['group']
+    exclude_column = args['group']
+    columns_to_keep = x_df.dtypes != 'object'
+    columns_to_keep |= (x_df.columns == exclude_column)
+    x_df = x_df.loc[:, columns_to_keep]
     y_df = df[[data_info['data']['Y'][0]]]
     y_df.rename(columns={data_info['data']['Y'][0]: "Y"}, inplace=True)
 

metacountregressor/helperprocess.py

@@ -1,10 +1,28 @@
+from os.path import exists
 import numpy as np
 import pandas as pd
 import csv
 import matplotlib.pyplot as plt
+from scipy import stats as st
+from sklearn.preprocessing import StandardScaler
+
 
 plt.style.use('https://github.com/dhaitz/matplotlib-stylesheets/raw/master/pitayasmoothie-dark.mplstyle')
 
+
+
+
+
+from itertools import product
+
+# Function to create a list of dictionaries from a parameter grid
+def generate_param_combinations(param_grid):
+    keys = param_grid.keys()
+    values = param_grid.values()
+    combinations = [dict(zip(keys, v)) for v in product(*values)]
+    return combinations
+
+
 ##Select the best Features Based on RF
 def select_features(X_train, y_train, n_f=16):
     try:
@@ -77,6 +95,7 @@ def findCorrelation(corr, cutoff=0.9, exact=None):    """
     findCorrelation(R1, cutoff=0.6, exact=True)   # ['x1', 'x5', 'x4']
     """
 
+
 def _findCorrelation_fast(corr, avg, cutoff):
 
     combsAboveCutoff = corr.where(lambda x: (np.tril(x) == 0) & (x > cutoff)).stack().index
@@ -151,6 +170,230 @@ def remove_files(yes=1):
             os.remove('pop_log.csv')
 
 
+# Function to process the DataFrame
+'''
+Example usuage
+# Configuration dictionary
+config = {
+    'Age': {
+        'type': 'bin',
+        'bins': [0, 18, 35, 50, 100],
+        'labels': ['Child', 'YoungAdult', 'MiddleAged', 'Senior'],
+        'prefix': 'Age_Binned'
+    },
+    'Income': {
+        'type': 'bin',
+        'bins': [0, 2000, 5000, 10000],
+        'labels': ['Low', 'Medium', 'High'],
+        'prefix': 'Income_Binned'
+    },
+    'Gender': {
+        'type': 'one-hot',
+        'prefix': 'Gender'
+    },
+    'Score': {
+        'type': 'none'
+    }
+}
+'''
+def null_handler(vari):
+    if vari in locals():
+        return vari
+    else:
+        print(f'{vari} does not exist, setting None..')
+        return None
+
+
+def set_up_analyst_constraints(data_characteristic, model_terms,  variable_decisions_alt = None):
+
+
+    name_data_characteristics = data_characteristic.columns.tolist()
+    # Get non-None values as a list
+    non_none_terms = [value for value in model_terms.values() if value is not None]
+    # how to make name_data_characteristics - non_none_terms
+
+    result = [item for item in name_data_characteristics if item not in non_none_terms]
+    distu = ['normal', 'uniform', 'triangular']
+    tra = ['no', 'sqrt', 'arcsinh']
+    if model_terms.get('group') is None:
+        print('cant have grouped rpm, removing level 4 from every item')
+        MAKE_ALL_4_FALSE = True
+    else:
+        MAKE_ALL_4_FALSE = False
+
+    variable_decisions = {
+        name: {
+            'levels': list(range(6)),
+            'Distributions': distu,
+            'Transformations': tra
+        }
+        for name in result
+    }
+    # Override elements in the original dictionary with the alt dictionary
+    if variable_decisions_alt is not None:
+        for key, alt_value in variable_decisions_alt.items():
+            if key in variable_decisions:
+                # Update the existing entry
+                variable_decisions[key].update(alt_value)
+            else:
+                # Add new entry if it doesn't exist
+                variable_decisions[key] = alt_value
+    # Prepare the data for the DataFrame
+    rows = []
+    for column_name, details in variable_decisions.items():
+        # Create a row dictionary
+        row = {'Column': column_name}
+
+        # Add levels as True/False for Level 0 through Level 5
+        for level in range(6):  # Assuming Level 0 to Level 5
+
+            if level == 4 and MAKE_ALL_4_FALSE:
+                row[f'Level {level}'] = False
+            else:
+                row[f'Level {level}'] = level in details['levels']
+
+        # Add distributions and transformations directly
+
+        # Add distributions and transformations as comma-separated strings
+        row['Distributions'] = str(details['Distributions'])
+        row['Transformations'] = str(details['Transformations'])
+
+        rows.append(row)
+
+    # Create the DataFrame
+    df = pd.DataFrame(rows)
+
+    data_new = data_characteristic.rename(columns={v: k for k, v in model_terms.items() if v in data_characteristic.columns})
+    return  df, data_new
+
+# Function to guess Low, Medium, High ranges
+def guess_low_medium_high(column_name, series):
+    # Compute the tertiles (33rd and 66th percentiles)
+    #print('did it make it...')
+    #mode_value = st.mode(series)  # Get the most frequent value
+    #i dont think this works cayse its not a seriers any other way
+    is_binary = series.isin([0, 1]).all()
+    if is_binary:
+        return {
+            'type': 'binary',
+            'bins': [0,1],
+            'labels': ['Off', 'On'],
+            'prefix': f'{column_name}'
+
+        }
+
+   # series = pd.to_numeric(series, errors='coerce').fillna(mode_value)
+    low_threshold = np.quantile(series, 0.33)
+    high_threshold = np.quantile(series,0.66)
+
+    # Define the bins and labels
+    bins = [np.min(series) - 1, low_threshold, high_threshold, np.max(series)]
+    # Handle duplicate bins by adjusting labels
+    if len(set(bins)) < len(bins):  # Check for duplicate bin edges
+        if low_threshold == high_threshold:
+            # Collapse to two bins (Low and High)
+            bins = [np.min(series) - 1, low_threshold, np.max(series)]
+            labels = ['Low', 'High']
+        else:
+            # Collapse to three unique bins
+            bins = sorted(set(bins))  # Remove duplicate edges
+            labels = [f'Bin {i + 1}' for i in range(len(bins) - 1)]
+    else:
+        # Standard case: Low, Medium, High
+        labels = ['Low', 'Medium', 'High']
+
+    return {
+        'type': 'bin',
+        'bins': bins,
+        'labels': labels,
+        'prefix': f'{column_name}'
+    }
+
+def transform_dataframe(df, config):
+    output_df = pd.DataFrame()
+
+    for column, settings in config.items():
+        if settings['type'] == 'bin':
+            # Apply binning
+            # Get unique bins (remove duplicates)
+            unique_bins = sorted(set(settings['bins']))
+
+            # Adjust labels if necessary
+            if len(unique_bins) - 1 != len(settings['labels']):
+                print(f"Adjusting labels to match bins: {len(unique_bins) - 1} bins detected.")
+                labels = [f'Bin {i+1}' for i in range(len(unique_bins) - 1)]
+            else:
+                labels = settings['labels']
+
+            # Perform the binning
+            binned_d = pd.cut(
+                df[column],
+                bins=unique_bins,  # Deduplicated bins
+                labels=labels,     # Adjusted or original labels
+                right=False        # Adjust based on whether to include the right edge
+            )
+            # One-hot encode the binned column
+            binned_dummies = pd.get_dummies(binned_d, prefix=settings['prefix'])
+            output_df = pd.concat([output_df, binned_dummies], axis=1)
+
+        elif settings['type'] == 'one-hot':
+            # One-hot encode the column
+            one_hot_dummies = pd.get_dummies(df[column], prefix=settings.get('prefix', column))
+            output_df = pd.concat([output_df, one_hot_dummies], axis=1)
+
+        elif settings['type'] == 'continuous':
+            # Apply function to continuous data
+            data = df[column]
+            if 'bounds' in settings:
+                # Apply bounds filtering
+                lower, upper = settings['bounds']
+                data = data[(data >= lower) & (data <= upper)]
+            if 'apply_func' in settings:
+                # Apply custom function
+                data = data.apply(settings['apply_func'])
+            output_df[column] = data
+
+        elif settings['type'] == 'none':
+            # Leave the column unchanged
+            if column in df.columns:
+
+                output_df = pd.concat([output_df, df[[column]]], axis=1)
+            else: 
+                print(f'config variable {column} is not in the data. Ignoring ...')
+    return output_df
+
+# Helper function to guess column type and update `config`
+def guess_column_type(column_name, series):
+
+    if series.empty:
+        raise ValueError(f"The column {column_name} contains no numeric data.")
+
+    if series.dtype == 'object' or series.dtype.name == 'category':
+        # If the column is categorical (e.g., strings), assume one-hot encoding
+        return {'type': 'one-hot', 'prefix': column_name}
+    elif pd.api.types.is_numeric_dtype(series):
+        unique_values = series.nunique()
+
+        if unique_values < 5:
+            return {'type': 'one-hot', 'prefix': column_name}
+
+        elif np.max(series) - np.min(series) > 20:
+            print('made it through here')
+            # If there are few unique values, assume binning with default bins
+            return guess_low_medium_high(column_name,series)
+        else:
+           # # Otherwise, assume continuous data with normalization
+            # Otherwise, fallback to continuous standardization
+            return {
+                'type': 'continuous',
+                'apply_func': (lambda x: (x - series.mean()) / series.std())  # Z-Score Standardization
+            }
+    else:
+        # Default fallback (leave the column unchanged)
+        return {'type': 'none'}
+
+
+
 def as_wide_factor(x_df, yes=1, min_factor=2, max_factor=8, keep_original=0, exclude=[]):
     if not yes:
         return x_df
@@ -173,7 +416,7 @@ def PCA_code(X, n_components=5):
 
 
 def interactions(df, keep=None, drop_this_perc=0.6, interact = False):
-
+    full_columns = df.columns
     if interact:
         interactions_list = []
         for i, var_i in enumerate(df.columns):
@@ -199,14 +442,31 @@ def interactions(df, keep=None, drop_this_perc=0.6, interact = False):
         df = pd.concat([df, df_interactions], axis=1, sort=False)
 
     # second
-    corr_matrix = df.corr().abs()
+    # Remove `keep` columns from the correlation matrix
+    if keep is not None:
+        missing_columns = [col for col in keep if col not in df.columns]
+     
+        if missing_columns:
+            print(f"The following columns are not in the DataFrame and will be ignored: {missing_columns}")
+            keep = [col for col in keep if col not in missing_columns]
+        df_corr = df.drop(columns=keep, errors='ignore', inplace=False)  # Exclude `keep` columns
+    else:
+        df_corr = df
+
+    # Compute the absolute correlation matrix
+    corr_matrix = df_corr.corr().abs()
+
+    # Keep only the upper triangle of the correlation matrix
     upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
 
-    # Find features with correlation greater than 0.6
+    # Find features with correlation greater than the threshold
     to_drop = [column for column in upper.columns if any(upper[column] > drop_this_perc)]
+
+    # Ensure `keep` columns are not dropped
     if keep is not None:
-        to_drop = [column for column in to_drop if column not in keep]
-    # Drop features
+        to_drop = [column for column in to_drop if column not in full_columns]
+
+    # Drop the identified features
     df.drop(to_drop, axis=1, inplace=True)
 
     return df
@@ -330,3 +590,5 @@ def entries_to_remove(entries, the_dict):
     for key in entries:
         if key in the_dict:
             del the_dict[key]
+
+

metacountregressor/main.py

@@ -28,12 +28,65 @@ def convert_df_columns_to_binary_and_wide(df):
     return df
 
 
-def process_arguments():
+
+
+
+
+def process_arguments(**kwargs):
     '''
     TRYING TO TURN THE CSV FILES INTO RELEVANT ARGS
     '''
-    data_characteristic = pd.read_csv('problem_data.csv')
-    analyst_d = pd.read_csv('decisions.csv')
+    #dataset
+    '''
+    if kwargs.get('dataset_file', False
+    ):
+        dataset = pd.read_csv(kwargs.get('dataset_file'))
+        named_data_headers = dataset.columns.tolist()
+        decision_constants = {name: list(range(7)) for name in named_data_headers}
+        data_info = {
+
+
+            'AADT': {
+                'type': 'continuous',
+                'bounds': [0.0, np.infty],
+                'discrete': False,
+                'apply_func': (lambda x: np.log(x + 1)),
+            },
+            'SPEED': {
+                'type': 'continuous',
+                'bounds': [0, 100],
+                'enforce_bounds': True,
+                'discrete': True
+            },
+            'TIME': {
+                'type': 'continuous',
+                'bounds': [0, 23.999],
+                'discrete': False
+            }
+        }
+        #remove ID CoLUMNS from dataset
+        dataset = dataset.drop(columns = [
+            'ID'
+        ])
+        for c in dataset.columns:
+            if c not in data_info.keys():
+                data_info[c] = {'type': 'categorical'}
+
+        data_new  =helperprocess.transform_dataframe(dataset,data_info)
+
+        update_constant = kwargs.get('analyst_constraints')
+        #update the decision_constraints
+    '''
+    data_characteristic = pd.read_csv(kwargs.get('problem_data', 'problem_data.csv'))
+    # Extract the column as a list of characteristic names
+    #name_data_characteristics = data_characteristic.columns.tolist()
+
+    # Create the dictionary
+    #decision_constraints = {name: list(range(7)) for name in name_data_characteristics}
+
+    #print('this gets all the features, I need to remove...')
+
+    analyst_d = pd.read_csv(kwargs.get('decison_constraints', 'decisions.csv'))
     hyper = pd.read_csv('setup_hyper.csv')
 
     new_data = {'data': data_characteristic,
@@ -41,7 +94,14 @@ def process_arguments():
                 'hyper': hyper}
     return new_data
 
+def process_package_arguments():
+
+    new_data = {}
+    pass
+
+
 def main(args, **kwargs):
+
     '''METACOUNT REGRESSOR TESTING ENVIRONMENT'''
 
     '''
@@ -114,13 +174,25 @@ def main(args, **kwargs):
         X = df
         y = df['FREQ']  # Frequency of crashes
         X['Offset'] = np.log(df['AADT'])  # Explicitley define how to offset the data, no offset otherwise
+        df['Offset'] = np.log(df['AADT'])
         # Drop Y, selected offset term and  ID as there are no panels
         X = df.drop(columns=['FREQ', 'ID', 'AADT'])
-
+        # Step 0: Process Data
+        model_terms = {
+            'Y': 'FREQ',  # Replace 'FREQ' with the name of your dependent variable
+            'group': None,  # Replace 'group_column' with the name of your grouping column (or None if not used)
+            'panels': None,  # Replace 'panel_column' with the name of your panel column (or None if not used)
+            'Offset': 'Offset'  # Replace None with the name of your offset column if using one
+        }
+        a_des, df = helperprocess.set_up_analyst_constraints(df, model_terms)
         # some example argument, these are defualt so the following line is just for claritity
         args = {'algorithm': 'hs', 'test_percentage': 0.15, 'test_complexity': 6, 'instance_number': 1,
-                'val_percentage': 0.15, 'obj_1': 'bic', '_obj_2': 'RMSE_TEST', "MAX_TIME": 6}
+                'val_percentage': 0.15, 'obj_1': 'bic', '_obj_2': 'RMSE_TEST', "MAX_TIME": 6, 'desicions':a_des}
         # Fit the model with metacountregressor
+        # Step 5: Transform the dataset based on the configuration
+        #data_new = helperprocess.transform_dataframe(dataset, config)
+        y = df[['Y']]
+        X = df.drop(columns=['Y'])
         obj_fun = ObjectiveFunction(X, y, **args)
         # replace with other metaheuristics if desired
         results = harmony_search(obj_fun)
@@ -162,8 +234,8 @@ def main(args, **kwargs):
             'rdm_cor_terms': [],
             'grouped_terms': [],
             'hetro_in_means': [],
-            'transformations': ['no', 'log', 'log', 'no', 'no', 'no', 'no'],
-            'dispersion': 1
+            'transformations': ['no', 'log', 'no', 'no', 'no', 'no', 'no'],
+            'dispersion': 0
         }
 
         keep = ['Constant', 'US', 'RSMS', 'MCV', 'RSHS', 'AADT', 'Curve50', 'Offset']
@@ -172,13 +244,27 @@ def main(args, **kwargs):
     elif dataset == 4:
         manual_fit_spec = {
             'fixed_terms': ['const', 'LOWPRE', 'GBRPM', 'FRICTION'],
-            'rdm_terms': ['Expose:normal', 'INTPM:normal', 'CPM:normal', 'HISNOW:normal'],
+            'rdm_terms': ['EXPOSE:normal', 'INTPM:normal', 'CPM:normal', 'HISNOW:normal'],
             'rdm_cor_terms': [],
             'grouped_terms': [],
             'hetro_in_means': [],
             'transformations': ['no', 'no', 'no', 'no', 'no', 'no', 'no', 'no'],
             'dispersion': 1
         }
+        '''
+        manual_fit_spec = {
+            'fixed_terms': ['const', 'LOWPRE', 'GBRPM', 'FRICTION', 'EXPOSE', 'INTPM', 'CPM', 'HISNOW'],
+            'rdm_terms': [],
+            'rdm_cor_terms': [],
+            'grouped_terms': [],
+            'hetro_in_means': [],
+            'transformations': ['no', 'no', 'no', 'no', 'no', 'no', 'no', 'no'],
+            'dispersion': 1
+        }
+        '''
+
+
+        '''
         print('overriding this delete, just want to test the NB')
         manual_fit_spec = {
             'fixed_terms': ['const'],
@@ -189,7 +275,7 @@ def main(args, **kwargs):
             'transformations': ['no'],
             'dispersion': 1
         }
-
+        '''
         df = pd.read_csv('./data/Ex-16-3.csv')  # read in the data
         y_df = df[['FREQ']].copy()  # only consider crashes
         y_df.rename(columns={"FREQ": "Y"}, inplace=True)
@@ -262,6 +348,17 @@ def main(args, **kwargs):
         x_df = helperprocess.interactions(x_df, drop_this_perc=0.8)
         x_df['county'] = group_grab
 
+        print('benchmark specification')
+        manual_fit_spec = {
+            'fixed_terms': ['const', 'monthly_AADT', 'segment_length', 'speed', 'paved_shoulder', 'curve'],
+            'rdm_terms': [],
+            'rdm_cor_terms': [],
+            'grouped_terms': ['DP01:normal', 'DX32:normal'],
+            'hetro_in_means': [],
+            'transformations': ['no', 'no', 'no', 'no', 'no', 'no'],
+            'dispersion': 0
+        }
+
     elif dataset == 9:
         df = pd.read_csv('panel_synth.csv')  # read in the data
         y_df = df[['Y']].copy()  # only consider crashes
@@ -286,19 +383,21 @@ def main(args, **kwargs):
         keep = ['group', 'constant', 'element_ID']
 
         x_df = helperprocess.interactions(x_df, keep)
-    else:  # the dataset has been selected in the program as something else
-        data_info = process_arguments()
+
+
+    elif dataset ==10:  # the dataset has been selected in the program as something else
+        data_info = process_arguments(**args)
         data_info['hyper']
         data_info['analyst']
         data_info['data']['Y']
         #data_info['data']['Group'][0]
         #data_info['data']['Panel'][0]
         args['decisions'] = data_info['analyst']
-
-        if not np.isnan(data_info['data']['Grouped'][0]):
+        print('check the args of the decions')
+        if type(data_info['data']['Grouped'][0]) == str and len(data_info['data']['Grouped'][0]) >1:
             args['group'] = data_info['data']['Grouped'][0]
             args['ID'] = data_info['data']['Grouped'][0]
-        if not np.isnan(data_info['data']['Panel'][0]):
+        if type(data_info['data']['Panel'][0]) == str and len(data_info['data']['Panel'][0])>1:
             args['panels'] = data_info['data']['Panel'][0]
 
         df = pd.read_csv(str(data_info['data']['Problem'][0]))
@@ -306,6 +405,10 @@ def main(args, **kwargs):
         y_df = df[[data_info['data']['Y'][0]]]
         y_df.rename(columns={data_info['data']['Y'][0]: "Y"}, inplace=True)
         print('test') #FIXME
+    else:
+        print('PROCESS THE PACKAGE ARGUMENTS SIMULIAR TO HOW ONE WOULD DEFINE THE ENVIRONMENT')
+        data_info =process_package_arguments()
+
 
     if args['Keep_Fit'] == str(2) or args['Keep_Fit'] == 2:
         if manual_fit_spec is None:
@@ -411,55 +514,63 @@ if __name__ == '__main__':
     parser = argparse.ArgumentParser(prog='main',
                                      epilog=main.__doc__,
                                      formatter_class=argparse.RawDescriptionHelpFormatter, conflict_handler='resolve')
-
-    parser.add_argument('-line', type=int, default=1,
-                        help='line to read in csv to pass in argument')
-
-    if vars(parser.parse_args())['line'] is not None:
-        reader = csv.DictReader(open('set_data.csv', 'r'))
-        args = list()
-        line_number_obs = 0
-        for dictionary in reader:  # TODO find a way to handle multiple args
-            args = dictionary
-            if line_number_obs == int(vars(parser.parse_args())['line']):
-                break
-            line_number_obs += 1
-        args = dict(args)
-
-        for key, value in args.items():
-            try:
-                # Attempt to parse the string value to a Python literal if value is a string.
-                if isinstance(value, str):
-                    value = ast.literal_eval(value)
-            except (ValueError, SyntaxError):
-                # If there's a parsing error, value remains as the original string.
-                pass
-
-            # Add the argument to the parser with the potentially updated value.
-            parser.add_argument(f'-{key}', default=value)
-
-        for i, action in enumerate(parser._optionals._actions):
-            if "-algorithm" in action.option_strings:
-                parser._optionals._actions[i].help = "optimization algorithm"
-
-        override = True
-        if override:
-            print('todo turn off, in testing phase')
-            parser.add_argument('-problem_number', default='10')
-            print('did it make it')
-        if 'algorithm' not in args:
-            parser.add_argument('-algorithm', type=str, default='hs',
-                                help='optimization algorithm')
-        elif 'Manual_Fit' not in args:
-            parser.add_argument('-Manual_Fit', action='store_false', default=None,
-                                help='To fit a model manually if desired.')
-
-        parser.add_argument('-seperate_out_factors', action='store_false', default=False,
-                            help='Trie of wanting to split data that is potentially categorical as binary'
-                                 ' we want to split the data for processing')
-        parser.add_argument('-supply_csv', type = str, help = 'enter the name of the csv, please include it as a full directorys')
+    
+    
+    BATCH_JOB = False
+
+    if BATCH_JOB:
+        parser.add_argument('-dataset_file', default='data/Ex-16-3.csv', help='supply the path to the dataset')
+
+        parser.add_argument('-line', type=int, default=1,
+                            help='line to read in csv to pass in argument')
+
+        if vars(parser.parse_args())['line'] is not None:
+            reader = csv.DictReader(open('set_data.csv', 'r'))
+            args = list()
+            line_number_obs = 0
+            for dictionary in reader:  # TODO find a way to handle multiple args
+                args = dictionary
+                if line_number_obs == int(vars(parser.parse_args())['line']):
+                    break
+                line_number_obs += 1
+            args = dict(args)
+
+
+            for key, value in args.items():
+                try:
+                    # Attempt to parse the string value to a Python literal if value is a string.
+                    if isinstance(value, str):
+                        value = ast.literal_eval(value)
+                except (ValueError, SyntaxError):
+                    # If there's a parsing error, value remains as the original string.
+                    pass
+
+                # Add the argument to the parser with the potentially updated value.
+                parser.add_argument(f'-{key}', default=value)
+
+            for i, action in enumerate(parser._optionals._actions):
+                if "-algorithm" in action.option_strings:
+                    parser._optionals._actions[i].help = "optimization algorithm"
+
+            override = True
+            if override:
+                print('WARNING: TESTING ENVIRONMENT, TURN OFF FOR RELEASE')
+                parser.add_argument('-problem_number', default='10')
+
+            if 'algorithm' not in args:
+                parser.add_argument('-algorithm', type=str, default='hs',
+                                    help='optimization algorithm')
+            elif 'Manual_Fit' not in args:
+                parser.add_argument('-Manual_Fit', action='store_false', default=None,
+                                    help='To fit a model manually if desired.')
+
+            parser.add_argument('-seperate_out_factors', action='store_false', default=False,
+                                help='Trie of wanting to split data that is potentially categorical as binary'
+                                    ' we want to split the data for processing')
+            parser.add_argument('-supply_csv', type = str, help = 'enter the name of the csv, please include it as a full directories')
 
     else:  # DIDN"T SPECIFY LINES TRY EACH ONE MANNUALY
+        print("RUNNING WITH ARGS")
         parser.add_argument('-com', type=str, default='MetaCode',
                             help='line to read csv')