def test_create_project_param(qtbot): """ Create a single Project parameter. Does not user the overarching application due to mouseClick failing """ assert bw.projects.current == "pytest_project" assert ProjectParameter.select().count() == 0 project_db_tab = ParameterDefinitionTab() qtbot.addWidget(project_db_tab) project_db_tab.build_tables() table = project_db_tab.project_table bw.parameters.new_project_parameters([ { "name": "param_1", "amount": 1.0 }, { "name": "param_2", "amount": 1.0 }, { "name": "param_3", "amount": 1.0 }, ]) table.model.sync() assert table.rowCount() == 3 # New parameter is named 'param_1' assert table.model.index(0, 0).data() == "param_1" assert ProjectParameter.select().count() == 3 assert ProjectParameter.select().where( ProjectParameter.name == "param_1").exists()
def test_create_project_param(qtbot): """ Create a single Project parameter. Does not user the overarching application due to mouseClick failing """ assert bw.projects.current == "pytest_project" assert ProjectParameter.select().count() == 0 project_db_tab = ParameterDefinitionTab() qtbot.addWidget(project_db_tab) project_db_tab.build_tables() table = project_db_tab.project_table signal_list = [ signals.parameters_changed, signals.parameters_changed, signals.parameters_changed ] with qtbot.waitSignals(signal_list, timeout=1000): qtbot.mouseClick(project_db_tab.new_project_param, QtCore.Qt.LeftButton) qtbot.mouseClick(project_db_tab.new_project_param, QtCore.Qt.LeftButton) qtbot.mouseClick(project_db_tab.new_project_param, QtCore.Qt.LeftButton) assert table.rowCount() == 3 # New parameter is named 'param_1' assert table.model.index(0, 0).data() == "param_1" assert ProjectParameter.select().count() == 3 assert ProjectParameter.get_or_none(name="param_1") is not None
def build_df(cls): """ Build a dataframe using the ProjectParameters set in brightway """ data = [ cls.parse_parameter(p) for p in ProjectParameter.select() ] df = pd.DataFrame(data, columns=cls.combine_columns()) return df
def process_brightway_parameters() -> Iterable[tuple]: """ Converts brightway parameters of all types into a simple structure in order of possible dependency. """ return itertools.chain( ((p.name, "project", p.amount) for p in ProjectParameter.select()), ((p.name, p.database, p.amount) for p in DatabaseParameter.select()), ((p.name, p.group, p.amount) for p in ActivityParameter.select()))
def __init__(self, seed: Optional[int] = None): super().__init__() parameters = itertools.chain(ProjectParameter.select(), DatabaseParameter.select(), ActivityParameter.select()) self.uncertainties = UncertaintyBase.from_dicts( *[getattr(p, "data", {}) for p in parameters]) self.mc_generator = MCRandomNumberGenerator(self.uncertainties, seed=seed)
def from_bw_parameters(cls) -> 'Parameters': """Construct a Parameters list from brightway2 parameters.""" return cls(chain( (Parameter(p.name, "project", p.amount, "project") for p in ProjectParameter.select()), (Parameter(p.name, p.database, p.amount, "database") for p in DatabaseParameter.select()), (Parameter(p.name, p.group, p.amount, "activity") for p in ActivityParameter.select()), ))
def sync(self, *args, **kwargs) -> None: self.beginResetModel() self.root.clear() self.endResetModel() self._data.update({ "project": ProjectParameter.select().iterator(), "database": DatabaseParameter.select().iterator(), "activity": ActivityParameter.select().iterator(), }) self.setup_model_data() self.updated.emit()
def add_parameter(self) -> None: """ Build a new parameter and immediately store it. """ counter = (ProjectParameter.select().count() + DatabaseParameter.select().count()) try: bw.parameters.new_project_parameters([ {"name": "param_{}".format(counter + 1), "amount": 1.0} ], False) signals.parameters_changed.emit() except ValueError as e: simple_warning_box(self, "Name already in use!", str(e))
def add_parameter(self) -> None: """ Add a new database parameter to the dataframe NOTE: The new parameter uses the first database it can find. """ counter = (ProjectParameter.select().count() + DatabaseParameter.select().count()) database = next(iter(bw.databases)) try: bw.parameters.new_database_parameters([ {"name": "param_{}".format(counter + 1), "amount": 1.0} ], database, False) signals.parameters_changed.emit() except ValueError as e: simple_warning_box(self, "Name already in use!", str(e))
def sync(self) -> None: self.data.update({ "project": ProjectParameter.select().iterator(), "database": DatabaseParameter.select().iterator(), "activity": ActivityParameter.select().iterator(), })
def loadParams(global_variable=True, dbname=None): """ Load parameters from Brightway database, as per : https://stats-arrays.readthedocs.io/en/latest/ Parameters ---------- global_variable If true, loaded parameters are made available as global variable. dbname : None. By default load all project and database parameters. If provided, only load DB params """ enumParams = defaultdict(lambda: dict()) def register(param): _param_registry()[param.name] = param # Make it available as global var if global_variable: if param.name in builtins.__dict__: error( "Variable '%s' was already defined : overidding it with param." % param.name) builtins.__dict__[param.name] = param select = DatabaseParameter.select() if dbname: select = select.where(DatabaseParameter.database == dbname) params = list(select) if not dbname: params += list(ProjectParameter.select()) for bwParam in params: data = bwParam.data data["amount"] = bwParam.amount name = bwParam.name type = data.get(UNCERTAINTY_TYPE, None) # print("Data for ", name, data) # Common extra args args = _loadArgs(data) if type == _UncertaintyType.DISCRETE: # Boolean or enum if data.get('scale') is not None: # Enum param : group them by common prefix splits = name.split("_") enum_value = splits.pop() enum_name = "_".join(splits) enumParams[enum_name][enum_value] = data continue elif data["maximum"] == 2: del args["max"], args["min"] param = newBoolParam(name, save=False, **args) else: error( "Non boolean discrete values (max != 2) are not supported for param :", name) continue else: # Float parameter if type is None: error( "'Uncertainty type' of param %s not provided. Assuming UNIFORM" ) type = _UncertaintyType.UNIFORM # Uncertainty type to distribution type args["distrib"] = _DistributionTypeMapReverse[type] if type == _UncertaintyType.TRIANGLE: args["default"] = data["loc"] elif type in [_UncertaintyType.NORMAL, _UncertaintyType.LOGNORMAL]: args["default"] = data["loc"] args["std"] = data["scale"] elif type == _UncertaintyType.BETA: args["default"] = data["loc"] args["std"] = data["scale"] args["a"] = data["loc"] args["b"] = data["shape"] param = newFloatParam(name, save=False, **args) # Save it in shared dictionnary register(param) # Loop on EnumParams for param_name, param_values in enumParams.items(): first_enum_param = list(param_values.values())[0] args = _loadArgs(first_enum_param) del args["default"] # Dictionary of enum values with scale as weight args["values"] = { key: data["scale"] for key, data in param_values.items() } # Default enum value is the one with amount=1 defaults = list(key for key, data in param_values.items() if data.get("amount") == 1) if len(defaults) == 1: default = defaults[0] else: default = None error("No default enum value found for ", param_name, defaults) param = newEnumParam(param_name, default, save=False, **args) # Save it in shared dict register(param)
def get_project_parameters(self): return self.order_dicts([o.dict for o in ProjectParameter.select()], 'parameter')
def loadParams(): """Load parameters from Brightway database, as per : https://stats-arrays.readthedocs.io/en/latest/""" enumParams=defaultdict(lambda : dict()) for bwParam in ProjectParameter.select(): data = bwParam.data data["amount"] = bwParam.amount name = bwParam.name type = data.get(UNCERTAINTY_TYPE, None) # print("Data for ", name, data) # Common extra args args = _loadArgs(data) if type == _UncertaintyType.DISCRETE : # Boolean or enum if data.get('scale') is not None : # Enum param : group them by common prefix splits = name.split("_") enum_value = splits.pop() enum_name = "_".join(splits) enumParams[enum_name][enum_value] = data continue elif data["maximum"] == 2 : param = newBoolParam(name, save=False, **args) else: _eprint("Non boolean discrete values (max != 2) are not supported for param :", name) continue else : # Uncertainty type to distribution type args["distrib"] = _DistributionTypeMapReverse[type] if type == _UncertaintyType.TRIANGLE : args["default"] = data["loc"] if type in [_UncertaintyType.NORMAL, _UncertaintyType.LOGNORMAL]: args["default"] = data["loc"] args["std"] = data["scale"] elif type == _UncertaintyType.BETA: args["default"] = data["loc"] args["std"] = data["scale"] args["a"] = data["loc"] args["b"] = data["shape"] param = newFloatParam(name, save=False, **args) # Save it in shared dict _param_registry()[bwParam.name] = param # Loop on EnumParams for param_name, param_values in enumParams.items() : first_enum_param = list(param_values.values())[0] args = _loadArgs(first_enum_param) del args["default"] # Dictionary of enum values with scale as weight args["values"] = {key : data["scale"] for key, data in param_values.items()} # Default enum value is the one with amount=1 defaults = list(key for key, data in param_values.items() if data.get("amount") == 1) if len(defaults) == 1 : default = defaults[0] else : default= None _eprint("No default enum value found for ", param_name, defaults) param = newEnumParam(param_name, default, save=False, **args) # Save it in shared dict _param_registry()[bwParam.name] = param
def ExportProjectParameters(f='ProjectParamExport.xlsx'): params = {i: p.dict for i, p in enumerate(ProjectParameter.select())} pd.DataFrame.from_dict(params).T.to_excel('ProjectParamExport.xlsx')
def sync(self) -> None: data = [self.parse_parameter(p) for p in ProjectParameter.select()] self._dataframe = pd.DataFrame(data, columns=self.columns()) self.param_col = self._dataframe.columns.get_loc("parameter") self.updated.emit()