hestia-earth-models 0.64.4__py3-none-any.whl → 0.64.5__py3-none-any.whl

hestia_earth/models/blonkConsultants2016/ch4ToAirNaturalVegetationBurning.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,16 +8,10 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "functionalUnit": "1 ha",
         "or": [
             {
-                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
                 "cycleDuration": "",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "value": "> 0",
-                    "economicValueShare": "> 0"
-                }],
                 "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
             },
             {
@@ -65,14 +59,16 @@ def _run(land_occupation: float, ch4_forest_biomass_burning: float):
 
 
 def _should_run(cycle: dict):
+    is_1_ha_functional_unit = cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value
     land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
     ch4_forest_biomass_burning = get_emission_factor(TERM_ID, cycle, 'ch4forestBiomassBurning')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
                     land_occupation=land_occupation,
                     ch4_forest_biomass_burning=ch4_forest_biomass_burning)
 
-    should_run = all([land_occupation, ch4_forest_biomass_burning is not None])
+    should_run = all([is_1_ha_functional_unit, land_occupation, ch4_forest_biomass_burning is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, land_occupation, ch4_forest_biomass_burning
 

hestia_earth/models/blonkConsultants2016/co2ToAirAboveGroundBiomassStockChangeLandUseChange.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,16 +8,10 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "functionalUnit": "1 ha",
         "or": [
             {
-                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
                 "cycleDuration": "",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "value": "> 0",
-                    "economicValueShare": "> 0"
-                }],
                 "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
             },
             {
@@ -65,14 +59,16 @@ def _run(land_occupation: float, co2_land_use_change: float):
 
 
 def _should_run(cycle: dict):
+    is_1_ha_functional_unit = cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value
     land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
     co2_land_use_change = get_emission_factor(TERM_ID, cycle, 'co2LandUseChange')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
                     land_occupation=land_occupation,
                     co2_land_use_change=co2_land_use_change)
 
-    should_run = all([land_occupation, co2_land_use_change is not None])
+    should_run = all([is_1_ha_functional_unit, land_occupation, co2_land_use_change is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, land_occupation, co2_land_use_change
 

hestia_earth/models/blonkConsultants2016/n2OToAirNaturalVegetationBurningDirect.py

@@ -1,4 +1,4 @@
-from hestia_earth.schema import EmissionMethodTier
+from hestia_earth.schema import EmissionMethodTier, CycleFunctionalUnit
 
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.emission import _new_emission
@@ -8,20 +8,11 @@ from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
+        "functionalUnit": "1 ha",
         "or": [
             {
-                "@doc": "if the [cycle.functionalUnit](https://hestia.earth/schema/Cycle#functionalUnit) = 1 ha, additional properties are required",  # noqa: E501
                 "cycleDuration": "",
-                "products": [{
-                    "@type": "Product",
-                    "primary": "True",
-                    "value": "> 0",
-                    "economicValueShare": "> 0"
-                }],
-                "site": {
-                    "@type": "Site",
-                    "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
-                }
+                "practices": [{"@type": "Practice", "value": "", "term.@id": "longFallowRatio"}]
             },
             {
                 "@doc": "for plantations, additional properties are required",
@@ -68,14 +59,16 @@ def _run(land_occupation: float, n2o_forest_biomass_burning: float):
 
 
 def _should_run(cycle: dict):
+    is_1_ha_functional_unit = cycle.get('functionalUnit') == CycleFunctionalUnit._1_HA.value
     land_occupation = land_occupation_per_ha(MODEL, TERM_ID, cycle)
     n2o_forest_biomass_burning = get_emission_factor(TERM_ID, cycle, 'n2oforestBiomassBurning')
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
+                    is_1_ha_functional_unit=is_1_ha_functional_unit,
                     land_occupation=land_occupation,
                     n2o_forest_biomass_burning=n2o_forest_biomass_burning)
 
-    should_run = all([land_occupation, n2o_forest_biomass_burning is not None])
+    should_run = all([is_1_ha_functional_unit, land_occupation, n2o_forest_biomass_burning is not None])
     logShouldRun(cycle, MODEL, TERM_ID, should_run, methodTier=TIER)
     return should_run, land_occupation, n2o_forest_biomass_burning
 

hestia_earth/models/cycle/animal/input/properties.py

@@ -41,6 +41,12 @@ RETURNS = {
         }]
     }]
 }
+LOOKUPS = {
+    "crop-property": "dryMatter",
+    "forage-property": "dryMatter",
+    "processedFoor-property": "dryMatter",
+    "property": "feedipediaConversionEnum"
+}
 MODEL_KEY = 'properties'
 
 

hestia_earth/models/cycle/completeness/soilAmendment.py

@@ -6,7 +6,8 @@ This model checks if we have the requirements below and updates the
 """
 from hestia_earth.models.log import logRequirements
 from hestia_earth.models.utils import is_from_model
-from hestia_earth.models.utils.measurement import most_relevant_measurement, measurement_value
+from hestia_earth.models.utils.measurement import measurement_value
+from hestia_earth.models.utils.blank_node import most_relevant_blank_node_by_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -30,7 +31,7 @@ MODEL_KEY = 'soilAmendment'
 def run(cycle: dict):
     end_date = cycle.get('endDate')
     measurements = cycle.get('site', {}).get('measurements', [])
-    soilPh_measurement = most_relevant_measurement(measurements, 'soilPh', end_date)
+    soilPh_measurement = most_relevant_blank_node_by_id(measurements, 'soilPh', end_date)
     soilPh = measurement_value(soilPh_measurement)
 
     soilPh_added = is_from_model(soilPh_measurement)

hestia_earth/models/cycle/concentrateFeed.py

@@ -9,6 +9,7 @@ from hestia_earth.utils.model import find_primary_product
 from hestia_earth.utils.tools import list_sum, non_empty_list, flatten
 
 from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.utils.blank_node import merge_blank_nodes
 from hestia_earth.models.utils.property import _new_property, get_node_property_value, get_property_lookup_value
 from hestia_earth.models.utils.term import get_digestible_energy_terms, get_energy_digestibility_terms
 from . import MODEL
@@ -41,6 +42,7 @@ LOOKUPS = {
     "property": "commonToSupplementInAnimalFeed"
 }
 TERM_ID = 'concentrateFeedBlend,concentrateFeedUnspecified,feedMix'
+FIRST_TERM_ID = TERM_ID.split(',')[0]
 INPUT_TERM_TYPES = [
     TermTermType.CROP.value,
     TermTermType.FORAGE.value,
@@ -88,7 +90,7 @@ def _calculate_value(cycle: dict, product: dict, inputs: list, property_id: str,
 def _calculate_default_value(cycle: dict, product: dict, inputs: list, property_id: str):
     values = [(
         i.get('term', {}).get('@id'),
-        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=TERM_ID),
+        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=FIRST_TERM_ID),
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
@@ -97,8 +99,9 @@ def _calculate_default_value(cycle: dict, product: dict, inputs: list, property_
 def _calculate_N_value(cycle: dict, product: dict, inputs: list, property_id: str):
     values = [(
         i.get('term', {}).get('@id'),
-        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=TERM_ID) or
-        get_node_property_value(MODEL, i, 'crudeProteinContent', default=0, handle_percents=False, term=TERM_ID) * 0.16,
+        get_node_property_value(MODEL, i, property_id, handle_percents=False, term=FIRST_TERM_ID) or
+        get_node_property_value(
+            MODEL, i, 'crudeProteinContent', default=0, handle_percents=False, term=FIRST_TERM_ID) * 0.16,
         list_sum(i.get('value', []))
     ) for i in inputs]
     return _calculate_value(cycle, product, inputs, property_id, values)
@@ -136,7 +139,10 @@ def _run_property(cycle: dict, product: dict, inputs: list):
 
 def _run(cycle: dict, product: dict, inputs: list):
     properties = non_empty_list(flatten(map(_run_property(cycle, product, inputs), PROPERTY_TO_VALUE.items())))
-    return [{**product, 'properties': product.get('properties', []) + properties}] if len(properties) > 0 else []
+    return [product | {
+        # keep the original values, so merge orignal in new values
+        'properties': merge_blank_nodes(properties, product.get('properties', []))
+    }] if len(properties) > 0 else []
 
 
 def _should_run(cycle: dict):

hestia_earth/models/cycle/input/properties.py

@@ -34,6 +34,12 @@ RETURNS = {
         }]
     }]
 }
+LOOKUPS = {
+    "crop-property": "dryMatter",
+    "forage-property": "dryMatter",
+    "processedFoor-property": "dryMatter",
+    "property": "feedipediaConversionEnum"
+}
 MODEL_KEY = 'properties'
 
 

hestia_earth/models/cycle/liveAnimal.py

@@ -10,7 +10,7 @@ from hestia_earth.utils.tools import list_sum, safe_parse_float
 from hestia_earth.models.log import logRequirements, logShouldRun
 from hestia_earth.models.utils.product import _new_product
 from hestia_earth.models.utils.site import valid_site_type
-from .utils import _get_liveAnimal_term_id
+from .utils import get_liveAnimal_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -74,7 +74,7 @@ def _should_run(cycle: dict):
     propertyPerHead_value = safe_parse_float(propertyPerHead.get('value'), None)
 
     # make sure the `liveAnimal` Term is not already present as a Product or Input
-    term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     has_liveAnimal_product = find_term_match(cycle.get('products', []), term_id, None) is not None
     has_liveAnimal_input = find_term_match(cycle.get('products', []), term_id, None) is not None
 

hestia_earth/models/cycle/milkYield.py

@@ -16,7 +16,7 @@ from hestia_earth.models.log import logRequirements, logShouldRun, log_blank_nod
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.site import valid_site_type
 from hestia_earth.models.utils.term import get_lookup_value
-from .utils import _get_liveAnimal_term_id
+from .utils import get_liveAnimal_term_id
 from . import MODEL
 
 REQUIREMENTS = {
@@ -85,7 +85,7 @@ def _run(cycle: dict, product: dict):
     term = product.get('term', {})
     practice_id = _practice_id(term)
 
-    live_animal_term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    live_animal_term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     live_animal_node = find_term_match(cycle.get('animals', []), live_animal_term_id)
 
     value = list_sum(product.get('value')) / cycleDuration / live_animal_node.get('value')
@@ -115,7 +115,7 @@ def _should_run_product(cycle: dict, product: dict):
 
     has_product_value = list_sum(product.get('value', [])) > 0
 
-    live_animal_term_id = _get_liveAnimal_term_id(product, model_key=MODEL_KEY)
+    live_animal_term_id = get_liveAnimal_term_id(product, model_key=MODEL_KEY)
     live_animal_node = find_term_match(cycle.get('animals', []), live_animal_term_id)
     has_live_animal_node_value = live_animal_node.get('value', 0) > 0
 

hestia_earth/models/cycle/otherSitesArea.py

@@ -0,0 +1,59 @@
+"""
+Other Sites Area
+
+For animal production cycles, use the `stockingDensityAnimalHousingAverage` to calculate the average area required
+for all animals.
+"""
+from hestia_earth.schema import SiteSiteType
+
+from .siteArea import _is_site_valid, _should_run as _should_run_site, _run
+
+REQUIREMENTS = {
+    "Cycle": {
+        "otherSites": [{
+            "@type": "Site",
+            "siteType": "animal housing"
+        }],
+        "none": {
+            "site": {
+                "@type": "Site",
+                "siteType": "animal housing"
+            }
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "value": "> 0"
+        }],
+        "practices": [{
+            "@type": "Practice",
+            "term.@id": "stockingDensityAnimalHousingAverage"
+        }]
+    }
+}
+RETURNS = {
+    "The otherSitesArea as an array of number": ""
+}
+MODEL_KEY = 'otherSitesArea'
+
+
+def _should_run(cycle: dict):
+    other_sites_valid = list(filter(
+        lambda site: site.get('siteType') == SiteSiteType.ANIMAL_HOUSING.value,
+        cycle.get('otherSites', [])
+    ))
+
+    should_run = all([
+        not _is_site_valid(cycle.get('site', {})),
+        len(other_sites_valid) == 1
+    ]) and _should_run_site(cycle, other_sites_valid[0], key=MODEL_KEY)
+    return should_run
+
+
+def run(cycle: dict):
+    other_sites = cycle.get('otherSites', [])
+    other_sites_area = cycle.get('otherSitesArea')
+    return [
+        _run(cycle) if _is_site_valid(site) else other_sites_area[index] if other_sites_area else None
+        for index, site in enumerate(other_sites)
+    ] if _should_run(cycle) else []

hestia_earth/models/cycle/otherSitesUnusedDuration.py

@@ -51,6 +51,13 @@ def _find_site_practice(practices: list, site_id: str):
     ).get('value'), None)
 
 
+def _is_valid(data: dict): return all([
+        data.get('valid-site'),
+        data.get(_PRACTICE_TERM_ID) is not None,
+        data.get('site-duration') is not None
+    ])
+
+
 def _should_run(cycle: dict):
     otherSitesDuration = cycle.get('otherSitesDuration', [])
     practices = cycle.get('practices', [])
@@ -66,13 +73,7 @@ def _should_run(cycle: dict):
         for index, site in enumerate(cycle.get('otherSites', []))
     ]
 
-    has_valid_sites = any([
-        all([
-            data.get('valid-site'),
-            data.get(_PRACTICE_TERM_ID) is not None,
-            (data.get('site-duration') or 0) >= 0
-        ]) for data in site_data
-    ])
+    has_valid_sites = any(map(_is_valid, site_data))
 
     logRequirements(cycle, model=MODEL, key=MODEL_KEY,
                     has_valid_sites=has_valid_sites,
@@ -86,6 +87,6 @@ def _should_run(cycle: dict):
 def run(cycle: dict):
     should_run, site_data = _should_run(cycle)
     return [
-        _run(data.get('site-duration'), data.get(_PRACTICE_TERM_ID)) if data.get('valid-site') else None
+        _run(data.get('site-duration'), data.get(_PRACTICE_TERM_ID)) if _is_valid(data) else None
         for data in site_data
     ] if should_run else []

hestia_earth/models/cycle/pastureSystem.py

@@ -10,7 +10,8 @@ from hestia_earth.utils.model import find_primary_product, find_term_match
 from hestia_earth.models.log import logRequirements, logShouldRun, debugValues
 from hestia_earth.models.utils.practice import _new_practice
 from hestia_earth.models.utils.site import valid_site_type
-from hestia_earth.models.utils.measurement import most_relevant_measurement, measurement_value
+from hestia_earth.models.utils.measurement import measurement_value
+from hestia_earth.models.utils.blank_node import most_relevant_blank_node_by_id
 from hestia_earth.models.utils.term import get_pasture_system_terms
 from . import MODEL
 
@@ -46,7 +47,7 @@ def _practice(term_id: str):
 def _run(cycle: dict):
     end_date = cycle.get('endDate')
     measurements = cycle.get('site', {}).get('measurements', [])
-    slope = measurement_value(most_relevant_measurement(measurements, 'slope', end_date))
+    slope = measurement_value(most_relevant_blank_node_by_id(measurements, 'slope', end_date))
     term_id = 'confinedPastureSystem' if slope <= 2.5 else 'hillyPastureSystem'
 
     debugValues(cycle, model=MODEL, term=term_id,

hestia_earth/models/cycle/product/properties.py

@@ -28,6 +28,12 @@ RETURNS = {
         }]
     }]
 }
+LOOKUPS = {
+    "crop-property": "dryMatter",
+    "forage-property": "dryMatter",
+    "processedFoor-property": "dryMatter",
+    "property": "feedipediaConversionEnum"
+}
 MODEL_KEY = 'properties'
 DRY_MATTER_TERM_ID = 'dryMatter'
 

hestia_earth/models/cycle/siteArea.py

@@ -0,0 +1,83 @@
+"""
+Site Area
+
+For animal production cycles, use the `stockingDensityAnimalHousingAverage` to calculate the average area required
+for all animals.
+"""
+from hestia_earth.schema import TermTermType, SiteSiteType
+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 . import MODEL
+
+REQUIREMENTS = {
+    "Cycle": {
+        "site": {
+            "@type": "Site",
+            "siteType": "animal housing"
+        },
+        "none": {
+            "otherSites": [{
+                "@type": "Site",
+                "siteType": "animal housing"
+            }]
+        },
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "value": "> 0"
+        }],
+        "practices": [{
+            "@type": "Practice",
+            "term.@id": "stockingDensityAnimalHousingAverage",
+            "value": "> 0"
+        }]
+    }
+}
+RETURNS = {
+    "The siteArea as a number": ""
+}
+MODEL_KEY = 'siteArea'
+
+
+def _is_site_valid(site: dict): return site.get('siteType') == SiteSiteType.ANIMAL_HOUSING.value
+
+
+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)
+
+
+def _should_run(cycle: dict, site: dict, key=MODEL_KEY):
+    site_type_valid = _is_site_valid(site)
+    animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
+    values = [{
+        'id': p.get('term', {}).get('@id'),
+        'value': p.get('value')
+    } for p in animals]
+    has_animals = bool(animals)
+    stocking_density = list_sum(
+        find_term_match(cycle.get('practices', []), 'stockingDensityAnimalHousingAverage', {}).get('value', [-1])
+    )
+
+    logRequirements(cycle, model=MODEL, key=key,
+                    site_type_valid=site_type_valid,
+                    values=log_as_table(values),
+                    stocking_density=stocking_density)
+
+    should_run = all([
+        site_type_valid,
+        has_animals,
+        (stocking_density or 0) > 0
+    ])
+    logShouldRun(cycle, MODEL, None, should_run, key=key)
+    return should_run
+
+
+def run(cycle: dict):
+    site = cycle.get('site')
+    has_other_sites_valid = any(map(_is_site_valid, cycle.get('otherSites', [])))
+    return _run(cycle) if _should_run(cycle, site, key=MODEL_KEY) and not has_other_sites_valid else None

hestia_earth/models/cycle/stockingDensityAnimalHousingAverage.py

@@ -1,17 +1,18 @@
 from hestia_earth.schema import TermTermType
-from hestia_earth.utils.model import find_primary_product
+from hestia_earth.utils.model import filter_list_term_type
 
-from hestia_earth.models.log import logRequirements, logShouldRun
+from hestia_earth.models.log import logRequirements, logShouldRun, log_as_table
+from hestia_earth.models.utils import weighted_average
 from hestia_earth.models.utils.blank_node import get_lookup_value
 from hestia_earth.models.utils.practice import _new_practice
 from . import MODEL
 
 REQUIREMENTS = {
     "Cycle": {
-        "products": [{
-            "@type": "Product",
-            "primary": "True",
-            "term.termType": "liveAnimal"
+        "animals": [{
+            "@type": "Animal",
+            "term.termType": "liveAnimal",
+            "value": "> 0"
         }]
     }
 }
@@ -32,21 +33,32 @@ def _practice(value: float):
     return practice
 
 
-def _should_run(cycle: dict):
-    product = find_primary_product(cycle)
-    is_live_animal_product = (product or {}).get('term', {}).get('termType') == TermTermType.LIVEANIMAL.value
+def _run(values: list):
+    # take a weighted average
+    value = weighted_average([
+        (p.get('lookup'), p.get('value')) for p in values
+    ])
+    return [_practice(value)]
+
 
-    lookup_value = get_lookup_value((product or {}).get('term', {}), LOOKUPS['liveAnimal'])
+def _should_run(cycle: dict):
+    animals = filter_list_term_type(cycle.get('animals', []), TermTermType.LIVEANIMAL)
+    values = [{
+        'id': p.get('term', {}).get('@id'),
+        'value': p.get('value'),
+        'lookup': get_lookup_value(p.get('term', {}), LOOKUPS['liveAnimal'])
+    } for p in animals]
+    has_animals = bool(animals)
+    has_values = all([all([p.get('value') is not None, p.get('lookup') is not None]) for p in values])
 
     logRequirements(cycle, model=MODEL, term=TERM_ID,
-                    is_live_animal_product=is_live_animal_product,
-                    lookup_value=lookup_value)
+                    values=log_as_table(values))
 
-    should_run = all([is_live_animal_product > 0, lookup_value is not None])
+    should_run = all([has_animals, has_values])
     logShouldRun(cycle, MODEL, TERM_ID, should_run)
-    return should_run, lookup_value
+    return should_run, values
 
 
 def run(cycle: dict):
-    should_run, lookup_value = _should_run(cycle)
-    return _practice(lookup_value) if should_run else []
+    should_run, values = _should_run(cycle)
+    return _run(values) if should_run else []

hestia_earth/models/cycle/utils.py

@@ -5,7 +5,7 @@ from hestia_earth.models.utils.term import get_lookup_value
 from . import MODEL
 
 
-def _get_liveAnimal_term_id(product: dict, **log_ars):
+def get_liveAnimal_term_id(product: dict, **log_ars):
     term_id = get_lookup_value(product.get('term', {}), 'liveAnimalTermId', model=MODEL, **log_ars)
     return term_id.split(';')[0] if term_id else None