lca-algebraic 1.4.1.dev0__tar.gz → 1.4.1.dev1__tar.gz

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lca_algebraic
-Version: 1.4.1.dev0
+Version: 1.4.1.dev1
 Summary: This library provides a layer above Brightway for defining parametric models and running super fast LCA for monte carlo analysis.
 Author-email: OIE - Mines ParisTech <raphael.jolivet@mines-paristech.fr>
 License: BSD
@@ -29,6 +29,7 @@ Requires-Dist: deprecation
 Requires-Dist: SALib
 Requires-Dist: pint
 Requires-Dist: typing-extensions
+Requires-Dist: xarray>=2022.3.0
 Provides-Extra: bw2
 Requires-Dist: brightway2; extra == "bw2"
 Requires-Dist: pypardiso; platform_machine == "x86_64" and extra == "bw2"

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/activity.py

@@ -168,13 +168,11 @@ class ActivityExtended(Activity):
             or dict of attributes, for updating both at once, or any other attribute.
             The amount can reference the symbol 'old_amount' that will be replaced with the current amount of the exchange.
         """
-
-        if not _isForeground(self["database"]):
+        if not _isForeground(self["database"]) and not Settings.internals:
             msg = f"You are updating a background activity in {self['database']}. Use copyActivity() in a foreground db instead."
             if Settings.strict_mode:
                 raise Exception(msg)
-            else:
-                warn(msg)
+            warn(msg)
 
         # Update exchanges
         for ex_target_or_name, updates in updates.items():
@@ -541,12 +539,11 @@ def _equals(val1: ValueOrExpression, val2: ValueOrExpression):
 
 
 def _newAct(db_name, code):
-    if not _isForeground(db_name):
+    if not _isForeground(db_name) and not Settings.internals:
         msg = f"You are creating activity in background DB {db_name}. Use copyActivity() in a foreground db instead."
         if Settings.strict_mode:
             raise Exception(msg)
-        else:
-            warn(msg)
+        warn(msg)
 
     db = _getDb(db_name)
     # Already present : delete it ?
@@ -632,7 +629,9 @@ def newActivity(
 
 
 @atomic
-def copyActivity(db_name, activity: ActivityExtended, code=None, withExchanges=True, **kwargs) -> ActivityExtended:
+def copyActivity(
+    db_name, activity: ActivityExtended, code=None, withExchanges=True, input_mapping=None, **kwargs
+) -> ActivityExtended:
     """Copy an activity and its exchanges into another database. You usually want to copy activities from your background to
     your foreground DB to update them, keeping your background DB clean.
 
@@ -675,6 +674,9 @@ def copyActivity(db_name, activity: ActivityExtended, code=None, withExchanges=T
             data["output"] = res.key
         if data["input"] == activity.key:
             data["input"] = res.key
+        if input_mapping and data["input"] in input_mapping:
+            # Input mapping, used to migrate proxy db linked to premise scenarios
+            data["input"] = input_mapping[data["input"]]
 
         # Chemical formulas might be in ecoinvent technosphere
         # We don't want them

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/base_utils.py

@@ -1,4 +1,5 @@
 from contextlib import AbstractContextManager
+from functools import cache
 from inspect import isfunction
 from typing import Dict, Iterable, Tuple, Union
 
@@ -26,6 +27,20 @@ def _isnumber(value):
 dbs = dict()
 
 
+def invalidate_db(dbname=None):
+    """Drop the pooled Database instances so a fresh one is built on next access.
+
+    bw25 keeps an internal (session/ORM) view inside a Database object that is not
+    invalidated when a database is deleted or recreated. Keep the pool in sync so that
+    activities are not resolved to stale (deleted) node ids.
+    """
+    global dbs
+    if dbname is None:
+        dbs = dict()
+    else:
+        dbs.pop(dbname, None)
+
+
 def _getDb(dbname):
     """Pool of Database instances"""
     if dbname not in dbs:
@@ -174,6 +189,7 @@ def one(it: Iterable):
     return it[0]
 
 
+@cache
 def getActByCode(db_name, code):
     """Get activity by code"""
     return _getDb(db_name).get(code)
@@ -181,4 +197,4 @@ def getActByCode(db_name, code):
 
 # Types
 ValueOrExpression = Union[float, Basic, Quantity]
-MethodKey = Tuple[str]
+MethodKey = Tuple[str, ...]

lca_algebraic-1.4.1.dev1/lca_algebraic/bw_wrapper/__init__.py

@@ -0,0 +1,150 @@
+from typing import Callable, Iterable, List, Tuple, Type
+
+import pandas as pd
+
+from .protocol import BrightwayBackend
+
+_INSTALL_MSG = (
+    "Brightway is required. Install one of:\n" "  pip install 'lca_algebraic[bw2]'\n" "  pip install 'lca_algebraic[bw25]'"
+)
+
+
+def _bw2data_major_version(bw2data) -> int:
+    version = bw2data.__version__
+    if isinstance(version, tuple):
+        return int(version[0])
+    return int(str(version).split(".")[0])
+
+
+def _load_backend() -> BrightwayBackend:
+    try:
+        import bw2data
+    except ImportError as exc:
+        raise ImportError(_INSTALL_MSG) from exc
+
+    if _bw2data_major_version(bw2data) >= 4:
+        from .bw25 import BW25Backend
+
+        return BW25Backend()
+
+    from .bw2 import BW2Backend
+
+    return BW2Backend()
+
+
+_backend = _load_backend()
+
+Activity = _backend.Activity
+ActivityDataset = _backend.ActivityDataset
+Exchange = _backend.Exchange
+ExchangeDataset = _backend.ExchangeDataset
+ActivityProxyBase = _backend.ActivityProxyBase
+LCIBackend = _backend.LCIBackend
+sqlite3_lci_db = _backend.sqlite3_lci_db
+dict_as_exchangedataset = _backend.dict_as_exchangedataset
+
+name = _backend.name
+
+_LAZY_ATTRS = frozenset({"databases", "projects", "methods"})
+
+
+def __getattr__(attr: str):
+    if attr in _LAZY_ATTRS:
+        return getattr(_backend, attr)
+    raise AttributeError(f"module {__name__!r} has no attribute {attr!r}")
+
+
+def Database(db_name: str):
+    return _backend.Database(db_name)
+
+
+def Method(key: Tuple):
+    return _backend.Method(key)
+
+
+def get_activity(key):
+    return _backend.get_activity(key)
+
+
+def iter_database(db_name: str) -> Iterable:
+    return _backend.iter_database(db_name)
+
+
+def multi_lca(
+    activities: List[dict],
+    methods: List[Tuple],
+    act_name_fn: Callable,
+    method_name_fn: Callable,
+) -> pd.DataFrame:
+    return _backend.multi_lca(activities, methods, act_name_fn, method_name_fn)
+
+
+def is_output_exchange(exc) -> bool:
+    return _backend.is_output_exchange(exc)
+
+
+def exchange_type_for_sub_act(sub_act) -> str:
+    return _backend.exchange_type_for_sub_act(sub_act)
+
+
+def process_node_default() -> str:
+    return _backend.process_node_default()
+
+
+def production_edge_default() -> str:
+    return _backend.production_edge_default()
+
+
+def activity_not_found() -> Type[Exception]:
+    return _backend.activity_not_found()
+
+
+def new_database_parameters(params, db_name: str) -> None:
+    _backend.new_database_parameters(params, db_name)
+
+
+def new_project_parameters(params) -> None:
+    _backend.new_project_parameters(params)
+
+
+def copy_activity_skip_keys() -> set:
+    return _backend.copy_activity_skip_keys()
+
+
+def bw2setup() -> None:
+    _backend.bw2setup()
+
+
+def SingleOutputEcospold2Importer(path, dbname, use_mp=False):
+    return _backend.SingleOutputEcospold2Importer(path, dbname, use_mp=use_mp)
+
+
+__all__ = [
+    "Activity",
+    "ActivityProxyBase",
+    "BrightwayBackend",
+    "Database",
+    "Exchange",
+    "ExchangeDataset",
+    "LCIBackend",
+    "Method",
+    "SingleOutputEcospold2Importer",
+    "activity_not_found",
+    "bw2setup",
+    "copy_activity_skip_keys",
+    "databases",
+    "dict_as_exchangedataset",
+    "exchange_type_for_sub_act",
+    "get_activity",
+    "is_output_exchange",
+    "iter_database",
+    "methods",
+    "multi_lca",
+    "name",
+    "new_database_parameters",
+    "new_project_parameters",
+    "process_node_default",
+    "production_edge_default",
+    "projects",
+    "sqlite3_lci_db",
+]

lca_algebraic-1.4.1.dev1/lca_algebraic/bw_wrapper/bw2.py

@@ -0,0 +1,98 @@
+from typing import Callable, List, Tuple
+
+import brightway2 as bw
+import pandas as pd
+from bw2data.backends import LCIBackend
+from bw2data.backends.peewee import (
+    Activity,
+    ActivityDataset,
+    Exchange,
+    ExchangeDataset,
+    sqlite3_lci_db,
+)
+from bw2data.backends.peewee.utils import dict_as_exchangedataset
+from bw2data.proxies import ActivityProxyBase
+from peewee import DoesNotExist
+
+_TECHNO_TYPES = [None, "process", "product", "processwithreferenceproduct", "multifunctional"]
+
+
+class BW2Backend:
+    name = "bw2"
+
+    Activity = Activity
+    ActivityDataset = ActivityDataset
+    Exchange = Exchange
+    ExchangeDataset = ExchangeDataset
+    ActivityProxyBase = ActivityProxyBase
+    LCIBackend = LCIBackend
+    sqlite3_lci_db = sqlite3_lci_db
+    dict_as_exchangedataset = staticmethod(dict_as_exchangedataset)
+
+    @property
+    def databases(self):
+        return bw.databases
+
+    @property
+    def projects(self):
+        return bw.projects
+
+    @property
+    def methods(self):
+        return bw.methods
+
+    def Database(self, name: str):
+        return bw.Database(name)
+
+    def Method(self, key: Tuple):
+        return bw.Method(key)
+
+    def get_activity(self, key):
+        return bw.get_activity(key)
+
+    def iter_database(self, db_name: str):
+        return iter(bw.Database(db_name))
+
+    def multi_lca(
+        self,
+        activities: List[dict],
+        methods: List[Tuple],
+        act_name_fn: Callable,
+        method_name_fn: Callable,
+    ) -> pd.DataFrame:
+        bw.calculation_setups["process"] = {"inv": activities, "ia": methods}
+        lca = bw.MultiLCA("process")
+        cols = [act_name_fn(act) for act_amount in activities for act in act_amount]
+        return pd.DataFrame(lca.results.T, index=[method_name_fn(method) for method in methods], columns=cols)
+
+    def is_output_exchange(self, exc) -> bool:
+        return exc.get("type") == "production"
+
+    def exchange_type_for_sub_act(self, sub_act) -> str:
+        if sub_act.get("type") in _TECHNO_TYPES:
+            return "technosphere"
+        return "biosphere"
+
+    def process_node_default(self) -> str:
+        return "process"
+
+    def production_edge_default(self) -> str:
+        return "production"
+
+    def activity_not_found(self):
+        return DoesNotExist
+
+    def new_database_parameters(self, params, db_name: str) -> None:
+        bw.parameters.new_database_parameters(params, db_name)
+
+    def new_project_parameters(self, params) -> None:
+        bw.parameters.new_project_parameters(params)
+
+    def copy_activity_skip_keys(self) -> set:
+        return {"database", "code"}
+
+    def bw2setup(self):
+        bw.bw2setup()
+
+    def SingleOutputEcospold2Importer(self, path, dbname, use_mp=False):
+        return bw.SingleOutputEcospold2Importer(path, dbname, use_mp=use_mp)

lca_algebraic-1.4.1.dev1/lca_algebraic/bw_wrapper/bw25.py

@@ -0,0 +1,115 @@
+from typing import Callable, List, Tuple
+
+import bw2calc
+import bw2data
+import numpy as np
+import pandas as pd
+from bw2data import Database
+from bw2data.backends import (
+    Activity,
+    ActivityDataset,
+    Exchange,
+    ExchangeDataset,
+    SQLiteBackend,
+    sqlite3_lci_db,
+)
+from bw2data.backends.utils import dict_as_exchangedataset
+from bw2data.configuration import labels
+from bw2data.errors import UnknownObject
+from bw2data.parameters import ParameterManager
+from bw2data.proxies import ActivityProxyBase
+
+
+class BW25Backend:
+    name = "bw25"
+
+    Activity = Activity
+    ActivityDataset = ActivityDataset
+    Exchange = Exchange
+    ExchangeDataset = ExchangeDataset
+    ActivityProxyBase = ActivityProxyBase
+    LCIBackend = SQLiteBackend
+    sqlite3_lci_db = sqlite3_lci_db
+    dict_as_exchangedataset = staticmethod(dict_as_exchangedataset)
+
+    @property
+    def databases(self):
+        return bw2data.databases
+
+    @property
+    def projects(self):
+        return bw2data.projects
+
+    @property
+    def methods(self):
+        return bw2data.methods
+
+    def Database(self, name: str):
+        return Database(name)
+
+    def Method(self, key: Tuple):
+        return bw2data.Method(key)
+
+    def get_activity(self, key):
+        return bw2data.get_activity(key)
+
+    def iter_database(self, db_name: str):
+        return iter(Database(db_name))
+
+    def multi_lca(
+        self,
+        activities: List[dict],
+        methods: List[Tuple],
+        act_name_fn: Callable,
+        method_name_fn: Callable,
+    ) -> pd.DataFrame:
+        meth_cfg = {"impact_categories": methods}
+        fu = {act_name_fn(act): {act.id: 1} for act_amount in activities for act in act_amount}
+
+        bw2data.databases.clean()
+        data_objs = bw2data.get_multilca_data_objs(fu, meth_cfg)
+        lca = bw2calc.MultiLCA(demands=fu, method_config=meth_cfg, data_objs=data_objs)
+        lca.lci()
+        lca.lcia()
+
+        rows = [method_name_fn(method) for method in methods]
+        cols = [act_name_fn(act) for act_amount in activities for act in act_amount]
+        results = lca.scores
+
+        return pd.DataFrame(
+            np.array([[results[m, a] for a in cols] for m in methods]),
+            index=rows,
+            columns=cols,
+        )
+
+    def is_output_exchange(self, exc) -> bool:
+        return exc.get("type") == labels.production_edge_default
+
+    def exchange_type_for_sub_act(self, sub_act) -> str:
+        if sub_act.get("type") in labels.lci_node_types:
+            return labels.consumption_edge_default
+        return labels.biosphere_edge_default
+
+    def process_node_default(self) -> str:
+        return labels.process_node_default
+
+    def production_edge_default(self) -> str:
+        return labels.production_edge_default
+
+    def activity_not_found(self):
+        return UnknownObject
+
+    def new_database_parameters(self, params, db_name: str) -> None:
+        ParameterManager().new_database_parameters(params, db_name)
+
+    def new_project_parameters(self, params) -> None:
+        ParameterManager().new_project_parameters(params)
+
+    def copy_activity_skip_keys(self) -> set:
+        return {"database", "code", "id"}
+
+    def bw2setup(self) -> None:
+        raise NotImplementedError("bw2setup is only supported with brightway2")
+
+    def SingleOutputEcospold2Importer(self, path, dbname, use_mp=False):
+        raise NotImplementedError("SingleOutputEcospold2Importer is only supported with brightway2")

lca_algebraic-1.4.1.dev1/lca_algebraic/bw_wrapper/protocol.py

@@ -0,0 +1,81 @@
+from typing import Any, Callable, Iterable, List, Protocol, Tuple, Type
+
+import pandas as pd
+
+
+class BrightwayBackend(Protocol):
+    """Brightway 2 / 2.5 compatibility surface used by lca_algebraic."""
+
+    Activity: Any
+    Exchange: Any
+    ActivityDataset: Any
+    ExchangeDataset: Any
+    ActivityProxyBase: Any
+    LCIBackend: Any
+    sqlite3_lci_db: Any
+    dict_as_exchangedataset: Callable[..., Any]
+
+    name: str
+
+    @property
+    def databases(self) -> Any:
+        ...
+
+    @property
+    def projects(self) -> Any:
+        ...
+
+    @property
+    def methods(self) -> Iterable:
+        ...
+
+    def Database(self, name: str) -> Any:
+        ...
+
+    def Method(self, key: Tuple) -> Any:
+        ...
+
+    def get_activity(self, key) -> Any:
+        ...
+
+    def iter_database(self, db_name: str) -> Iterable:
+        ...
+
+    def multi_lca(
+        self,
+        activities: List[dict],
+        methods: List[Tuple],
+        act_name_fn: Callable,
+        method_name_fn: Callable,
+    ) -> pd.DataFrame:
+        ...
+
+    def is_output_exchange(self, exc) -> bool:
+        ...
+
+    def exchange_type_for_sub_act(self, sub_act) -> str:
+        ...
+
+    def process_node_default(self) -> str:
+        ...
+
+    def production_edge_default(self) -> str:
+        ...
+
+    def activity_not_found(self) -> Type[Exception]:
+        ...
+
+    def new_database_parameters(self, params, db_name: str) -> None:
+        ...
+
+    def new_project_parameters(self, params) -> None:
+        ...
+
+    def copy_activity_skip_keys(self) -> set:
+        ...
+
+    def bw2setup(self) -> None:
+        ...
+
+    def SingleOutputEcospold2Importer(self, path, dbname, use_mp=False) -> Any:
+        ...

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/cache.py

@@ -8,14 +8,15 @@ from typing import Dict, Tuple
 from dill import Pickler, load
 from sympy.core.function import UndefinedFunction
 
-from lca_algebraic.bw_wrapper import databases, projects
+from lca_algebraic.bw_wrapper import Database, databases, projects
 
 from .database import _getMeta
-from .log import info, logger
+from .log import logger
 from .settings import PROXY_DB_FLAG, Settings
 
 LCIA_CACHE = "lcia"
 EXPR_CACHE = "expr"
+MAPPING_CACHE = "mapping"
 
 
 # Overide the behaviour for pickling sympy.UndefineFunction
@@ -43,11 +44,15 @@ def flush_caches():
         cache.sync()
 
 
-def get_dependant_dbs(db_name):
+def get_dependant_dbs(db_name, skip_proxy=True):
     """Recursively get list of dependant db names, including the current one"""
 
+    # Only work if database is up to date (processed)
+    if databases[db_name].get("dirty"):
+        Database(db_name).process()
+
     # Skip proxy databases
-    if _getMeta(db_name, PROXY_DB_FLAG):
+    if skip_proxy and _getMeta(db_name, PROXY_DB_FLAG):
         res = set()
     else:
         res = set([db_name])
@@ -150,7 +155,7 @@ class SyncDict(MutableMapping):
         if self.last_update <= file_mtime:
             return
 
-        info(f"Flushing cache {self.name} / {self.db_name}")
+        # info(f"Flushing cache {self.name} / {self.db_name}")
 
         tmp = self._filename() + ".tmp"
         with open(tmp, "wb") as f:
@@ -208,6 +213,11 @@ class ExprCache(_CacheDict):
         super().__init__(EXPR_CACHE, db_name)
 
 
+class MappingCache(_CacheDict):
+    def __init__(self, db_name):
+        super().__init__(MAPPING_CACHE, db_name)
+
+
 def clear_caches(local=True, disk=True):
     for cache_name in [LCIA_CACHE, EXPR_CACHE]:
         for db_name in databases:

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/database.py

@@ -20,6 +20,7 @@ from lca_algebraic.bw_wrapper import (
     sqlite3_lci_db,
 )
 
+from .base_utils import getActByCode, invalidate_db
 from .log import logger
 from .settings import PROXY_DB_FLAG
 
@@ -87,6 +88,15 @@ def resetDb(db_name, foreground=True):
         logger.warning("Db %s was here. Reseting it" % db_name)
         del dbmeta[db_name]
 
+    # Drop the pooled Database instance : it may hold a stale view (e.g. bw25 node ids)
+    # of a previously deleted/recreated database with the same name
+    invalidate_db(db_name)
+
+    # getActByCode() memoizes activity objects by (db_name, code). Activities are
+    # recreated with the same code on reset, so drop the memo to avoid returning
+    # stale (deleted) node ids.
+    getActByCode.cache_clear()
+
     db = Database(db_name)
     db.write(dict())
     if foreground:

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/lca.py

@@ -26,6 +26,7 @@ from lca_algebraic.base_utils import (
 )
 from lca_algebraic.bw_wrapper import (
     Activity,
+    ActivityDataset,
     Database,
     activity_not_found,
     databases,
@@ -35,9 +36,16 @@ from lca_algebraic.bw_wrapper import (
 from lca_algebraic.lambda_expression import LambdaExpr
 from lca_algebraic.settings import Settings
 
-from .cache import ExprCache, LCIACache
+from . import atomic, copyActivity, getActByCode, resetDb
+from .cache import (
+    ExprCache,
+    LCIACache,
+    MappingCache,
+    get_dependant_dbs,
+    get_last_update,
+)
 from .database import BIOSPHERE_PREFIX, DbContext, _isForeground, _setMeta
-from .log import info, logger, warn
+from .log import info, progress, warn
 from .matrix import ActMatrix, invert
 from .methods import method_name, method_unit
 from .params import (
@@ -58,6 +66,10 @@ from .sympy_utils import replace_and_cleanup
 IMPACTS_SYMBOL = IndexedBase("impacts")
 
 
+# Mapping for activities for premise / scenarios
+MAPPING_KEYS = ("name", "location", "unit", "reference product")
+
+
 def register_user_function(sym, func):
     """Register a custom function with is python implementation
     Parameters
@@ -165,7 +177,10 @@ def _multiLCAWithCache(all_acts, methods) -> Dict[Tuple[ActivityExtended, Method
             )
 
             if len(remaining_acts) > 0 and len(remaining_methods) > 0:
-                info(f"Computing LCA for {len(remaining_acts)} background acts on methods {remaining_methods}")
+                progress(
+                    f"Computing brightway LCIA for {db_name}. "
+                    f"{len(remaining_acts)} background acts on methods {remaining_methods}"
+                )
 
                 lca = _multiLCAWithProxies(remaining_acts, remaining_methods)
 
@@ -215,7 +230,7 @@ def _actToLambdaExpr(model: Activity, axis=None, alpha=1) -> LambdaExpr:
         mset_key = _matrices_set_cache_key(base_key)
 
         if mset_key not in cache.data:
-            logger.debug(f"{db_name} matrices were not in expression cache, computing...")
+            progress(f"{db_name} matrices were not in expression cache, computing...")
             if axis is None:
                 cache.data[mset_key] = AxisMatricesSet(variants={"_all_": _computeMatrices(db_name=db_name)})
             else:
@@ -238,7 +253,7 @@ def lambdify_expr(expr):
 
 
 def _preMultiLCAAlgebric(
-    model: ActivityExtended, methods: MethodKey, alpha: ValueOrExpression = 1, axis=None
+    model: ActivityExtended, methods: List[MethodKey], alpha: ValueOrExpression = 1, axis: str = None, scenario: list[str] = None
 ) -> list[LambdaExpr]:
     """
     This method transforms an activity into a set of functions ready to compute LCA very fast on a set on methods.
@@ -252,12 +267,15 @@ def _preMultiLCAAlgebric(
             alpha = alpha.magnitude
 
         def _key(method):
-            return (model, axis, method, alpha)
+            key = (model, axis, method, alpha)
+            if scenario:
+                key += (scenario,)
+            return key
 
         with ExprCache(model["database"]) as cache:
             missing_methods = [method for method in methods if not _key(method) in cache.data]
             if len(missing_methods) > 0:
-                exprs = _modelToExpr(model, methods=missing_methods, axis=axis, alpha=alpha)
+                exprs = _modelToExpr(model, methods=missing_methods, axis=axis, alpha=alpha, scenario=scenario)
                 for method, expr in zip(missing_methods, exprs):
                     cache.data[_key(method)] = expr
 
@@ -266,7 +284,150 @@ def _preMultiLCAAlgebric(
             return list(cache.data[_key(method)] for method in methods)
 
 
-def _modelToExpr(model: Activity, methods: List[MethodKey], axis=None, alpha: ValueOrExpression = 1) -> List[LambdaExpr]:
+def _build_mapping_key(act: Activity):
+    return tuple(act.get(attr) for attr in MAPPING_KEYS)
+
+
+def _get_dependant_scenario(db_name):
+    """Get premise scenarios of which depend this database (exchanges pointing to other dbs)"""
+    res = set()
+    for target_db in get_dependant_dbs(db_name, skip_proxy=False):
+        if target_db == db_name or Settings.scenario_separator not in target_db:
+            continue
+
+        _, scenario = target_db.split(Settings.scenario_separator)
+        res.add(scenario)
+
+    if len(res) == 0:
+        return None
+    if len(res) == 1:
+        return list(res)[0]
+
+    raise Exception(f"Database {db_name} depends on more than one premise scenarios : {res}")
+
+
+def _code_by_key(db_name: str) -> Dict[Tuple, str]:
+    """List all activities of a db by their keys => code"""
+
+    master_key = "all_acts"
+
+    with MappingCache(db_name) as cache:
+        if master_key not in cache.data:
+            progress(f"Building cache of keys for {db_name}")
+
+            query = (
+                ActivityDataset.select(ActivityDataset.code, ActivityDataset.data)
+                .where(ActivityDataset.database == db_name)
+                .tuples()
+            )
+
+            mapping = dict()
+            for code, data in query:
+                key = _build_mapping_key(data)
+                if key in mapping:
+                    raise Exception(f"Duplicate key {key} in {db_name}")
+                mapping[key] = code
+
+            cache.data[master_key] = mapping
+
+        return cache.data[master_key]
+
+
+def _key_to_key_mapping(source_db, dest_db):
+    """Return mapping of {(db, code) : (db, code)}"""
+
+    src_code_by_key = _code_by_key(source_db)
+    dest_code_by_key = _code_by_key(dest_db)
+
+    return {
+        (source_db, src_code): (dest_db, dest_code_by_key[src_key])
+        for src_key, src_code in src_code_by_key.items()
+        if src_key in dest_code_by_key
+    }
+
+
+@atomic
+def _duplicate_db_for_scenario(origin_db, target_db):
+    """Duplicate a proxy database and targets another scenario"""
+
+    # Empty the target
+    resetDb(target_db, foreground=False)
+
+    with temp_settings(internals=True):
+        target_scenario = target_db.split(Settings.scenario_separator)[1]
+
+        progress(f"Duplicating proxy database {origin_db} for IAM scenario {target_scenario}")
+
+        # Gather all mappings
+        all_mappings = dict()
+        for dependant_db in get_dependant_dbs(origin_db, skip_proxy=False):
+            if Settings.scenario_separator not in dependant_db or dependant_db == origin_db:
+                continue
+
+            dep_db_prefix, dep_scenario = dependant_db.split(Settings.scenario_separator)
+            dep_target_db = dep_db_prefix + Settings.scenario_separator + target_scenario
+            all_mappings.update(_key_to_key_mapping(dependant_db, dep_target_db))
+
+        # Loop on activities
+        for act in Database(origin_db):
+            copyActivity(db_name=target_db, activity=act, code=act["name"], input_mapping=all_mappings)
+
+
+def _map_activities(acts: list[Activity], source_db: str, target_db: str):
+    dependant_scenario = _get_dependant_scenario(source_db)
+
+    # Support for automatically creating or updating proxy db for other scenarios
+    if target_db not in databases:
+        # To dependancy : this is a root premise DB : missing scenrio should not happen
+        if dependant_scenario is None:
+            raise Exception(f"Missing target database for premise scenrio  {target_db}")
+
+        info(f"Proxy database {target_db} was missing. Creating from  {source_db}")
+        _duplicate_db_for_scenario(source_db, target_db)
+
+    # Exiisting db This is a proxy db
+    # Check it did not change
+    elif dependant_scenario is not None and get_last_update(source_db) > get_last_update(target_db):
+        info(f"Proxy database {source_db} changed. Updating {target_db}")
+        _duplicate_db_for_scenario(source_db, target_db)
+
+    code_by_key = _code_by_key(target_db)
+
+    def _get_target_act(act):
+        key = _build_mapping_key(act)
+        try:
+            code = code_by_key[key]
+        except KeyError:
+            key_dict = {k: v for k, v in zip(MAPPING_KEYS, key)}
+            raise Exception(f"Failed to find mapping for activity {key_dict} in target db {target_db}")
+
+        return getActByCode(target_db, code)
+
+    return {act: _get_target_act(act) for act in acts}
+
+
+def _compute_scenario_mapping(acts: list[Activity], scenario: str = None):
+    """In case a scenario is requested"""
+
+    res = dict()
+
+    for db_name, acts in _group_acts_by_db(acts).items():
+        # Not premise Db or no scenario requested ? => no mapping
+        if Settings.scenario_separator not in db_name or scenario is None:
+            # Map all activities to themselves
+            res.update({act: act for act in acts})
+
+        else:
+            prefix, source_scenario = db_name.split(Settings.scenario_separator)
+            target_db = prefix + Settings.scenario_separator + scenario
+            res.update(_map_activities(acts, db_name, target_db))
+
+    return res
+
+
+def _modelToExpr(
+    model: Activity, methods: List[MethodKey], axis=None, alpha: ValueOrExpression = 1, scenario: str = None
+) -> List[LambdaExpr]:
     """
     Compute expressions corresponding to a model for each impact, replacing activities by the value of its impact
 
@@ -283,13 +444,17 @@ def _modelToExpr(model: Activity, methods: List[MethodKey], axis=None, alpha: Va
         zero.impacts = []
         return [zero] * len(methods)
 
+    # Possibly map bg activities to another target scenario db
+    act_mapping = _compute_scenario_mapping(generic_lambda_expr.background_activities, scenario=scenario)
+
     # Compute LCA for background activities
-    all_impacts = _multiLCAWithCache(generic_lambda_expr.background_activities, methods)
+    all_impacts = _multiLCAWithCache(act_mapping.values(), methods)
 
     res = list()
 
     for method in methods:
-        impacts = {bg_act: all_impacts[bg_act, method] for bg_act in generic_lambda_expr.background_activities}
+        impacts = {bg_act: all_impacts[target_act, method] for bg_act, target_act in act_mapping.items()}
+
         res.append(generic_lambda_expr.with_impacts(impacts))
 
     return res
@@ -320,6 +485,12 @@ def _postMultiLCAAlgebric(methods, lambdas: List[LambdaExpr], with_params=False,
 
     param_length = _compute_param_length(params)
 
+    if len(lambdas[0].impacts) > 0:
+        first_impact = lambdas[0].impacts[0]
+        if isinstance(first_impact, (list, np.ndarray)):
+            nb_scenarios = len(first_impact)
+            param_length = max(param_length, nb_scenarios)
+
     # lambda are SymDict ?
     # If use them as number of params
     if lambdas[0].has_axis and len(lambdas[0].expr) > 1:
@@ -536,13 +707,49 @@ def compute_inventory(
     return DataFrame(items)
 
 
+def _merge_lambda_scenarios(lambdas: list[list[LambdaExpr]]):
+    """
+    Merge impact vector from several lambda comming from several premise scenarios.
+    All the expressions are he same, only the vector of impact differs.
+    We merge several impact_vectors into a single vector of vectors
+    """
+
+    # Ensure liust (from generators)
+    lambdas = list(lambdas)
+
+    # They are all the same for all scenarios except for the impacts
+    ref_lambdas = lambdas[0]
+
+    nb_scenarios = len(lambdas)
+
+    if nb_scenarios == 1:
+        return ref_lambdas
+
+    # Copy lambda of first scennario
+    res = []
+    for imethod, expr in enumerate(ref_lambdas):
+        expr = copy(expr)
+        res.append(expr)
+        expr.impacts = list()
+        for ibackground in range(len(expr.background_activities)):
+            impacts = np.array([lambdas[iscenario][imethod].impacts[ibackground] for iscenario in range(nb_scenarios)])
+            expr.impacts.append(impacts)
+    return res
+
+
 def compute_impacts(
-    models,
-    methods,
-    axis=None,
-    functional_unit=1,
+    models: Union[
+        Activity,
+        List[Activity],
+        List[Tuple[Activity, float]],
+        Dict[Activity, float],
+    ],
+    methods: Union[MethodKey, List[MethodKey]],
+    axis: str = None,
+    functional_unit: float = 1,
     return_params=False,
     description=None,
+    scenario: Union[str, list[str]] = None,
     **params,
 ):
     """
@@ -562,7 +769,7 @@ def compute_impacts(
         In case of several models, you cannot use list of parameters
 
     methods :
-        List of methods / impacts to consider
+        Single method or list of methods / impacts to consider
 
     axis:
         Designates the name of a custom attribute of foreground activities.
@@ -577,6 +784,11 @@ def compute_impacts(
         In the later case, all parameters should have the same number of values.
         Paremeters that are not provided will have their default value set.
 
+    scenario:
+        Premise scenario to target, as suffix of database name (separated with # by default).
+        This may also be a list of scenarios, in which case the number of scenarios should be equal to the
+        length of other list parameters (if any).
+
     functional_unit:
         Quantity (static or Sympy formula) by which to divide impacts. Optional, 1 by default.
 
@@ -643,7 +855,11 @@ def compute_impacts(
             if functional_unit != 1:
                 alpha = alpha / functional_unit
 
-            lambdas = _preMultiLCAAlgebric(model, methods, alpha=alpha, axis=axis)
+            scenarios = scenario if isinstance(scenario, list) else [scenario]
+
+            lambdas = _merge_lambda_scenarios(
+                _preMultiLCAAlgebric(model, methods, scenario=scenario, alpha=alpha, axis=axis) for scenario in scenarios
+            )
 
             unit: Optional[Unit] = functional_unit.units if isinstance(functional_unit, Quantity) else None
 
@@ -662,6 +878,16 @@ def compute_impacts(
             # param with several values
             list_params = {k: vals for k, vals in params.items() if isinstance(vals, list)}
 
+            if isinstance(scenario, list):
+                if len(list_params) > 0:
+                    nb_params_values = len(list(list_params.values())[0])
+                    if len(scenario) != nb_params_values:
+                        raise Exception(
+                            f"Number of scenarios {len(scenario)} different from param values length {nb_params_values} "
+                        )
+
+                list_params["scenario"] = scenario
+
             # Shapes the output / index according to the axis or multi param entry
             if axis:
                 df[axis] = lambdas[0].axis_keys
@@ -721,9 +947,12 @@ def _isBioAct(act: ActivityExtended):
     return (BIOSPHERE_PREFIX in db_name) or ("type" in act and act["type"] in ["emission", "natural resource"])
 
 
-def _getOrCreateProxyDb(db_name):
+def _getOrCreateProxyDb(db_name, scenario=None):
     """Init proxy db to biosphere if not done yet"""
     proxyname = db_name + "-proxy"
+    if scenario:
+        proxyname += Settings.scenario_separator + scenario
+
     if proxyname not in databases:
         db = Database(proxyname)
         db.write(dict())
@@ -732,9 +961,23 @@ def _getOrCreateProxyDb(db_name):
 
 
 def _getOrCreateProxy(act: ActivityExtended, exchanges: dict[ActivityExtended, float]):
-    proxy_db = _getOrCreateProxyDb(act["database"])
+    scenarios = set()
+    for target_act in exchanges.keys():
+        db_name = target_act["database"]
+        if Settings.scenario_separator in db_name:
+            scenario = db_name.split(Settings.scenario_separator)[1]
+            scenarios.add(scenario)
+
+    if len(scenarios) == 0:
+        scenario = None
+    elif len(scenarios) == 1:
+        scenario = list(scenarios)[0]
+    else:
+        raise Exception(f"Found several scenrios in activity to proxy : {scenarios}")
+
+    proxy_db = _getOrCreateProxyDb(act["database"], scenario=scenario)
     proxy_code = act["code"] + "#proxy"
-    with temp_settings(strict_mode=False):
+    with temp_settings(internals=True):
         try:
             proxy = _getDb(proxy_db).get(proxy_code)
 

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/log.py

@@ -1,6 +1,10 @@
 import logging
 import os
 
+PROGRESS = 25
+
+logging.addLevelName(PROGRESS, "PROGRESS")
+
 LOGLEVEL = os.environ.get("LOGLEVEL", "INFO").upper()
 # logging.basicConfig(level=LOGLEVEL, format="[%(levelname)s] %(message)s")
 
@@ -27,3 +31,7 @@ def warn(*args):
 def info(*args):
     msg = " ".join(str(item) for item in args)
     logger.info(msg)
+
+
+def progress(msg, *args):
+    logger._log(PROGRESS, msg, args)

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/params.py

@@ -938,9 +938,7 @@ class ParamRegistry:
         if param.dbname in self.params[key]:
             message = "[ParamRegistry] Param %s was already defined in '%s' " % (param.name, param.dbname or "<project>")
 
-            if Settings.param_overriding_enabled:
-                warn(message + " overriding")
-            else:
+            if not Settings.param_overriding_enabled:
                 raise Exception(message + "overriding disabled in Settings")
 
         self.params[key][param.dbname] = param

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic/settings.py

@@ -28,6 +28,9 @@ class Settings:
     # When activted, forbids any creation or update in background database
     strict_mode: bool = False
 
+    # Set temporarly to true for internal tools not to trigger warnings
+    internals = False
+
     # Use "Common Sub expression patterns" in sympy lambdify
     cse_mode = CSE.DEFAULT
 
@@ -35,6 +38,10 @@ class Settings:
     # If set to flase, you shoudl ensure flushing caches yourself
     auto_flush = True
 
+    # Separator considered in database name for scenarios
+    # You may chose another one with several safer catacters like "__" or "-scenario-"
+    scenario_separator = "#"
+
 
 # Flag used on Db to set it as proxy
 PROXY_DB_FLAG = "isProxy"

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lca_algebraic
-Version: 1.4.1.dev0
+Version: 1.4.1.dev1
 Summary: This library provides a layer above Brightway for defining parametric models and running super fast LCA for monte carlo analysis.
 Author-email: OIE - Mines ParisTech <raphael.jolivet@mines-paristech.fr>
 License: BSD
@@ -29,6 +29,7 @@ Requires-Dist: deprecation
 Requires-Dist: SALib
 Requires-Dist: pint
 Requires-Dist: typing-extensions
+Requires-Dist: xarray>=2022.3.0
 Provides-Extra: bw2
 Requires-Dist: brightway2; extra == "bw2"
 Requires-Dist: pypardiso; platform_machine == "x86_64" and extra == "bw2"

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic.egg-info/SOURCES.txt

@@ -24,8 +24,13 @@ lca_algebraic.egg-info/SOURCES.txt
 lca_algebraic.egg-info/dependency_links.txt
 lca_algebraic.egg-info/requires.txt
 lca_algebraic.egg-info/top_level.txt
+lca_algebraic/bw_wrapper/__init__.py
+lca_algebraic/bw_wrapper/bw2.py
+lca_algebraic/bw_wrapper/bw25.py
+lca_algebraic/bw_wrapper/protocol.py
 test/test_axis_dict.py
 test/test_axis_matrices_cache.py
 test/test_cache.py
+test/test_premise.py
 test/test_sympy.py
 test/test_units.py

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/lca_algebraic.egg-info/requires.txt

@@ -10,6 +10,7 @@ deprecation
 SALib
 pint
 typing-extensions
+xarray>=2022.3.0
 
 [bw2]
 brightway2

{lca_algebraic-1.4.1.dev0 → lca_algebraic-1.4.1.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lca_algebraic"
-version = "1.4.1.dev0"
+version = "1.4.1.dev1"
 
 description = "This library provides a layer above Brightway for defining parametric models and running super fast LCA for monte carlo analysis."
 readme = "README.md"
@@ -38,6 +38,7 @@ dependencies = [
   "SALib",
   "pint",
   "typing-extensions",
+  "xarray>=2022.3.0",
 ]
 
 [project.optional-dependencies]
@@ -63,7 +64,7 @@ Documentation = "https://lca-algebraic.readthedocs.io/"
 Changelog = "https://github.com/oie-mines-paristech/lca_algebraic/blob/main/RELEASE_NOTES.md"
 
 [tool.setuptools]
-packages = ["lca_algebraic"]
+packages = ["lca_algebraic", "lca_algebraic.bw_wrapper"]
 
 [tool.setuptools.package-data]
 lca_algebraic = ["README.md"]

lca_algebraic-1.4.1.dev1/test/test_premise.py

@@ -0,0 +1,99 @@
+from numpy.ma.testutils import assert_array_equal
+
+from lca_algebraic import resetDb, newActivity, newFloatParam, compute_impacts, temp_settings
+from test.conftest import DataFixture, USER_DB, assert_impacts
+
+
+def test_compute_impact_with_scenario(data: DataFixture):
+    # Scnerio database are separated with '#'
+    BG_DB1 = "bg#scen1"
+    BG_DB2 = "bg#scen2"
+
+    # Build two databases
+    resetDb(BG_DB1, foreground=False)
+    resetDb(BG_DB2, foreground=False)
+
+    # Add twin BG activities
+    bg_act = newActivity(BG_DB1, name="bg_act", unit="kg", exchanges={data.bio1: 1.0})
+
+    # Same activitiy with different exchange in scenario 2
+    bg_act2 = newActivity(BG_DB2, name="bg_act", unit="kg", exchanges={data.bio1: 2.0})
+
+    # Build parametrized model on BG1
+    p1 = newFloatParam("p1", default=1, min=0, max=1)
+
+    fg_act = newActivity(USER_DB, "fg", "kg", {bg_act: p1})
+
+    # Raw impacts without scenario : targeting scen1
+    res = compute_impacts(models=fg_act, methods=data.ibio1, p1=1.0)
+
+    assert_impacts(res, 1.0)
+
+    # Impact for scenario 2
+    res = compute_impacts(models=fg_act, methods=data.ibio1, scenario="scen2", p1=1.0)
+
+    assert_impacts(res, 2.0)
+
+
+def test_compute_impact_with_several_scenarios(data: DataFixture):
+    # Scnerio database are separated with '#'
+    BG_DB1 = "bg#scen1"
+    BG_DB2 = "bg#scen2"
+
+    # Build two databases
+    resetDb(BG_DB1, foreground=False)
+    resetDb(BG_DB2, foreground=False)
+
+    # Add twin BG activities
+    bg_act = newActivity(BG_DB1, name="bg_act", unit="kg", exchanges={data.bio1: 1.0})
+
+    # Same activitiy with different exchange in scenario 2
+    bg_act2 = newActivity(BG_DB2, name="bg_act", unit="kg", exchanges={data.bio1: 2.0})
+
+    # Build parametrized model on BG1
+    p1 = newFloatParam("p1", default=1, min=0, max=1)
+
+    fg_act = newActivity(USER_DB, "fg", "kg", {bg_act: p1})
+
+    # Raw impacts without scenario : targeting scen1
+    res = compute_impacts(
+        models=fg_act,
+        methods=data.ibio1,
+        # p1=[1.0, 3.0],
+        scenario=["scen1", "scen2"],
+    )
+
+    assert_array_equal(res.values.flatten(), [1.0, 2.0])
+
+    # also vary parameter at the same time
+    res = compute_impacts(models=fg_act, methods=data.ibio1, p1=[1.0, 3.0], scenario=["scen1", "scen2"])
+
+    assert_array_equal(res.values.flatten(), [1.0, 6.0])
+
+    print(res)
+
+
+def test_compute_impact_with_background_proxy(data: DataFixture):
+    """Test the same with background proxy factorization activated"""
+
+    with temp_settings(factorize_static_bg=True, strict_mode=True):
+        # Scnerio database are separated with '#'
+        BG_DB1 = "bg#scen1"
+        BG_DB2 = "bg#scen2"
+
+        # Build two databases
+        resetDb(BG_DB1, foreground=False)
+        resetDb(BG_DB2, foreground=False)
+
+        with temp_settings(internals=True):
+            # Add twin BG activities
+            bg_act = newActivity(BG_DB1, name="bg_act", unit="kg", exchanges={data.bio1: 1.0})
+            bg_act2 = newActivity(BG_DB2, name="bg_act", unit="kg", exchanges={data.bio1: 2.0})
+
+        # Static amount so that backgrounf proxy is created
+        fg_act = newActivity(USER_DB, "fg", "kg", {bg_act: 1})
+
+        # Impact for scenario 2
+        res = compute_impacts(models=fg_act, methods=data.ibio1, scenario="scen2")
+
+        assert_impacts(res, 2.0)