Pylint report from report.jinja2

Unable to import 'agentlib.utils.plugin_import'

Unable to import 'agentlib_mpc.optimization_backends'

Unable to import 'numpy'

Unable to import 'pandas'

Unable to import 'pydantic'

Unable to import 'agentlib_mpc.utils'

Unused strip_multi_index imported from agentlib_flexquant.utils.data_handling

Too few public methods (1/2)

Too few public methods (0/2)

Variable name "dt" doesn't conform to snake_case naming style

Attribute name "dt" doesn't conform to snake_case naming style

Either all return statements in a function should return an expression, or none of them should.

Too many arguments (12/5)

Too many arguments (6/5)

Unnecessarily calls dunder method __deepcopy__. Use copy.deepcopy function.

Unnecessary "else" after "return", remove the "else" and de-indent the code inside it

Unnecessarily calls dunder method __deepcopy__. Use copy.deepcopy function.

Too many arguments (6/5)

Unnecessarily calls dunder method __deepcopy__. Use copy.deepcopy function.

Too many instance attributes (11/7)

Too few public methods (0/2)

Too many arguments (6/5)

Assigning the same variable 'series' to itself

Unable to import 'pandas'

Unable to import 'pydantic'

Unable to import 'agentlib.core.datamodels'

Unable to import 'pydantic'

Too few public methods (1/2)

Too few public methods (0/2)

Variable name "df" doesn't conform to snake_case naming style

Unable to import 'pandas'

Unable to import 'pydantic'

Unable to import 'agentlib.core.agent'

Unable to import 'agentlib.modules.simulation.simulator'

Unable to import 'agentlib.utils'

Unable to import 'agentlib_mpc.modules.mpc'

Unable to import 'agentlib_mpc.utils'

Unable to import 'agentlib_mpc.utils.analysis'

Variable name "df" doesn't conform to snake_case naming style

Variable name "df" doesn't conform to snake_case naming style

Too many instance attributes (29/7)

Too many arguments (6/5)

Variable name "f" doesn't conform to snake_case naming style

Variable name "f" doesn't conform to snake_case naming style

Variable name "df" doesn't conform to snake_case naming style

Unable to import 'pydantic'

Unused import pydantic

Unable to import 'pydantic'

Unable to import 'agentlib.core.agent'

Unable to import 'agentlib.core.errors'

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

Too few public methods (1/2)

Too few public methods (0/2)

Too few public methods (1/2)

Missing function or method docstring

Class name "INTEGRATION_METHOD" doesn't conform to PascalCase naming style

Unable to import 'pydantic'

Too few public methods (0/2)

Too few public methods (0/2)

Too few public methods (0/2)

Too few public methods (1/2)

Too few public methods (1/2)

Unable to import 'pydantic'

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

Unable to import 'pydantic'

Too few public methods (0/2)

Too few public methods (1/2)

Too few public methods (0/2)

Too few public methods (0/2)

Unable to import 'astor'

Unable to import 'black'

Reimport 'json' (imported line 11)

standard import "import json" should be placed before "import astor"

Imports from package json are not grouped

Unable to import 'numpy'

Reimport 'deepcopy' (imported line 14)

standard import "from copy import deepcopy" should be placed before "import astor"

Imports from package copy are not grouped

Reimport 'Path' (imported line 15)

standard import "from pathlib import Path" should be placed before "import astor"

Imports from package pathlib are not grouped

Reimport 'Union' (imported line 16)

standard import "from typing import List, Union" should be placed before "import astor"

Imports from package typing are not grouped

Unused List imported from typing

Unable to import 'pydantic'

Unable to import 'agentlib.core.agent'

Unable to import 'agentlib.core.datamodels'

Unable to import 'agentlib.core.errors'

Unable to import 'agentlib.core.module'

Unable to import 'agentlib.utils'

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

Unable to import 'agentlib_mpc.models.casadi_model'

Unable to import 'agentlib_mpc.modules.mpc_full'

Unable to import 'agentlib_mpc.optimization_backends.casadi_.basic'

Unable to import 'agentlib_mpc.data_structures.casadi_utils'

Too many instance attributes (17/7)

Line too long (104/100)

Line too long (104/100)

Variable name "f" doesn't conform to snake_case naming style

Lambda may not be necessary

Variable name "f" doesn't conform to snake_case naming style

Too many branches (18/12)

Unnecessarily calls dunder method __setattr__. Set attribute directly or use setattr built-in function.

Access to a protected member _collocation_polynomial of a client class

Too many local variables (17/15)

Variable name "f" doesn't conform to snake_case naming style

Variable name "f" doesn't conform to snake_case naming style

Too many branches (19/12)

Unnecessary "else" after "raise", remove the "else" and de-indent the code inside it

Variable name "f" doesn't conform to snake_case naming style

Unable to import 'agentlib_mpc.modules'

standard import "import os" should be placed before "from agentlib_mpc.modules import minlp_mpc, mpc_full"

standard import "import math" should be placed before "from agentlib_mpc.modules import minlp_mpc, mpc_full"

Unable to import 'numpy'

Unable to import 'pandas'

standard import "from typing import Optional, Dict" should be placed before "from agentlib_mpc.modules import minlp_mpc, mpc_full"

Unable to import 'pydantic'

standard import "from collections.abc import Iterable" should be placed before "from agentlib_mpc.modules import minlp_mpc, mpc_full"

Unused agentlib_flexquant.data_structures.globals imported as glbs

Unable to import 'agentlib'

third party import "from agentlib import AgentVariable" should be placed before "import agentlib_flexquant.data_structures.globals as glbs"

Unable to import 'agentlib_mpc.modules'

Reimport 'mpc_full' (imported line 4)

Reimport 'minlp_mpc' (imported line 4)

third party import "from agentlib_mpc.modules import mpc_full, minlp_mpc" should be placed before "import agentlib_flexquant.data_structures.globals as glbs"

Imports from package agentlib_mpc are not grouped

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

third party import "from agentlib_mpc.data_structures.mpc_datamodels import Results" should be placed before "import agentlib_flexquant.data_structures.globals as glbs"

Missing class docstring

Too few public methods (0/2)

No exception type(s) specified

Missing function or method docstring

Variable name "df" doesn't conform to snake_case naming style

Too many arguments (6/5)

Too many local variables (18/15)

Unused argument 'mpc_time_step'

Use of eval

Missing class docstring

Too few public methods (0/2)

No exception type(s) specified

Missing function or method docstring

Variable name "df" doesn't conform to snake_case naming style

Too many arguments (6/5)

Too many local variables (19/15)

Unused argument 'mpc_time_step'

Use of eval

Unable to import 'agentlib'

Unable to import 'numpy'

Unable to import 'pandas'

Unable to import 'pydantic'

Too few public methods (0/2)

Too few public methods (1/2)

Too few public methods (1/2)

Attribute name "df" doesn't conform to snake_case naming style

Missing function or method docstring

Too many branches (17/12)

Variable name "n" doesn't conform to snake_case naming style

Variable name "ts" doesn't conform to snake_case naming style

Argument name "df" doesn't conform to snake_case naming style

Argument name "ts" doesn't conform to snake_case naming style

Argument name "n" doesn't conform to snake_case naming style

Too many local variables (18/15)

Too many branches (15/12)

Unused variable 'i'

Too many arguments (8/5)

Missing module docstring

Unable to import 'agentlib'

Unable to import 'numpy'

Unable to import 'pandas'

Unable to import 'agentlib.core.datamodels'

third party import "from agentlib.core.datamodels import AgentVariable" should be placed before "import agentlib_flexquant.data_structures.globals as glbs"

Unable to import 'pydantic'

third party import "from pydantic import ConfigDict, Field, model_validator" should be placed before "import agentlib_flexquant.data_structures.globals as glbs"

Missing class docstring

Too few public methods (1/2)

Missing function or method docstring

Attribute 'random_generator' defined outside __init__

Missing function or method docstring

Attribute 'cooldown_ticker' defined outside __init__

Variable name "df" doesn't conform to snake_case naming style

Unused argument 'name'

Line too long (102/100)

Attribute 'cooldown_ticker' defined outside __init__

Unused argument 'name'

Unnecessary pass statement

Unused argument 'inp'

Unused argument 'name'

Missing function or method docstring

Unable to import 'numpy'

Unable to import 'pandas'

Unable to import 'pydantic'

Reimport 'Dict' (imported line 4)

Reimport 'Union' (imported line 4)

standard import "from typing import Dict, Union, Optional" should be placed before "import numpy as np"

Imports from package typing are not grouped

standard import "from collections.abc import Iterable" should be placed before "import numpy as np"

Unable to import 'agentlib.core.datamodels'

Unable to import 'agentlib_mpc.modules'

Unused full_trajectory_prefix imported from agentlib_flexquant.data_structures.globals

Unused STORED_ENERGY_ALIAS_NEG imported from agentlib_flexquant.data_structures.globals

Unused STORED_ENERGY_ALIAS_POS imported from agentlib_flexquant.data_structures.globals

Missing class docstring

Too few public methods (0/2)

No exception type(s) specified

Variable name "df" doesn't conform to snake_case naming style

Missing function or method docstring

Missing function or method docstring

Too many arguments (6/5)

Too many local variables (18/15)

Unused argument 'mpc_time_step'

Use of eval

Missing class docstring

Too few public methods (0/2)

No exception type(s) specified

Missing function or method docstring

Missing function or method docstring

Variable name "df" doesn't conform to snake_case naming style

Too many arguments (6/5)

Too many local variables (19/15)

Unused argument 'mpc_time_step'

Use of eval

Missing module docstring

Unable to import 'pydantic'

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[362:543]
==agentlib_flexquant.modules.shadow_mpc:[382:563]
        if not self.config.set_outputs:
            return
        self.logger.info("Sending optimal output values to data_broker.")

        # simulate with the casadi simulator
        self.sim_flex_model(solution)

        df = solution.df
        if self.flex_results is not None:
            for output in self.var_ref.outputs:
                if output not in [
                    self.config.power_variable_name,
                    self.config.storage_variable_name,
                ]:
                    series = df.variable[output]
                    self.set(output, series)
            # send the power and storage variable value from simulation results
            upsampled_output_power = self.flex_results[self.config.power_variable_name]
            self.set(self.config.power_variable_name, upsampled_output_power)
            if self.config.storage_variable_name is not None:
                upsampled_output_storage = self.flex_results[self.config.storage_variable_name]
                self.set(self.config.storage_variable_name, upsampled_output_storage.dropna())
        else:
            for output in self.var_ref.outputs:
                series = df.variable[output]
                self.set(output, series)

    def sim_flex_model(self, solution):
        """simulate the flex model over the preditcion horizon and save results"""

        # return if sim_time_step is not a positive integer and system is in provision
        if not (self.config.casadi_sim_time_step > 0 and not self.get("in_provision").value):
            return

        # read the defined simulation time step
        sim_time_step = self.config.casadi_sim_time_step
        mpc_time_step = self.config.time_step

        # set the horizon length and the number of simulation steps
        total_horizon_time = int(self.config.prediction_horizon * self.config.time_step)
        n_simulation_steps = math.ceil(total_horizon_time / sim_time_step)

        # read the current optimization result
        result_df = solution.df

        # initialize the flex sim results Dataframe
        self._initialize_flex_results(
            n_simulation_steps, total_horizon_time, sim_time_step, result_df
        )

        # Update model parameters and initial states
        self._update_model_parameters()
        self._update_initial_states(result_df)

        # Run simulation
        self._run_simulation(
            n_simulation_steps, sim_time_step, mpc_time_step, result_df, total_horizon_time
        )

        # set index of flex results to the same as mpc result
        store_results_df = self.flex_results.copy(deep=True)
        store_results_df.index = self.flex_results.index.tolist()

        # save results
        if not os.path.exists(self.res_file_flex):
            store_results_df.to_csv(self.res_file_flex)
        else:
            store_results_df.to_csv(self.res_file_flex, mode="a", header=False)

        # set the flex results format same as mpc result while updating Agentvariable
        self.flex_results.index = self.flex_results.index.get_level_values(1)

    def _initialize_flex_results(
        self, n_simulation_steps, horizon_length, sim_time_step, result_df
    ):
        """Initialize the flex results dataframe with the correct dimension and index and fill with
         existing results from optimization"""

        # create MultiIndex for collocation points
        index_coll = pd.MultiIndex.from_arrays(
            [[self.env.now] * len(result_df.index), result_df.index],
            names=["time_step", "time"]
            # Match the names with multi_index but note they're reversed
        )
        # create Multiindex for full simulation sample times
        index_full_sample = pd.MultiIndex.from_tuples(
            zip(
                [self.env.now] * (n_simulation_steps + 1),
                range(0, horizon_length + sim_time_step, sim_time_step),
            ),
            names=["time_step", "time"],
        )
        # merge indexes
        new_index = index_coll.union(index_full_sample).sort_values()
        # initialize the flex results with correct dimension
        self.flex_results = pd.DataFrame(np.nan, index=new_index, columns=self.var_ref.outputs)

        # Get the optimization outputs and create a series for fixed optimization outputs with the
        # correct MultiIndex format
        opti_outputs = result_df.variable[self.config.power_variable_name]
        fixed_opti_output = pd.Series(
            opti_outputs.values,
            index=index_coll,
        )
        # fill the output value at the time step where it already exists in optimization output
        for idx in fixed_opti_output.index:
            if idx in self.flex_results.index:
                self.flex_results.loc[idx, self.config.power_variable_name] = fixed_opti_output[idx]

    def _update_model_parameters(self):
        """update the value of module parameters with value from config,
        since creating a model just reads the value in the model class but not the config
        """

        for par in self.config.parameters:
            self.flex_model.set(par.name, par.value)

    def _update_initial_states(self, result_df):
        """set the initial value of states"""

        # get state values from the mpc optimization result
        state_values = result_df.variable[self.var_ref.states]
        # update state values with last measurement
        for state, value in zip(self.var_ref.states, state_values.iloc[0]):
            self.flex_model.set(state, value)

    def _run_simulation(
        self, n_simulation_steps, sim_time_step, mpc_time_step, result_df, total_horizon_time
    ):
        """simulate with flex model over the prediction horizon"""

        # get control and input values from the mpc optimization result
        control_values = result_df.variable[
            [*self.var_ref.controls, *self.var_ref.binary_controls]
        ].dropna()
        input_values = result_df.parameter[self.var_ref.inputs].dropna()

        # Get the simulation time step index
        sim_time_index = np.arange(0, (n_simulation_steps + 1) * sim_time_step, sim_time_step)

        # Reindex the controls and inputs to sim_time_index
        control_values_full = control_values.copy().reindex(sim_time_index, method="ffill")
        input_values_full = input_values.copy().reindex(sim_time_index, method="nearest")

        for i in range(0, n_simulation_steps):
            current_sim_time = i * sim_time_step

            # Apply control and input values from the appropriate MPC step
            for control, value in zip(
                self.var_ref.controls,
                control_values_full.loc[current_sim_time, self.var_ref.controls],
            ):
                self.flex_model.set(control, value)

            for binary_control, value in zip(
                self.var_ref.binary_controls,
                control_values_full.loc[current_sim_time, self.var_ref.binary_controls],
            ):
                self.flex_model.set(binary_control, value)

            for input_var, value in zip(
                self.var_ref.inputs, input_values_full.loc[current_sim_time]
            ):
                # change the type of iterable input, since casadi model can't deal with iterable
                if issubclass(eval(self.flex_model.get(input_var).type), Iterable):
                    self.flex_model.get(input_var).type = type(value).__name__
                self.flex_model.set(input_var, value)

            # do integration
            # reduce the simulation time step so that the total horizon time will not be exceeded
            if current_sim_time + sim_time_step <= total_horizon_time:
                t_sample = sim_time_step
            else:
                t_sample = total_horizon_time - current_sim_time
            self.flex_model.do_step(t_start=0, t_sample=t_sample)

            # save output
            for output in self.var_ref.outputs:
                self.flex_results.loc[
                    (self.env.now, current_sim_time + t_sample), output
                ] = self.flex_model.get_output(output).value

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[98:234]
==agentlib_flexquant.modules.shadow_mpc:[382:514]
        if not self.config.set_outputs:
            return
        self.logger.info("Sending optimal output values to data_broker.")

        # simulate with the casadi simulator
        self.sim_flex_model(solution)

        # extract solution DataFrama
        df = solution.df

        # send the outputs
        if self.flex_results is not None:
            for output in self.var_ref.outputs:
                if output not in [
                    self.config.power_variable_name,
                    self.config.storage_variable_name,
                ]:
                    series = df.variable[output]
                    self.set(output, series)
            # send the power and storage variable value from simulation results
            upsampled_output_power = self.flex_results[self.config.power_variable_name]
            self.set(self.config.power_variable_name, upsampled_output_power)
            if self.config.storage_variable_name is not None:
                upsampled_output_storage = self.flex_results[self.config.storage_variable_name]
                self.set(self.config.storage_variable_name, upsampled_output_storage.dropna())
        else:
            for output in self.var_ref.outputs:
                series = df.variable[output]
                self.set(output, series)

    def sim_flex_model(self, solution):
        """simulate the flex model over the preditcion horizon and save results"""

        # return if sim_time_step is not a positive integer and system is in provision
        if not (self.config.casadi_sim_time_step > 0 and not self.get("in_provision").value):
            return

        # read the defined simulation time step
        sim_time_step = self.config.casadi_sim_time_step
        mpc_time_step = self.config.time_step

        # set the horizon length and the number of simulation steps
        total_horizon_time = int(self.config.prediction_horizon * self.config.time_step)
        n_simulation_steps = math.ceil(total_horizon_time / sim_time_step)

        # read the current optimization result
        result_df = solution.df

        # initialize the flex sim results Dataframe
        self._initialize_flex_results(
            n_simulation_steps, total_horizon_time, sim_time_step, result_df
        )

        # Update model parameters and initial states
        self._update_model_parameters()
        self._update_initial_states(result_df)

        # Run simulation
        self._run_simulation(
            n_simulation_steps, sim_time_step, mpc_time_step, result_df, total_horizon_time
        )

        # set index of flex results to the same as mpc result
        store_results_df = self.flex_results.copy(deep=True)
        store_results_df.index = self.flex_results.index.tolist()

        # save results
        if not os.path.exists(self.res_file_flex):
            store_results_df.to_csv(self.res_file_flex)
        else:
            store_results_df.to_csv(self.res_file_flex, mode="a", header=False)

        # set the flex results format same as mpc result while updating Agentvariable
        self.flex_results.index = self.flex_results.index.get_level_values(1)

    def _initialize_flex_results(
        self, n_simulation_steps, horizon_length, sim_time_step, result_df
    ):
        """Initialize the flex results dataframe with the correct dimension and index
        and fill with existing results from optimization
        """

        # create MultiIndex for collocation points
        index_coll = pd.MultiIndex.from_arrays(
            [[self.env.now] * len(result_df.index), result_df.index],
            names=["time_step", "time"]
            # Match the names with multi_index but note they're reversed
        )
        # create Multiindex for full simulation sample times
        index_full_sample = pd.MultiIndex.from_tuples(
            zip(
                [self.env.now] * (n_simulation_steps + 1),
                range(0, horizon_length + sim_time_step, sim_time_step),
            ),
            names=["time_step", "time"],
        )
        # merge indexes
        new_index = index_coll.union(index_full_sample).sort_values()
        # initialize the flex results with correct dimension
        self.flex_results = pd.DataFrame(np.nan, index=new_index, columns=self.var_ref.outputs)

        # Get the optimization outputs and create a series for fixed optimization outputs with the
        # correct MultiIndex format
        opti_outputs = result_df.variable[self.config.power_variable_name]
        fixed_opti_output = pd.Series(
            opti_outputs.values,
            index=index_coll,
        )
        # fill the output value at the time step where it already exists in optimization output
        for idx in fixed_opti_output.index:
            if idx in self.flex_results.index:
                self.flex_results.loc[idx, self.config.power_variable_name] = fixed_opti_output[idx]

    def _update_model_parameters(self):
        """update the value of module parameters with value from config,
        since creating a model just reads the value in the model class but not the config
        """

        for par in self.config.parameters:
            self.flex_model.set(par.name, par.value)

    def _update_initial_states(self, result_df):
        """set the initial value of states"""

        # get state values from the mpc optimization result
        state_values = result_df.variable[self.var_ref.states]
        # update state values with last measurement
        for state, value in zip(self.var_ref.states, state_values.iloc[0]):
            self.flex_model.set(state, value)

    def _run_simulation(
        self, n_simulation_steps, sim_time_step, mpc_time_step, result_df, total_horizon_time
    ):
        """simulate with flex model over the prediction horizon"""

        # get control and input values from the mpc optimization result

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[181:276]
==agentlib_flexquant.modules.shadow_mpc:[190:285]
        index_coll = pd.MultiIndex.from_arrays(
            [[self.env.now] * len(result_df.index), result_df.index],
            names=["time_step", "time"]
            # Match the names with multi_index but note they're reversed
        )
        # create Multiindex for full simulation sample times
        index_full_sample = pd.MultiIndex.from_tuples(
            zip(
                [self.env.now] * (n_simulation_steps + 1),
                range(0, horizon_length + sim_time_step, sim_time_step),
            ),
            names=["time_step", "time"],
        )
        # merge indexes
        new_index = index_coll.union(index_full_sample).sort_values()
        # initialize the flex results with correct dimension
        self.flex_results = pd.DataFrame(np.nan, index=new_index, columns=self.var_ref.outputs)

        # Get the optimization outputs and create a series for fixed optimization outputs with the
        # correct MultiIndex format
        opti_outputs = result_df.variable[self.config.power_variable_name]
        fixed_opti_output = pd.Series(
            opti_outputs.values,
            index=index_coll,
        )
        # fill the output value at the time step where it already exists in optimization output
        for idx in fixed_opti_output.index:
            if idx in self.flex_results.index:
                self.flex_results.loc[idx, self.config.power_variable_name] = fixed_opti_output[idx]

    def _update_model_parameters(self):
        """update the value of module parameters with value from config,
        since creating a model just reads the value in the model class but not the config
        """

        for par in self.config.parameters:
            self.flex_model.set(par.name, par.value)

    def _update_initial_states(self, result_df):
        """set the initial value of states"""

        # get state values from the mpc optimization result
        state_values = result_df.variable[self.var_ref.states]
        # update state values with last measurement
        for state, value in zip(self.var_ref.states, state_values.iloc[0]):
            self.flex_model.set(state, value)

    def _run_simulation(
        self, n_simulation_steps, sim_time_step, mpc_time_step, result_df, total_horizon_time
    ):
        """simulate with flex model over the prediction horizon"""

        # get control and input values from the mpc optimization result
        control_values = result_df.variable[self.var_ref.controls].dropna()
        input_values = result_df.parameter[self.var_ref.inputs].dropna()

        # Get the simulation time step index
        sim_time_index = np.arange(0, (n_simulation_steps + 1) * sim_time_step, sim_time_step)

        # Reindex the controls and inputs to sim_time_index
        control_values_full = control_values.copy().reindex(sim_time_index, method="ffill")
        input_values_full = input_values.copy().reindex(sim_time_index, method="nearest")

        for i in range(0, n_simulation_steps):
            current_sim_time = i * sim_time_step

            # Apply control and input values from the appropriate MPC step
            for control, value in zip(
                self.var_ref.controls, control_values_full.loc[current_sim_time]
            ):
                self.flex_model.set(control, value)

            for input_var, value in zip(
                self.var_ref.inputs, input_values_full.loc[current_sim_time]
            ):
                # change the type of iterable input, since casadi model can't deal with iterable
                if issubclass(eval(self.flex_model.get(input_var).type), Iterable):
                    self.flex_model.get(input_var).type = type(value).__name__
                self.flex_model.set(input_var, value)

            # do integration
            # reduce the simulation time step so that the total horizon time will not be exceeded
            if current_sim_time + sim_time_step <= total_horizon_time:
                t_sample = sim_time_step
            else:
                t_sample = total_horizon_time - current_sim_time
            self.flex_model.do_step(t_start=0, t_sample=t_sample)

            # save output
            for output in self.var_ref.outputs:
                self.flex_results.loc[
                    (self.env.now, current_sim_time + t_sample), output
                ] = self.flex_model.get_output(output).value

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[109:181]
==agentlib_flexquant.modules.shadow_mpc:[72:137]
        if self.flex_results is not None:
            for output in self.var_ref.outputs:
                if output not in [
                    self.config.power_variable_name,
                    self.config.storage_variable_name,
                ]:
                    series = df.variable[output]
                    self.set(output, series)
            # send the power and storage variable value from simulation results
            upsampled_output_power = self.flex_results[self.config.power_variable_name]
            self.set(self.config.power_variable_name, upsampled_output_power)
            if self.config.storage_variable_name is not None:
                upsampled_output_storage = self.flex_results[self.config.storage_variable_name]
                self.set(self.config.storage_variable_name, upsampled_output_storage.dropna())
        else:
            for output in self.var_ref.outputs:
                series = df.variable[output]
                self.set(output, series)

    def sim_flex_model(self, solution):
        """simulate the flex model over the preditcion horizon and save results"""

        # return if sim_time_step is not a positive integer and system is in provision
        if not (self.config.casadi_sim_time_step > 0 and not self.get("in_provision").value):
            return

        # read the defined simulation time step
        sim_time_step = self.config.casadi_sim_time_step
        mpc_time_step = self.config.time_step

        # set the horizon length and the number of simulation steps
        total_horizon_time = int(self.config.prediction_horizon * self.config.time_step)
        n_simulation_steps = math.ceil(total_horizon_time / sim_time_step)

        # read the current optimization result
        result_df = solution.df

        # initialize the flex sim results Dataframe
        self._initialize_flex_results(
            n_simulation_steps, total_horizon_time, sim_time_step, result_df
        )

        # Update model parameters and initial states
        self._update_model_parameters()
        self._update_initial_states(result_df)

        # Run simulation
        self._run_simulation(
            n_simulation_steps, sim_time_step, mpc_time_step, result_df, total_horizon_time
        )

        # set index of flex results to the same as mpc result
        store_results_df = self.flex_results.copy(deep=True)
        store_results_df.index = self.flex_results.index.tolist()

        # save results
        if not os.path.exists(self.res_file_flex):
            store_results_df.to_csv(self.res_file_flex)
        else:
            store_results_df.to_csv(self.res_file_flex, mode="a", header=False)

        # set the flex results format same as mpc result while updating Agentvariable
        self.flex_results.index = self.flex_results.index.get_level_values(1)

    def register_callbacks(self):

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[441:494]
==agentlib_flexquant.modules.shadow_mpc:[190:243]
        index_coll = pd.MultiIndex.from_arrays(
            [[self.env.now] * len(result_df.index), result_df.index],
            names=["time_step", "time"]
            # Match the names with multi_index but note they're reversed
        )
        # create Multiindex for full simulation sample times
        index_full_sample = pd.MultiIndex.from_tuples(
            zip(
                [self.env.now] * (n_simulation_steps + 1),
                range(0, horizon_length + sim_time_step, sim_time_step),
            ),
            names=["time_step", "time"],
        )
        # merge indexes
        new_index = index_coll.union(index_full_sample).sort_values()
        # initialize the flex results with correct dimension
        self.flex_results = pd.DataFrame(np.nan, index=new_index, columns=self.var_ref.outputs)

        # Get the optimization outputs and create a series for fixed optimization outputs with
        # the correct MultiIndex format
        opti_outputs = result_df.variable[self.config.power_variable_name]
        fixed_opti_output = pd.Series(
            opti_outputs.values,
            index=index_coll,
        )
        # fill the output value at the time step where it already exists in optimization output
        for idx in fixed_opti_output.index:
            if idx in self.flex_results.index:
                self.flex_results.loc[idx, self.config.power_variable_name] = fixed_opti_output[idx]

    def _update_model_parameters(self):
        """update the value of module parameters with value from config,
        since creating a model just reads the value in the model class but not the config
        """

        for par in self.config.parameters:
            self.flex_model.set(par.name, par.value)

    def _update_initial_states(self, result_df):
        """set the initial value of states"""

        # get state values from the mpc optimization result
        state_values = result_df.variable[self.var_ref.states]
        # update state values with last measurement
        for state, value in zip(self.var_ref.states, state_values.iloc[0]):
            self.flex_model.set(state, value)

    def _run_simulation(
        self, n_simulation_steps, sim_time_step, mpc_time_step, result_df, total_horizon_time
    ):
        """simulate with flex model over the prediction horizon"""

        # get control and input values from the mpc optimization result

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[253:276]
==agentlib_flexquant.modules.shadow_mpc:[542:563]
            for input_var, value in zip(
                self.var_ref.inputs, input_values_full.loc[current_sim_time]
            ):
                # change the type of iterable input, since casadi model can't deal with iterable
                if issubclass(eval(self.flex_model.get(input_var).type), Iterable):
                    self.flex_model.get(input_var).type = type(value).__name__
                self.flex_model.set(input_var, value)

            # do integration
            # reduce the simulation time step so that the total horizon time will not be exceeded
            if current_sim_time + sim_time_step <= total_horizon_time:
                t_sample = sim_time_step
            else:
                t_sample = total_horizon_time - current_sim_time
            self.flex_model.do_step(t_start=0, t_sample=t_sample)

            # save output
            for output in self.var_ref.outputs:
                self.flex_results.loc[
                    (self.env.now, current_sim_time + t_sample), output
                ] = self.flex_model.get_output(output).value

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[522:543]
==agentlib_flexquant.modules.shadow_mpc:[262:285]
            for input_var, value in zip(
                self.var_ref.inputs, input_values_full.loc[current_sim_time]
            ):
                # change the type of iterable input, since casadi model can't deal with iterable
                if issubclass(eval(self.flex_model.get(input_var).type), Iterable):
                    self.flex_model.get(input_var).type = type(value).__name__
                self.flex_model.set(input_var, value)

            # do integration
            # reduce the simulation time step so that the total horizon time will not be exceeded
            if current_sim_time + sim_time_step <= total_horizon_time:
                t_sample = sim_time_step
            else:
                t_sample = total_horizon_time - current_sim_time
            self.flex_model.do_step(t_start=0, t_sample=t_sample)

            # save output
            for output in self.var_ref.outputs:
                self.flex_results.loc[
                    (self.env.now, current_sim_time + t_sample), output
                ] = self.flex_model.get_output(output).value

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[318:339]
==agentlib_flexquant.modules.shadow_mpc:[312:327]
        if self.config.casadi_sim_time_step > 0:
            # generate a separate flex_model for integration to ensure the model used in MPC
            # optimization remains unaffected
            self.flex_model = type(self.model)(dt=self.config.casadi_sim_time_step)
            # generate the filename for the simulation results
            self.res_file_flex = self.config.optimization_backend["results_file"].replace(
                "mpc", "mpc_sim"
            )
            # clear the casadi simulator result at the first time step if already exists
            try:
                os.remove(self.res_file_flex)
            except:
                pass

    def register_callbacks(self):

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[60:81]
==agentlib_flexquant.modules.shadow_mpc:[50:67]
        if self.config.casadi_sim_time_step > 0:
            # generate a separate flex_model for integration to ensure
            # the model used in MPC optimization remains unaffected
            self.flex_model = type(self.model)(dt=self.config.casadi_sim_time_step)
            # generate the filename for the simulation results
            self.res_file_flex = self.config.optimization_backend["results_file"].replace(
                "mpc", "mpc_sim"
            )
            # clear the casadi simulator result at the first time step if already exists
            try:
                os.remove(self.res_file_flex)
            except:
                pass

    def pre_computation_hook(self):
        """Calculate relative start and end times for flexibility provision.

        When in provision mode, computes the relative timing for flexibility
        events based on the external power profile timestamps and current
        environment time.
        """

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[235:249]
==agentlib_flexquant.modules.shadow_mpc:[517:531]
        input_values = result_df.parameter[self.var_ref.inputs].dropna()

        # Get the simulation time step index
        sim_time_index = np.arange(0, (n_simulation_steps + 1) * sim_time_step, sim_time_step)

        # Reindex the controls and inputs to sim_time_index
        control_values_full = control_values.copy().reindex(sim_time_index, method="ffill")
        input_values_full = input_values.copy().reindex(sim_time_index, method="nearest")

        for i in range(0, n_simulation_steps):
            current_sim_time = i * sim_time_step

            # Apply control and input values from the appropriate MPC step
            for control, value in zip(

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[497:511]
==agentlib_flexquant.modules.shadow_mpc:[244:258]
        input_values = result_df.parameter[self.var_ref.inputs].dropna()

        # Get the simulation time step index
        sim_time_index = np.arange(0, (n_simulation_steps + 1) * sim_time_step, sim_time_step)

        # Reindex the controls and inputs to sim_time_index
        control_values_full = control_values.copy().reindex(sim_time_index, method="ffill")
        input_values_full = input_values.copy().reindex(sim_time_index, method="nearest")

        for i in range(0, n_simulation_steps):
            current_sim_time = i * sim_time_step

            # Apply control and input values from the appropriate MPC step
            for control, value in zip(

Similar lines in 2 files
==agentlib_flexquant.modules.flexibility_indicator:[453:476]
==agentlib_flexquant.modules.flexibility_market:[87:96]
        results_file = self.config.results_file
        try:
            results = pd.read_csv(results_file, header=[0], index_col=[0, 1])
            return results
        except FileNotFoundError:
            self.logger.error("Results file %s was not found.", results_file)
            return None

    def register_callbacks(self):

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[282:288]
==agentlib_flexquant.modules.shadow_mpc:[25:31]
    casadi_sim_time_step: int = Field(
        default=0,
        description="Time step for simulation with Casadi simulator. Value is read from "
                    "FlexQuantConfig",
    )
    power_variable_name: str = Field(

Similar lines in 2 files
==agentlib_flexquant.modules.flexibility_indicator:[324:332]
==agentlib_flexquant.modules.flexibility_market:[61:69]
        if self.results_file and self.results_file.suffix != ".csv":
            raise ValueError(
                f"Invalid file extension for 'results_file': '{self.results_file}'. "
                f"Expected a '.csv' file."
            )
        return self

Unable to import 'numpy'

Unable to import 'agentlib.core.errors'

Unable to import 'agentlib_mpc.optimization_backends.casadi_.minlp_cia'

Unable to import 'agentlib_mpc.optimization_backends.casadi_.core.casadi_backend'

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

Consider explicitly re-raising using 'except ImportError as exc' and 'raise OptionalDependencyError(used_object='Pycombina', dependency_install='.\\ after cloning pycombina. Instructions: https://pycombina.readthedocs.io/en/latest/install.html#') from exc'

Anomalous backslash in string: '\ '. String constant might be missing an r prefix.

Missing class docstring

Too few public methods (0/2)

Missing class docstring

Too few public methods (0/2)

Missing class docstring

Too few public methods (1/2)

Useless parent or super() delegation in method '__init__'

Missing function or method docstring

Unnecessary "elif" after "continue", remove the leading "el" from "elif"

Bad indentation. Found 20 spaces, expected 16

Line too long (149/100)

Bad indentation. Found 20 spaces, expected 16

Bad indentation. Found 20 spaces, expected 16

Bad indentation. Found 20 spaces, expected 16

Bad indentation. Found 20 spaces, expected 16

Bad indentation. Found 24 spaces, expected 20

Bad indentation. Found 24 spaces, expected 20

Missing module docstring

Unable to import 'agentlib.core.agent'

Unable to import 'agentlib.core.module'

Unable to import 'agentlib.modules'

Variable name "v" doesn't conform to snake_case naming style

Consider iterating with .items()

Variable name "vv" doesn't conform to snake_case naming style

Variable name "v" doesn't conform to snake_case naming style

Either all return statements in a function should return an expression, or none of them should.

Else clause on loop without a break statement, remove the else and de-indent all the code inside it

Lambda expression called directly. Execute the expression inline instead.

Missing function or method docstring

Missing module docstring

Unable to import 'pandas'

Unable to import 'agentlib_mpc.utils'

Argument name "s" doesn't conform to snake_case naming style

Missing function or method docstring

Lambda may not be necessary

Use of eval

Argument name "df" doesn't conform to snake_case naming style

Missing module docstring

Unable to import 'pandas'

Unable to import 'agentlib.core.agent'

Unable to import 'agentlib_mpc.utils'

Unable to import 'agentlib_mpc.utils.analysis'

Unable to import 'agentlib_mpc.utils.plotting.interactive'

Unable to import 'dash'

Unable to import 'plotly'

Unable to import 'pydantic'

Use 'from agentlib_flexquant.data_structures import flex_results' instead

Too few public methods (0/2)

Too many instance attributes (8/7)

Too many arguments (7/5)

Attribute name "LINE_PROPERTIES" doesn't conform to snake_case naming style

Unnecessary use of a comprehension, use list(self.intersection_mpcs_sim.keys()) instead.

Consider iterating the dictionary directly instead of calling .keys()

Too many statements (135/50)

Argument name "s" doesn't conform to snake_case naming style

Either all return statements in a function should return an expression, or none of them should.

Either all return statements in a function should return an expression, or none of them should.

Too many arguments (6/5)

Consider iterating the dictionary directly instead of calling .keys()

Variable name "ts" doesn't conform to snake_case naming style

Consider using '{"t": 20, "b": 20}' instead of a call to 'dict'.

Using an f-string that does not have any interpolated variables

Missing module docstring

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

Unused full_trajectory_prefix imported from agentlib_flexquant.data_structures.globals

Redefining built-in 'type'

Redefining built-in 'type'

Method name "visit_Module" doesn't conform to snake_case naming style

Method name "visit_ClassDef" doesn't conform to snake_case naming style

Unnecessary "elif" after "return", remove the leading "el" from "elif"

Consider merging these isinstance calls to isinstance(body.value, (ast.BinOp, ast.Tuple))

Consider merging these isinstance calls to isinstance(body.value, (ast.BinOp, ast.Tuple))

Unused variable 'ind'

Missing function or method docstring