hestia-earth-utils 0.15.16__tar.gz → 0.16.2__tar.gz

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/PKG-INFO

@@ -1,16 +1,35 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: hestia_earth_utils
-Version: 0.15.16
+Version: 0.16.2
 Summary: HESTIA's utils library
 Home-page: https://gitlab.com/hestia-earth/hestia-utils
 Author: HESTIA Team
 Author-email: guillaumeroyer.mail@gmail.com
 License: MIT
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: hestia-earth-schema>=35.0.1
+Requires-Dist: requests>=2.24.0
+Requires-Dist: urllib3~=1.26.0
+Requires-Dist: python-dateutil>=2.8.1
+Requires-Dist: numpy>=2
+Requires-Dist: flatten_json
+Provides-Extra: pivot-csv
+Requires-Dist: pandas>=2; extra == "pivot-csv"
+Provides-Extra: table
+Requires-Dist: pandas>=2; extra == "table"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # HESTIA Utils
 
@@ -60,5 +79,3 @@ from hestia_earth.utils.lookup import download_lookup
 
 df = download_lookup('crop.csv')
 ```
-
-

hestia_earth_utils-0.16.2/hestia_earth/utils/csv_utils.py

@@ -0,0 +1,72 @@
+import io
+import csv
+import re
+import numpy as np
+
+_MISSING_VALUE = '-'
+_MISSING = -99999
+_DELIMITER = ','
+_QUOTE_CHAR = '"'
+ENCODING = 'ISO-8859-1'
+# default: " !#$%&'()*+,-./:;<=>?@[\\]^{|}~"
+_DELETE_CHARS = " !#$%&'()*,./:;<=>?@^{|}~"
+
+
+def is_missing_value(value): return value == _MISSING_VALUE or value == _MISSING or value == str(_MISSING)
+
+
+def _replace_missing_values(value: str): return str(_MISSING) if str(value) == _MISSING_VALUE else value
+
+
+def _replace_chars(value: str): return re.sub(f'[{re.escape(_DELETE_CHARS)}]', '', value.replace(' ', '_'))
+
+
+def _text_to_csv(csv_content: str):
+    return csv.reader(io.StringIO(csv_content.strip()), delimiter=_DELIMITER, quotechar=_QUOTE_CHAR)
+
+
+def _csv_reader_converter(field_str_bytes):
+    field_str = field_str_bytes if isinstance(field_str_bytes, str) else field_str_bytes.decode('utf-8')
+    reader = _text_to_csv(field_str)
+
+    try:
+        return _replace_missing_values(next(reader)[0].strip())
+    except StopIteration:
+        return str(_MISSING)
+
+
+def _get_columns(csv_content: str):
+    try:
+        reader = _text_to_csv(csv_content)
+        names = next(reader)
+        return list(map(_replace_chars, names))
+    except StopIteration:
+        return []
+
+
+def csv_str_to_recarray(csv_content: str) -> np.recarray:
+    names = _get_columns(csv_content)
+    num_cols = len(names)
+
+    converters_dict = {
+        i: _csv_reader_converter
+        for i in range(num_cols)
+    }
+
+    # TODO: find the maximum column size instead of using 1000
+    max_size = 1000
+    return np.loadtxt(
+        io.StringIO(csv_content.strip()),
+        delimiter=_DELIMITER,
+        quotechar=_QUOTE_CHAR,
+        skiprows=1,
+        converters=converters_dict,
+        dtype=[(name, f"U{max_size}") for name in names],
+        encoding=ENCODING
+    ).view(np.recarray)
+
+
+def csv_file_to_recarray(filepath: str):
+    with open(filepath, 'r', encoding=ENCODING) as f:
+        content = f.read()
+    return csv_str_to_recarray(content)

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/hestia_earth/utils/lookup.py

@@ -1,51 +1,16 @@
 from functools import reduce
-from io import StringIO
 from typing import Union
-import re
 import requests
-import csv
 import numpy
+import traceback
 
 from .storage import _load_from_storage
 from .request import request_url, web_url
+from .csv_utils import csv_str_to_recarray, csv_file_to_recarray, is_missing_value, _replace_chars
 
-DELIMITER = '\t'
-ENCODING = 'ISO-8859-1'
-GLOSSARY_FOLDER = 'glossary/lookups'
+_GLOSSARY_FOLDER = 'glossary/lookups'
 _memory = {}
-MISSING_VALUE = '-'
-MISSING = -99999
 _INDEX_COL = 'termid'
-# default: " !#$%&'()*+,-./:;<=>?@[\\]^{|}~"
-_DELETE_CHARS = " !#$%&'()*,./:;<=>?@^{|}~"
-
-
-def _is_missing_value(value): return value == MISSING_VALUE or value == MISSING or value == str(MISSING)
-
-
-def _replace_missing_values(value: str): return str(MISSING) if str(value) == '-' else value
-
-
-def _rewrite_csv_file_as_tab(filepath: str):
-    with open(filepath, 'r', encoding=ENCODING) as fp:
-        reader = csv.reader(fp)
-        for row in reader:
-            yield DELIMITER.join(list(map(_replace_missing_values, row)))
-
-
-def _rewrite_csv_text_as_tab(text: str):
-    reader = csv.reader(StringIO(text))
-    for row in reader:
-        yield DELIMITER.join(list(map(_replace_missing_values, row)))
-
-
-def _recfromcsv(data): return numpy.recfromcsv(data,
-                                               missing_values=MISSING_VALUE,
-                                               filling_values=MISSING,
-                                               delimiter=DELIMITER,
-                                               encoding=ENCODING,
-                                               case_sensitive=True,
-                                               deletechars=_DELETE_CHARS)
 
 
 def _memory_wrapper(key: str, func):
@@ -70,12 +35,12 @@ def load_lookup(filepath: str, keep_in_memory: bool = False):
     numpy.recarray
         The `numpy.recarray` converted from the csv content.
     """
-    def load(): return _recfromcsv(_rewrite_csv_file_as_tab(filepath))
+    def load(): return csv_file_to_recarray(filepath)
     return _memory_wrapper(filepath, load) if keep_in_memory else load()
 
 
 def _download_lookup_data(filename: str):
-    filepath = f"{GLOSSARY_FOLDER}/{filename}"
+    filepath = f"{_GLOSSARY_FOLDER}/{filename}"
 
     def fallback():
         url = request_url(f"{web_url()}/{filepath}")
@@ -121,12 +86,14 @@ def download_lookup(filename: str, keep_in_memory: bool = True, build_index: boo
     """
     def load():
         data = _download_lookup_data(filename)
-        rec = _recfromcsv(_rewrite_csv_text_as_tab(data)) if data else None
+        rec = csv_str_to_recarray(data) if data else None
         return (_build_index(rec) if build_index else rec) if data else None
 
     try:
         return _memory_wrapper(filename, load) if keep_in_memory else load()
     except Exception:
+        stack = traceback.format_exc()
+        print(stack)
         return None
 
 
@@ -144,7 +111,19 @@ def column_name(key: str):
     str
         The column name that can be used in `get_table_value`.
     """
-    return re.sub('[' + re.escape(_DELETE_CHARS) + ']', '', key.replace(' ', '_')) if key else ''
+    return _replace_chars(key) if key else ''
+
+
+def _parse_value(value: str):
+    """ 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)
+        )
+    except Exception:
+        return value
 
 
 def _get_single_table_value(data: Union[dict, numpy.recarray], col_match: str, col_match_with, col_val):
@@ -191,7 +170,7 @@ def get_table_value(lookup: Union[dict, numpy.recarray], col_match: str, col_mat
             _get_single_table_value(lookup, col_match, col_match_with, col_val) if single else
             _get_multiple_table_values(lookup, col_match, col_match_with, col_val)
         )
-        return None if _is_missing_value(value) else value
+        return None if is_missing_value(value) else _parse_value(value)
     except Exception:
         return None
 
@@ -251,7 +230,7 @@ def extract_grouped_data(data: str, key: str) -> str:
         **{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 value
+    return None if is_missing_value(value) else _parse_value(value)
 
 
 def extract_grouped_data_closest_date(data: str, year: int) -> str:
@@ -278,13 +257,13 @@ def extract_grouped_data_closest_date(data: str, year: int) -> str:
         lambda prev, curr: {
             **prev,
             **{curr.split(':')[0]: curr.split(':')[1]}
-        } if len(curr) > 0 and not _is_missing_value(curr.split(':')[1]) else prev,
+        } 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 data_by_date.get(closest_year)
+    return None if closest_year is None else _parse_value(data_by_date.get(closest_year))
 
 
 def lookup_term_ids(lookup: Union[dict, numpy.recarray]):

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/hestia_earth/utils/pivot/pivot_csv.py

@@ -2,6 +2,7 @@ import copy
 import json
 import re
 import numpy as np
+import pandas as pd
 from hestia_earth.schema import UNIQUENESS_FIELDS, Term, NODE_TYPES
 from hestia_earth.schema.utils.sort import get_sort_key, SORT_CONFIG
 from flatten_json import flatten as flatten_json
@@ -11,17 +12,6 @@ from ..api import find_term_ids_by_names
 from ._shared import EXCLUDE_FIELDS, EXCLUDE_PRIVATE_FIELDS, _with_csv_formatting, _filter_emissions_not_relevant
 
 
-PANDAS_IMPORT_ERROR_MSG = "Run `pip install pandas>=1.2` to use this functionality"
-try:
-    import pandas as pd
-
-    version = [int(x) for x in pd.__version__.split('+')[0].split(".")]
-    if version[0] < 1 or (version[0] == 1 and version[1] < 2):
-        raise ImportError(PANDAS_IMPORT_ERROR_MSG)
-except ImportError:
-    raise ImportError(PANDAS_IMPORT_ERROR_MSG)
-
-
 # We only want to pivot array items containing blank nodes
 # Assume these are all fields with uniqueness fields not of type Node
 def _get_blank_node_uniqueness_fields():

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/hestia_earth/utils/table.py

@@ -1,22 +1,12 @@
 from functools import reduce
 import numpy as np
+import pandas as pd
 from hestia_earth.schema import NodeType
 
 # __package__ = "hestia_earth.utils" # required to run interactively in vscode
 from .tools import flatten
 
 
-PANDAS_IMPORT_ERROR_MSG = "Run `pip install pandas>=1.2` to use this functionality"
-try:
-    import pandas as pd
-
-    version = [int(x) for x in pd.__version__.split('+')[0].split(".")]
-    if version[0] < 1 or (version[0] == 1 and version[1] < 2):
-        raise ImportError(PANDAS_IMPORT_ERROR_MSG)
-except ImportError:
-    raise ImportError(PANDAS_IMPORT_ERROR_MSG)
-
-
 def _replace_ids(df):
     # in columns, first letter is always lower case
     node_types = [e.value[0].lower() + e.value[1:] for e in NodeType]
@@ -74,11 +64,6 @@ def format_for_upload(filepath: str):
     pandas.DataFrame
         Formatted pandas dataframe
     """
-    try:
-        import pandas as pd
-    except ImportError:
-        raise ImportError("Run `pip install pandas~=1.2.0` to use this functionality")
-
     df = pd.read_csv(filepath, index_col=None, na_values="")
 
     # replace @id with id for top-level Node

hestia_earth_utils-0.16.2/hestia_earth/utils/version.py

@@ -0,0 +1 @@
+VERSION = '0.16.2'

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/hestia_earth_utils.egg-info/PKG-INFO

@@ -1,16 +1,35 @@
-Metadata-Version: 2.1
-Name: hestia-earth-utils
-Version: 0.15.16
+Metadata-Version: 2.4
+Name: hestia_earth_utils
+Version: 0.16.2
 Summary: HESTIA's utils library
 Home-page: https://gitlab.com/hestia-earth/hestia-utils
 Author: HESTIA Team
 Author-email: guillaumeroyer.mail@gmail.com
 License: MIT
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Programming Language :: Python :: 3.9
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
+Requires-Dist: hestia-earth-schema>=35.0.1
+Requires-Dist: requests>=2.24.0
+Requires-Dist: urllib3~=1.26.0
+Requires-Dist: python-dateutil>=2.8.1
+Requires-Dist: numpy>=2
+Requires-Dist: flatten_json
+Provides-Extra: pivot-csv
+Requires-Dist: pandas>=2; extra == "pivot-csv"
+Provides-Extra: table
+Requires-Dist: pandas>=2; extra == "table"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 # HESTIA Utils
 
@@ -60,5 +79,3 @@ from hestia_earth.utils.lookup import download_lookup
 
 df = download_lookup('crop.csv')
 ```
-
-

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/hestia_earth_utils.egg-info/SOURCES.txt

@@ -3,11 +3,11 @@ README.md
 setup.py
 bin/hestia-format-upload
 bin/hestia-pivot-csv
-hestia_earth/__init__.py
 hestia_earth/utils/__init__.py
 hestia_earth/utils/api.py
 hestia_earth/utils/blank_node.py
 hestia_earth/utils/calculation_status.py
+hestia_earth/utils/csv_utils.py
 hestia_earth/utils/cycle.py
 hestia_earth/utils/date.py
 hestia_earth/utils/descriptive_stats.py
@@ -36,6 +36,19 @@ hestia_earth_utils.egg-info/SOURCES.txt
 hestia_earth_utils.egg-info/dependency_links.txt
 hestia_earth_utils.egg-info/requires.txt
 hestia_earth_utils.egg-info/top_level.txt
-tests/pivot/__init__.py
-tests/pivot/test_pivot_csv.py
-tests/pivot/test_pivot_json.py
+tests/test_api.py
+tests/test_blank_node.py
+tests/test_calculation_status.py
+tests/test_cycle.py
+tests/test_date.py
+tests/test_descriptive_stats.py
+tests/test_emission.py
+tests/test_lookup.py
+tests/test_lookup_utils.py
+tests/test_model.py
+tests/test_pipeline.py
+tests/test_request.py
+tests/test_stats.py
+tests/test_table.py
+tests/test_term.py
+tests/test_tools.py

hestia_earth_utils-0.16.2/hestia_earth_utils.egg-info/requires.txt

@@ -0,0 +1,12 @@
+hestia-earth-schema>=35.0.1
+requests>=2.24.0
+urllib3~=1.26.0
+python-dateutil>=2.8.1
+numpy>=2
+flatten_json
+
+[pivot-csv]
+pandas>=2
+
+[table]
+pandas>=2

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/hestia_earth_utils.egg-info/top_level.txt

@@ -1,2 +1 @@
 hestia_earth
-tests

{hestia_earth_utils-0.15.16 → hestia_earth_utils-0.16.2}/setup.py

@@ -1,5 +1,5 @@
 import pathlib
-from setuptools import find_packages, setup
+from setuptools import find_namespace_packages, setup
 
 from hestia_earth.utils.version import VERSION
 
@@ -23,15 +23,18 @@ setup(
     author_email='guillaumeroyer.mail@gmail.com',
     license='MIT',
     classifiers=[
-        'License :: OSI Approved :: GNU General Public License v3 (GPLv3)',
-        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.12',
     ],
-    packages=find_packages(exclude=('tests', 'scripts')),
+    packages=find_namespace_packages(include=['hestia_earth.*']),
+    python_requires='>=3.12',
     include_package_data=True,
     install_requires=REQUIRES,
-    python_requires='>=3.9',
     scripts=[
         'bin/hestia-pivot-csv',
         'bin/hestia-format-upload'
-    ]
+    ],
+    extras_require={
+        'pivot-csv': ['pandas>=2'],
+        'table': ['pandas>=2'],
+    }
 )

hestia_earth_utils-0.16.2/tests/test_api.py

@@ -0,0 +1,169 @@
+from unittest.mock import patch
+import os
+import requests
+import json
+from hestia_earth.schema import SchemaType
+import pytest
+
+from .utils import fixtures_path
+from hestia_earth.utils.request import api_url
+from hestia_earth.utils.api import (
+    search,
+    find_related,
+    download_hestia,
+    node_exists,
+    find_node,
+    find_node_exact,
+    find_term_ids_by_names,
+)
+
+
+fake_related_response = {'results': [[{'@id': 'related_id'}]]}
+fake_download_response = {'@id': 'id', '@type': 'type'}
+
+
+class FakeFindRelatedSuccess():
+    def json():
+        return fake_related_response
+
+
+class FakeFindRelatedError():
+    def json():
+        return {}
+
+
+class FakeFindRelatedException():
+    def json():
+        raise requests.exceptions.RequestException('error')
+
+
+class FakeDownloadSuccess():
+    def json():
+        return fake_download_response
+
+
+class FakeDownloadError():
+    def json():
+        raise requests.exceptions.RequestException('error')
+
+
+class FakeNodeExistSuccess():
+    def json():
+        return fake_download_response
+
+
+class FakeNodeExistError():
+    def json():
+        return {"message": "not-found", "details": {}}
+
+
+class FakeElasticSearchEmptyResult:
+    def json():
+        return {"results": []}
+
+
+@patch('requests.get', return_value=FakeFindRelatedSuccess)
+def test_find_related_success(mock_get):
+    res = find_related(SchemaType.CYCLE, 'id', SchemaType.SOURCE)
+    assert res == fake_related_response.get('results')
+    mock_get.assert_called_once_with(
+        f"{api_url()}/cycles/id/sources?limit=100", headers={'Content-Type': 'application/json'}
+    )
+
+
+@patch('requests.get', return_value=FakeFindRelatedError)
+def test_find_related_error(*args):
+    res = find_related(SchemaType.CYCLE, 'id', SchemaType.SOURCE)
+    assert not res
+
+
+@patch('requests.get', return_value=FakeFindRelatedException)
+def test_find_related_exception(*args):
+    res = find_related(SchemaType.CYCLE, 'id', SchemaType.SOURCE)
+    assert not res
+
+
+@patch('requests.get', return_value=FakeDownloadError)  # make sure fallback is not enabled
+def test_download_hestia_local_file(*args):
+    id = 'sandContent'
+    with open(f"{fixtures_path}/Term/{id}.jsonld", encoding='utf-8') as f:
+        expected = json.load(f)
+    os.environ['DOWNLOAD_FOLDER'] = fixtures_path
+    res = download_hestia(id, SchemaType.TERM)
+    assert res == expected
+    del os.environ['DOWNLOAD_FOLDER']
+
+
+@patch('requests.get', return_value=FakeDownloadSuccess)
+def test_download_hestia_success(mock_get):
+    res = download_hestia('id', SchemaType.SOURCE)
+    assert res == fake_download_response
+    mock_get.assert_called_once_with(
+        f"{api_url()}/sources/id", headers={'Content-Type': 'application/json'})
+
+
+@patch('requests.get', return_value=FakeDownloadError)
+def test_download_hestia_error(*args):
+    res = download_hestia('id', SchemaType.SOURCE)
+    assert not res
+
+
+@patch('requests.get', return_value=FakeNodeExistError)  # make sure fallback is not enabled
+def test_node_exists_local_file(*args):
+    os.environ['DOWNLOAD_FOLDER'] = fixtures_path
+    id = 'sandContent'
+    assert node_exists(id, SchemaType.TERM)
+    del os.environ['DOWNLOAD_FOLDER']
+
+
+@patch('requests.get', return_value=FakeNodeExistSuccess)
+def test_node_exists_true(*args):
+    assert node_exists('id', SchemaType.SOURCE)
+
+
+@patch('requests.get', return_value=FakeNodeExistError)
+def test_node_exists_false(*args):
+    assert not node_exists('id', SchemaType.SOURCE)
+
+
+def test_search():
+    name = 'Wheat'
+    res = search(query={
+        'bool': {
+            'must': [{'match': {'name': name}}]
+        }
+    }, limit=2)
+    assert res[0].get('name').startswith(name)
+
+
+def test_find_node():
+    name = 'Wheat'
+    res = find_node(SchemaType.TERM, {'name': name}, 2)
+    assert res[0].get('name').startswith(name)
+
+
+def test_find_node_exact():
+    name = 'Wheat'
+    res = find_node_exact(SchemaType.TERM, {'name': name})
+    assert not res
+
+    name = 'Wheat, grain'
+    res = find_node_exact(SchemaType.TERM, {'name': name})
+    assert res.get('name') == name
+
+
+def test_find_term_ids_by_names():
+    names = ["Harris Termite Powder", "Wheat, grain", "Urea (kg N)"]
+    res = find_term_ids_by_names(names, 2)
+    assert res == {
+        "Wheat, grain": "wheatGrain",
+        "Harris Termite Powder": "harrisTermitePowder",
+        "Urea (kg N)": "ureaKgN",
+    }
+
+
+@patch("requests.post", return_value=FakeElasticSearchEmptyResult)
+def test_find_term_ids_by_names_error(mock):
+    names = ["id_not_found_name"]
+    with pytest.raises(Exception, match=names[0]):
+        find_term_ids_by_names(names)

hestia_earth_utils-0.16.2/tests/test_blank_node.py

@@ -0,0 +1,59 @@
+# import os
+# import json
+# from pytest import mark
+# from hestia_earth.schema import TermTermType
+
+# from tests.utils import fixtures_path
+# from hestia_earth.utils.blank_node import get_node_value, ArrayTreatment, get_blank_nodes_calculation_status
+
+# fixtures_folder = os.path.join(fixtures_path, 'blank_node')
+# calculation_status_folder = os.path.join(fixtures_folder, 'calculation_status')
+
+
+# def test_get_node_value():
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': [10]}
+#     assert get_node_value(blank_node, 'value', default=None) == 10
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': [0]}
+#     assert get_node_value(blank_node, 'value', default=None) == 0
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}}
+#     assert get_node_value(blank_node, 'value', default=None) is None
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': [10, 20]}
+#     assert get_node_value(blank_node, 'value', default=None) == 15
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': True}
+#     assert get_node_value(blank_node, 'value', default=None) is True
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': 10}
+#     assert get_node_value(blank_node, 'value', default=None) == 10
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': None}
+#     assert get_node_value(blank_node, 'value', default=None) is None
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': None}
+#     assert get_node_value(blank_node, 'value', default=0) == 0
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': [10, None, 20]}
+#     assert get_node_value(blank_node, 'value', default=None) == 15
+
+#     blank_node = {'term': {'termType': 'crop', '@id': 'wheatGrain'}, 'value': [10, None, 20]}
+#     assert get_node_value(blank_node, 'value', array_treatment=ArrayTreatment.SUM) == 30
+
+
+# @mark.parametrize(
+#     'folder,list_key,termType',
+#     [
+#         ('cycle', 'emissions', TermTermType.EMISSION),
+#     ]
+# )
+# def test_get_blank_nodes_calculation_status(folder: str, list_key: str, termType: TermTermType):
+#     with open(f"{calculation_status_folder}/{folder}/node.jsonld", encoding='utf-8') as f:
+#         node = json.load(f)
+
+#     with open(f"{calculation_status_folder}/{folder}/{list_key}-{termType.value}.json", encoding='utf-8') as f:
+#         expected = json.load(f)
+
+#     result = get_blank_nodes_calculation_status(node, list_key=list_key, termType=termType)
+#     assert result == expected, folder