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)

Trailing whitespace

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.

Trailing whitespace

Line too long (115/100)

Too many arguments (13/5)

Too many arguments (6/5)

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

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

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

Too many arguments (9/5)

Too many local variables (17/15)

Line too long (119/100)

Too few public methods (0/2)

Too many arguments (6/5)

Assigning the same variable 'series' to itself

Trailing whitespace

Trailing whitespace

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.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

Import outside toplevel (warnings)

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'

Unable to import 'agentlib.core.agent'

Unable to import 'agentlib.core.errors'

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

Line too long (106/100)

Line too long (117/100)

Trailing whitespace

Trailing whitespace

Missing function or method docstring

Too few public methods (1/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'

Line too long (109/100)

Trailing whitespace

Too few public methods (1/2)

Trailing whitespace

Missing function or method docstring

Trailing whitespace

Trailing whitespace

Trailing whitespace

Trailing whitespace

Trailing whitespace

Trailing whitespace

Trailing whitespace

Trailing whitespace

Trailing whitespace

Too many lines in module (1050/1000)

Unable to import 'astor'

Unable to import 'black'

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

Unable to import 'numpy'

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

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

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

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.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)

Lambda may not be necessary

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

Too many local variables (22/15)

Too many branches (27/12)

Too many statements (73/50)

Redefining built-in 'input'

Use lazy % formatting in logging functions

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

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

Access to a protected member _collocation_polynomial of a client class

Too many local variables (18/15)

Line too long (110/100)

Line too long (115/100)

Line too long (110/100)

Line too long (115/100)

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

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

Use lazy % formatting in logging functions

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

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

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

Consider explicitly re-raising using 'raise Exception(f"Could not adapt and create a new simulation config due to: {e}. Please check {simulator_agent_config} and '{save_name_suffix}'") from e'

Raising too general exception: Exception

Unable to import 'numpy'

Unable to import 'pandas'

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

Unable to import 'pydantic'

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

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.mpc'

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

Unable to import 'agentlib_mpc.data_structures.mpc_datamodels'

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

Missing class docstring

Too few public methods (0/2)

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)

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)

Trailing whitespace

Trailing whitespace

Trailing whitespace

Line too long (102/100)

Missing function or method docstring

Line too long (134/100)

Trailing whitespace

Line too long (138/100)

Trailing whitespace

Line too long (128/100)

Missing function or method docstring

Line too long (103/100)

Line too long (103/100)

Trailing whitespace

Trailing whitespace

Unused variable 'alias'

Trailing whitespace

Trailing whitespace

Trailing whitespace

Line too long (114/100)

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

Line too long (107/100)

Missing function or method docstring

Trailing whitespace

Trailing whitespace

Trailing whitespace

Line too long (102/100)

Trailing whitespace

Trailing whitespace

Trailing whitespace

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 (16/12)

Unused variable 'i'

Too many arguments (8/5)

Trailing newlines

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'

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'

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

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.mpc'

Missing class docstring

Too few public methods (0/2)

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

Line too long (102/100)

Missing function or method docstring

Line too long (102/100)

Line too long (102/100)

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)

Missing function or method docstring

Line too long (102/100)

Line too long (102/100)

Missing function or method docstring

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

Line too long (102/100)

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'

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'

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

third party import "from agentlib_mpc.optimization_backends.casadi_.core.discretization import Results" should be placed before "from agentlib_flexquant.data_structures.globals import full_trajectory_suffix"

Imports from package agentlib_mpc are not grouped

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

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

Missing function or method docstring

Too many local variables (20/15)

Missing function or method docstring

Missing function or method docstring

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

Final newline missing

Missing module docstring

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[315:349]
==agentlib_flexquant.modules.shadow_mpc:[306:338]
        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:[217:257]
==agentlib_flexquant.modules.shadow_mpc:[540:580]
        )

        # 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

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[258:306]
==agentlib_flexquant.modules.shadow_mpc:[253:300]
                                         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

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[648:687]
==agentlib_flexquant.modules.shadow_mpc:[629:666]
        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:[151:174]
==agentlib_flexquant.modules.shadow_mpc:[481:501]
        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:

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[324:349]
==agentlib_flexquant.modules.shadow_mpc:[645:666]
            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:[664:687]
==agentlib_flexquant.modules.shadow_mpc:[315:338]
            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:[589:633]
==agentlib_flexquant.modules.shadow_mpc:[253:296]
                                         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:[484:501]
==agentlib_flexquant.modules.shadow_mpc:[481:498]
        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

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[241:257]
==agentlib_flexquant.modules.shadow_mpc:[235:251]
        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

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[522:546]
==agentlib_flexquant.modules.shadow_mpc:[515:539]
            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(

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[191:215]
==agentlib_flexquant.modules.shadow_mpc:[115:139]
            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(

Similar lines in 2 files
==agentlib_flexquant.data_structures.flexquant:[18:31]
==agentlib_flexquant.data_structures.mpcs:[15:27]
excluded_fields = [
        "rdf_class",
        "source",
        "type",
        "timestamp",
        "description",
        "unit",
        "clip",
        "interpolation_method",
        "allowed_values",
    ]

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[162:174]
==agentlib_flexquant.modules.shadow_mpc:[91:103]
        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:

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[612:639]
==agentlib_flexquant.modules.shadow_mpc:[599:623]
        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

Similar lines in 2 files
==agentlib_flexquant.data_structures.mpcs:[15:23]
==agentlib_flexquant.utils.config_management:[125:133]
    excluded_fields = [
        "rdf_class",
        "source",
        "type",
        "timestamp",
        "description",
        "unit",
        "clip",

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[217:241]
==agentlib_flexquant.modules.shadow_mpc:[140:156]
        )

        # 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

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[492:501]
==agentlib_flexquant.modules.shadow_mpc:[91:100]
        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

Similar lines in 2 files
==agentlib_flexquant.modules.flexibility_indicator:[504:527]
==agentlib_flexquant.modules.flexibility_market:[88:97]
        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 write_results(self, df: pd.DataFrame, ts: float, n: int) -> pd.DataFrame:
        """Write every data of variables in self.var_list in an DataFrame.

        DataFrame will be updated every time step

        Args:
            df: DataFrame which is initialised as an empty DataFrame with columns
            according to self.var_list
            ts: time step
            n: number of time steps during prediction horizon

        Returns:
            DataFrame with results of every variable in self.var_list

        """

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[262:271]
==agentlib_flexquant.modules.shadow_mpc:[584:592]
        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:

Similar lines in 2 files
==agentlib_flexquant.modules.flexibility_indicator:[357:364]
==agentlib_flexquant.modules.flexibility_market:[62:70]
        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

Similar lines in 2 files
==agentlib_flexquant.modules.baseline_mpc:[281:302]
==agentlib_flexquant.modules.shadow_mpc:[599:617]
        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

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.

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()

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 (7/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'

Redefining built-in 'type'

Redefining built-in 'type'

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

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"

Trailing whitespace

Line too long (109/100)

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

Final newline missing