hestia-earth-utils 0.16.9__py3-none-any.whl → 0.16.10__py3-none-any.whl

hestia_earth/utils/emission.py

@@ -17,7 +17,9 @@ from .lookup_utils import (
 )
 
 
-def emissions_in_system_boundary(termType: TermTermType = TermTermType.EMISSION) -> List[str]:
+def emissions_in_system_boundary(
+    termType: TermTermType = TermTermType.EMISSION,
+) -> List[str]:
     """
     Get all emissions included in HESTIA system boundary.
 
@@ -33,23 +35,30 @@ def emissions_in_system_boundary(termType: TermTermType = TermTermType.EMISSION)
 
 def cycle_emission_is_in_system_boundary(cycle: dict):
     def filter_term(term_id: str):
-        return is_in_system_boundary(term_id) and all(map(lambda check: check(cycle, term_id), [
-            is_siteType_allowed,
-            is_site_measurement_id_allowed,
-            is_product_termType_allowed,
-            is_product_id_allowed,
-            is_input_termType_allowed,
-            is_input_id_allowed,
-            is_practice_termType_allowed,
-            is_practice_id_allowed,
-            is_transformation_termType_allowed,
-            is_transformation_id_allowed,
-        ]))
+        return is_in_system_boundary(term_id) and all(
+            map(
+                lambda check: check(cycle, term_id),
+                [
+                    is_siteType_allowed,
+                    is_site_measurement_id_allowed,
+                    is_product_termType_allowed,
+                    is_product_id_allowed,
+                    is_input_termType_allowed,
+                    is_input_id_allowed,
+                    is_practice_termType_allowed,
+                    is_practice_id_allowed,
+                    is_transformation_termType_allowed,
+                    is_transformation_id_allowed,
+                ],
+            )
+        )
 
     return filter_term
 
 
-def cycle_emissions_in_system_boundary(cycle: dict, termType: TermTermType = TermTermType.EMISSION):
+def cycle_emissions_in_system_boundary(
+    cycle: dict, termType: TermTermType = TermTermType.EMISSION
+):
     """
     Get all emissions relevant for the Cycle, included in HESTIA system boundary.
 
@@ -60,4 +69,6 @@ def cycle_emissions_in_system_boundary(cycle: dict, termType: TermTermType = Ter
     """
     lookup = download_lookup(f"{termType.value}.csv")
     # find all emissions in system boundary
-    return list(filter(cycle_emission_is_in_system_boundary(cycle), lookup_term_ids(lookup)))
+    return list(
+        filter(cycle_emission_is_in_system_boundary(cycle), lookup_term_ids(lookup))
+    )

hestia_earth/utils/lookup.py

@@ -7,7 +7,7 @@ import pandas as pd
 from .storage import _load_from_storage
 from .request import request_url, web_url
 
-_GLOSSARY_FOLDER = 'glossary/lookups'
+_GLOSSARY_FOLDER = "glossary/lookups"
 _memory = {}
 
 
@@ -18,7 +18,7 @@ def _memory_wrapper(key: str, func):
 
 
 def _read_csv(value: str) -> pd.DataFrame:
-    return pd.read_csv(value, na_values=['-', ''])
+    return pd.read_csv(value, na_values=["-", ""])
 
 
 def _read_csv_from_string(data: str) -> pd.DataFrame:
@@ -26,7 +26,7 @@ def _read_csv_from_string(data: str) -> pd.DataFrame:
 
 
 def is_missing_value(value):
-    return pd.isna(value) or value is None or value == '' or value == '-'
+    return pd.isna(value) or value is None or value == "" or value == "-"
 
 
 def load_lookup(filepath: str, keep_in_memory: bool = False):
@@ -45,7 +45,10 @@ def load_lookup(filepath: str, keep_in_memory: bool = False):
     numpy.recarray
         The `numpy.recarray` converted from the csv content.
     """
-    def load(): return _read_csv(filepath)
+
+    def load():
+        return _read_csv(filepath)
+
     return _memory_wrapper(filepath, load) if keep_in_memory else load()
 
 
@@ -54,12 +57,12 @@ def _download_lookup_data(filename: str):
 
     def fallback():
         url = request_url(f"{web_url()}/{filepath}")
-        data = requests.get(url).content.decode('utf-8')
-        return data if data and '<html' not in data else None
+        data = requests.get(url).content.decode("utf-8")
+        return data if data and "<html" not in data else None
 
     try:
         data = _load_from_storage(filepath, glossary=True)
-        return data.decode('utf-8') if data else None
+        return data.decode("utf-8") if data else None
     except ImportError:
         return fallback()
 
@@ -82,6 +85,7 @@ def download_lookup(filename: str, keep_in_memory: bool = True):
     numpy.recarray
         The `numpy.recarray` converted from the csv content.
     """
+
     def load():
         data = _download_lookup_data(filename)
         return _read_csv_from_string(data) if data else None
@@ -100,12 +104,12 @@ def column_name(key: str):
 
 
 def _parse_value(value: str):
-    """ Automatically converts the value to float or bool if possible """
+    """Automatically converts the value to float or bool if possible"""
     try:
         return (
-            True if str(value).lower() == 'true' else
-            False if str(value).lower() == 'false' else
-            float(value)
+            True
+            if str(value).lower() == "true"
+            else False if str(value).lower() == "false" else float(value)
         )
     except Exception:
         return value
@@ -116,7 +120,13 @@ def _get_single_table_value(df: pd.DataFrame, col_match: str, col_match_with, co
     return None if filtered_df.empty else filtered_df[col_val].iloc[0]
 
 
-def get_table_value(lookup: pd.DataFrame, col_match: str, col_match_with: str, col_val: Any, default_value=''):
+def get_table_value(
+    lookup: pd.DataFrame,
+    col_match: str,
+    col_match_with: str,
+    col_val: Any,
+    default_value="",
+):
     """
     Get a value matched by one or more columns from a `numpy.recarray`.
 
@@ -166,7 +176,11 @@ def find_term_ids_by(lookup: pd.DataFrame, col_match: str, col_match_with: str):
         The list of `term.id` that matched the expected column value.
     """
     filtered_df = lookup[lookup[col_match] == col_match_with]
-    term_ids = filtered_df['term.id'].unique().tolist() if 'term.id' in filtered_df.columns else []
+    term_ids = (
+        filtered_df["term.id"].unique().tolist()
+        if "term.id" in filtered_df.columns
+        else []
+    )
     return list(map(str, term_ids))
 
 
@@ -190,10 +204,15 @@ def extract_grouped_data(data: str, key: str) -> str:
     str
         The value found or `None` if no match.
     """
-    grouped_data = reduce(lambda prev, curr: {
-        **prev,
-        **{curr.split(':')[0]: curr.split(':')[1]}
-    }, data.split(';'), {}) if data is not None and isinstance(data, str) and len(data) > 1 else {}
+    grouped_data = (
+        reduce(
+            lambda prev, curr: {**prev, **{curr.split(":")[0]: curr.split(":")[1]}},
+            data.split(";"),
+            {},
+        )
+        if data is not None and isinstance(data, str) and len(data) > 1
+        else {}
+    )
     value = grouped_data.get(key)
     return None if is_missing_value(value) else _parse_value(value)
 
@@ -218,17 +237,28 @@ def extract_grouped_data_closest_date(data: str, year: int) -> str:
     str
         The closest value found.
     """
-    data_by_date = reduce(
-        lambda prev, curr: {
-            **prev,
-            **{curr.split(':')[0]: curr.split(':')[1]}
-        } if len(curr) > 0 and not is_missing_value(curr.split(':')[1]) else prev,
-        data.split(';'),
-        {}
-    ) if data is not None and isinstance(data, str) and len(data) > 1 else {}
+    data_by_date = (
+        reduce(
+            lambda prev, curr: (
+                {**prev, **{curr.split(":")[0]: curr.split(":")[1]}}
+                if len(curr) > 0 and not is_missing_value(curr.split(":")[1])
+                else prev
+            ),
+            data.split(";"),
+            {},
+        )
+        if data is not None and isinstance(data, str) and len(data) > 1
+        else {}
+    )
     dist_years = list(data_by_date.keys())
-    closest_year = min(dist_years, key=lambda x: abs(int(x) - year)) if len(dist_years) > 0 else None
-    return None if closest_year is None else _parse_value(data_by_date.get(closest_year))
+    closest_year = (
+        min(dist_years, key=lambda x: abs(int(x) - year))
+        if len(dist_years) > 0
+        else None
+    )
+    return (
+        None if closest_year is None else _parse_value(data_by_date.get(closest_year))
+    )
 
 
 def lookup_term_ids(lookup: pd.DataFrame):
@@ -245,7 +275,11 @@ def lookup_term_ids(lookup: pd.DataFrame):
     list[str]
         The `term.id` values from the lookup.
     """
-    return list(map(str, lookup['term.id'].tolist())) if 'term.id' in lookup.columns else []
+    return (
+        list(map(str, lookup["term.id"].tolist()))
+        if "term.id" in lookup.columns
+        else []
+    )
 
 
 def lookup_columns(lookup: pd.DataFrame):

hestia_earth/utils/lookup_utils.py

@@ -6,153 +6,173 @@ from .lookup import _download_lookup_data, download_lookup, get_table_value
 from .api import download_hestia
 from .tools import non_empty_list, flatten
 
-_ALLOW_ALL = 'all'
+_ALLOW_ALL = "all"
 
 
 @lru_cache()
 def _allowed_mapping_data():
-    data = _download_lookup_data('allowed-mapping.json')
+    data = _download_lookup_data("allowed-mapping.json")
     data = json.loads(data) if data else {}
     return data
 
 
 def _is_site(site: dict):
-    return site.get('@type', site.get('type')) == 'Site' if site else None
+    return site.get("@type", site.get("type")) == "Site" if site else None
 
 
 def _get_sites(node: dict):
-    site = node.get('site', node.get('cycle', {}).get('site'))
-    other_sites = node.get('otherSites', node.get('cycle', {}).get('otherSites', []))
+    site = node.get("site", node.get("cycle", {}).get("site"))
+    other_sites = node.get("otherSites", node.get("cycle", {}).get("otherSites", []))
     return non_empty_list([site] + other_sites)
 
 
 def _get_site_types(node: dict):
     sites = [node] if _is_site(node) else _get_sites(node)
-    return non_empty_list([site.get('siteType') for site in sites])
+    return non_empty_list([site.get("siteType") for site in sites])
 
 
 def _get_site_measurements(node: dict):
     sites = [node] if _is_site(node) else _get_sites(node)
-    return flatten([non_empty_list(site.get('measurements', [])) for site in sites])
+    return flatten([non_empty_list(site.get("measurements", [])) for site in sites])
 
 
-def _blank_node_term_values(blank_nodes: list, key: str = '@id'):
-    return non_empty_list([v.get('term', {}).get(key) for v in blank_nodes])
+def _blank_node_term_values(blank_nodes: list, key: str = "@id"):
+    return non_empty_list([v.get("term", {}).get(key) for v in blank_nodes])
 
 
 @lru_cache()
 def _allowed_model_mapping(model: str, term_id: str, column: str):
     mapping = _allowed_mapping_data()
-    value = mapping.get(term_id, {}).get(model, {}).get(column) if mapping else get_table_value(
-        download_lookup(f"{(download_hestia(term_id) or {}).get('termType')}-model-{column}.csv"),
-        'term.id', term_id, column
+    value = (
+        mapping.get(term_id, {}).get(model, {}).get(column)
+        if mapping
+        else get_table_value(
+            download_lookup(
+                f"{(download_hestia(term_id) or {}).get('termType')}-model-{column}.csv"
+            ),
+            "term.id",
+            term_id,
+            column,
+        )
     )
-    return (value or _ALLOW_ALL).split(';') if isinstance(value, str) else _ALLOW_ALL
+    return (value or _ALLOW_ALL).split(";") if isinstance(value, str) else _ALLOW_ALL
 
 
 def _is_model_value_allowed(model: str, term_id: str, values: list, lookup_column: str):
     allowed_values = _allowed_model_mapping(model, term_id, lookup_column)
-    return any([
-        _ALLOW_ALL in allowed_values,
-        len(values) == 0
-    ]) or any([value in allowed_values for value in values])
+    return any([_ALLOW_ALL in allowed_values, len(values) == 0]) or any(
+        [value in allowed_values for value in values]
+    )
 
 
 def is_model_siteType_allowed(model: str, term_id: str, data: dict):
     values = _get_site_types(data)
-    return _is_model_value_allowed(model, term_id, values, 'siteTypesAllowed')
+    return _is_model_value_allowed(model, term_id, values, "siteTypesAllowed")
 
 
 def is_model_product_id_allowed(model: str, term_id: str, data: dict):
-    values = _blank_node_term_values(data.get('products', []))
-    return _is_model_value_allowed(model, term_id, values, 'productTermIdsAllowed')
+    values = _blank_node_term_values(data.get("products", []))
+    return _is_model_value_allowed(model, term_id, values, "productTermIdsAllowed")
 
 
 def is_model_measurement_id_allowed(model: str, term_id: str, data: dict):
-    values = _blank_node_term_values(data.get('measurements', []))
-    return _is_model_value_allowed(model, term_id, values, 'measurementIdsAllowed')
+    values = _blank_node_term_values(data.get("measurements", []))
+    return _is_model_value_allowed(model, term_id, values, "measurementIdsAllowed")
 
 
 @lru_cache()
 def _allowed_mapping(term_id: str, column: str):
     mapping = _allowed_mapping_data()
-    value = mapping.get(term_id, {}).get(column) if mapping else get_table_value(
-        download_lookup(f"{(download_hestia(term_id) or {}).get('termType')}.csv"),
-        'term.id', term_id, column
+    value = (
+        mapping.get(term_id, {}).get(column)
+        if mapping
+        else get_table_value(
+            download_lookup(f"{(download_hestia(term_id) or {}).get('termType')}.csv"),
+            "term.id",
+            term_id,
+            column,
+        )
     )
-    return (value or _ALLOW_ALL).split(';') if isinstance(value, str) else _ALLOW_ALL
+    return (value or _ALLOW_ALL).split(";") if isinstance(value, str) else _ALLOW_ALL
 
 
 def _is_term_value_allowed(term_id: str, values: list, lookup_column: str):
     allowed_values = _allowed_mapping(term_id, lookup_column)
-    return any([
-        _ALLOW_ALL in allowed_values,
-        len(values) == 0
-    ]) or any([value in allowed_values for value in values])
+    return any([_ALLOW_ALL in allowed_values, len(values) == 0]) or any(
+        [value in allowed_values for value in values]
+    )
 
 
 def is_siteType_allowed(data: dict, term_id: str):
     values = _get_site_types(data)
-    return _is_term_value_allowed(term_id, values, 'siteTypesAllowed')
+    return _is_term_value_allowed(term_id, values, "siteTypesAllowed")
 
 
 def is_site_measurement_id_allowed(data: dict, term_id: str):
     measurements = _get_site_measurements(data)
-    values = _blank_node_term_values(measurements, key='@id')
-    return _is_term_value_allowed(term_id, values, 'siteMeasurementIdsAllowed')
+    values = _blank_node_term_values(measurements, key="@id")
+    return _is_term_value_allowed(term_id, values, "siteMeasurementIdsAllowed")
 
 
 def is_product_termType_allowed(data: dict, term_id: str):
-    products = data.get('products', [])
-    values = _blank_node_term_values(products, key='termType')
-    return _is_term_value_allowed(term_id, values, 'productTermTypesAllowed')
+    products = data.get("products", [])
+    values = _blank_node_term_values(products, key="termType")
+    return _is_term_value_allowed(term_id, values, "productTermTypesAllowed")
 
 
 def is_product_id_allowed(data: dict, term_id: str):
-    products = data.get('products', [])
-    values = _blank_node_term_values(products, key='@id')
-    return _is_term_value_allowed(term_id, values, 'productTermIdsAllowed')
+    products = data.get("products", [])
+    values = _blank_node_term_values(products, key="@id")
+    return _is_term_value_allowed(term_id, values, "productTermIdsAllowed")
 
 
 def is_input_termType_allowed(data: dict, term_id: str):
-    inputs = data.get('inputs', [])
-    values = _blank_node_term_values(inputs, key='termType')
-    return _is_term_value_allowed(term_id, values, 'inputTermTypesAllowed')
+    inputs = data.get("inputs", [])
+    values = _blank_node_term_values(inputs, key="termType")
+    return _is_term_value_allowed(term_id, values, "inputTermTypesAllowed")
 
 
 def is_input_id_allowed(data: dict, term_id: str):
-    inputs = data.get('inputs', [])
-    values = _blank_node_term_values(inputs, key='@id')
-    return _is_term_value_allowed(term_id, values, 'inputTermIdsAllowed')
+    inputs = data.get("inputs", [])
+    values = _blank_node_term_values(inputs, key="@id")
+    return _is_term_value_allowed(term_id, values, "inputTermIdsAllowed")
 
 
 def is_practice_termType_allowed(data: dict, term_id: str):
-    practices = data.get('practices', [])
-    values = _blank_node_term_values(practices, key='termType')
-    return _is_term_value_allowed(term_id, values, 'practiceTermTypesAllowed')
+    practices = data.get("practices", [])
+    values = _blank_node_term_values(practices, key="termType")
+    return _is_term_value_allowed(term_id, values, "practiceTermTypesAllowed")
 
 
 def is_practice_id_allowed(data: dict, term_id: str):
-    practices = data.get('practices', [])
-    values = _blank_node_term_values(practices, key='@id')
-    return _is_term_value_allowed(term_id, values, 'practiceTermIdsAllowed')
+    practices = data.get("practices", [])
+    values = _blank_node_term_values(practices, key="@id")
+    return _is_term_value_allowed(term_id, values, "practiceTermIdsAllowed")
 
 
 def is_transformation_termType_allowed(data: dict, term_id: str):
-    is_transformation = data.get('@type', data.get('type')) == SchemaType.TRANSFORMATION.value
-    values = non_empty_list([data.get('term', {}).get('termType')])
-    return not is_transformation or _is_term_value_allowed(term_id, values, 'transformationTermTypesAllowed')
+    is_transformation = (
+        data.get("@type", data.get("type")) == SchemaType.TRANSFORMATION.value
+    )
+    values = non_empty_list([data.get("term", {}).get("termType")])
+    return not is_transformation or _is_term_value_allowed(
+        term_id, values, "transformationTermTypesAllowed"
+    )
 
 
 def is_transformation_id_allowed(data: dict, term_id: str):
-    is_transformation = data.get('@type', data.get('type')) == SchemaType.TRANSFORMATION.value
-    values = non_empty_list([data.get('term', {}).get('@id')])
-    return not is_transformation or _is_term_value_allowed(term_id, values, 'transformationTermIdsAllowed')
+    is_transformation = (
+        data.get("@type", data.get("type")) == SchemaType.TRANSFORMATION.value
+    )
+    values = non_empty_list([data.get("term", {}).get("@id")])
+    return not is_transformation or _is_term_value_allowed(
+        term_id, values, "transformationTermIdsAllowed"
+    )
 
 
 def is_node_type_allowed(data: dict, term_id: str):
-    values = non_empty_list([data.get('@type', data.get('type'))])
-    return _is_term_value_allowed(term_id, values, 'typesAllowed')
+    values = non_empty_list([data.get("@type", data.get("type"))])
+    return _is_term_value_allowed(term_id, values, "typesAllowed")
 
 
 @lru_cache()
@@ -171,10 +191,16 @@ def is_in_system_boundary(term_id: str) -> bool:
         True if the Term is included in the HESTIA system boundary, False otherwise.
     """
     mapping = _allowed_mapping_data()
-    column = 'inHestiaDefaultSystemBoundary'
-    value = mapping.get(term_id, {}).get(column) if mapping else get_table_value(
-        download_lookup(f"{(download_hestia(term_id) or {}).get('termType')}.csv"),
-        'term.id', term_id, column
+    column = "inHestiaDefaultSystemBoundary"
+    value = (
+        mapping.get(term_id, {}).get(column)
+        if mapping
+        else get_table_value(
+            download_lookup(f"{(download_hestia(term_id) or {}).get('termType')}.csv"),
+            "term.id",
+            term_id,
+            column,
+        )
     )
     # handle numpy bool from table value
     return not (not value)

hestia_earth/utils/model.py

@@ -4,8 +4,8 @@ from hestia_earth.schema import TermTermType, NodeType
 from .tools import get_dict_key
 
 _LINKED_NODE_KEYS = {
-    NodeType.SOURCE.value: ['name'],
-    NodeType.TERM.value: ['name', 'termType', 'units']
+    NodeType.SOURCE.value: ["name"],
+    NodeType.TERM.value: ["name", "termType", "units"],
 }
 
 
@@ -23,12 +23,14 @@ def linked_node(node: dict):
     dict
         The node with only: `@type`, `@id`, `name`, `termType` and `units` fields.
     """
-    node_type = node.get('@type', '')
-    keys = ['@type', '@id'] + _LINKED_NODE_KEYS.get(node_type, [])
+    node_type = node.get("@type", "")
+    keys = ["@type", "@id"] + _LINKED_NODE_KEYS.get(node_type, [])
     return {key: node[key] for key in keys if key in node}
 
 
-def find_term_match(values: list, term_id: str, default_val: Any = {}, match_params: dict = {}):
+def find_term_match(
+    values: list, term_id: str, default_val: Any = {}, match_params: dict = {}
+):
     """
     Return the element in a list which matches the `Term` with the given `@id`.
 
@@ -48,17 +50,19 @@ def find_term_match(values: list, term_id: str, default_val: Any = {}, match_par
     dict
         The matching object.
     """
+
     def is_match(value: dict):
-        return all([
-            value.get('term', {}).get('@id') == term_id
-        ] + [
-            get_dict_key(value, k) == v for k, v in match_params.items()
-        ])
+        return all(
+            [value.get("term", {}).get("@id") == term_id]
+            + [get_dict_key(value, k) == v for k, v in match_params.items()]
+        )
 
     return next((v for v in values if is_match(v)), default_val)
 
 
-def filter_list_term_type(values: list, term_type: Union[TermTermType, str, List[TermTermType], List[str]]) -> list:
+def filter_list_term_type(
+    values: list, term_type: Union[TermTermType, str, List[TermTermType], List[str]]
+) -> list:
     """
     Filters the values by filtering by the `term.termType` property.
 
@@ -76,7 +80,9 @@ def filter_list_term_type(values: list, term_type: Union[TermTermType, str, List
     """
     term_types = [t for t in term_type] if isinstance(term_type, list) else [term_type]
     term_types = [(t if isinstance(t, str) else t.value) for t in term_types]
-    return list(filter(lambda i: i.get('term', {}).get('termType') in term_types, values))
+    return list(
+        filter(lambda i: i.get("term", {}).get("termType") in term_types, values)
+    )
 
 
 def find_primary_product(cycle: dict) -> dict:
@@ -93,53 +99,52 @@ def find_primary_product(cycle: dict) -> dict:
     dict
         The primary `Product`.
     """
-    products = cycle.get('products', [])
-    return next((p for p in products if p.get('primary', False)), products[0]) if len(products) > 0 else None
+    products = cycle.get("products", [])
+    return (
+        next((p for p in products if p.get("primary", False)), products[0])
+        if len(products) > 0
+        else None
+    )
 
 
-def _convert_m3_to_kg(value: float, **kwargs): return value * kwargs.get('density')
+def _convert_m3_to_kg(value: float, **kwargs):
+    return value * kwargs.get("density")
 
 
-def _convert_m3_to_l(value: float, **kwargs): return value * 1000
+def _convert_m3_to_l(value: float, **kwargs):
+    return value * 1000
 
 
-def _convert_kg_to_m3(value: float, **kwargs): return value / kwargs.get('density')
+def _convert_kg_to_m3(value: float, **kwargs):
+    return value / kwargs.get("density")
 
 
-def _convert_kg_to_l(value: float, **kwargs): return value / kwargs.get('density') * 1000
+def _convert_kg_to_l(value: float, **kwargs):
+    return value / kwargs.get("density") * 1000
 
 
-def _convert_liter_to_kg(value: float, **kwargs): return value * kwargs.get('density') / 1000
+def _convert_liter_to_kg(value: float, **kwargs):
+    return value * kwargs.get("density") / 1000
 
 
-def _convert_liter_to_m3(value: float, **kwargs): return value / 1000
+def _convert_liter_to_m3(value: float, **kwargs):
+    return value / 1000
 
 
-def _convert_mj_to_kwh(value: float, **kwargs): return value / 3.6
+def _convert_mj_to_kwh(value: float, **kwargs):
+    return value / 3.6
 
 
-def _convert_kwh_to_mj(value: float, **kwargs): return value * 3.6
+def _convert_kwh_to_mj(value: float, **kwargs):
+    return value * 3.6
 
 
 CONVERTERS = {
-    'm3': {
-        'kg': _convert_m3_to_kg,
-        'L': _convert_m3_to_l
-    },
-    'kg': {
-        'm3': _convert_kg_to_m3,
-        'L': _convert_kg_to_l
-    },
-    'L': {
-        'kg': _convert_liter_to_kg,
-        'm3': _convert_liter_to_m3
-    },
-    'kWh': {
-        'MJ': _convert_kwh_to_mj
-    },
-    'MJ': {
-        'kWh': _convert_mj_to_kwh
-    }
+    "m3": {"kg": _convert_m3_to_kg, "L": _convert_m3_to_l},
+    "kg": {"m3": _convert_kg_to_m3, "L": _convert_kg_to_l},
+    "L": {"kg": _convert_liter_to_kg, "m3": _convert_liter_to_m3},
+    "kWh": {"MJ": _convert_kwh_to_mj},
+    "MJ": {"kWh": _convert_mj_to_kwh},
 }