def test_exchange_save():
database = DatabaseChooser("testy")
data = {
("testy", "A"): {},
("testy", "C"): {"type": "biosphere"},
("testy", "B"): {
"exchanges": [
{"input": ("testy", "A"), "amount": 1, "type": "technosphere"},
{"input": ("testy", "B"), "amount": 1, "type": "production"},
{"input": ("testy", "C"), "amount": 1, "type": "biosphere"},
]
},
}
then = datetime.datetime.now().isoformat()
database.write(data)
act = database.get("B")
exc = [x for x in act.production()][0]
exc["amount"] = 2
exc.save()
assert databases[database.name].get("dirty")
assert database.metadata.get("dirty")
assert database.metadata["modified"] > then
exc = [x for x in act.production()][0]
assert exc["amount"] == 2
def test_base_class(self):
database = DatabaseChooser("a database")
self.assertEqual(database._metadata, databases)
self.assertEqual(
[x[0] for x in database.dtype_fields],
[numpy_string(x) for x in ('input', 'output', 'row', 'col', 'type')]
)
def test_untyped_exchange_error():
database = DatabaseChooser("testy")
database_data = {
("testy", "A"): {"exchanges": [{"amount": 1, "input": ("testy", "A")}]},
}
with pytest.raises(UntypedExchange):
database.write(database_data, process=False)
def test_dirty_activities(self):
database = DatabaseChooser("testy")
data = {
("testy", "A"): {},
("testy", "C"): {'type': 'biosphere'},
("testy", "B"): {'exchanges': [
{'input': ("testy", "A"),
'amount': 1,
'type': 'technosphere'},
{'input': ("testy", "B"),
'amount': 1,
'type': 'production'},
{'input': ("testy", "C"),
'amount': 1,
'type': 'biosphere'},
]},
}
database.write(data)
act = database.get("B")
exc = [x for x in act.production()][0]
exc['amount'] = 2
exc.save()
self.assertTrue(databases['testy']['dirty'])
lca = act.lca()
self.assertFalse(databases['testy'].get('dirty'))
self.assertEqual(
lca.supply_array[lca.activity_dict[("testy", "A")]],
0.5
)
def test_no_input_raises_invalid_exchange():
database = DatabaseChooser("testy")
database_data = {
("testy", "A"): {"exchanges": [{"amount": 1}]},
}
with pytest.raises(InvalidExchange):
database.write(database_data, process=False)
def test_processed_array():
database = DatabaseChooser("a database")
database.write(
{
("a database", "2"): {
"type": "process",
"exchanges": [
{
"input": ("a database", "2"),
"amount": 42,
"uncertainty_type": 7,
"type": "production",
}
],
}
}
)
package = load_datapackage(ZipFS(database.filepath_processed()))
print(package.resources)
array = package.get_resource("a_database_technosphere_matrix.data")[0]
assert array.shape == (1,)
assert array[0] == 42
array = package.get_resource("a_database_technosphere_matrix.distributions")[0]
assert array.shape == (1,)
assert array[0]["uncertainty_type"] == 7
def test_delete_activity_parameters():
db = DatabaseChooser("example")
db.register()
a = db.new_activity(code="A", name="An activity")
a.save()
b = db.new_activity(code="B", name="Another activity")
b.save()
a.new_exchange(amount=0,
input=b,
type="technosphere",
formula="foo * bar + 4").save()
activity_data = [{
'name': 'reference_me',
'formula': 'sqrt(25)',
'database': 'example',
'code': "B",
}, {
'name': 'bar',
'formula': 'reference_me + 2',
'database': 'example',
'code': "A",
}]
parameters.new_activity_parameters(activity_data, "my group")
parameters.add_exchanges_to_group("my group", a)
assert ActivityParameter.select().count() == 2
assert ParameterizedExchange.select().count() == 1
a.delete()
assert ActivityParameter.select().count() == 1
assert not ParameterizedExchange.select().count()
def test_exchange_save(self):
database = DatabaseChooser("testy")
data = {
("testy", "A"): {},
("testy", "C"): {'type': 'biosphere'},
("testy", "B"): {'exchanges': [
{'input': ("testy", "A"),
'amount': 1,
'type': 'technosphere'},
{'input': ("testy", "B"),
'amount': 1,
'type': 'production'},
{'input': ("testy", "C"),
'amount': 1,
'type': 'biosphere'},
]},
}
then = datetime.datetime.now().isoformat()
database.write(data)
act = database.get("B")
exc = [x for x in act.production()][0]
exc['amount'] = 2
exc.save()
self.assertTrue(databases[database.name].get("dirty"))
self.assertTrue(database.metadata.get("dirty"))
self.assertTrue(database.metadata['modified'] > then)
exc = [x for x in act.production()][0]
self.assertEqual(exc['amount'], 2)
def extract_brightway2_databases(database_names):
"""Extract a Brightway2 SQLiteBackend database to the Wurst internal format.
``database_names`` is a list of database names. You should already be in the correct project.
Returns a list of dataset documents."""
ERROR = "Must pass list of database names"
if isinstance(database_names, str):
database_names = [database_names]
assert isinstance(database_names, (list, tuple, set)), ERROR
databases = [DatabaseChooser(name) for name in database_names]
ERROR = "Wrong type of database object (must be SQLiteBackend)"
assert all(isinstance(obj, SQLiteBackend) for obj in databases), ERROR
# Construct generators for both activities and exchanges
# Need to be clever to minimize copying and memory use
activity_qs = ActivityDataset.select().where(ActivityDataset.database << database_names)
exchange_qs = ExchangeDataset.select().where(ExchangeDataset.output_database << database_names)
# Retrieve all activity data
print("Getting activity data")
activities = [extract_activity(o) for o in tqdm(activity_qs)]
# Add each exchange to the activity list of exchanges
print("Adding exchange data to activities")
add_exchanges_to_consumers(activities, exchange_qs)
# Add details on exchanges which come from our databases
print("Filling out exchange data")
add_input_info_for_indigenous_exchanges(activities, database_names)
add_input_info_for_external_exchanges(activities, database_names)
return activities
def test_raise_wrong_database():
data = {
("foo", '1'): {}
}
d = DatabaseChooser("bar")
with pytest.raises(WrongDatabase):
d.write(data)
def test_process_without_exchanges_still_in_processed_array():
database = DatabaseChooser("a database")
database.write({("a database", "foo"): {}})
package = load_datapackage(ZipFS(database.filepath_processed()))
array = package.get_resource("a_database_technosphere_matrix.data")[0]
assert array[0] == 1
assert array.shape == (1,)
def __init__(self, destination_db):
# Check that database exists
if len(DatabaseChooser(destination_db)) == 0:
raise NameError('The database selected is empty. Make sure the name is correct and that the current'
' brightway2 project contains the database.')
self.destination = destination_db
self.db = wurst.extract_brightway2_databases(self.destination)
def test_zero_amount_is_valid_exchange(self):
database = DatabaseChooser("testy")
database.register()
database_data = {
("testy", "A"): {'exchanges': [
{'input': ('testy', 'A'), 'type': 'technosphere', 'amount': 0.}
]},
}
database.write(database_data, process=False)
def test_process_adds_to_mappings():
database = DatabaseChooser("testy")
database_data = {
("testy", "A"): {'location': 'CH'},
("testy", "B"): {'location': 'DE'},
}
database.write(database_data)
assert ("testy", "A") in mapping and ("testy", "B") in mapping
assert "CH" in geomapping and "DE" in geomapping
def test_change_code(activity):
db = DatabaseChooser("a database")
assert len(db) == 1
old_key = activity.key[:]
activity["code"] = "a new one"
assert len(db) == 1
assert get_activity(("a database", "a new one"))
with pytest.raises(DoesNotExist):
get_activity(old_key)
def test_no_amount_raises_invalid_exchange():
database = DatabaseChooser("testy")
database_data = {
("testy", "A"): {
"exchanges": [{"input": ("testy", "A"), "type": "technosphere"}]
},
}
with pytest.raises(InvalidExchange):
database.write(database_data, process=False)
def test_untyped_exchange_error(self):
database = DatabaseChooser("testy")
database.register()
database_data = {
("testy", "A"): {'exchanges': [
{'amount': 1, 'input': ('testy', 'A')}
]},
}
with self.assertRaises(UntypedExchange):
database.write(database_data, process=False)
def test_no_input_raises_invalid_exchange(self):
database = DatabaseChooser("testy")
database.register()
database_data = {
("testy", "A"): {'exchanges': [
{'amount': 1}
]},
}
with self.assertRaises(InvalidExchange):
database.write(database_data, process=False)
def test_no_amount_raises_invalid_exchange(self):
database = DatabaseChooser("testy")
database.register()
database_data = {
("testy", "A"): {'exchanges': [
{'input': ('testy', 'A'), 'type': 'technosphere'}
]},
}
with self.assertRaises(InvalidExchange):
database.write(database_data, process=False)
def test_zero_amount_is_valid_exchange():
database = DatabaseChooser("testy")
database_data = {
("testy", "A"): {
"exchanges": [
{"input": ("testy", "A"), "type": "technosphere", "amount": 0.0}
]
},
}
database.write(database_data, process=False)
def test_find_graph_dependents():
databases['one'] = {'depends': ['two', 'three']}
databases['two'] = {'depends': ['four', 'five']}
databases['three'] = {'depends': ['four']}
databases['four'] = {'depends': ['six']}
databases['five'] = {'depends': ['two']}
databases['six'] = {'depends': []}
assert (
DatabaseChooser('one').find_graph_dependents() ==
{'one', 'two', 'three', 'four', 'five', 'six'}
)
def test_new_activity():
database = DatabaseChooser("a database")
database.register()
act = database.new_activity("foo", this="that", name="something")
act.save()
act = database.get("foo")
assert act["database"] == "a database"
assert act["code"] == "foo"
assert act["location"] == "GLO"
assert act["this"] == "that"
def test_process_checks_process_type():
database = DatabaseChooser("a database")
database.write(
{
("a database", "foo"): {"exchanges": [], "type": "process"},
("a database", "bar"): {"type": "definitely not a process"},
},
process=True,
)
# This shouldn't raise an error
assert database.process() is None
def test_process_without_exchanges_still_in_processed_array(self):
database = DatabaseChooser("a database")
database.write({("a database", "foo"): {}})
fp = os.path.join(
projects.dir,
"processed",
database.filename + ".npy"
)
array = np.load(fp)
self.assertEqual(array['amount'][0], 1)
self.assertEqual(array.shape, (1,))
def test_new_activity(self):
database = DatabaseChooser("a database")
database.register()
act = database.new_activity('foo', this="that", name='something')
act.save()
act = database.get('foo')
self.assertEqual(act['database'], 'a database')
self.assertEqual(act['code'], 'foo')
self.assertEqual(act['location'], 'GLO')
self.assertEqual(act['this'], 'that')
def test_deletes_from_database():
d = DatabaseChooser("biosphere")
d.write(biosphere)
assert "biosphere" in databases
del databases['biosphere']
assert next(sqlite3_lci_db.execute_sql(
"select count(*) from activitydataset where database = 'biosphere'"
)) == (0,)
assert next(sqlite3_lci_db.execute_sql(
"select count(*) from exchangedataset where output_database = 'biosphere'"
)) == (0,)
def test_process_geomapping_array(self):
database = DatabaseChooser("a database")
database.register()
database.write({})
fp = os.path.join(
projects.dir,
"processed",
database.filename + ".geomapping.npy"
)
array = np.load(fp)
fieldnames = {'activity', 'geo', 'row', 'col'}
self.assertFalse(fieldnames.difference(set(array.dtype.names)))
def test_process_unknown_object():
database = DatabaseChooser("testy")
data = {
("testy", "A"): {},
("testy", "B"): {
"exchanges": [
{"input": ("testy", "A"), "amount": 1, "type": "technosphere"},
{"input": ("testy", "C"), "amount": 1, "type": "technosphere"},
]
},
}
with pytest.raises(UnknownObject):
database.write(data)
def test_method_processed_array(reset):
database = DatabaseChooser("foo")
database.write({("foo", "bar"): {}})
method = Method(("a", "method"))
method.write([[("foo", "bar"), 42]])
package = load_datapackage(ZipFS(method.filepath_processed()))
data = package.get_resource("a_method_matrix_data.data")[0]
assert np.allclose(data, [42])
indices = package.get_resource("a_method_matrix_data.indices")[0]
assert np.allclose(indices["row"], get_id(("foo", "bar")))
assert np.allclose(indices["col"], geomapping[config.global_location])
def test_process_invalid_exchange_value():
database = DatabaseChooser("testy")
data = {
("testy", "A"): {},
("testy", "B"): {
"exchanges": [
{"input": ("testy", "A"), "amount": np.nan, "type": "technosphere"},
{"input": ("testy", "C"), "amount": 1, "type": "technosphere"},
]
},
}
with pytest.raises(ValueError):
database.write(data)