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