hestia-earth-models 0.64.8__tar.gz → 0.64.9__tar.gz

{hestia-earth-models-0.64.8/hestia_earth_models.egg-info → hestia-earth-models-0.64.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hestia-earth-models
-Version: 0.64.8
+Version: 0.64.9
 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

{hestia-earth-models-0.64.8 → hestia-earth-models-0.64.9}/hestia_earth/models/cycle/siteArea.py

@@ -9,6 +9,7 @@ from hestia_earth.utils.model import filter_list_term_type, find_term_match
 from hestia_earth.utils.tools import list_sum
 
 from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import square_meter_to_hectare
 from . import MODEL
 
 REQUIREMENTS = {
@@ -48,7 +49,7 @@ def _run(cycle: dict):
     animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
     stocking_density = find_term_match(
         cycle.get('practices', []), 'stockingDensityAnimalHousingAverage', {}).get('value', [])
-    return round(list_sum([a.get('value') for a in animals]) / list_sum(stocking_density), 7)
+    return square_meter_to_hectare(round(list_sum([a.get('value') for a in animals]) / list_sum(stocking_density), 7))
 
 
 def _should_run(cycle: dict, site: dict, key=MODEL_KEY):

hestia-earth-models-0.64.9/hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandOccupation.py

@@ -0,0 +1,120 @@
+"""
+Characterises [soilQualityIndexLandOccupation](https://hestia.earth/term/soilQualityIndexLandOccupation)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from typing import Tuple
+
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.landCover import get_pef_grouping
+from hestia_earth.models.utils.lookup import fallback_country, _node_value
+from . import MODEL
+from .utils import get_coefficient_factor
+from ..utils.impact_assessment import get_country_id
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "optional": {"country": {"@type": "Term", "termType": "region"}},
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "value": ">0",
+            "term.@id": ["landOccupationInputsProduction", "landOccupationDuringCycle"],
+            "term.units": "m2*year",
+            "landCover": {"@type": "Term", "term.termType": "landCover"}
+        }]
+    }
+}
+
+LOOKUPS = {
+    "@doc": "Performs lookup on landCover.csv for column headers and region-pefTermGrouping-landOccupation.csv for CFs",
+    "region-pefTermGrouping-landOccupation": "",
+    "landCover": "pefTermGrouping"
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+TERM_ID = 'soilQualityIndexLandOccupation'
+LOOKUP = f"{list(LOOKUPS.keys())[1]}.csv"
+
+authorised_indicators = ["landOccupationInputsProduction", "landOccupationDuringCycle"]
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(land_occupation_indicators: list):
+    values = [indicator['coefficient'] * indicator['area-by-year'] for indicator in land_occupation_indicators]
+    return _indicator(list_sum(values))
+
+
+def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
+    land_occupation_indicators = [
+        i for i in filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE) if
+        i.get('landCover', {}).get('termType') == TermTermType.LANDCOVER.value and
+        i.get('term', {}).get('@id', '') in authorised_indicators
+    ]
+
+    found_land_occupation_indicators = [{
+        'area-by-year': _node_value(land_occupation_indicator),
+        'area-unit': land_occupation_indicator.get('term', {}).get("units"),
+        'land-cover-id': land_occupation_indicator.get('landCover', {}).get("@id"),
+        'country-id': get_country_id(impact_assessment),
+        'area-by-year-is-valid': _node_value(land_occupation_indicator) is not None and _node_value(
+            land_occupation_indicator) > 0,
+        'area-unit-is-valid': land_occupation_indicator.get('term', {}).get("units") == "m2*year",
+        'used-country': fallback_country(get_country_id(impact_assessment), [download_lookup(LOOKUP)]),
+
+    } for land_occupation_indicator in land_occupation_indicators]
+
+    found_indicators_with_coefficient = [
+        indicator | {
+            'coefficient': get_coefficient_factor(
+                LOOKUP, indicator['used-country'],
+                get_pef_grouping(indicator['land-cover-id']),
+                term_id=TERM_ID
+            ),
+            "using-fallback-country-region-world-CFs": indicator['used-country'] != indicator['country-id']
+        } for indicator in found_land_occupation_indicators
+    ]
+
+    has_valid_land_occupations = all(
+        [
+            indicator['area-by-year-is-valid'] and indicator['area-unit-is-valid']
+            for indicator in found_land_occupation_indicators
+        ]) if found_land_occupation_indicators else False
+
+    valid_indicator_with_coef = [indicator for indicator in found_indicators_with_coefficient if
+                                 indicator['coefficient'] is not None and
+                                 indicator['area-by-year-is-valid'] and
+                                 indicator['area-unit-is-valid']]
+
+    has_land_occupation_indicators = bool(land_occupation_indicators)
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_land_occupation_indicators=has_land_occupation_indicators,
+                    has_valid_land_occupations=has_valid_land_occupations,
+                    land_occupation_indicators=log_as_table(found_indicators_with_coefficient)
+                    )
+
+    should_run = has_land_occupation_indicators and has_valid_land_occupations
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_indicator_with_coef
+
+
+def run(impact_assessment: dict):
+    should_run, land_occupation_indicators = _should_run(impact_assessment)
+    return _run(land_occupation_indicators) if should_run else None

hestia-earth-models-0.64.9/hestia_earth/models/environmentalFootprintV3/soilQualityIndexLandTransformation.py

@@ -0,0 +1,168 @@
+"""
+Characterises [soilQualityIndexLandTransformation](https://hestia.earth/term/soilQualityIndexLandTransformation)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from typing import List, Tuple, Optional
+
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import download_lookup
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from . import MODEL
+from .utils import get_coefficient_factor
+from ..utils.impact_assessment import get_country_id
+from ..utils.indicator import _new_indicator
+from ..utils.landCover import get_pef_grouping
+from ..utils.lookup import fallback_country, _node_value
+from ..utils.term import download_all_land_cover_terms
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {
+                "@type": "Indicator",
+                "term.units": "m2 / year",
+                "term.termType": "resourceUse",
+                "term.name": "Land transformation from",
+                "value": "> 0",
+                "landCover": {"@type": "Term", "term.termType": "landCover"}
+            }
+        ],
+        "optional": {"country": {"@type": "Term", "termType": "region"}}
+    }
+}
+
+# Note: CFs in `region-pefTermGrouping-landTransformation-from.csv` appear to be the opposite values as those in
+# `region-pefTermGrouping-landTransformation-to.csv` but can be different in some cases.
+LOOKUPS = {
+    "region-pefTermGrouping-landTransformation-from": "using country and `pefTermGrouping` from `landCover`",
+    "region-pefTermGrouping-landTransformation-to": "using country and `pefTermGrouping` from `landCover`",
+    "landCover": "pefTermGrouping"
+}
+
+from_lookup_file = f"{list(LOOKUPS.keys())[0]}.csv"
+to_lookup_file = f"{list(LOOKUPS.keys())[1]}.csv"
+
+LOOKUP = {
+    "from": from_lookup_file,
+    "to": to_lookup_file
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": ""
+    }
+}
+
+TERM_ID = 'soilQualityIndexLandTransformation'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(transformations: List[dict]):
+    values = [(transformation['factor-from'] + transformation['factor-to']) * transformation['area'] for transformation
+              in transformations]
+    return _indicator(list_sum(values))
+
+
+def _extract_land_cover_from_indicator_id(indicator: dict) -> Optional[str]:
+    """
+    Given a indicator with term type `resourceUse` return the equivalent `landCover` term
+    """
+    term_in_id = indicator.get('term', {}).get('@id', '') \
+        .removeprefix("landTransformationFrom") \
+        .removesuffix("20YearAverageInputsProduction") \
+        .removesuffix("20YearAverageDuringCycle")
+    term_in_id = term_in_id[0].lower() + term_in_id[1:] if term_in_id else None
+    return term_in_id
+
+
+def _is_valid_indicator(indicator: dict, land_cover_term_ids: list[str]) -> bool:
+    term_id = _extract_land_cover_from_indicator_id(indicator)
+    return term_id in land_cover_term_ids
+
+
+def _should_run(impact_assessment: dict) -> Tuple[bool, list]:
+    resource_uses = filter_list_term_type(impact_assessment.get('emissionsResourceUse', []), TermTermType.RESOURCEUSE)
+    land_cover_term_ids = [term.get("@id") for term in download_all_land_cover_terms()] if resource_uses else []
+
+    land_transformation_indicators = [i for i in resource_uses if _is_valid_indicator(i, land_cover_term_ids)]
+
+    found_transformations = [
+        {
+            'area': _node_value(transformation_indicator) * 20,
+            'area-unit': transformation_indicator.get('term', {}).get("units"),
+            'land-cover-id-from': _extract_land_cover_from_indicator_id(transformation_indicator),
+            'land-cover-id-to': transformation_indicator.get('landCover', {}).get("@id"),
+            'indicator-id': transformation_indicator.get('term', {}).get('@id', ''),
+            'good-land-cover-term': transformation_indicator.get('landCover', {}).get('termType') == 'landCover',
+            'country-id': get_country_id(impact_assessment),
+            'area-is-valid': _node_value(transformation_indicator) is not None and _node_value(
+                transformation_indicator) > 0,
+            'area-unit-is-valid': transformation_indicator.get('term', {}).get("units") == "m2 / year",
+            'lookup-country': fallback_country(get_country_id(impact_assessment),
+                                               [download_lookup(from_lookup_file), download_lookup(to_lookup_file)]),
+        } for transformation_indicator in land_transformation_indicators
+    ]
+
+    found_transformations_with_coefficient = [
+        transformation | {
+            "using-fallback-country-region-world-CFs": transformation['lookup-country'] != transformation['country-id'],
+            'factor-from': get_coefficient_factor(
+                lookup_name=from_lookup_file,
+                country_id=transformation['lookup-country'],
+                term_id=TERM_ID,
+                occupation_type=get_pef_grouping(transformation['land-cover-id-from'])) if
+            transformation['land-cover-id-from'] else None,
+            'factor-to': get_coefficient_factor(
+                lookup_name=to_lookup_file,
+                country_id=transformation['lookup-country'],
+                term_id=TERM_ID,
+                occupation_type=get_pef_grouping(transformation['land-cover-id-to'])) if
+            transformation['land-cover-id-to'] else None
+        } for transformation in found_transformations
+    ]
+
+    valid_transformations_with_coef = [
+        t for t in found_transformations_with_coefficient if all([
+            t['area-is-valid'],
+            t['area-unit-is-valid'],
+            t['factor-from'] is not None,
+            t['factor-to'] is not None
+        ])
+    ]
+
+    has_land_transformation_indicators = bool(land_transformation_indicators)
+
+    all_transformations_are_valid = all(
+        [
+            all([t['area-is-valid'], t['area-unit-is-valid'], t['good-land-cover-term']])
+            for t in found_transformations_with_coefficient
+        ]
+    ) if found_transformations_with_coefficient else False
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_land_occupation_indicators=has_land_transformation_indicators,
+                    all_transformations_are_valid=all_transformations_are_valid,
+                    has_valid_transformations_with_coef=bool(valid_transformations_with_coef),
+                    found_transformations=log_as_table(found_transformations_with_coefficient)
+                    )
+
+    should_run = has_land_transformation_indicators is False or all([has_land_transformation_indicators,
+                                                                     all_transformations_are_valid])
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_transformations_with_coef
+
+
+def run(impact_assessment: dict):
+    should_run, transformations = _should_run(impact_assessment)
+    return _run(transformations) if should_run else None

hestia-earth-models-0.64.9/hestia_earth/models/environmentalFootprintV3/soilQualityIndexTotalLandUseEffects.py

@@ -0,0 +1,77 @@
+"""
+Characterises [soilQualityIndexTotalLandUseEffects](https://hestia.earth/term/soilQualityIndexTotalLandUseEffects)
+based on an updated [LANCA model (De Laurentiis et al. 2019)](
+http://publications.jrc.ec.europa.eu/repository/handle/JRC113865) and on the LANCA (Regionalised) Characterisation
+Factors version 2.5 (Horn and Meier, 2018).
+"""
+from hestia_earth.utils.model import find_term_match
+from hestia_earth.utils.tools import list_sum
+
+from hestia_earth.models.log import logRequirements, logShouldRun
+from . import MODEL
+from ..utils.indicator import _new_indicator
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [
+            {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandOccupation"},
+            {"@type": "Indicator", "value": "", "term.@id": "soilQualityIndexLandTransformation"}
+        ]
+    }
+}
+
+RETURNS = {
+    "Indicator": {
+        "value": "",
+        "methodTier": "tier 1",
+        "statsDefinition": "modelled"
+    }
+}
+TERM_ID = 'soilQualityIndexTotalLandUseEffects'
+
+
+def _indicator(value: float):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    return indicator
+
+
+def _run(indicators: list):
+    values = [indicator['value'] for indicator in indicators]
+    return _indicator(list_sum(values))
+
+
+def _should_run(impactassessment: dict) -> tuple[bool, list]:
+    land_indicators = [
+        i for i in impactassessment.get('emissionsResourceUse', []) if
+        i.get('term', {}).get('@id', '') in ['soilQualityIndexLandOccupation', 'soilQualityIndexLandTransformation']
+    ]
+    has_indicators = bool(land_indicators)
+
+    land_occupation_indicator = find_term_match(land_indicators, "soilQualityIndexLandOccupation",
+                                                default_val=None)
+    has_land_occupation_indicator = bool(land_occupation_indicator)
+
+    land_transformation_indicator = find_term_match(land_indicators, "soilQualityIndexLandTransformation",
+                                                    default_val=None)
+    has_land_transformation_indicator = bool(land_transformation_indicator)
+
+    has_valid_values = all([isinstance(indicator.get('value', None), (int, float)) for indicator in land_indicators])
+
+    logRequirements(impactassessment, model=MODEL, term=TERM_ID,
+                    has_indicators=has_indicators,
+                    has_land_occupation_indicator=has_land_occupation_indicator,
+                    has_land_transformation_indicator=has_land_transformation_indicator,
+                    has_valid_values=has_valid_values
+                    )
+
+    should_run = all([has_indicators, has_valid_values,
+                      has_land_occupation_indicator, has_land_transformation_indicator])
+
+    logShouldRun(impactassessment, MODEL, TERM_ID, should_run)
+    return should_run, land_indicators
+
+
+def run(impactassessment: dict):
+    should_run, indicators = _should_run(impactassessment)
+    return _run(indicators) if should_run else None

{hestia-earth-models-0.64.8 → hestia-earth-models-0.64.9}/hestia_earth/models/faostat2018/landTransformationFromCropland100YearAverage.py

@@ -20,7 +20,8 @@ LOOKUPS = {
 }
 RETURNS = {
     "Indicator": [{
-        "value": ""
+        "value": "",
+        "landCover": ""
     }]
 }
 TERM_ID = 'landTransformationFromTemporaryCropland100YearAverageDuringCycle,landTransformationFromPermanentCropland100YearAverageDuringCycle'  # noqa: E501
@@ -30,7 +31,7 @@ PERMANENT_TERM_ID = 'landTransformationFromPermanentCropland100YearAverageDuring
 
 
 def _indicator(term_id: str, value: float):
-    indicator = _new_indicator(term_id, MODEL)
+    indicator = _new_indicator(term_id, MODEL, 'cropland')
     indicator['value'] = value
     return indicator
 

{hestia-earth-models-0.64.8 → hestia-earth-models-0.64.9}/hestia_earth/models/faostat2018/landTransformationFromCropland20YearAverage.py

@@ -20,7 +20,8 @@ LOOKUPS = {
 }
 RETURNS = {
     "Indicator": [{
-        "value": ""
+        "value": "",
+        "landCover": ""
     }]
 }
 TERM_ID = 'landTransformationFromTemporaryCropland20YearAverageDuringCycle,landTransformationFromPermanentCropland20YearAverageDuringCycle'  # noqa: E501
@@ -30,7 +31,7 @@ PERMANENT_TERM_ID = 'landTransformationFromPermanentCropland20YearAverageDuringC
 
 
 def _indicator(term_id: str, value: float):
-    indicator = _new_indicator(term_id, MODEL)
+    indicator = _new_indicator(term_id, MODEL, 'cropland')
     indicator['value'] = value
     return indicator
 

hestia-earth-models-0.64.9/hestia_earth/models/frischknechtEtAl2000/ionisingRadiationKbqU235Eq.py

@@ -0,0 +1,122 @@
+from hestia_earth.schema import TermTermType
+from hestia_earth.utils.lookup import get_table_value, download_lookup, column_name
+from hestia_earth.utils.model import filter_list_term_type
+from hestia_earth.utils.tools import flatten
+
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils.indicator import _new_indicator
+from hestia_earth.models.utils.lookup import _node_value
+from . import MODEL
+
+REQUIREMENTS = {
+    "ImpactAssessment": {
+        "emissionsResourceUse": [{
+            "@type": "Indicator",
+            "value": "",
+            "term.@id": [
+                "ionisingCompoundsToAirInputsProduction",
+                "ionisingCompoundsToWaterInputsProduction",
+                "ionisingCompoundsToSaltwaterInputsProduction"
+            ],
+            "inputs": {"@type": "Term", "term.termType": "waste", "term.units": "kg"}
+        }]
+    }
+}
+LOOKUPS = {
+    "waste": [
+        "ionisingCompoundsToAirInputsProduction",
+        "ionisingCompoundsToWaterInputsProduction",
+        "ionisingCompoundsToSaltwaterInputsProduction"
+    ]
+}
+RETURNS = {
+    "Indicator": [{
+        "value": "",
+        "inputs": ""
+    }]
+}
+
+TERM_ID = 'ionisingRadiationKbqU235Eq'
+
+
+def _valid_waste(input: dict) -> bool:
+    return input.get('units', '').startswith("kg") and input.get('termType', '') == TermTermType.WASTE.value
+
+
+def _valid_emission(emission: dict) -> bool:
+    return len(emission.get('inputs', [])) == 1 and isinstance(_node_value(emission), (int, float))
+
+
+def _indicator(value: float, input: dict):
+    indicator = _new_indicator(TERM_ID, MODEL)
+    indicator['value'] = value
+    indicator['inputs'] = [input]
+    return indicator
+
+
+def _run(emissions: list):
+    indicators = [
+        _indicator(value=emission['value'] * emission['coefficient'], input=emission['input'])
+        for emission in emissions
+    ]
+    return indicators
+
+
+def _should_run(impact_assessment: dict):
+    emissions = [emission for emission in filter_list_term_type(impact_assessment.get('emissionsResourceUse', []),
+                                                                TermTermType.EMISSION)
+                 if emission.get('term', {}).get('@id', '') in LOOKUPS[TermTermType.WASTE.value]]
+
+    has_emissions = bool(emissions)
+
+    emissions_unpacked = flatten(
+        [
+            [
+                {
+                    "input-term-id": input.get('@id'),
+                    "input-term-type": input.get('termType'),
+                    "indicator-term-id": emission['term']['@id'],
+                    "indicator-is-valid": _valid_emission(emission),
+                    "input": input,
+                    "indicator-input-is-valid": _valid_waste(input),
+                    "value": _node_value(emission),
+                    "coefficient": get_table_value(array=download_lookup(filename="waste.csv"),
+                                                   col_match='termid',
+                                                   col_match_with=input.get('@id'),
+                                                   col_val=column_name(emission['term']['@id'])) if input else None
+                } for input in emission['inputs'] or [{}]]
+            for emission in emissions
+        ]
+    )
+
+    valid_emission_with_cf = [em for em in emissions_unpacked if em['coefficient'] is not None
+                              and em['indicator-is-valid'] is True
+                              and em['indicator-input-is-valid'] is True]
+
+    valid_input_requirements = all([
+        all([
+            em['indicator-is-valid'],
+            em['indicator-input-is-valid']
+        ])
+        for em in emissions_unpacked
+    ])
+
+    all_emissions_have_known_cf = all([em['coefficient'] is not None for em in emissions_unpacked]) and bool(
+        emissions_unpacked)
+
+    logRequirements(impact_assessment, model=MODEL, term=TERM_ID,
+                    has_emissions=has_emissions,
+                    valid_input_requirements=valid_input_requirements,
+                    all_emissions_have_known_CF=all_emissions_have_known_cf,
+                    emissions=log_as_table(emissions_unpacked)
+                    )
+
+    should_run = valid_input_requirements
+
+    logShouldRun(impact_assessment, MODEL, TERM_ID, should_run)
+    return should_run, valid_emission_with_cf
+
+
+def run(impact_assessment: dict):
+    should_run, emissions = _should_run(impact_assessment)
+    return _run(emissions) if should_run else []

hestia-earth-models-0.64.9/hestia_earth/models/ipcc2019/animal/fatContent.py

@@ -0,0 +1,38 @@
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "practices": {
+                "@type": "Practice",
+                "term.termType": "animalManagement"
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-milkFatContent": "fat content",
+    "liveAnimal": "milkYieldPracticeTermIds"
+}
+RETURNS = {
+    "Animal": [{
+        "practices": [{
+            "@type": "Practice",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'fatContent'
+
+
+def run(cycle: dict):
+    animals = should_run_by_productivity_lookup(
+        TERM_ID, cycle, list(LOOKUPS.keys())[0], practice_id=LOOKUPS['liveAnimal']
+    )
+    return list(map(run_animal_by_productivity(TERM_ID, include_practice=True), animals))

hestia-earth-models-0.64.9/hestia_earth/models/ipcc2019/animal/liveweightGain.py

@@ -0,0 +1,38 @@
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "none": {
+                "properties": [{
+                    "@type": "Property",
+                    "value": "",
+                    "term.@id": "liveweightGain"
+                }]
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-liveweightGain": "liveweight gain"
+}
+RETURNS = {
+    "Animal": [{
+        "properties": [{
+            "@type": "Property",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'liveweightGain'
+
+
+def run(cycle: dict):
+    animals = should_run_by_productivity_lookup(TERM_ID, cycle, list(LOOKUPS.keys())[0])
+    return list(map(run_animal_by_productivity(TERM_ID), animals))

hestia-earth-models-0.64.9/hestia_earth/models/ipcc2019/animal/liveweightPerHead.py

@@ -0,0 +1,38 @@
+from .utils import should_run_by_productivity_lookup, run_animal_by_productivity
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "country": {"@type": "Term", "termType": "region"}
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "none": {
+                "properties": [{
+                    "@type": "Property",
+                    "value": "",
+                    "term.@id": "liveweightPerHead"
+                }]
+            }
+        }]
+    }
+}
+LOOKUPS = {
+    "region-liveAnimal-liveweightPerHead": "liveweight per head"
+}
+RETURNS = {
+    "Animal": [{
+        "properties": [{
+            "@type": "Property",
+            "value": ""
+        }]
+    }]
+}
+TERM_ID = 'liveweightPerHead'
+
+
+def run(cycle: dict):
+    animals = should_run_by_productivity_lookup(TERM_ID, cycle, list(LOOKUPS.keys())[0])
+    return list(map(run_animal_by_productivity(TERM_ID), animals))