def test_convert_backend(self):
self.maxDiff = None
database = DatabaseChooser("a database")
database.write({
("a database", "foo"): {
'exchanges': [{
'input': ("a database", "foo"),
'amount': 1,
'type': 'production',
}],
'location': 'bar',
'name': 'baz'
},
})
database = convert_backend('a database', "singlefile")
self.assertEqual(databases['a database']['backend'], 'singlefile')
self.assertEqual(databases['a database']['version'], 1)
expected = {
("a database", "foo"): {
'code': 'foo',
'database': 'a database',
'exchanges': [{
'input': ("a database", "foo"),
'output': ("a database", "foo"),
'amount': 1,
'type': 'production',
}],
'location': 'bar',
'name': 'baz'
},
}
self.assertEqual(database.load(), expected)
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_uncertainty():
database = DatabaseChooser("db")
database.write({
("db", "a"): {
'exchanges': [{
'input': ("db", "a"),
'amount': 2,
'type': 'production',
'uncertainty type': 1,
'loc': 2,
'scale': 3,
'shape': 4,
'maximum': 5,
'negative': True,
'name': 'a'
}]}
})
expected = {
'uncertainty type': 1,
'loc': 2,
'scale': 3,
'shape': 4,
'maximum': 5,
'negative': True,
}
exchange = list(database.get("a").exchanges())[0]
assert exchange.uncertainty == expected
def test_uncertainty():
database = DatabaseChooser("db")
database.write({
("db", "a"): {
"exchanges": [{
"input": ("db", "a"),
"amount": 2,
"type": "production",
"uncertainty type": 1,
"loc": 2,
"scale": 3,
"shape": 4,
"maximum": 5,
"negative": True,
"name": "a",
}]
}
})
expected = {
"uncertainty type": 1,
"loc": 2,
"scale": 3,
"shape": 4,
"maximum": 5,
"negative": True,
}
exchange = list(database.get("a").exchanges())[0]
assert exchange.uncertainty == expected
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_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_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 activity():
database = DatabaseChooser("db")
database.write({
("db", "a"): {
'exchanges': [{
'input': ("db", "a"),
'amount': 2,
'type': 'production',
}, {
'input': ("db", "b"),
'amount': 3,
'type': 'technosphere',
}, {
'input': ("db", "c"),
'amount': 4,
'type': 'biosphere',
}],
'name': 'a'
},
("db", "b"): {'name': 'b'},
("db", "c"): {'name': 'c', 'type': 'biosphere'},
("db", "d"): {
'name': 'd',
'exchanges': [{
'input': ("db", "a"),
'amount': 5,
'type': 'technosphere'
}, {
'input': ("db", "b"),
'amount': -0.1,
'type': 'substitution'
}]
},
})
return database.get("a")
def test_method_write_adds_num_cfs_to_metadata(reset):
assert not len(databases)
assert not len(methods)
assert not AD.select().count()
database = DatabaseChooser("testy")
data = {
("testy", "A"): {},
("testy", "B"): {
"exchanges": [
{"input": ("testy", "A"), "amount": 1, "type": "technosphere"},
]
},
}
database.write(data)
method_data = [
[("testy", "A"), 1],
[("testy", "B"), 1],
]
name = ("a", "method")
method = Method(name)
method.register()
method.write(method_data)
assert methods[name]["num_cfs"] == 2
def activity_and_method():
database = DatabaseChooser("db")
database.write({
("db", "a"): {
'exchanges': [{
'input': ("db", "a"),
'amount': 2,
'type': 'production',
}, {
'input': ("db", "b"),
'amount': 3,
'type': 'technosphere',
}, {
'input': ("db", "c"),
'amount': 4,
'type': 'biosphere',
}],
'name': 'a'
},
("db", "b"): {'name': 'b'},
("db", "c"): {'name': 'c', 'type': 'biosphere'},
("db", "d"): {
'name': 'd',
'exchanges': [{
'input': ("db", "a"),
'amount': 5,
'type': 'technosphere'
}]
},
})
cfs = [(("db", "c"), 42)]
method = Method(("a method",))
method.register()
method.write(cfs)
return database.get("a"), method
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_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 test_change_code_not_unique_raises_error():
database = DatabaseChooser("a database")
database.write(
{
("a database", "foo"): {
"exchanges": [
{"input": ("a database", "foo"), "amount": 1, "type": "production",}
],
"location": "bar",
"name": "baz",
},
("a database", "already there"): {
"exchanges": [
{
"input": ("a database", "already there"),
"amount": 1,
"type": "production",
}
],
"location": "bar",
"name": "baz",
},
}
)
act = database.get("foo")
with pytest.raises(ValueError):
act["code"] = "already there"
def test_change_code_not_unique_raises_error():
database = DatabaseChooser("a database")
database.write({
("a database", "foo"): {
'exchanges': [{
'input': ("a database", "foo"),
'amount': 1,
'type': 'production',
}],
'location':
'bar',
'name':
'baz'
},
("a database", "already there"): {
'exchanges': [{
'input': ("a database", "already there"),
'amount': 1,
'type': 'production',
}],
'location':
'bar',
'name':
'baz'
},
})
act = database.get('foo')
with pytest.raises(ValueError):
act['code'] = "already there"
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 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_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_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_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_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_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_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_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_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)
def test_sqlite_processed_array_order():
database = DatabaseChooser("testy")
data = {
("testy", "C"): {},
("testy", "A"): {},
("testy", "B"): {
"exchanges": [
{"input": ("testy", "A"), "amount": 1, "type": "technosphere"},
{"input": ("testy", "A"), "amount": 2, "type": "technosphere"},
{"input": ("testy", "C"), "amount": 2, "type": "biosphere"},
{"input": ("testy", "C"), "amount": 3, "type": "biosphere"},
{"input": ("testy", "B"), "amount": 4, "type": "production"},
{"input": ("testy", "B"), "amount": 1, "type": "production"},
]
},
}
database.write(data)
lookup = {k: get_id(("testy", k)) for k in "ABC"}
t = sorted(
[
(lookup["A"], lookup["B"], 1),
(lookup["A"], lookup["B"], 2),
# Implicit production
(lookup["C"], lookup["C"], 1),
(lookup["A"], lookup["A"], 1),
# Explicit production
(lookup["B"], lookup["B"], 4),
(lookup["B"], lookup["B"], 1),
]
)
b = sorted([(lookup["C"], lookup["B"], 2), (lookup["C"], lookup["B"], 3),])
package = load_datapackage(ZipFS(database.filepath_processed()))
array = package.get_resource("testy_technosphere_matrix.data")[0]
assert array.shape == (6,)
assert np.allclose(array, [x[2] for x in t])
array = package.get_resource("testy_technosphere_matrix.indices")[0]
assert array.shape == (6,)
assert np.allclose(array["row"], [x[0] for x in t])
assert np.allclose(array["col"], [x[1] for x in t])
array = package.get_resource("testy_biosphere_matrix.data")[0]
assert array.shape == (2,)
assert np.allclose(array, [x[2] for x in b])
array = package.get_resource("testy_biosphere_matrix.indices")[0]
assert array.shape == (2,)
assert np.allclose(array["row"], [x[0] for x in b])
assert np.allclose(array["col"], [x[1] for x in b])
def activity():
database = DatabaseChooser("a database")
database.write(
{
("a database", "foo"): {
"exchanges": [
{"input": ("a database", "foo"), "amount": 1, "type": "production",}
],
"location": "bar",
"name": "baz",
},
}
)
return database.get("foo")
def test_normalization_process_row(reset):
database = DatabaseChooser("foo")
database.write({("foo", "bar"): {}})
norm = Normalization(("foo",))
norm.write([[("foo", "bar"), 42]])
package = load_datapackage(ZipFS(norm.filepath_processed()))
data = package.get_resource("foo_matrix_data.data")[0]
assert np.allclose(data, [42])
indices = package.get_resource("foo_matrix_data.indices")[0]
assert np.allclose(indices["row"], get_id(("foo", "bar")))
assert np.allclose(indices["col"], get_id(("foo", "bar")))
def test_uncertainty_type_missing():
database = DatabaseChooser("db")
database.write({
("db", "a"): {
'exchanges': [{
'input': ("db", "a"),
'amount': 2,
'type': 'production',
'name': 'a'
}]}
})
exchange = list(database.get("a").exchanges())[0]
assert exchange.uncertainty_type.id == 0
assert exchange.uncertainty_type == sa.UndefinedUncertainty
def test_convert_same_backend(self):
database = DatabaseChooser("a database")
database.write({
("a database", "foo"): {
'exchanges': [{
'input': ("a database", "foo"),
'amount': 1,
'type': 'production',
}],
'location': 'bar',
'name': 'baz'
},
})
self.assertFalse(convert_backend('a database', "sqlite"))
