:param task: Type of task, either 'classification', 'regression', or 'clustering'.
    :param time_left_for_this_task: Time limit for the AutoML task in seconds.
    :param per_run_time_limit: Time limit for each model run in seconds.
    """
    self.task = task
    self.time_left_for_this_task = time_left_for_this_task
    self.per_run_time_limit = per_run_time_limit
    self.automl = None
    self.model = None

def fit(self, X, y=None, cluster_algorithm='kmeans', **kwargs):
    """
    Fit the AutoML model to the data.
    
    :param X: Features as a DataFrame or array.
    :param y: Target variable as a Series or array (for classification and regression tasks).
    :param cluster_algorithm: Clustering algorithm to use ('kmeans', 'dbscan', or 'agglomerative').
    :param kwargs: Additional keyword arguments for the clustering algorithm.
    """
    if self.task == 'classification':
        self.automl = autosklearn.classification.AutoSklearnClassifier(
            time_left_for_this_task=self.time_left_for_this_task,
            per_run_time_limit=self.per_run_time_limit
        )
        self.automl.fit(X, y)
        self.model = self.automl.show_models()
    elif self.task == 'regression':
        self.automl = autosklearn.regression.AutoSklearnRegressor(
            time_left_for_this_task=self.time_left_for_this_task,
            per_run_time_limit=self.per_run_time_limit
        )
        self.automl.fit(X, y)
        self.model = self.automl.show_models()
    elif self.task == 'clustering':
        if cluster_algorithm == 'kmeans':
            self.model = KMeans(**kwargs)
        elif cluster_algorithm == 'dbscan':
            self.model = DBSCAN(**kwargs)
        elif cluster_algorithm == 'agglomerative':
            self.model = AgglomerativeClustering(**kwargs)
        else:
            raise ValueError("Clustering algorithm must be 'kmeans', 'dbscan', or 'agglomerative'.")
        self.model.fit(X)
    else:
        raise ValueError("Task must be 'classification', 'regression', or 'clustering'.")

def predict(self, X):
    """
    Predict using the trained AutoML model.
    
    :param X: Features as a DataFrame or array.
    :return: Predictions as an array.
    """
    if self.automl:
        return self.automl.predict(X)
    elif self.model:
        return self.model.predict(X)
    else:
        print("Model has not been fitted yet.")
        return None

def evaluate(self, X, y):
    """
    Evaluate the model on the given data.
    
    :param X: Features as a DataFrame or array.
    :param y: True target variable values as a Series or array.
    :return: Evaluation metric.
    """
    predictions = self.predict(X)
    if self.task == 'classification':
        return accuracy_score(y, predictions)
    elif self.task == 'regression':
        return mean_squared_error(y, predictions, squared=False)
    elif self.task == 'clustering':
        # For clustering, evaluation metrics are different (e.g., silhouette score, etc.)
        # Implement specific metrics as needed
        return None

def save_model(self, file_path):
    """
    Save the trained model to a file.
    
    :param file_path: Path to the file where the model will be saved.
    """
    if self.automl or self.model:
        joblib.dump(self.automl if self.automl else self.model, file_path)
    else:
        print("Model has not been fitted yet.")

def load_model(self, file_path):
    """
    Load a trained model from a file.
    
    :param file_path: Path to the file where the model is saved.
    """
    self.model = joblib.load(file_path)

def get_model(self):
    """
    Get the underlying AutoML or clustering model.
    
    :return: AutoML or clustering model object.
    """
    return self.automl if self.task in ['classification', 'regression'] else self.model

def show_models(self):
    """
    Show the models found during the AutoML process.
    
    :return: List of models.
    """
    if self.task in ['classification', 'regression'] and self.automl:
        return self.model
    else:
        print("Model has not been fitted yet.")
        return None

    :param dataframe: Pandas DataFrame containing the data.
    :param formula: Formula for the regression model (e.g., 'y ~ x1 + x2').
    """
    self.dataframe = dataframe
    self.formula = formula
    self.model = None
    self.results = None

def fit_model(self):
    """
    Fit the regression model using the provided formula and data.
    
    :return: Fitted regression model results.
    """
    try:
        self.model = smf.ols(formula=self.formula, data=self.dataframe)
        self.results = self.model.fit()
        return self.results
    except Exception as e:
        print(f"Error fitting model: {e}")

def summary(self):
    """
    Print the summary of the fitted regression model.
    """
    if self.results:
        print(self.results.summary())
    else:
        print("Model has not been fitted yet.")

def plot_diagnostics(self):
    """
    Plot regression diagnostics.
    """
    if self.results:
        sm.graphics.plot_regress_exog(self.results, self.formula.split('~')[1].strip())
        plt.show()
    else:
        print("Model has not been fitted yet.")

def calculate_vif(self):
    """
    Calculate Variance Inflation Factor (VIF) for the independent variables.
    
    :return: DataFrame containing VIF values.
    """
    if self.model:
        X = self.model.exog
        vif_data = pd.DataFrame()
        vif_data["variable"] = self.model.exog_names
        vif_data["VIF"] = [variance_inflation_factor(X, i) for i in range(X.shape[1])]
        return vif_data
    else:
        print("Model has not been fitted yet.")
        return None

def residuals_histogram(self):
    """
    Plot a histogram of the residuals.
    """
    if self.results:
        residuals = self.results.resid
        plt.hist(residuals, bins=30, edgecolor='k')
        plt.title('Residuals Histogram')
        plt.xlabel('Residuals')
        plt.ylabel('Frequency')
        plt.show()
    else:
        print("Model has not been fitted yet.")

def check_heteroscedasticity(self):
    """
    Perform Breusch-Pagan test for heteroscedasticity.
    
    :return: Test statistic and p-value.
    """
    if self.results:
        _, pval, __, f_pval = het_breuschpagan(self.results.resid, self.results.model.exog)
        return {"Lagrange multiplier p-value": pval, "F-statistic p-value": f_pval}
    else:
        print("Model has not been fitted yet.")
        return None

def check_autocorrelation(self):
    """
    Perform Durbin-Watson test for autocorrelation.
    
    :return: Durbin-Watson statistic.
    """
    if self.results:
        dw = sm.stats.durbin_watson(self.results.resid)
        return dw
    else:
        print("Model has not been fitted yet.")
        return None

def qq_plot(self):
    """
    Generate a QQ plot of the residuals to check for normality.
    """
    if self.results:
        sm.qqplot(self.results.resid, line='s')
        plt.title('QQ Plot')
        plt.show()
    else:
        print("Model has not been fitted yet.")

def leverage_plot(self):
    """
    Generate a leverage plot to detect influential points.
    """
    if self.results:
        sm.graphics.influence_plot(self.results, criterion="cooks")
        plt.show()
    else:
        print("Model has not been fitted yet.")

def set_dataframe(self, dataframe):
    """
    Set a new DataFrame for regression analysis.
    
    :param dataframe: Pandas DataFrame to use for regression analysis.
    """
    self.dataframe = dataframe

def set_formula(self, formula):
    """
    Set a new formula for regression analysis.
    
    :param formula: Formula for the regression model (e.g., 'y ~ x1 + x2').
    """
    self.formula = formula

def run_all_diagnostics(self):
    """
    Run all regression diagnostics and print the results.
    """
    if not self.results:
        print("Model has not been fitted yet.")
        return

    # Print the summary of the model
    self.summary()

    # Calculate VIF
    vif_data = self.calculate_vif()
    print("\nVariance Inflation Factor (VIF):")
    print(vif_data)

    # Plot residuals histogram
    print("\nResiduals Histogram:")
    self.residuals_histogram()

    # Check for heteroscedasticity
    heteroscedasticity_test = self.check_heteroscedasticity()
    print("\nHeteroscedasticity Test (Breusch-Pagan):")
    print(heteroscedasticity_test)

    # Check for autocorrelation
    autocorrelation_test = self.check_autocorrelation()
    print("\nAutocorrelation Test (Durbin-Watson):")
    print(f"Durbin-Watson statistic: {autocorrelation_test}")

    # Generate QQ plot
    print("\nQQ Plot:")
    self.qq_plot()

    # Generate leverage plot
    print("\nLeverage Plot:")
    self.leverage_plot()

def predict(self, new_data):
    """
    Predict the response for a new dataset.
    
    :param new_data: Pandas DataFrame containing the new data.
    :return: Predictions as a Pandas Series.
    """
    if self.results:
        try:
            predictions = self.results.predict(new_data)
            return predictions
        except Exception as e:
            print(f"Error making predictions: {e}")
    else:
        print("Model has not been fitted yet.")
        return None

    :param title: Title of the Streamlit app.
    :param description: Description of the Streamlit app.
    """
    self.title = title
    self.description = description

def render_title(self):
    """
    Render the title of the app.
    """
    st.title(self.title)

def render_description(self):
    """
    Render the description of the app.
    """
    st.write(self.description)

def render_file_uploader(self, label="Upload a file", file_types=["csv", "xlsx"]):
    """
    Render a file uploader and return the uploaded file.
    
    :param label: Label for the file uploader.
    :param file_types: List of allowed file types.
    :return: Uploaded file.
    """
    uploaded_file = st.file_uploader(label, type=file_types)
    return uploaded_file

def read_file(self, uploaded_file):
    """
    Read the uploaded file into a Pandas DataFrame.
    
    :param uploaded_file: Uploaded file.
    :return: DataFrame containing the file data.
    """
    if uploaded_file.name.endswith('.csv'):
        df = pd.read_csv(uploaded_file)
    elif uploaded_file.name.endswith('.xlsx'):
        df = pd.read_excel(uploaded_file)
    else:
        st.error("Unsupported file format!")
        return None
    return df

def render_dataframe(self, df):
    """
    Render a Pandas DataFrame in the app.
    
    :param df: DataFrame to render.
    """
    st.dataframe(df)

def render_sidebar(self, df):
    """
    Render the sidebar with user input options.
    
    :param df: DataFrame to be used for sidebar options.
    :return: User selected options from sidebar.
    """
    st.sidebar.title("Options")
    chart_type = st.sidebar.selectbox("Select Chart Type", ["Line Chart", "Bar Chart", "Scatter Plot"])
    x_axis = st.sidebar.text_input("X-axis Column")
    y_axis = st.sidebar.text_input("Y-axis Column")
    columns = st.sidebar.multiselect("Select Columns", options=df.columns.tolist())
    date_column = st.sidebar.selectbox("Select Date Column", options=["None"] + df.columns.tolist())
    date_range = st.sidebar.date_input("Select Date Range", [])
    search_term = st.sidebar.text_input("Search Term")
    return chart_type, x_axis, y_axis, columns, date_column, date_range, search_term

def filter_data(self, df, date_column, date_range, search_term):
    """
    Filter data based on date range and search term.
    
    :param df: DataFrame to filter.
    :param date_column: Column to use for date filtering.
    :param date_range: Date range for filtering.
    :param search_term: Search term for filtering.
    :return: Filtered DataFrame.
    """
    if date_column != "None" and date_range:
        start_date, end_date = date_range
        df = df[(df[date_column] >= pd.to_datetime(start_date)) & (df[date_column] <= pd.to_datetime(end_date))]

    if search_term:
        df = df[df.apply(lambda row: row.astype(str).str.contains(search_term, case=False).any(), axis=1)]
    
    return df

def render_plot(self, df, chart_type, x_axis, y_axis):
    """
    Render a plot from a DataFrame.
    
    :param df: DataFrame to plot.
    :param chart_type: Type of chart to plot.
    :param x_axis: Column name for the x-axis.
    :param y_axis: Column name for the y-axis.
    """
    if x_axis not in df.columns or y_axis not in df.columns:
        st.error("Invalid columns for plotting. Please check the column names.")
        return

    plt.figure(figsize=(10, 6))

    if chart_type == "Line Chart":
        sns.lineplot(data=df, x=x_axis, y=y_axis)
    elif chart_type == "Bar Chart":
        sns.barplot(data=df, x=x_axis, y=y_axis)
    elif chart_type == "Scatter Plot":
        sns.scatterplot(data=df, x=x_axis, y=y_axis)
    
    plt.title(f"{chart_type} of {y_axis} vs {x_axis}")
    st.pyplot(plt)

def render_download_button(self, df, label="Download data as CSV", file_name="data.csv"):
    """
    Render a download button for the DataFrame.
    
    :param df: DataFrame to download.
    :param label: Label for the download button.
    :param file_name: Default file name for the download.
    """
    csv = df.to_csv(index=False).encode('utf-8')
    st.download_button(label=label, data=csv, file_name=file_name, mime='text/csv')

def run(self):
    """
    Run the Streamlit app.
    """
    self.render_title()
    self.render_description()

    # Render file uploader and read the uploaded file
    uploaded_file = self.render_file_uploader()
    if uploaded_file is not None:
        df = self.read_file(uploaded_file)
        if df is not None:
            # Display the data frame
            self.render_dataframe(df)
            
            # Render sidebar and get user inputs
            chart_type, x_axis, y_axis, columns, date_column, date_range, search_term = self.render_sidebar(df)
            
            # Filter data based on user inputs
            df_filtered = self.filter_data(df, date_column, date_range, search_term)
            
            # Display the filtered data frame
            self.render_dataframe(df_filtered)
            
            # Render plot based on user inputs
            if x_axis and y_axis:
                self.render_plot(df_filtered, chart_type, x_axis, y_axis)
            
            # Render download button for the filtered data
            self.render_download_button(df_filtered)

    :param credentials_file: Path to the Google API credentials JSON file.
    :param sheet_name: Name of the Google Sheet to interact with.
    """
    self.credentials_file = credentials_file
    self.sheet_name = sheet_name
    self.client = self.authenticate()
    self.sheet = self.client.open(sheet_name)

def authenticate(self):
    """
    Authenticate and create a Google Sheets client.
    
    :return: Google Sheets client.
    """
    scope = [
        'https://spreadsheets.google.com/feeds',
        'https://www.googleapis.com/auth/drive'
    ]
    creds = ServiceAccountCredentials.from_json_keyfile_name(self.credentials_file, scope)
    client = gspread.authorize(creds)
    return client

def get_worksheet(self, worksheet_name):
    """
    Get a worksheet by name.
    
    :param worksheet_name: Name of the worksheet.
    :return: Worksheet object.
    """
    return self.sheet.worksheet(worksheet_name)

def read_worksheet(self, worksheet_name):
    """
    Read data from a worksheet into a Pandas DataFrame.
    
    :param worksheet_name: Name of the worksheet.
    :return: DataFrame containing the worksheet data.
    """
    worksheet = self.get_worksheet(worksheet_name)
    data = worksheet.get_all_records()
    return pd.DataFrame(data)

def write_to_worksheet(self, worksheet_name, dataframe):
    """
    Write a Pandas DataFrame to a worksheet.
    
    :param worksheet_name: Name of the worksheet.
    :param dataframe: DataFrame containing the data to write.
    """
    worksheet = self.get_worksheet(worksheet_name)
    worksheet.clear()
    worksheet.update([dataframe.columns.values.tolist()] + dataframe.values.tolist())

def append_to_worksheet(self, worksheet_name, dataframe):
    """
    Append a Pandas DataFrame to the end of a worksheet.
    
    :param worksheet_name: Name of the worksheet.
    :param dataframe: DataFrame containing the data to append.
    """
    worksheet = self.get_worksheet(worksheet_name)
    worksheet.append_rows(dataframe.values.tolist())

def create_worksheet(self, worksheet_name, rows=1000, cols=26):
    """
    Create a new worksheet.
    
    :param worksheet_name: Name of the worksheet to create.
    :param rows: Number of rows in the new worksheet.
    :param cols: Number of columns in the new worksheet.
    """
    self.sheet.add_worksheet(title=worksheet_name, rows=rows, cols=cols)

def delete_worksheet(self, worksheet_name):
    """
    Delete a worksheet by name.
    
    :param worksheet_name: Name of the worksheet to delete.
    """
    worksheet = self.get_worksheet(worksheet_name)
    self.sheet.del_worksheet(worksheet)

def list_worksheets(self):
    """
    List all worksheets in the Google Sheet.
    
    :return: List of worksheet names.
    """
    worksheets = self.sheet.worksheets()
    return [worksheet.title for worksheet in worksheets]

    :param api_key: OpenAI API key for authentication.
    :param model: Model to use for text generation.
    :param max_tokens: Maximum number of tokens to generate.
    :param temperature: Sampling temperature to use.
    """
    self.api_key = api_key
    openai.api_key = self.api_key
    self.model = model
    self.max_tokens = max_tokens
    self.temperature = temperature
    self.prompt = ""
    self.last_completion = None

def generate_text(self, prompt=None, n=1):
    """
    Generate text completion based on the given prompt.
    
    :param prompt: Text prompt for the model (if None, use the initialized prompt).
    :param n: Number of completions to generate.
    :return: The best generated text completion.
    """
    if prompt is None:
        prompt = self.prompt

    try:
        response = openai.Completion.create(
            model=self.model,
            prompt=prompt,
            max_tokens=self.max_tokens,
            temperature=self.temperature,
            n=n
        )
        completions = [choice.text.strip() for choice in response.choices]
        self.last_completion = max(completions, key=len)  # Assuming the best completion is the longest one
        return self.last_completion
    except Exception as e:
        print(f"Error generating text: {e}")
        return None

def get_last_completion(self):
    """
    Get the last generated text completion.
    
    :return: Last generated text completion.
    """
    return self.last_completion

def engineer_prompt(self, context, task, details=None, format_specification=None):
    """
    Engineer a prompt based on provided context, task, and optional details and format specification.
    
    :param context: Background information or context for the prompt.
    :param task: The main task or question for the prompt.
    :param details: Additional details or requirements for the prompt.
    :param format_specification: Format specifications for the output.
    """
    self.prompt = f"Context: {context}\n"
    self.prompt += f"Task: {task}\n"
    
    if details:
        self.prompt += f"Details: {details}\n"
    
    if format_specification:
        self.prompt += f"Format: {format_specification}\n"
    
    self.prompt += "Response: "

# Initialize the class with default parameters
gpt = GPTTextCompletion(
    api_key=api_key,
    model="text-davinci-003",
    max_tokens=150,
    temperature=0.7
)

# Use the prompt engineering method to create a prompt and set it as the class attribute
context = "You are an expert in machine learning."
task = "Explain the concept of overfitting."
details = "Include examples and methods to prevent it."
format_specification = "Provide the response in a structured format with bullet points."
gpt.engineer_prompt(context, task, details, format_specification)

# Generate text using the engineered prompt
best_completion = gpt.generate_text(n=3)

# Print the best completion
print("Best Completion:\n", best_completion)

    :param credentials_file: Path to the Google Cloud service account key JSON file.
    :param project_id: Google Cloud project ID.
    """
    self.credentials = service_account.Credentials.from_service_account_file(credentials_file)
    self.client = bigquery.Client(credentials=self.credentials, project=project_id)

def query(self, query):
    """
    Execute a SQL query and return the results as a DataFrame.
    
    :param query: SQL query string.
    :return: DataFrame containing the query results.
    """
    query_job = self.client.query(query)
    result = query_job.result()
    return result.to_dataframe()

def insert_rows(self, table_id, rows_to_insert):
    """
    Insert rows into a BigQuery table.
    
    :param table_id: Table ID in the format `project.dataset.table`.
    :param rows_to_insert: List of rows to insert, where each row is a dictionary.
    :return: List of errors encountered during the insert operation.
    """
    errors = self.client.insert_rows_json(table_id, rows_to_insert)
    if errors:
        print(f"Encountered errors while inserting rows: {errors}")
    return errors

def load_dataframe(self, dataframe, table_id, if_exists='replace'):
    """
    Load a DataFrame into a BigQuery table.
    
    :param dataframe: Pandas DataFrame to load.
    :param table_id: Table ID in the format `project.dataset.table`.
    :param if_exists: Behavior when the table exists. Options: 'replace', 'append'.
    """
    job_config = bigquery.LoadJobConfig()
    if if_exists == 'replace':
        job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
    elif if_exists == 'append':
        job_config.write_disposition = bigquery.WriteDisposition.WRITE_APPEND
    else:
        raise ValueError("Invalid value for if_exists: 'replace' or 'append' expected.")

    job = self.client.load_table_from_dataframe(dataframe, table_id, job_config=job_config)
    job.result()  # Wait for the job to complete

    print(f"Loaded {job.output_rows} rows into {table_id}.")

def create_table(self, table_id, schema):
    """
    Create a new BigQuery table with the specified schema.
    
    :param table_id: Table ID in the format `project.dataset.table`.
    :param schema: List of bigquery.SchemaField objects defining the table schema.
    """
    table = bigquery.Table(table_id, schema=schema)
    table = self.client.create_table(table)
    print(f"Created table {table_id}")

def delete_table(self, table_id):
    """
    Delete a BigQuery table.
    
    :param table_id: Table ID in the format `project.dataset.table`.
    """
    self.client.delete_table(table_id, not_found_ok=True)
    print(f"Deleted table {table_id}")

def list_datasets(self):
    """
    List all datasets in the project.
    
    :return: List of dataset IDs.
    """
    datasets = list(self.client.list_datasets())
    return [dataset.dataset_id for dataset in datasets]

def list_tables(self, dataset_id):
    """
    List all tables in a dataset.
    
    :param dataset_id: Dataset ID.
    :return: List of table IDs.
    """
    tables = list(self.client.list_tables(dataset_id))
    return [table.table_id for table in tables]

    :param dataframe: Pandas DataFrame to profile.
    """
    self.dataframe = dataframe

def generate_report(self, output_file=None):
    """
    Generate a profile report of the DataFrame.
    
    :param output_file: Optional file path to save the report as an HTML file.
    :return: ProfileReport object.
    """
    try:
        profile = ProfileReport(self.dataframe, explorative=True)
        if output_file:
            profile.to_file(output_file)
        return profile
    except Exception as e:
        print(f"Error generating report: {e}")

def set_dataframe(self, dataframe):
    """
    Set a new DataFrame for profiling.
    
    :param dataframe: Pandas DataFrame to profile.
    """
    self.dataframe = dataframe

def get_dataframe(self):
    """
    Get the current DataFrame being profiled.
    
    :return: Pandas DataFrame.
    """
    return self.dataframe

def fit(self, df, regressors=None, **kwargs):
    """
    Fit the Prophet model to the data.
    
    :param df: DataFrame with columns 'ds' and 'y' for time series data.
    :param regressors: List of additional regressor column names.
    :param kwargs: Additional keyword arguments for the Prophet model.
    """
    self.model = Prophet(**kwargs)
    if regressors:
        for regressor in regressors:
            self.model.add_regressor(regressor)
    self.model.fit(df)

def predict(self, future):
    """
    Predict using the fitted Prophet model.
    
    :param future: DataFrame with a column 'ds' and optional regressor columns.
    :return: DataFrame with predictions.
    """
    if self.model:
        return self.model.predict(future)
    else:
        print("Model has not been fitted yet.")
        return None

def save_model(self, file_path):
    """
    Save the trained model to a file.
    
    :param file_path: Path to the file where the model will be saved.
    """
    if self.model:
        with open(file_path, 'w') as f:
            f.write(model_to_json(self.model))
    else:
        print("Model has not been fitted yet.")

def load_model(self, file_path):
    """
    Load a trained model from a file.
    
    :param file_path: Path to the file where the model is saved.
    """
    with open(file_path, 'r') as f:
        self.model = model_from_json(f.read())

def tune_hyperparameters(self, df, regressors=None, initial='730 days', period='180 days', horizon='365 days'):
    """
    Tune hyperparameters for the Prophet model using cross-validation and performance metrics.
    
    :param df: DataFrame with columns 'ds' and 'y' for time series data.
    :param regressors: List of additional regressor column names.
    :param initial: Initial training period for cross-validation.
    :param period: Period between cutoff dates for cross-validation.
    :param horizon: Forecast horizon for cross-validation.
    """
    param_grid = {
        'changepoint_prior_scale': [0.001, 0.01, 0.1, 0.5],
        'seasonality_prior_scale': [0.01, 0.1, 1.0, 10.0],
        'holidays_prior_scale': [0.01, 0.1, 1.0, 10.0],
        'seasonality_mode': ['additive', 'multiplicative'],
        'yearly_seasonality': [5, 10, 15, 20],
        'weekly_seasonality': [5, 10, 15, 20],
        'daily_seasonality': [0, 5, 10]
    }

    best_rmse = float('inf')
    best_params = {}

    for cps in param_grid['changepoint_prior_scale']:
        for sps in param_grid['seasonality_prior_scale']:
            for hps in param_grid['holidays_prior_scale']:
                for sm in param_grid['seasonality_mode']:
                    for ys in param_grid['yearly_seasonality']:
                        for ws in param_grid['weekly_seasonality']:
                            for ds in param_grid['daily_seasonality']:
                                params = {
                                    'changepoint_prior_scale': cps,
                                    'seasonality_prior_scale': sps,
                                    'holidays_prior_scale': hps,
                                    'seasonality_mode': sm,
                                    'yearly_seasonality': ys,
                                    'weekly_seasonality': ws,
                                    'daily_seasonality': ds
                                }

                                model = Prophet(**params)
                                if regressors:
                                    for regressor in regressors:
                                        model.add_regressor(regressor)
                                model.fit(df)
                                
                                df_cv = cross_validation(model, initial=initial, period=period, horizon=horizon)
                                df_p = performance_metrics(df_cv)
                                rmse = df_p['rmse'].mean()

                                if rmse < best_rmse:
                                    best_rmse = rmse
                                    best_params = params

    self.best_params = best_params
    print(f"Best hyperparameters: {self.best_params}")

def fit_with_best_params(self, df, regressors=None):
    """
    Fit the Prophet model with the best hyperparameters.
    
    :param df: DataFrame with columns 'ds' and 'y' for time series data.
    :param regressors: List of additional regressor column names.
    """
    if self.best_params:
        self.fit(df, regressors, **self.best_params)
    else:
        print("Hyperparameters have not been tuned yet.")