Updating bw-functional datasets

Author: Marin Visscher

bw_functional/__init__.py

@@ -1,5 +1,4 @@
 __all__ = (
-    "__version__",
     "allocation_strategies",
     "generic_allocation",
     "Process",
@@ -9,11 +8,12 @@
     "FunctionalSQLiteDatabase",
     "property_allocation",
     "convert_sqlite_to_functional_sqlite",
-    "convert_functional_sqlite_to_sqlite"
+    "convert_functional_sqlite_to_sqlite",
+    "update",
 )
-# import os
-__version__ = "0.0.2"
 
+from importlib import metadata
+# import os
 from logging import getLogger
 
 from bw2data import labels
@@ -24,6 +24,7 @@
 from .node_classes import Process, Product
 from .edge_classes import MFExchange, MFExchanges
 from .convert import convert_sqlite_to_functional_sqlite, convert_functional_sqlite_to_sqlite
+from .update import update, latest
 
 log = getLogger(__name__)
 
@@ -38,9 +39,10 @@
 
 # make sure allocation happens on parameter changes
 def _init_signals():
-    from bw2data.signals import on_activity_parameter_recalculate
+    from bw2data.signals import on_activity_parameter_recalculate, project_changed
 
     on_activity_parameter_recalculate.connect(_check_parameterized_exchange_for_allocation)
+    project_changed.connect(_check_and_update)
 
 def _check_parameterized_exchange_for_allocation(_, name):
     import bw2data as bd
@@ -65,4 +67,18 @@ def _check_parameterized_exchange_for_allocation(_, name):
             continue
         process.allocate()
 
+def _check_and_update(dataset):
+    if dataset.data is None:
+        dataset.data = {}
+        dataset.save()
+
+    current = dataset.data.get("bw_functional_version")
+
+    if current != latest:
+        log.info(f"Updating {dataset.name} to latest bw_functional datastructure version {latest}")
+        dataset.data["bw_functional_version"] = update(current)
+        dataset.save()
+
+    return
+
 _init_signals()

bw_functional/node_classes.py

@@ -11,6 +11,13 @@
 log = getLogger(__name__)
 
 
+INHERITED_FIELDS = [
+    "database",
+    "location",
+    "name",
+]
+
+
 class MFActivity(Activity):
     """
     A class representing an activity of the functional_sqlite backend.
@@ -192,9 +199,19 @@ def save(self, signal: bool = True, data_already_set: bool = False, force_insert
 
         super().save(signal, data_already_set, force_insert)
 
-        if not created and old.data.get("allocation") != self.get("allocation"):
+        if created:
+            return
+
+        if old.data.get("allocation") != self.get("allocation"):
             self.allocate()
 
+        if changed_fields := [field for field in INHERITED_FIELDS if self.get(field) != old.data.get(field)]:
+            log.info(f"Updating inherited fields {changed_fields} for products of process {self}")
+            for product in self.products():
+                for field in changed_fields:
+                    product._set_inherited(field, self.get(field))
+                product.save()
+
     def copy(self, *args, **kwargs):
         """
         Create a copy of the process.
@@ -245,9 +262,16 @@ def new_product(self, type="product", **kwargs):
         Returns:
             Product: A new product.
         """
+        if kwargs.get("reference product") is None:
+
+            kwargs["reference product"] = kwargs.get("product", kwargs.get("name", f"Unnamed {type}"))
+
         kwargs["type"] = type
         kwargs["processor"] = self.key
-        kwargs["database"] = self["database"]
+
+        for field in INHERITED_FIELDS:
+            kwargs[field] = self.get(field)
+
         kwargs["properties"] = {p: self.property_template(p) for p in self.available_properties()}
         return Product(**kwargs)
 
@@ -288,7 +312,7 @@ def property_template(self, name: str, amount=1.0) -> dict:
             "normalize": normalize.pop() if normalize else True
         }
 
-    def products(self):
+    def products(self) -> list["Product"]:
         """
         Retrieve the products (products or wastes) associated with the process.
 
@@ -367,6 +391,18 @@ class Product(MFActivity):
     products, including saving, deleting, and validating them, as well as handling
     processing edges and substitution.
     """
+    def __setitem__(self, key, value):
+        if key in INHERITED_FIELDS:
+            raise KeyError(f"Field '{key}' is inherited from the processor and cannot be set directly.")
+        if key in ["product", "reference product"]:
+            # explicit synonyms
+            super().__setitem__("product", value)
+            super().__setitem__("reference product", value)
+            return
+        super().__setitem__(key, value)
+
+    def _set_inherited(self, key, value):
+        super().__setitem__(key, value)
 
     def save(self, signal: bool = True, data_already_set: bool = False, force_insert: bool = False):
         """

bw_functional/update.py

@@ -0,0 +1,32 @@
+
+latest = "0b89"
+
+def update(version: str | None) -> str:
+    if version is None:
+        update_0b89()
+        return "0b89"
+    return version
+
+def update_0b89():
+    import bw2data as bd
+    import tqdm
+    from .node_classes import Process
+
+    bf_db_names = [name for name, dict in bd.databases.items() if dict.get("backend") == "functional_sqlite"]
+    for db_name in bf_db_names:
+        database = bd.Database(db_name)
+
+        for process in tqdm.tqdm(database, desc=f"Updating {db_name} to bw_functional 0b89", total=len(database)):
+            if not isinstance(process, Process):
+                continue
+
+            for product in process.products():
+                if not product.get("product"):
+                    product["product"] = product["name"]
+
+                product._set_inherited("name", process["name"])
+                product._set_inherited("database", process["database"])
+                product._set_inherited("location", process["location"])
+
+                product.save()
+