openepd 6.13.2__py3-none-any.whl → 7.0.1__py3-none-any.whl

openepd/model/lcia.py

@@ -16,7 +16,10 @@
 from enum import StrEnum
 from typing import Any, ClassVar
 
-from openepd.compat.pydantic import pyd
+import pydantic
+from pydantic import ConfigDict
+from typing_extensions import Self
+
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Measurement
 from openepd.model.validation.quantity import ExternalValidationConfig
@@ -30,34 +33,34 @@ class EolScenario(BaseOpenEpdSchema):
     otherwise the outcomes can be statistically combined.
     """
 
-    name: str = pyd.Field(
+    name: str = pydantic.Field(
         max_length=40,
-        example="Landfill",
+        examples=["Landfill"],
         description="A brief text description of the scenario, preferably from list eol_scenario_names",
     )
-    likelihood: float | None = pyd.Field(
+    likelihood: float | None = pydantic.Field(
         description="The weigting of this scenario used in the C1 .. C4 dataset. For example, the overall C1 shoudl be "
         "equal to weighted sum of C1 from all the scenarios, weighted by likelihood.",
-        example=0.33,
+        examples=[0.33],
         default=None,
     )
-    C1: Measurement | None = pyd.Field(
+    C1: Measurement | None = pydantic.Field(
         description="Deconstruction and Demolition under this scenario",
         default=None,
     )
-    C2: Measurement | None = pyd.Field(
+    C2: Measurement | None = pydantic.Field(
         description="Transport to waste processing or disposal under this scenario.",
         default=None,
     )
-    C3: Measurement | None = pyd.Field(
+    C3: Measurement | None = pydantic.Field(
         description="Waste Processing under this scenario",
         default=None,
     )
-    C4: Measurement | None = pyd.Field(
+    C4: Measurement | None = pydantic.Field(
         description="Disposal under this scenario",
         default=None,
     )
-    D: Measurement | None = pyd.Field(
+    D: Measurement | None = pydantic.Field(
         description="Potential net benefits from reuse, recycling, and/or energy recovery beyond "
         "the system boundary under this scenario",
         default=None,
@@ -74,35 +77,35 @@ class ScopeSet(BaseOpenEpdSchema):
 
     allowed_units: ClassVar[str | tuple[str, ...] | None] = None
 
-    A1A2A3: Measurement | None = pyd.Field(
+    A1A2A3: Measurement | None = pydantic.Field(
         description="Sum of A1..A3",
         default=None,
     )
-    A1: Measurement | None = pyd.Field(
+    A1: Measurement | None = pydantic.Field(
         description="Raw Material Supply",
         default=None,
     )
-    A2: Measurement | None = pyd.Field(
+    A2: Measurement | None = pydantic.Field(
         description="Transport to Manufacturing",
         default=None,
     )
-    A3: Measurement | None = pyd.Field(
+    A3: Measurement | None = pydantic.Field(
         description="Manufacturing",
         default=None,
     )
-    A4: Measurement | None = pyd.Field(
+    A4: Measurement | None = pydantic.Field(
         description="Transport to Construction",
         default=None,
     )
-    A5: Measurement | None = pyd.Field(
+    A5: Measurement | None = pydantic.Field(
         description="Construction",
         default=None,
     )
-    B1: Measurement | None = pyd.Field(
+    B1: Measurement | None = pydantic.Field(
         description="Use impacts over Reference Service Life (Predicted)",
         default=None,
     )
-    B1_years: float | None = pyd.Field(
+    B1_years: float | None = pydantic.Field(
         gt=0,
         lt=100,
         description="Timeframe over which B1 is evaluated, in years. "
@@ -110,103 +113,106 @@ class ScopeSet(BaseOpenEpdSchema):
         "B1_years=1.0 or  B1=12.3kgCO2e, B1_years=10.0",
         default=None,
     )
-    B2: Measurement | None = pyd.Field(
+    B2: Measurement | None = pydantic.Field(
         description="Predicted Maintenance Impacts over Reference Service Life",
         default=None,
     )
-    B2_years: float | None = pyd.Field(
+    B2_years: float | None = pydantic.Field(
         gt=0,
         lt=100,
         description="Predicted Maintenance Impacts over Reference Service Life",
         default=None,
     )
-    B3: Measurement | None = pyd.Field(
+    B3: Measurement | None = pydantic.Field(
         description="Predicted Repair impacts over Reference Service Life",
         default=None,
     )
-    B3_years: float | None = pyd.Field(
+    B3_years: float | None = pydantic.Field(
         gt=0,
         lt=100,
         description="Timeframe over which B3 is evaluated, in years",
         default=None,
     )
-    B4: Measurement | None = pyd.Field(
+    B4: Measurement | None = pydantic.Field(
         description="Predicted Replacement Impacts over the Building lifetime "
         "('Estimated Construction Works lifespan') specified in the PCR.",
         default=None,
     )
-    B4_years: float | None = pyd.Field(
+    B4_years: float | None = pydantic.Field(
         gt=0,
         lt=100,
         description="Timeframe over which B4 is evaluated, in years",
         default=None,
     )
-    B5: Measurement | None = pyd.Field(
+    B5: Measurement | None = pydantic.Field(
         description="Predicted Refurbishment Impacts over the Building lifetime "
         "('Estimated Construction Works lifespan') specified in the PCR.",
         default=None,
     )
-    B5_years: float | None = pyd.Field(
+    B5_years: float | None = pydantic.Field(
         gt=0,
         lt=100,
         description="Timeframe over which B5 is evaluated, in years",
         default=None,
     )
-    B6: Measurement | None = pyd.Field(
+    B6: Measurement | None = pydantic.Field(
         description="Predicted Impacts related to Operational Energy Use",
         default=None,
     )
-    B6_years: float | None = pyd.Field(
+    B6_years: float | None = pydantic.Field(
         gt=0,
         lt=100,
         description="Timeframe over which B6 is evaluated, in years",
         default=None,
     )
-    B7: Measurement | None = pyd.Field(
+    B7: Measurement | None = pydantic.Field(
         description="Predicted Impacts related to Operational Water Use",
         default=None,
     )
-    B7_years: float | None = pyd.Field(
+    B7_years: float | None = pydantic.Field(
         gt=0,
         lt=100,
         description="Timeframe over which B7 is evaluated, in years",
         default=None,
     )
-    C_scenarios: list[EolScenario] | None = pyd.Field(
+    C_scenarios: list[EolScenario] | None = pydantic.Field(
         description="A list of possible end-of-life scenarios, "
         "for use in analyses where the end-of-life can be predicted.",
         default=None,
     )
-    C1: Measurement | None = pyd.Field(
+    C1: Measurement | None = pydantic.Field(
         description="Deconstruction and Demolition",
         default=None,
     )
-    C2: Measurement | None = pyd.Field(
+    C2: Measurement | None = pydantic.Field(
         description="Transport to waste processing or disposal.",
         default=None,
     )
-    C3: Measurement | None = pyd.Field(
+    C3: Measurement | None = pydantic.Field(
         description="Waste Processing",
         default=None,
     )
-    C4: Measurement | None = pyd.Field(
+    C4: Measurement | None = pydantic.Field(
         description="Disposal",
         default=None,
     )
-    D: Measurement | None = pyd.Field(
+    D: Measurement | None = pydantic.Field(
         default=None,
         description="Potential net benefits from reuse, recycling, and/or energy recovery beyond the system boundary.",
     )
 
-    @pyd.root_validator
-    def _unit_validator(cls, values: dict[str, Any]) -> dict[str, Any]:
+    model_config = pydantic.ConfigDict(from_attributes=True)
+
+    @pydantic.model_validator(mode="after")
+    def _unit_validator(self) -> Self:
         all_units = set()
 
-        for k, v in values.items():
+        for k in self.model_fields:
+            v = getattr(self, k, None)
             if isinstance(v, Measurement):
                 all_units.add(v.unit)
 
-        if not cls.allowed_units:
+        if not self.allowed_units:
             # For unknown units - only units should be the same across all measurements (textually)
             if len(all_units) > 1:
                 raise ValueError("All scopes and measurements should be expressed in the same unit.")
@@ -219,9 +225,9 @@ class ScopeSet(BaseOpenEpdSchema):
                     ExternalValidationConfig.QUANTITY_VALIDATOR.validate_same_dimensionality(first, unit)
 
         # can correctly validate unit
-        if cls.allowed_units is not None and len(all_units) == 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:
+        if self.allowed_units is not None and len(all_units) == 1 and ExternalValidationConfig.QUANTITY_VALIDATOR:
             unit = next(iter(all_units))
-            allowed_units = cls.allowed_units if isinstance(cls.allowed_units, tuple) else (cls.allowed_units,)
+            allowed_units = self.allowed_units if isinstance(self.allowed_units, tuple) else (self.allowed_units,)
 
             matched_unit = False
             for allowed_unit in allowed_units:
@@ -235,7 +241,7 @@ class ScopeSet(BaseOpenEpdSchema):
                     f"'{', '.join(allowed_units)}' is only allowed unit for this scopeset. Provided '{unit}'"
                 )
 
-        return values
+        return self
 
 
 class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
@@ -273,11 +279,11 @@ class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
         # probably unknown impact, coming from 'extra' fields
         return getattr(self, name, None)
 
-    @pyd.root_validator(skip_on_failure=True)
+    @pydantic.model_validator(mode="before")
     def _extra_scopeset_validator(cls, values: dict[str, Any]) -> dict[str, Any]:
         for f in values:
             # only interested in validating the extra fields
-            if f in cls.__fields__:
+            if f in cls.model_fields:
                 continue
 
             # extra impact of an unknown type - engage validation of ScopeSet
@@ -296,125 +302,132 @@ class ScopesetByNameBase(BaseOpenEpdSchema, extra="allow"):
 class ScopeSetGwp(ScopeSet):
     """ScopeSet measured in kgCO2e."""
 
-    allowed_units = "kgCO2e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgCO2e"
 
 
 class ScopeSetOdp(ScopeSet):
     """ScopeSet measured in kgCFC11e."""
 
-    allowed_units = "kgCFC11e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgCFC11e"
 
 
 class ScopeSetAp(ScopeSet):
     """ScopeSet measured in kgSO2e."""
 
-    allowed_units = ("kgSO2e", "molHe")
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = ("kgSO2e", "molHe")
 
 
 class ScopeSetEpNe(ScopeSet):
     """ScopeSet measured in kgNe."""
 
-    allowed_units = "kgNe"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgNe"
 
 
 class ScopeSetPocp(ScopeSet):
     """ScopeSet measured in kgO3e."""
 
-    allowed_units = ("kgO3e", "kgNMVOCe")
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = ("kgO3e", "kgNMVOCe")
 
 
 class ScopeSetEpFresh(ScopeSet):
     """ScopeSet measured in kgPO4e."""
 
-    allowed_units = "kgPO4e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kgPO4e"
 
 
 class ScopeSetEpTerr(ScopeSet):
     """ScopeSet measured in molNe."""
 
-    allowed_units = "molNe"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "molNe"
 
 
 class ScopeSetIrp(ScopeSet):
     """ScopeSet measured in kilo Becquerel equivalent of u235."""
 
-    allowed_units = "kBqU235e"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kBqU235e"
 
 
 class ScopeSetCTUh(ScopeSet):
     """ScopeSet measured in CTUh."""
 
-    allowed_units = "CTUh"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "CTUh"
 
 
 class ScopeSetM3Aware(ScopeSet):
     """ScopeSet measured in m3AWARE Water consumption by AWARE method."""
 
-    allowed_units = "m3AWARE"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "m3AWARE"
 
 
 class ScopeSetCTUe(ScopeSet):
     """ScopeSet measured in CTUe."""
 
-    allowed_units = "CTUe"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "CTUe"
 
 
 class ScopeSetDiseaseIncidence(ScopeSet):
     """ScopeSet measuring disease incidence measured in AnnualPerCapita (cases)."""
 
-    allowed_units = "AnnualPerCapita"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "AnnualPerCapita"
 
 
 class ScopeSetMass(ScopeSet):
     """ScopeSet measuring mass in kg."""
 
-    allowed_units = "kg"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "kg"
 
 
 class ScopeSetVolume(ScopeSet):
     """ScopeSet measuring mass in kg."""
 
-    allowed_units = "m3"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "m3"
 
 
 class ScopeSetMassOrVolume(ScopeSet):
     """ScopeSet measuring mass in kg OR volume in m3, example: radioactive waste."""
 
-    allowed_units = ("kg", "m3")
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = ("kg", "m3")
 
 
 class ScopeSetEnergy(ScopeSet):
     """ScopeSet measuring mass in kg."""
 
-    allowed_units = "MJ"
+    allowed_units: ClassVar[str | tuple[str, ...] | None] = "MJ"
 
 
 class ImpactSet(ScopesetByNameBase):
     """A set of impacts, such as GWP, ODP, AP, EP, POCP, EP-marine, EP-terrestrial, EP-freshwater, etc."""
 
-    gwp: ScopeSetGwp | None = pyd.Field(
+    gwp: ScopeSetGwp | None = pydantic.Field(
         default=None,
         description="GWP100, calculated per IPCC guidelines.  If any CO2 removals are "
         "part of this figure, the gwp-fossil, gwp-bioganic, gwp-luluc, an "
         "gwp-nonCO2 fields are required, as is "
         "kg_C_biogenic_per_declared_unit.",
     )
-    odp: ScopeSetOdp | None = pyd.Field(default=None, description="Ozone Depletion Potential")
-    ap: ScopeSetAp | None = pyd.Field(default=None, description="Acidification Potential")
-    ep: ScopeSetEpNe | None = pyd.Field(
-        default=None, description="Eutrophication Potential in Marine Ecosystems. Has the same meaning as ep-marine."
+    odp: ScopeSetOdp | None = pydantic.Field(default=None, description="Ozone Depletion Potential")
+    ap: ScopeSetAp | None = pydantic.Field(default=None, description="Acidification Potential")
+    ep: ScopeSetEpNe | None = pydantic.Field(
+        default=None,
+        description="Eutrophication Potential in Marine Ecosystems. Has the same meaning as ep-marine.",
+    )
+    pocp: ScopeSetPocp | None = pydantic.Field(
+        default=None, description="Photochemical Smog (Ozone) creation potential"
     )
-    pocp: ScopeSetPocp | None = pyd.Field(default=None, description="Photochemical Smog (Ozone) creation potential")
-    ep_marine: ScopeSetEpNe | None = pyd.Field(
+    ep_marine: ScopeSetEpNe | None = pydantic.Field(
         alias="ep-marine", default=None, description="Has the same meaning as 'ep'"
     )
-    ep_fresh: ScopeSetEpFresh | None = pyd.Field(
-        alias="ep-fresh", default=None, description="Eutrophication Potential in Freshwater Ecosystems"
+    ep_fresh: ScopeSetEpFresh | None = pydantic.Field(
+        alias="ep-fresh",
+        default=None,
+        description="Eutrophication Potential in Freshwater Ecosystems",
     )
-    ep_terr: ScopeSetEpTerr | None = pyd.Field(
-        alias="ep-terr", default=None, description="Eutrophication Potential in Terrestrial Ecosystems"
+    ep_terr: ScopeSetEpTerr | None = pydantic.Field(
+        alias="ep-terr",
+        default=None,
+        description="Eutrophication Potential in Terrestrial Ecosystems",
     )
-    gwp_biogenic: ScopeSetGwp | None = pyd.Field(
+    gwp_biogenic: ScopeSetGwp | None = pydantic.Field(
         alias="gwp-biogenic",
         default=None,
         description="Net GWP from removals of atmospheric CO2 into biomass and  emissions of CO2 from biomass sources. "
@@ -423,7 +436,7 @@ class ImpactSet(ScopesetByNameBase):
         "space (similar biome).  They must not have been sold, committed, or credited to any other "
         "product.  Harvesting from native forests is handled under GWP_luluc for EN15804.",
     )
-    gwp_luluc: ScopeSetGwp | None = pyd.Field(
+    gwp_luluc: ScopeSetGwp | None = pydantic.Field(
         alias="gwp-luluc",
         default=None,
         description="Climate change effects related to land use and land use change, for example biogenic carbon "
@@ -431,50 +444,52 @@ class ImpactSet(ScopesetByNameBase):
         "emissions). All related emissions for native forests are included under this category. "
         "Uptake for native forests is set to 0 kgCO2 for EN15804.",
     )
-    gwp_nonCO2: ScopeSetGwp | None = pyd.Field(
+    gwp_nonCO2: ScopeSetGwp | None = pydantic.Field(
         alias="gwp-nonCO2",
         default=None,
         description="GWP from non-CO2, non-fossil sources, such as livestock-sourced CH4 and agricultural N2O.",
     )
-    gwp_fossil: ScopeSetGwp | None = pyd.Field(
+    gwp_fossil: ScopeSetGwp | None = pydantic.Field(
         alias="gwp-fossil",
         default=None,
         description="Climate change effects due to greenhouse gas emissions originating from the oxidation or "
         "reduction of fossil fuels or materials containing fossil carbon. [Source: EN15804]",
     )
-    WDP: ScopeSetM3Aware | None = pyd.Field(
+    WDP: ScopeSetM3Aware | None = pydantic.Field(
         default=None,
         description="Deprivation-weighted water consumption, calculated by the AWARE method "
         "(https://wulca-waterlca.org/aware/what-is-aware)",
     )
-    PM: ScopeSetDiseaseIncidence | None = pyd.Field(
+    PM: ScopeSetDiseaseIncidence | None = pydantic.Field(
         default=None,
         description="Potential incidence of disease due to particulate matter emissions.",
     )
-    IRP: ScopeSetIrp | None = pyd.Field(
+    IRP: ScopeSetIrp | None = pydantic.Field(
         default=None,
         description="Potential ionizing radiation effect on human health, relative to U235.",
     )
-    ETP_fw: ScopeSetCTUe | None = pyd.Field(
+    ETP_fw: ScopeSetCTUe | None = pydantic.Field(
         alias="ETP-fw",
         default=None,
         description="Ecotoxicity in freshwater, in potential Comparative Toxic Unit for ecosystems.",
     )
-    HTP_c: ScopeSetCTUh | None = pyd.Field(
+    HTP_c: ScopeSetCTUh | None = pydantic.Field(
         alias="HTP-c",
         default=None,
         description="Human toxicity, cancer effects in potential Comparative Toxic Units for humans.",
     )
-    HTP_nc: ScopeSetCTUh | None = pyd.Field(
+    HTP_nc: ScopeSetCTUh | None = pydantic.Field(
         alias="HTP-nc",
         default=None,
         description="Human toxicity, noncancer effects in potential Comparative Toxic Units for humans.",
     )
-    SQP: ScopeSet | None = pyd.Field(
+    SQP: ScopeSet | None = pydantic.Field(
         default=None,
         description="Land use related impacts / Soil quality, in potential soil quality parameters.",
     )
 
+    model_config = pydantic.ConfigDict(from_attributes=True)
+
 
 class LCIAMethod(StrEnum):
     """A list of available LCA methods."""
@@ -520,24 +535,31 @@ class LCIAMethod(StrEnum):
             return cls.UNKNOWN
 
 
-class Impacts(pyd.BaseModel):
+class Impacts(pydantic.RootModel[dict[LCIAMethod, ImpactSet]]):
     """List of environmental impacts, compiled per one of the standard Impact Assessment methods."""
 
-    class Config:
-        # pydantic schema generator gets lost in this structure, so we need to re-establish it manually for openapi
-        schema_extra = {
-            "properties": {
-                str(lm): {"description": str(lm), "allOf": [{"$ref": "#/components/schemas/ImpactSet"}]}
-                for lm in LCIAMethod
-            },
-            "additionalProperties": None,
-        }
-
-    __root__: dict[LCIAMethod, ImpactSet]
+    @staticmethod
+    def _update_schema_extra(schema, model):
+        schema.update(
+            {
+                "properties": {
+                    str(lm): {
+                        "description": str(lm),
+                        # This is an internal representation of the reference which exists in Pydantic during
+                        # generation process
+                        "allOf": [{"$ref": "#/components/schemas/openepd__model__lcia__ImpactSet-Input__1"}],
+                    }
+                    for lm in LCIAMethod
+                },
+                "additionalProperties": None,
+            }
+        )
+
+    model_config: ClassVar[ConfigDict] = ConfigDict(json_schema_extra=_update_schema_extra)
 
     def set_unknown_lcia(self, impact_set: ImpactSet):
         """Set the impact set as an unknown LCIA method."""
-        self.__root__[LCIAMethod.UNKNOWN] = impact_set
+        self.root[LCIAMethod.UNKNOWN] = impact_set
 
     def set_impact_set(self, lcia_method: LCIAMethod | str | None, impact_set: ImpactSet):
         """
@@ -550,7 +572,7 @@ class Impacts(pyd.BaseModel):
         else:
             if isinstance(lcia_method, str):
                 lcia_method = LCIAMethod.get_by_name(lcia_method)
-            self.__root__[lcia_method] = impact_set
+            self.root[lcia_method] = impact_set
 
     def replace_lcia_method(self, lcia_method: LCIAMethod, new_lcia_method: LCIAMethod) -> None:
         """
@@ -562,95 +584,95 @@ class Impacts(pyd.BaseModel):
         if impact_set is None:
             return None
         self.set_impact_set(new_lcia_method, impact_set)
-        del self.__root__[lcia_method]
+        del self.root[lcia_method]
 
     def get_impact_set(
         self, lcia_method: LCIAMethod | str | None, default_val: ImpactSet | None = None
     ) -> ImpactSet | None:
         """Return the impact set for the given LCIA method."""
         if lcia_method is None:
-            return self.__root__.get(LCIAMethod.UNKNOWN, default_val)
+            return self.root.get(LCIAMethod.UNKNOWN, default_val)
         if isinstance(lcia_method, str):
             lcia_method = LCIAMethod.get_by_name(lcia_method)
-        return self.__root__.get(lcia_method, default_val)
+        return self.root.get(lcia_method, default_val)
 
     def available_methods(self) -> set[LCIAMethod]:
         """Return a list of available LCIA methods."""
-        return set(self.__root__.keys())
+        return set(self.root.keys())
 
     def as_dict(self) -> dict[LCIAMethod, ImpactSet]:
         """Return the impacts as a dictionary."""
-        return self.__root__
+        return self.root
 
 
 class ResourceUseSet(ScopesetByNameBase):
     """A set of resource use indicators, such as RPRec, RPRm, etc."""
 
-    RPRec: ScopeSetEnergy | None = pyd.Field(
+    RPRec: ScopeSetEnergy | None = pydantic.Field(
         description="Renewable primary resources used as energy carrier (fuel). "
         "First use bio-based materials used as an energy source. Hydropower, solar and wind power used "
         "in the technosphere are also included in this indicator",
         default=None,
     )
-    RPRm: ScopeSetEnergy | None = pyd.Field(
+    RPRm: ScopeSetEnergy | None = pydantic.Field(
         description="Renewable primary resources with energy content used as material. "
         "First use biobased materials used as materials (e.g. wood, hemp, etc.).",
         default=None,
     )
-    rpre: ScopeSetEnergy | None = pyd.Field(
+    rpre: ScopeSetEnergy | None = pydantic.Field(
         description="Renewable primary energy resources as energy",
         default=None,
     )
-    nrpre: ScopeSetEnergy | None = pyd.Field(
+    nrpre: ScopeSetEnergy | None = pydantic.Field(
         description="Non-renewable primary resources as energy (fuel)",
         default=None,
     )
-    nrprm: ScopeSetEnergy | None = pyd.Field(
+    nrprm: ScopeSetEnergy | None = pydantic.Field(
         description="Non-renewable primary resources as material",
         default=None,
     )
-    fw: ScopeSetVolume | None = pyd.Field(
+    fw: ScopeSetVolume | None = pydantic.Field(
         description="Use of net fresh water",
         default=None,
     )
-    sm: ScopeSetMass | None = pyd.Field(
+    sm: ScopeSetMass | None = pydantic.Field(
         description="Use of secondary materials",
         default=None,
     )
-    rsf: ScopeSetEnergy | None = pyd.Field(
+    rsf: ScopeSetEnergy | None = pydantic.Field(
         description="Use of renewable secondary materials",
         default=None,
     )
-    nrsf: ScopeSetEnergy | None = pyd.Field(
+    nrsf: ScopeSetEnergy | None = pydantic.Field(
         description="Use of non-renewable secondary fuels",
         default=None,
     )
-    re: ScopeSetEnergy | None = pyd.Field(
+    re: ScopeSetEnergy | None = pydantic.Field(
         description="Renewable energy resources",
         default=None,
     )
-    pere: ScopeSetEnergy | None = pyd.Field(
+    pere: ScopeSetEnergy | None = pydantic.Field(
         description="Use of renewable primary energy excluding renewable primary energy resources used as raw materials",
         default=None,
     )
-    perm: ScopeSetEnergy | None = pyd.Field(
+    perm: ScopeSetEnergy | None = pydantic.Field(
         description="Use of renewable primary energy resources used as raw materials",
         default=None,
     )
-    pert: ScopeSetEnergy | None = pyd.Field(
+    pert: ScopeSetEnergy | None = pydantic.Field(
         description="Total use of renewable primary energy resources",
         default=None,
     )
-    penre: ScopeSetEnergy | None = pyd.Field(
+    penre: ScopeSetEnergy | None = pydantic.Field(
         description="Use of non-renewable primary energy excluding "
         "non-renewable primary energy resources used as raw materials",
         default=None,
     )
-    penrm: ScopeSetEnergy | None = pyd.Field(
+    penrm: ScopeSetEnergy | None = pydantic.Field(
         description="Use of non-renewable primary energy resources used as raw materials",
         default=None,
     )
-    penrt: ScopeSetEnergy | None = pyd.Field(
+    penrt: ScopeSetEnergy | None = pydantic.Field(
         description="Total use of non-renewable primary energy resources",
         default=None,
     )
@@ -659,51 +681,51 @@ class ResourceUseSet(ScopesetByNameBase):
 class OutputFlowSet(ScopesetByNameBase):
     """A set of output flows, such as waste, emissions, etc."""
 
-    twd: ScopeSetMass | None = pyd.Field(
+    twd: ScopeSetMass | None = pydantic.Field(
         description="Total waste disposed",
         default=None,
     )
-    hwd: ScopeSetMass | None = pyd.Field(
+    hwd: ScopeSetMass | None = pydantic.Field(
         description="Hazardous waste disposed",
         default=None,
     )
-    nhwd: ScopeSetMass | None = pyd.Field(
+    nhwd: ScopeSetMass | None = pydantic.Field(
         description="Non-hazardous waste disposed",
         default=None,
     )
-    rwd: ScopeSetMass | None = pyd.Field(
+    rwd: ScopeSetMass | None = pydantic.Field(
         description="Radioactive waste disposed",
         default=None,
     )
-    hlrw: ScopeSetMassOrVolume | None = pyd.Field(
+    hlrw: ScopeSetMassOrVolume | None = pydantic.Field(
         description="High level radioactive waste disposed",
         default=None,
     )
-    illrw: ScopeSetMassOrVolume | None = pyd.Field(
+    illrw: ScopeSetMassOrVolume | None = pydantic.Field(
         description="Intermediate level radioactive waste disposed",
         default=None,
     )
-    cru: ScopeSetMass | None = pyd.Field(
+    cru: ScopeSetMass | None = pydantic.Field(
         description="Components for re-use",
         default=None,
     )
-    mr: ScopeSetMass | None = pyd.Field(
+    mr: ScopeSetMass | None = pydantic.Field(
         description="Recycled materials",
         default=None,
     )
-    mfr: ScopeSetMass | None = pyd.Field(
+    mfr: ScopeSetMass | None = pydantic.Field(
         description="Materials for recycling",
         default=None,
     )
-    mer: ScopeSetMass | None = pyd.Field(
+    mer: ScopeSetMass | None = pydantic.Field(
         description="Materials for energy recovery",
         default=None,
     )
-    ee: ScopeSetEnergy | None = pyd.Field(
+    ee: ScopeSetEnergy | None = pydantic.Field(
         description="Exported energy",
         default=None,
     )
-    eh: ScopeSetEnergy | None = pyd.Field(
+    eh: ScopeSetEnergy | None = pydantic.Field(
         description="Exported heat",
         default=None,
     )
@@ -712,16 +734,19 @@ class OutputFlowSet(ScopesetByNameBase):
 class WithLciaMixin(BaseOpenEpdSchema):
     """Mixin for LCIA data."""
 
-    impacts: Impacts | None = pyd.Field(
+    impacts: Impacts | None = pydantic.Field(
         description="List of environmental impacts, compiled per one of the standard Impact Assessment methods",
-        example={"TRACI 2.1": {"gwp": {"A1A2A3": {"mean": 22.4, "unit": "kgCO2e"}}}},
+        examples=[{"TRACI 2.1": {"gwp": {"A1A2A3": {"mean": 22.4, "unit": "kgCO2e"}}}}],
+        default=None,
     )
-    resource_uses: ResourceUseSet | None = pyd.Field(
+    resource_uses: ResourceUseSet | None = pydantic.Field(
         description="Set of Resource Use Indicators, over various LCA scopes",
-        example={"RPRe": {"A1A2A3": {"mean": 12, "unit": "MJ", "rsd": 0.12}}},
+        examples=[{"RPRe": {"A1A2A3": {"mean": 12, "unit": "MJ", "rsd": 0.12}}}],
+        default=None,
     )
-    output_flows: OutputFlowSet | None = pyd.Field(
+    output_flows: OutputFlowSet | None = pydantic.Field(
         description="Set of Waste and Output Flow indicators which describe the waste categories "
         "and other material output flows derived from the LCI.",
-        example={"hwd": {"A1A2A3": {"mean": 2300, "unit": "kg", "rsd": 0.22}}},
+        examples=[{"hwd": {"A1A2A3": {"mean": 2300, "unit": "kg", "rsd": 0.22}}}],
+        default=None,
     )