hestia-earth-models 0.69.0__py3-none-any.whl → 0.70.0__py3-none-any.whl

hestia_earth/models/pooreNemecek2018/excretaKgN.py

@@ -52,7 +52,7 @@ REQUIREMENTS = {
             }
         ],
         "optional": {
-            "practices": [{"@type": "Practice", "term.termType": "systemn"}]
+            "practices": [{"@type": "Practice", "term.termType": "system"}]
         }
     }
 }

hestia_earth/models/pooreNemecek2018/freshwaterWithdrawalsDuringCycle.py

@@ -13,7 +13,7 @@ from . import MODEL
 
 REQUIREMENTS = {
     "ImpactAssessment": {
-        "product": {"@type": "Product", "term": {"@type": "Term"}},
+        "product": {"@type": "Product"},
         "cycle": {
             "@type": "Cycle",
             "products": [{

hestia_earth/models/pooreNemecek2018/utils.py

@@ -80,11 +80,14 @@ def get_excreta_product_with_ratio(cycle: dict, lookup: str, **log_args):
         ) | {'value': [practice.get('ratio')]}
         for product, practice in practices_with_products
         # ignore matching products with an existing value
-        if not product or not product.get('value', [])
+        if all([
+            not product or not product.get('value', []),
+            product or practice.get('product-id')
+        ])
     ] if practices_with_products else None
 
-    return products or [{
+    return products or non_empty_list([{
         '@type': 'Product',
         'term': {'@type': 'Term', '@id': default_product_id},
         'value': [100]
-    }]
+    } if default_product_id else None])

hestia_earth/models/schmidt2007/ch4ToAirWasteTreatment.py

@@ -9,9 +9,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
+            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
             "completeness.waste": ""
         }
     }

hestia_earth/models/schmidt2007/h2SToAirWasteTreatment.py

@@ -9,9 +9,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
+            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
             "completeness.waste": ""
         }
     }

hestia_earth/models/schmidt2007/n2OToAirWasteTreatmentDirect.py

@@ -9,9 +9,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
+            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
             "completeness.waste": ""
         }
     }

hestia_earth/models/schmidt2007/nh3ToAirWasteTreatment.py

@@ -9,9 +9,7 @@ from . import MODEL
 REQUIREMENTS = {
     "Cycle": {
         "or": {
-            "product": [
-                {"@type": "Product", "value": "", "term.termType": "waste"}
-            ],
+            "products": [{"@type": "Product", "value": "", "term.termType": "waste"}],
             "completeness.waste": ""
         }
     }

hestia_earth/models/site/management.py

@@ -140,12 +140,14 @@ def management(data: dict):
 
 
 def _get_cycle_duration(cycle: dict, land_cover_id: str):
-    return cycle.get('cycleDuration') or safe_parse_float(get_table_value(
+    cycle_duration = cycle.get('cycleDuration')
+    lookup_value = None if cycle_duration else safe_parse_float(get_table_value(
         download_lookup("crop.csv"),
         column_name('landCoverTermId'),
         land_cover_id,
         column_name('maximumCycleDuration')
-    ))
+    ), default=None)
+    return cycle_duration or (lookup_value - 1 if lookup_value else None)
 
 
 def _gap_filled_date_only_str(date_str: str, mode: str = DatestrGapfillMode.END) -> str:
@@ -164,7 +166,7 @@ def _gap_filled_start_date(land_cover_id: str, end_date: str, cycle: dict) -> di
     cycle_duration = _get_cycle_duration(cycle, land_cover_id)
     return {
         "startDate": max(
-            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration - 1)
+            _gap_filled_date_obj(end_date) - timedelta(days=cycle_duration)
             if cycle_duration else datetime.fromtimestamp(0),
             _gap_filled_date_obj(cycle.get("startDate"), mode=DatestrGapfillMode.START)
             if cycle.get("startDate") else datetime.fromtimestamp(0)

hestia_earth/models/site/pre_checks/country.py

@@ -1,4 +1,6 @@
-from hestia_earth.utils.api import download_hestia
+from hestia_earth.schema import TermTermType
 
+from hestia_earth.models.utils.term import download_term
 
-def run(site: dict): return site | {'country': download_hestia(site.get('country', {}).get('@id'))}
+
+def run(site: dict): return site | {'country': download_term(site.get('country', {}).get('@id'), TermTermType.REGION)}

hestia_earth/models/transformation/input/excreta.py

@@ -28,7 +28,7 @@ RETURNS = {
             "@type": "Input",
             "term.termType": "excreta",
             "value": "",
-            "fromCycle": "true"
+            "fromCycle": "True"
         }]
     }]
 }

hestia_earth/models/utils/aggregated.py

@@ -10,7 +10,6 @@ from . import current_year
 from .cycle import is_organic
 
 MODEL_KEY = 'impactAssessment'
-MATCH_WORLD_QUERY = {'match': {'country.name.keyword': {'query': 'World', 'boost': 1}}}
 
 
 def aggregated_end_date(end_date: str):
@@ -18,26 +17,25 @@ def aggregated_end_date(end_date: str):
     return min([round(math.floor(year / 10) * 10) + 9, current_year()])
 
 
-def _match_region_country(region: dict, country: dict):
-    region_name = region.get('name') if region else None
+def _match_country_query(name: str = 'World', boost: int = 1):
+    return {'match': {'country.name.keyword': {'query': name, 'boost': boost}}}
+
+
+def _match_country(country: dict):
     country_name = country.get('name') if country else None
     return {
         'bool': {
             # either get with exact country, or default to global
             'should': non_empty_list([
-                (
-                    {'match': {'region.name.keyword': {'query': region_name, 'boost': 1000}}} if region_name else
-                    {'match': {'country.name.keyword': {'query': country_name, 'boost': 1000}}} if country_name else
-                    None
-                ),
-                MATCH_WORLD_QUERY
+                _match_country_query(name=country_name, boost=1000) if country_name else None,
+                _match_country_query()
             ]),
             'minimum_should_match': 1
         }
     }
 
 
-def find_closest_impact(cycle: dict, end_date: str, term: dict, region: dict, country: dict, must_queries=[]):
+def find_closest_impact(cycle: dict, end_date: str, term: dict, country: dict, must_queries=[]):
     query = {
         'bool': {
             'must': non_empty_list([
@@ -54,7 +52,7 @@ def find_closest_impact(cycle: dict, end_date: str, term: dict, region: dict, co
                         'minimum_should_match': 1
                     }
                 } if term else None,
-                _match_region_country(region, country)
+                _match_country(country)
             ]) + must_queries,
             'should': [
                 # if the Cycle is organic, we can try to match organic aggregate first
@@ -76,14 +74,13 @@ def _link_input_to_impact(model: str, cycle: dict, date: int):
     def run(input: dict):
         term = input.get('term', {})
         term_id = term.get('@id')
-        region = input.get('region')
         country = input.get('country')
-        impact = find_closest_impact(cycle, date, term, region, country)
+        impact = find_closest_impact(cycle, date, term, country)
 
-        search_by_region_id = (region or country or {}).get('@id') or 'region-world'
+        search_by_country_id = (country or {}).get('@id') or 'region-world'
         debugValues(cycle, model=model, term=term_id, key=MODEL_KEY,
                     search_by_input_term_id=term_id,
-                    search_by_region_id=search_by_region_id,
+                    search_by_country_id=search_by_country_id,
                     search_by_end_date=str(date),
                     impact_assessment_id_found=(impact or {}).get('@id'))
 

hestia_earth/models/utils/blank_node.py

@@ -398,9 +398,17 @@ def convert_to_nitrogen(node: dict, model: str, blank_nodes: list, **log_args):
         return value or get_node_property_value(model, input, 'crudeProteinContent', default=0, **log_args) / 6.25
 
     values = [(i, prop_value(i)) for i in blank_nodes]
-    missing_nitrogen_property = [i.get('term', {}).get('@id') for i, p_value in values if not p_value]
+    missing_nitrogen_property = [i.get('term', {}).get('@id') for i, value in values if not value]
 
     debugValues(node, model=model,
+                convertion_details=log_as_table([
+                    {
+                        'id': i.get('term', {}).get('@id'),
+                        'value': list_sum(i.get('value', [])),
+                        'conversion-factor': value
+                    }
+                    for i, value in values
+                ]),
                 missing_nitrogen_property=';'.join(set(missing_nitrogen_property)),
                 **log_args)
 
@@ -1010,6 +1018,7 @@ def group_nodes_by_year(
     nodes: list[dict],
     default_node_duration: int = 1,
     sort_result: bool = True,
+    include_spillovers: bool = False,
     inner_key: Union[Any, None] = None,
     mode: GroupNodesByYearMode = GroupNodesByYearMode.START_AND_END_DATE
 ) -> dict[int, list[dict]]:
@@ -1026,6 +1035,10 @@ def group_nodes_by_year(
         Default duration of a node years if start date is not available, by default 1.
     sort_result : bool, optional
         Flag to sort the result by year, by default True.
+    include_spillovers : bool, optional
+        If grouping by start and end date, flag to determine whether nodes should be included in year groups that they
+        spill-over into. If `False` year groups will not include nodes that overlap with them by less than 30% of a
+        year, unless it is the only year group it overlaps with. By default False.
     inner_key: Any | None
         An optional inner dictionary key for the outputted annualised groups (can be used to merge annualised
         dictionaries together), default value: `None`.
@@ -1066,6 +1079,7 @@ def group_nodes_by_year(
 
             should_run = (
                 mode == GroupNodesByYearMode.DATES
+                or include_spillovers
                 or _validate_time_fraction_dict(
                     time_fraction_dict,
                     is_final_year

hestia_earth/models/utils/product.py

@@ -153,7 +153,7 @@ def get_animal_produced_nitrogen(model: str, products: list) -> float:
     def product_value(product: dict):
         value = convert_product_to_unit(product, Units.KG_LIVEWEIGHT)
         property = prop_value(product)
-        return value * property / 100 if all([value, property]) else 0
+        return value * property if all([value, property]) else 0
 
     return list_sum(list(map(product_value, products)))
 

hestia_earth/models/utils/source.py

@@ -52,7 +52,8 @@ def _extract(content: str):
 
 def _list_sources():
     dir = pathlib.Path(ROOT_DIR)
-    files = list(dir.rglob('**/*.py'))
+    # ignore current file
+    files = list(filter(lambda f: not str(f).endswith('utils/source.py'), list(dir.rglob('**/*.py'))))
     return list(set(flatten([_extract(open(f, 'r').read().replace('\n', '')) for f in files])))
 
 

hestia_earth/models/utils/term.py

@@ -715,7 +715,7 @@ def get_land_cover_terms():
 
     Returns
     -------
-        List of landCover terms with associated siteTypes.
+        List of landCover terms IDs.
     """
     terms = search({
         "bool": {
@@ -726,3 +726,28 @@ def get_land_cover_terms():
         },
     }, limit=LIMIT, fields=['@id'])
     return list(map(lambda n: n["@id"], terms))
+
+
+def get_ionophore_terms():
+    """
+    Find all `Ionophore` terms from the Glossary: https://hestia.earth/glossary?query=ionophore
+
+    Returns
+    -------
+        List of ionophore term IDs.
+    """
+    terms = search({
+        "bool": {
+            "must": [
+                {"match": {"@type": SchemaType.TERM.value}},
+                {"match_phrase_prefix": {"name": "ionophore"}}
+            ],
+            "should": [
+                {"match": {"termType": TermTermType.FEEDFOODADDITIVE.value}},
+                {"match": {"termType": TermTermType.VETERINARYDRUG.value}},
+
+            ],
+            "minimum_should_match": 1
+        },
+    }, limit=LIMIT, fields=['@id'])
+    return list(map(lambda n: n["@id"], terms))

hestia_earth/models/version.py

@@ -1 +1 @@
-VERSION = '0.69.0'
+VERSION = '0.70.0'

{hestia_earth_models-0.69.0.dist-info → hestia_earth_models-0.70.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.69.0
+Version: 0.70.0
 Summary: HESTIA's set of modules for filling gaps in the activity data using external datasets (e.g. populating soil properties with a geospatial dataset using provided coordinates) and internal lookups (e.g. populating machinery use from fuel use). Includes rules for when gaps should be filled versus not (e.g. never gap fill yield, gap fill crop residue if yield provided etc.).
 Home-page: https://gitlab.com/hestia-earth/hestia-engine-models
 Author: HESTIA Team