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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lca_algebraic
-Version: 1.4.1.dev0
+Version: 1.4.1.dev2
 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.dev2}/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.dev2}/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.dev2/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.dev2/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.dev2/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.dev2/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.dev2}/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.dev2}/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.dev2}/lca_algebraic/lambda_expression.py

@@ -1,6 +1,6 @@
 from copy import copy
 from dataclasses import dataclass
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from sympy import Basic, Expr, lambdify, parse_expr
 from sympy.printing.numpy import NumPyPrinter
@@ -8,6 +8,7 @@ from sympy.printing.numpy import NumPyPrinter
 from lca_algebraic.axis_dict import AxisDict
 from lca_algebraic.base_utils import _user_functions
 from lca_algebraic.bw_wrapper import Activity
+from lca_algebraic.log import warn
 from lca_algebraic.params import (
     _complete_params,
     _expand_param_names,
@@ -39,7 +40,7 @@ class LambdaExpr:
 
         # List of background activities, indexed in the same order as impacts[i]
         self.background_activities: List[Activity] = list()
-        self.impacts: List[float] = None
+        self.impacts: Optional[List[float]] = None
 
         if isinstance(expr, dict) and not isinstance(expr, AxisDict):
             # Come from JSON serialization
@@ -123,12 +124,17 @@ class LambdaExpr:
     def with_impacts(self, impacts: Dict[Activity, float]):
         """Transforms a generic LambaExpr toa one with custom impact values"""
         if self.impacts is not None:
-            raise Exception("You are specializing a LambaExpression with impacts already set.")
+            warn("You are specializing a LambaExpression with impacts already set.")
+
         res = copy(self)
         res.impacts = [impacts[bg_act] for bg_act in self.background_activities]
 
         return res
 
+    def impacts_dict(self):
+        """Returns list of impacts as dict"""
+        return {bg_act: val for bg_act, val in zip(self.background_activities, self.impacts)}
+
 
 def _filter_param_values(params, expanded_param_names):
     return {key: val for key, val in params.items() if key in expanded_param_names}