bw-functional 0b79__py3-none-any.whl

bw_functional/__init__.py

@@ -0,0 +1,65 @@
+__all__ = (
+    "__version__",
+    "allocation_strategies",
+    "generic_allocation",
+    "Process",
+    "Product",
+    "MFExchange",
+    "MFExchanges",
+    "FunctionalSQLiteDatabase",
+    "property_allocation",
+)
+# import os
+__version__ = "0.0.2"
+
+from logging import getLogger
+
+from bw2data import labels
+from bw2data.subclass_mapping import DATABASE_BACKEND_MAPPING, NODE_PROCESS_CLASS_MAPPING
+
+from .allocation import allocation_strategies, generic_allocation, property_allocation
+from .database import FunctionalSQLiteDatabase
+from .node_classes import Process, Product
+from .edge_classes import MFExchange, MFExchanges
+
+log = getLogger(__name__)
+
+DATABASE_BACKEND_MAPPING["functional_sqlite"] = FunctionalSQLiteDatabase
+NODE_PROCESS_CLASS_MAPPING["functional_sqlite"] = FunctionalSQLiteDatabase.node_class
+
+
+if "waste" not in labels.node_types:
+    labels.lci_node_types.append("waste")
+if "nonfunctional" not in labels.node_types:
+    labels.other_node_types.append("nonfunctional")
+
+# make sure allocation happens on parameter changes
+def _init_signals():
+    from bw2data.signals import on_activity_parameter_recalculate
+
+    on_activity_parameter_recalculate.connect(_check_parameterized_exchange_for_allocation)
+
+def _check_parameterized_exchange_for_allocation(_, name):
+    import bw2data as bd
+    from bw2data.parameters import ParameterizedExchange
+    from bw2data.backends import ExchangeDataset
+
+    databases = [k for k, v in bd.databases.items() if v["backend"] == "functional_sqlite"]
+
+    p_exchanges = ParameterizedExchange.select().where(ParameterizedExchange.group==name)
+    exc_ids = [p_exc.exchange for p_exc in p_exchanges]
+    exchanges = ExchangeDataset.select(ExchangeDataset.output_database, ExchangeDataset.output_code).where(
+        (ExchangeDataset.id.in_(exc_ids)) &
+        (ExchangeDataset.type == "production") &
+        (ExchangeDataset.output_database.in_(databases))
+    )
+    process_keys = set(exchanges.tuples())
+
+    for key in process_keys:
+        process = bd.get_activity(key)
+        if not isinstance(process, Process):
+            log.warning(f"Process {key} is not an instance of Process, skipping allocation check.")
+            continue
+        process.allocate()
+
+_init_signals()

bw_functional/allocation.py

@@ -0,0 +1,142 @@
+from functools import partial
+from typing import Callable, List
+from logging import getLogger
+
+from .node_classes import Process, Product
+
+log = getLogger(__name__)
+
+
+def generic_allocation(
+    process: Process,
+    getter: lambda function: float(),
+) -> None:
+    """
+    Perform allocation for a multifunctional process using a specified getter function.
+
+    This function calculates allocation factors for each product in a multifunctional process
+    based on the values returned by the `getter` function. The allocation factor for each product
+    is determined by dividing the value returned by the `getter` function for that function by the
+    sum of all values returned by the `getter` function for all product in the process.
+
+    Args:
+        process (Process): The process object to allocate. Must be an instance of the `Process` class.
+        getter (Callable): A function that takes a `Product` object and returns a float value
+            used for allocation calculations.
+
+    Raises:
+        ValueError: If the `process` is not an instance of the `Process` class.
+        ZeroDivisionError: If the sum of allocation factors is zero.
+
+    Notes:
+        - Products with a positive `substitution_factor` and a non-zero `allocation_factor` will
+          have their `allocation_factor` reset to 0.0 and will not be included in the allocation.
+        - Products with a non-positive `substitution_factor` are included in the allocation.
+    """
+    # Ensure the process is a valid Process instance
+    if not isinstance(process, Process):
+        raise ValueError("Activity must be a Process instance")
+
+    # Return none if the process is not multifunctional
+    if not process.multifunctional:
+        return
+
+    # Collect products eligible for allocation (functions that are not subsituted)
+    products = []
+    for product in process.products():
+        if product.get("substitution_factor", 0) > 0 and product["allocation_factor"] > 0:
+            # Reset allocation factor for products with positive substitution factor
+            product["allocation_factor"] = 0.0
+            product.save()
+        elif product.get("substitution_factor", 0) <= 0:
+            # Include functions with non-positive substitution factor
+            products.append(product)
+
+    # Calculate the total value for allocation
+    total = sum([getter(product) for product in products])
+
+    # Raise an error if the total is zero to avoid division by zero
+    if not total:
+        raise ZeroDivisionError("Sum of allocation factors is zero")
+
+    # Calculate and assign allocation factors for each product
+    for i, product in enumerate(products):
+        factor = getter(product) / total
+        product["allocation_factor"] = factor
+        product.save()
+
+
+def get_property_value(
+    product: Product,
+    property_label: str,
+) -> float:
+    """
+    Retrieve the value of a specified property from a given function.
+
+    This function extracts the value of a property identified by `property_label` from the
+    `properties` dictionary of the provided `Product` object. If the property is marked
+    as normalized, the value is calculated by multiplying the `amount` in the processing
+    edge with the `amount` of the property.
+
+    Args:
+        product (Product): The product object from which the property value is retrieved.
+            Must be an instance of the `Product` class.
+        property_label (str): The label of the property to retrieve.
+
+    Returns:
+        float: The value of the specified property.
+
+    Raises:
+        ValueError: If the provided `product` is not an instance of the `Product` class.
+        KeyError: If the `properties` dictionary is missing or the specified property
+            is not found in the `properties` dictionary.
+
+    Notes:
+        - If the property is stored as a float (legacy format), a warning is logged.
+        - If the property is normalized, the value is calculated as:
+          `product.processing_edge["amount"] * prop["amount"]`.
+    """
+    if not isinstance(product, Product):
+        raise ValueError("Passed non-function for allocation")
+
+    props = product.get("properties")
+
+    if not props:
+        raise KeyError(f"Product {product} from process {product.processor} doesn't have properties")
+
+    prop = props.get(property_label)
+
+    if not prop:
+        raise KeyError(f"Product {product} from {product.processor} missing property {property_label}")
+
+    if isinstance(prop, float):
+        log.warning("Property using legacy float format")
+        return prop
+
+    if prop.get("normalize", False):
+        return abs(product.processing_edge["amount"]) * prop["amount"]
+    else:
+        return prop["amount"]
+
+
+def property_allocation(property_label: str) -> Callable:
+    """
+    Create a partial function for allocating a process based on a specific property.
+
+    This function generates a callable that performs allocation for a multifunctional process
+    using a getter function that retrieves the value of the specified property.
+
+    Args:
+        property_label (str): The label of the property to be used for allocation.
+
+    Returns:
+        Callable: A partial function that performs allocation using the specified property.
+    """
+    getter = partial(get_property_value, property_label=property_label)
+    return partial(generic_allocation, getter=getter)
+
+
+allocation_strategies = {
+    "equal": partial(generic_allocation, getter=lambda x: 1.0),
+    "manual": partial(generic_allocation, getter=lambda x: x.get("allocation_factor", 1)),
+}

bw_functional/convert.py

@@ -0,0 +1,143 @@
+import tqdm
+from logging import getLogger
+
+import bw2data as bd
+from bw2data.backends import SQLiteBackend
+
+from .database import FunctionalSQLiteDatabase
+
+log = getLogger(__name__)
+
+
+def convert_sqlite_to_functional_sqlite(database_name: str) -> dict:
+    return SQLiteToFunctionalSQLite.convert(database_name)
+
+
+class SQLiteToFunctionalSQLite:
+    @classmethod
+    def convert(cls, database_name: str):
+        db = bd.Database(database_name)
+
+        if not isinstance(db, SQLiteBackend):
+            raise TypeError("Database is not of type SQLite.")
+
+        converted = {}
+
+        for key, ds in tqdm.tqdm(db.load().items()):
+            if ds["type"] in ["process", "processwithreferenceproduct"]:
+                converted.update(cls.convert_process(key, ds))
+
+        return converted
+
+    @classmethod
+    def convert_process(cls, key, ds):
+        ds["type"] = "process"
+        production = [x for x in enumerate(ds["exchanges"]) if x[1]["type"] == "production"]
+        if len(production) > 1:
+            # Check if the process has multiple production exchanges
+            # and raise an error if so
+            act = bd.get_activity(key)
+            raise ValueError("Cannot convert a process with multiple production exchanges to functional_sqlite.", act)
+
+        cls.convert_exchanges(key, ds)
+
+        if not production:
+            function_key, function = cls.create_function(key, ds)
+        else:
+            index, exchange = production.pop()
+            function_key, function = cls.create_function(key, ds, amount=exchange["amount"])
+            ds["exchanges"].pop(index)
+
+        return {key: ds, function_key: function}
+
+    @staticmethod
+    def create_function(key, ds, amount=1.0, name=None):
+        function_name = name or ds.get("reference product") or ds.get("product") or ds.get("name")
+        function_code = ds["code"] + "_function"
+        function_key = (key[0], function_code)
+
+        function = {
+            "type": "product" if amount > 0 else "waste",
+            "name": function_name,
+            "exchanges": [],
+            "database": ds["database"],
+            "code": function_code,
+            "processor": key,
+            "location": ds.get("location"),
+            "unit": ds.get("unit"),
+        }
+
+        ds["exchanges"].append({
+            "type": "production",
+            "input": function_key,
+            "output": key,
+            "amount": amount,
+        })
+
+        return function_key, function
+
+    @staticmethod
+    def convert_exchanges(key, ds) -> None:
+        excs = ds["exchanges"]
+        database, code = key
+
+        for exc in excs:
+            if exc["input"][0] != database:
+                continue
+            exc["input"] = (database, exc["input"][1] + "_function")
+
+
+def convert_functional_sqlite_to_sqlite(database_name: str):
+    return FunctionalSQLiteToSQLite.convert(database_name)
+
+
+class FunctionalSQLiteToSQLite:
+    @classmethod
+    def convert(cls, database_name: str):
+        db = bd.Database(database_name)
+
+        if not isinstance(db, FunctionalSQLiteDatabase):
+            raise TypeError("Database is not of type functional_sqlite.")
+
+        raw = db.load()
+        converted = {}
+
+        for key, ds in tqdm.tqdm(raw.items()):
+            if ds["type"] in ["product", "waste"]:
+                processor = raw[ds["processor"]]
+                converted[key] = cls.convert_function(key, ds, processor)
+
+        return converted
+
+    @classmethod
+    def convert_function(cls, key, ds, processor):
+        ds["type"] = "processwithreferenceproduct"
+        ds["product"] = ds["name"]
+        ds["name"] = processor["name"]
+
+        ds["exchanges"] = []
+        del ds["processor"]
+
+        for exc in processor["exchanges"]:
+            exc = exc.copy()
+            exc["output"] = key
+
+            if exc["type"] == "production" and exc["input"] != key:
+                # production exchange of another function than this one
+                continue
+
+            if exc["type"] != "production" and ds.get("allocation_factor"):
+                log.info(f"Allocating exchange from {exc['input']} to {ds['name']} "
+                         f"with factor {ds['allocation_factor']}")
+                exc["amount"] = exc["amount"] * ds['allocation_factor']
+                if exc.get("formula"):
+                    log.info(f"Allocating formula from {exc['input']} to {ds['name']}: "
+                             f"{exc['formula']} * {ds['allocation_factor']}")
+                    exc["formula"] = f"{exc['formula']} * {ds['allocation_factor']}"
+                if exc.get("uncertainty type"):
+                    log.warning(f"Exchange from {exc['input']} to {ds['name']} has an uncertainty distribution that "
+                                f"will not be allocated")
+
+            ds["exchanges"].append(exc)
+
+        return ds