Switch to loguru

Author: Marin Visscher

bw_functional/__init__.py

@@ -12,9 +12,7 @@
     "update",
 )
 
-from importlib import metadata
-# import os
-from logging import getLogger
+from loguru import logger
 
 from bw2data import labels
 from bw2data.subclass_mapping import DATABASE_BACKEND_MAPPING, NODE_PROCESS_CLASS_MAPPING
@@ -26,8 +24,6 @@
 from .convert import convert_sqlite_to_functional_sqlite, convert_functional_sqlite_to_sqlite
 from .update import update, latest
 
-log = getLogger(__name__)
-
 DATABASE_BACKEND_MAPPING["functional_sqlite"] = FunctionalSQLiteDatabase
 NODE_PROCESS_CLASS_MAPPING["functional_sqlite"] = FunctionalSQLiteDatabase.node_class
 
@@ -63,7 +59,7 @@ def _check_parameterized_exchange_for_allocation(_, name):
     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.")
+            logger.warning(f"Process {key} is not an instance of Process, skipping allocation check.")
             continue
         process.allocate()
 
@@ -75,7 +71,7 @@ def _check_and_update(dataset):
     current = dataset.data.get("bw_functional_version")
 
     if current != latest:
-        log.info(f"Updating {dataset.name} to latest bw_functional datastructure version {latest}")
+        logger.info(f"Updating {dataset.name} to latest bw_functional datastructure version {latest}")
         dataset.data["bw_functional_version"] = update(current)
         dataset.save()
 

bw_functional/allocation.py

@@ -1,11 +1,9 @@
 from functools import partial
-from typing import Callable, List
-from logging import getLogger
+from typing import Callable
+from loguru import logger
 
 from .node_classes import Process, Product
 
-log = getLogger(__name__)
-
 
 def generic_allocation(
     process: Process,
@@ -49,7 +47,7 @@ def generic_allocation(
             products.append(product)
 
     if not products:
-        log.warning(f"No products to allocate in process {process}")
+        logger.warning(f"No products to allocate in process {process}")
         return
 
     # Calculate the total value for allocation
@@ -110,7 +108,7 @@ def get_property_value(
         raise KeyError(f"Product {product} from {product.processor} missing property {property_label}")
 
     if isinstance(prop, float):
-        log.warning("Property using legacy float format")
+        logger.warning("Property using legacy float format")
         return prop
 
     if prop.get("normalize", False):

bw_functional/convert.py

@@ -1,13 +1,9 @@
 import tqdm
-from logging import getLogger
-
+from loguru import logger
 import bw2data as bd
-from bw2data.backends import SQLiteBackend
 
 from .database import FunctionalSQLiteDatabase
 
-log = getLogger(__name__)
-
 
 def convert_sqlite_to_functional_sqlite(database_dict: dict) -> dict:
     return SQLiteToFunctionalSQLite.convert(database_dict)
@@ -145,15 +141,15 @@ def convert_function(cls, key, ds, processor):
                 continue
 
             if exc["type"] != "production" and ds.get("allocation_factor"):
-                log.info(f"Allocating exchange from {exc['input']} to {ds['name']} "
+                logger.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']}: "
+                    logger.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 "
+                    logger.warning(f"Exchange from {exc['input']} to {ds['name']} has an uncertainty distribution that "
                                 f"will not be allocated")
 
             ds["exchanges"].append(exc)

bw_functional/database.py

@@ -1,13 +1,13 @@
 import sqlite3
 import pickle
 import datetime
-from logging import getLogger
 from time import time
 
-import numpy as np
-import pandas as pd
+from loguru import logger
 from fsspec.implementations.zip import ZipFileSystem
 
+import numpy as np
+import pandas as pd
 import stats_arrays as sa
 
 from bw_processing import clean_datapackage_name, create_datapackage
@@ -17,8 +17,6 @@
 
 from .node_classes import Process, Product
 
-log = getLogger(__name__)
-
 UNCERTAINTY_FIELDS = ["uncertainty_type", "loc", "scale", "shape", "minimum", "maximum"]
 
 
@@ -238,7 +236,7 @@ def id_mapper(key) -> NAType | int:
         # Close the SQLite connection
         con.close()
 
-        log.debug(f"Processing: built tables from SQL in {time() - t:.2f} seconds")
+        logger.debug(f"Processing: built tables from SQL in {time() - t:.2f} seconds")
 
         return node_df, exc_df, dependents
 

bw_functional/edge_classes.py

@@ -1,11 +1,9 @@
-from logging import getLogger
+from loguru import logger
 from copy import deepcopy
 
 from bw2data import projects, databases, errors
 from bw2data.backends.proxies import Exchange, Exchanges, ExchangeDataset
 
-log = getLogger(__name__)
-
 
 class MFExchanges(Exchanges):
     """
@@ -106,7 +104,7 @@ def save(self, signal: bool = True, data_already_set: bool = False, force_insert
             NotImplementedError: If parameterization is attempted for production exchanges.
         """
         from .node_classes import Process, Product
-        log.debug(f"Saving {self['type']} Exchange: {self}")
+        logger.debug(f"Saving {self['type']} Exchange: {self}")
 
         created = self.id is None  # the exchange is new if it has no id
         old = ExchangeDataset.get_by_id(self.id) if not created else None
@@ -150,11 +148,11 @@ def delete(self, signal: bool = True):
             function = self.input
             process = self.output
         except errors.UnknownObject:
-            log.warning(f"Could not retrieve input or output for exchange deletion. {self['input']=}, {self['output']=}")
+            logger.warning(f"Could not retrieve input or output for exchange deletion. {self['input']=}, {self['output']=}")
             super().delete(signal)
             return
 
-        log.debug(f"Deleting {self['type']} Exchange: {self}")
+        logger.debug(f"Deleting {self['type']} Exchange: {self}")
 
         super().delete(signal)
 

bw_functional/node_classes.py

@@ -1,15 +1,13 @@
-from typing import Optional, Union
-from logging import getLogger
+from typing import Optional
+
+from loguru import logger
 
 from bw2data import databases, get_node, labels
-from bw2data.backends import ExchangeDataset
 from bw2data.errors import UnknownObject, ValidityError
 from bw2data.backends.proxies import Activity, ActivityDataset
 
 from .edge_classes import MFExchanges, MFExchange
 
-log = getLogger(__name__)
-
 
 INHERITED_FIELDS = [
     "database",
@@ -41,7 +39,7 @@ def save(self, signal: bool = True, data_already_set: bool = False, force_insert
             data_already_set (bool, optional): Whether the data is already set. Defaults to False.
             force_insert (bool, optional): Whether to force an insert operation. Defaults to False.
         """
-        log.debug(f"Saving {self.__class__.__name__}: {self}")
+        logger.debug(f"Saving {self.__class__.__name__}: {self}")
         super().save(signal, data_already_set, force_insert)
 
     def delete(self, signal: bool = True):
@@ -53,7 +51,7 @@ def delete(self, signal: bool = True):
         Args:
             signal (bool, optional): Whether to send a signal after deletion. Defaults to True.
         """
-        log.debug(f"Deleting {self.__class__.__name__}: {self}")
+        logger.debug(f"Deleting {self.__class__.__name__}: {self}")
         super().delete(signal)
 
     @property
@@ -206,7 +204,7 @@ def save(self, signal: bool = True, data_already_set: bool = False, force_insert
             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}")
+            logger.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))
@@ -305,7 +303,7 @@ def property_template(self, name: str, amount=1.0) -> dict:
         normalize = set(prop.get("normalize", True) for prop in properties)
 
         if len(units) > 1 or len(normalize) > 1:
-            log.warning(f"Property {name} has inconsistent units or normalization across products.")
+            logger.warning(f"Property {name} has inconsistent units or normalization across products.")
 
         return {
             "unit": units.pop() if units else "unitless",
@@ -360,7 +358,7 @@ def allocate(self, strategy_label: Optional[str] = None) -> None:
             ValueError: If no allocation strategy is found.
         """
         if self.get("skip_allocation"):
-            log.debug(f"Skipping allocation for {repr(self)} (id: {self.id})")
+            logger.debug(f"Skipping allocation for {repr(self)} (id: {self.id})")
             return
 
         from . import allocation_strategies, property_allocation
@@ -376,7 +374,7 @@ def allocate(self, strategy_label: Optional[str] = None) -> None:
                 "Can't find `default_allocation` in input arguments, or process/database metadata."
             )
 
-        log.debug(f"Allocating {repr(self)} (id: {self.id}) with strategy {strategy_label}")
+        logger.debug(f"Allocating {repr(self)} (id: {self.id}) with strategy {strategy_label}")
 
         alloc_function = allocation_strategies.get(strategy_label, property_allocation(strategy_label))
         alloc_function(self)
@@ -439,7 +437,7 @@ def save(self, signal: bool = True, data_already_set: bool = False, force_insert
 
         # Check if the `processor` is the same as the one in the production edge otherwise update it
         if not created and edge.output != self["processor"]:
-            log.info(f"Switching processor for {self}")
+            logger.info(f"Switching processor for {self}")
             edge.output = self["processor"]
             edge.save()
 
@@ -500,7 +498,7 @@ def processing_edge(self) -> MFExchange | None:
         excs = self.exchanges(kinds=["production"], reverse=True)
 
         if len(excs) > 1:
-            log.warning(f"Multiple processing edges found for product {self['code']}.")
+            logger.warning(f"Multiple processing edges found for product {self['code']}.")
             return None
         if len(excs) == 0:
             return None

pyproject.toml

@@ -33,6 +33,8 @@ dependencies = [
     "bw2data>=4.0.1",
     "bw2io>=0.9.1",
     "bw_processing>=0.9.6",
+    "loguru",
+    "pandas",
 ]
 
 [project.urls]

recipe/meta.yaml

@@ -21,6 +21,8 @@ requirements:
   run:
     - python >=3.10
     - blinker
+    - loguru
+    - pandas
     - bw2data >=4.0.1
     - bw2io >=0.9.1
     - bw_processing >=0.9.6