openepd 2.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

openepd/model/epd.py

@@ -1,5 +1,5 @@
 #
-#  Copyright 2023 by C Change Labs Inc. www.c-change-labs.com
+#  Copyright 2024 by C Change Labs Inc. www.c-change-labs.com
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -20,42 +20,48 @@
 import datetime
 from typing import Annotated
 
-import pydantic as pyd
-
-from openepd.model.base import BaseOpenEpdSchema
+from openepd.compat.pydantic import pyd
+from openepd.model.base import BaseDocumentFactory, RootDocument
 from openepd.model.common import Amount, Ingredient, WithAltIdsMixin, WithAttachmentsMixin
 from openepd.model.lcia import Impacts, OutputFlowSet, ResourceUseSet
 from openepd.model.org import Org, Plant
 from openepd.model.pcr import Pcr
 from openepd.model.specs import Specs
 from openepd.model.standard import Standard
+from openepd.model.versioning import OpenEpdVersions, Version
+
+
+class BaseEpd(RootDocument):
+    """
+    Base class for EPD documents.
 
+    This class should not be used directly.  Use Epd or EpdVx instead.
+    """
+
+    pass
 
-class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
+
+class EpdV0(WithAttachmentsMixin, WithAltIdsMixin, BaseEpd):
     """Represent an EPD."""
 
+    _FORMAT_VERSION = OpenEpdVersions.Version0.as_str()
+
     # TODO: Add validator for open-xpd-uuid on this field
     id: str | None = pyd.Field(
         description="The unique ID for this EPD.  To ensure global uniqueness, should be registered at "
         "open-xpd-uuid.cqd.io/register or a coordinating registry.",
+        example="1u7zsed8",
         default=None,
-        json_schema_extra=dict(example="1u7zsed8"),
-    )
-    doctype: str = pyd.Field(
-        description='Describes the type and schema of the document. Must always always read "openEPD".',
-        default="OpenEPD",
     )
     product_name: str | None = pyd.Field(
-        max_length=200,
-        description="The name of the product described by this EPD",
-        json_schema_extra=dict(example="Mix 12345AC"),
+        max_length=200, description="The name of the product described by this EPD", example="Mix 12345AC", default=None
     )
     product_sku: str | None = pyd.Field(
-        default=None, max_length=200, description="Unique stock keeping identifier assigned by manufacturer"
+        max_length=200, description="Unique stock keeping identifier assigned by manufacturer"
     )
     product_description: str | None = pyd.Field(
         max_length=2000,
-        description="1-paragraph description of product. " "Supports plain text or github flavored markdown.",
+        description="1-paragraph description of product. Supports plain text or github flavored markdown.",
     )
     # TODO: add product_alt_names? E.g. ILCD has a list of synonymous names
     product_classes: dict[str, str | list[str]] = pyd.Field(
@@ -64,21 +70,21 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
     product_image_small: pyd.AnyUrl | None = pyd.Field(
         description="Pointer to image illustrating the product, which is no more than 200x200 pixels", default=None
     )
-    product_image: pyd.AnyUrl | None = pyd.Field(
+    product_image: pyd.AnyUrl | pyd.FileUrl | None = pyd.Field(
         description="pointer to image illustrating the product no more than 10MB", default=None
     )
     version: pyd.PositiveInt | None = pyd.Field(
         description="Version of this document. The document's issuer should increment it anytime even a single "
         "character changes, as this value is used to determine the most recent version.",
+        example=1,
         default=None,
-        json_schema_extra=dict(example=1),
     )
     language: str | None = pyd.Field(
-        default=None,
         min_length=2,
         max_length=2,
+        strip_whitespace=True,
         description="Language this EPD is captured in, as an ISO 639-1 code",
-        json_schema_extra=dict(example="en"),
+        example="en",
     )
     private: bool = pyd.Field(
         default=False,
@@ -89,66 +95,53 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         "number of required fields, to allow for multiple systems to coordinate "
         "incomplete EPDs.",
     )
-    declaration_url: pyd.AnyUrl | None = pyd.Field(
-        default=None,
+    declaration_url: str | None = pyd.Field(
         description="Link to data object on original registrar's site",
-        json_schema_extra=dict(example="https://epd-online.com/EmbeddedEpdList/Download/6029"),
+        example="https://epd-online.com/EmbeddedEpdList/Download/6029",
     )
     manufacturer: Org | None = pyd.Field(
-        default=None,
         description="JSON object for declaring Org. Sometimes called the "
-        '"Declaration Holder" or "Declaration Owner".',
+        '"Declaration Holder" or "Declaration Owner".'
     )
     epd_developer: Org | None = pyd.Field(
-        default=None,
         description="The organization responsible for the underlying LCA (and subsequent summarization as EPD).",
+        default=None,
     )
     epd_developer_email: pyd.EmailStr | None = pyd.Field(
         default=None,
+        example="john.doe@we-do-lca.com",
         description="Email contact for inquiries about development of this EPD. "
         "This must be an email which can be publicly shared.",
-        json_schema_extra=dict(example="john.doe@we-do-lca.com"),
     )
     plants: list[Plant] = pyd.Field(
-        max_length=32,
+        max_items=32,
         description="List of object(s) for one or more plant(s) that this declaration applies to.",
         default_factory=list,
     )
     program_operator: Org | None = pyd.Field(description="JSON object for program operator Org")
     program_operator_doc_id: str | None = pyd.Field(
-        default=None,
-        max_length=200,
-        description="Document identifier from Program Operator.",
-        json_schema_extra=dict(example="123-456.789/b"),
+        max_length=200, description="Document identifier from Program Operator.", example="123-456.789/b"
     )
     program_operator_version: str | None = pyd.Field(
-        default=None,
-        max_length=200,
-        description="Document version number from Program Operator.",
-        json_schema_extra=dict(example="4.3.0"),
+        max_length=200, description="Document version number from Program Operator.", example="4.3.0"
     )
     third_party_verifier: Org | None = pyd.Field(
-        default=None, description="JSON object for Org that performed a critical review of the EPD data"
+        description="JSON object for Org that performed a critical review of the EPD data"
     )
     third_party_verification_url: pyd.AnyUrl | None = pyd.Field(
-        default=None,
         description="Optional link to a verification statement.",
-        json_schema_extra=dict(example="https://we-verify-epds.com/en/letters/123-456.789b.pdf"),
+        example="https://we-verify-epds.com/en/letters/123-456.789b.pdf",
     )
     third_party_verifier_email: pyd.EmailStr | None = pyd.Field(
-        description="Email address of the third party verifier",
-        default=None,
-        json_schema_extra=dict(example="john.doe@example.com"),
+        description="Email address of the third party verifier", example="john.doe@example.com", default=None
     )
-    date_of_issue: datetime.date | None = pyd.Field(
-        default=None,
+    date_of_issue: datetime.datetime | None = pyd.Field(
+        example=datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc),
         description="Date the EPD was issued. This should be the first day on which the EPD is valid.",
-        json_schema_extra=dict(example=datetime.date(day=11, month=9, year=2019)),
     )
-    valid_until: datetime.date | None = pyd.Field(
-        default=None,
+    valid_until: datetime.datetime | None = pyd.Field(
+        example=datetime.datetime(day=11, month=9, year=2028, tzinfo=datetime.timezone.utc),
         description="Last date the EPD is valid on, including any extensions.",
-        json_schema_extra=dict(example=datetime.date(day=11, month=9, year=2028)),
     )
     pcr: Pcr | None = pyd.Field(
         description="JSON object for product category rules. Should point to the "
@@ -164,30 +157,29 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
     kg_per_declared_unit: Amount | None = pyd.Field(
         default=None,
         description="Mass of the product, in kilograms, per declared unit",
-        json_schema_extra=dict(example=Amount(qty=12.5, unit="kg")),
+        example=Amount(qty=12.5, unit="kg"),
     )
     kg_C_per_declared_unit: Amount | None = pyd.Field(
         default=None,
         description="Mass of elemental carbon, per declared unit, contained in the product itself at the manufacturing "
         "facility gate.  Used (among other things) to check a carbon balance or calculate incineration "
         "emissions.  The source of carbon (e.g. biogenic) is not relevant in this field.",
-        json_schema_extra=dict(example=Amount(qty=8.76, unit="kg")),
+        example=Amount(qty=8.76, unit="kg"),
     )
     kg_C_biogenic_per_declared_unit: Amount | None = pyd.Field(
         default=None,
         description="Mass of elemental carbon from biogenic sources, per declared unit, contained in the product "
         "itself at the manufacturing facility gate.  It may be presumed that any biogenic carbon content "
         "has been accounted for as -44/12 kgCO2e per kg C in stages A1-A3, per EN15804 and ISO 21930.",
-        json_schema_extra=dict(example=Amount(qty=8.76, unit="kg")),
+        example=Amount(qty=8.76, unit="kg"),
     )
     product_service_life_years: float | None = pyd.Field(
-        default=None,
         gt=0.0009,
         lt=101,
         description="Reference service life of the product, in years.  Serves as a maximum for replacement interval, "
         "which may also be constrained by usage or the service life of what the product goes into "
         "(e.g. a building).",
-        json_schema_extra=dict(example=50.0),
+        example=50.0,
     )
     annual_production: float | None = pyd.Field(
         gt=0,
@@ -197,14 +189,18 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         "Providing this data is optional, and it is acceptable to round or obfuscate it downwards "
         "(but not upwards) by any amount desired to protect confidentiality. For example, if the "
         "product volume is 123,456 m3, a value of 120,000, 100,000 or even 87,654 would be acceptable.",
-        json_schema_extra=dict(example=10000),
+        example=10000,
     )
     applicable_in: list[Annotated[str, pyd.Field(min_length=2, max_length=2)]] | None = pyd.Field(
-        max_length=100,
+        max_items=100,
         default=None,
         description="Jurisdiction(s) in which EPD is applicable. An empty array, or absent properties, "
-        "implies global applicability.",
-        json_schema_extra=dict(example=["US", "CA", "MX"]),
+        "implies global applicability. Accepts "
+        "[2-letter country codes](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2), "
+        "[M49 region codes](https://unstats.un.org/unsd/methodology/m49/), "
+        'or the alias "EU27" for the 27 members of the Euro bloc, or the alias "NAFTA" '
+        "for the members of North American Free Trade Agreement",
+        example=["US", "CA", "MX", "EU27", "NAFTA"],
     )
     product_usage_description: str | None = pyd.Field(
         default=None,
@@ -239,41 +235,64 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         description="Data structure(s) describing performance specs of product. Unique for each material type.",
     )
     includes: list[Ingredient] = pyd.Field(
-        max_length=255,
+        max_items=255,
         description="List of JSON objects pointing to product components. "
         "Each one should be an EPD or digitized LCI process.",
         default_factory=list,
     )
     lca_discussion: str | None = pyd.Field(
         max_length=20000,
-        description="""A rich text description containing information for experts reviewing the EPD contents. 
-Text descriptions required by ISO 14025, ISO 21930, EN 15804,, relevant PCRs, or program instructions and which do not 
-have specific openEPD fields should be entered here.  This field may be large, and may contain multiple sections 
-separated by github flavored markdown formatting.""",
-        json_schema_extra=dict(
-            example="""# Packaging
-Information on product-specific packaging: type, composition and possible reuse of packaging materials (paper, 
-strapping, pallets, foils, drums, etc.) shall be included in this Section. The EPD shall describe specific packaging 
-scenario assumptions, including disposition pathways for each packaging material by reuse, recycling, or landfill 
-disposal based on packaging type.*
+        description="""A rich text description containing information for experts reviewing the EPD contents.
+    Text descriptions required by ISO 14025, ISO 21930, EN 15804,, relevant PCRs, or program instructions and which do not
+    have specific openEPD fields should be entered here.  This field may be large, and may contain multiple sections
+    separated by github flavored markdown formatting.""",
+        example="""# Packaging
 
-# Product Installation
+    Information on product-specific packaging: type, composition and possible reuse of packaging materials (paper,
+    strapping, pallets, foils, drums, etc.) shall be included in this Section. The EPD shall describe specific packaging
+    scenario assumptions, including disposition pathways for each packaging material by reuse, recycling, or landfill
+    disposal based on packaging type.*
 
-A description of the type of processing, machinery, tools, dust extraction equipment, auxiliary materials, etc. 
-to be used during installation shall be included. Information on industrial and environmental protection may be 
-included in this section. Any waste treatment included within the system boundary of installation waste should be 
-specified.
+    # Product Installation
 
-# Use Conditions
+    A description of the type of processing, machinery, tools, dust extraction equipment, auxiliary materials, etc.
+    to be used during installation shall be included. Information on industrial and environmental protection may be
+    included in this section. Any waste treatment included within the system boundary of installation waste should be
+    specified.
 
-Use-stage environmental impacts of flooring products during building operations depend on product cleaning assumptions. 
-Information on cleaning frequency and cleaning products shall be provided based on the manufacturer’s recommendations. 
-In the absence of primary data, cleaning assumptions shall be documented.
-    """
-        ),
+    # Use Conditions
+
+    Use-stage environmental impacts of flooring products during building operations depend on product cleaning assumptions.
+    Information on cleaning frequency and cleaning products shall be provided based on the manufacturer’s recommendations.
+    In the absence of primary data, cleaning assumptions shall be documented.
+    """,
     )
 
     @classmethod
     def get_asset_type(cls) -> str | None:
         """Return the asset type of this class (see BaseOpenEpdSchema.get_asset_type for details)."""
         return "epd"
+
+    @pyd.validator("compliance", always=True, pre=True)
+    def validate_compliance(cls, v: list | None):
+        """Handle correctly None values for compliance field."""
+        if v is None:
+            return []
+        return v
+
+    @pyd.validator("includes", always=True, pre=True)
+    def validate_includes(cls, v: list | None):
+        """Handle correctly None values for includes field."""
+        if v is None:
+            return []
+        return v
+
+
+Epd = EpdV0
+
+
+class EpdFactory(BaseDocumentFactory[BaseEpd]):
+    """Factory for EPD objects."""
+
+    DOCTYPE_CONSTRAINT = "openEPD"
+    VERSION_MAP: dict[Version, type[BaseEpd]] = {OpenEpdVersions.Version0: EpdV0}

openepd/model/factory.py

@@ -0,0 +1,48 @@
+#
+#  Copyright 2024 by C Change Labs Inc. www.c-change-labs.com
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+#
+#  This software was developed with support from the Skanska USA,
+#  Charles Pankow Foundation, Microsoft Sustainability Fund, Interface, MKA Foundation, and others.
+#  Find out more at www.BuildingTransparency.org
+#
+from openepd.model.base import BaseDocumentFactory, OpenEpdDoctypes, RootDocument
+from openepd.model.epd import EpdFactory
+
+
+class DocumentFactory:
+    """A factory for creating documents regardless of the type."""
+
+    DOCTYPE_TO_FACTORY: dict[str, type[BaseDocumentFactory]] = {
+        OpenEpdDoctypes.Epd: EpdFactory,
+    }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> RootDocument:
+        """
+        Create a document from the dictionary.
+
+        Type of the document will be recognized from the `doctype` field.
+        :raise ValueError: if the document type is not specified or not supported.
+        """
+        doctype = data.get("doctype")
+        if doctype is None:
+            raise ValueError("The document type is not specified.")
+        factory = cls.DOCTYPE_TO_FACTORY.get(doctype)
+        if factory is None:
+            raise ValueError(
+                f"The document of type `{doctype}` is not supported. Supported documents are: "
+                + ", ".join(cls.DOCTYPE_TO_FACTORY.keys())
+            )
+        return factory.from_dict(data)

openepd/model/lcia.py

@@ -1,5 +1,5 @@
 #
-#  Copyright 2023 by C Change Labs Inc. www.c-change-labs.com
+#  Copyright 2024 by C Change Labs Inc. www.c-change-labs.com
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -19,8 +19,7 @@
 #
 from enum import StrEnum
 
-import pydantic as pyd
-
+from openepd.compat.pydantic import pyd
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Measurement
 
@@ -35,14 +34,14 @@ class EolScenario(BaseOpenEpdSchema):
 
     name: str = pyd.Field(
         max_length=40,
+        example="Landfill",
         description="A brief text description of the scenario, preferably from list eol_scenario_names",
-        json_schema_extra=dict(example="Landfill"),
     )
     likelihood: float | None = pyd.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,
         default=None,
-        json_schema_extra=dict(example=0.33),
     )
     C1: Measurement | None = pyd.Field(
         description="Deconstruction and Demolition under this scenario",
@@ -296,14 +295,14 @@ class LCIAMethod(StrEnum):
             return cls.UNKNOWN
 
 
-class Impacts(pyd.RootModel):
+class Impacts(pyd.BaseModel):
     """List of environmental impacts, compiled per one of the standard Impact Assessment methods."""
 
-    root: dict[LCIAMethod, ImpactSet]
+    __root__: dict[LCIAMethod, ImpactSet]
 
     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):
         """
@@ -316,25 +315,37 @@ class Impacts(pyd.RootModel):
         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:
+        """
+        Replace the LCIA method.
+
+        If the there is no impact set for the given LCIA method, do nothing.
+        """
+        impact_set = self.get_impact_set(lcia_method)
+        if impact_set is None:
+            return None
+        self.set_impact_set(new_lcia_method, impact_set)
+        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(BaseOpenEpdSchema):

openepd/model/org.py

@@ -1,5 +1,5 @@
 #
-#  Copyright 2023 by C Change Labs Inc. www.c-change-labs.com
+#  Copyright 2024 by C Change Labs Inc. www.c-change-labs.com
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -19,14 +19,14 @@
 #
 from typing import Annotated, Optional
 
-import pydantic as pyd
-
+from openepd.compat.pydantic import pyd
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Location, WithAltIdsMixin, WithAttachmentsMixin
+from openepd.model.validation.common import ReferenceStr
 
 
-class Org(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
-    """Represent an organization."""
+class OrgRef(BaseOpenEpdSchema):
+    """Represents Organisation with minimal data."""
 
     web_domain: str | None = pyd.Field(
         description="A web domain owned by organization. Typically is the org's home website address", default=None
@@ -34,20 +34,31 @@ class Org(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
     name: str | None = pyd.Field(
         max_length=200,
         description="Common name for organization",
+        example="C Change Labs",
+        default=None,
+    )
+    ref: ReferenceStr | None = pyd.Field(
         default=None,
-        json_schema_extra=dict(example="C Change Labs"),
+        example="https://buildingtransparency.org/ec3/epds/1u7zsed8",
+        description="Reference to this Org's JSON object",
     )
-    alt_names: Annotated[list[str], pyd.conlist(pyd.constr(max_length=200), max_length=255)] | None = pyd.Field(
+
+
+class Org(WithAttachmentsMixin, WithAltIdsMixin, OrgRef):
+    """Represent an organization."""
+
+    alt_names: Annotated[list[str], pyd.conlist(pyd.constr(max_length=200), max_items=255)] | None = pyd.Field(
         description="List of other names for organization",
+        example=["C-Change Labs", "C-Change Labs inc."],
         default=None,
-        json_schema_extra=dict(example=["C-Change Labs", "C-Change Labs inc."]),
     )
     # TODO: NEW field, not in the spec
+
     owner: Optional["Org"] = pyd.Field(description="Organization that controls this organization", default=None)
-    subsidiaries: Annotated[list[str], pyd.conlist(pyd.constr(max_length=200), max_length=255)] | None = pyd.Field(
+    subsidiaries: Annotated[list[str], pyd.conlist(pyd.constr(max_length=200), max_items=255)] | None = pyd.Field(
         description="Organizations controlled by this organization",
+        example=["cqd.io", "supplychaincarbonpricing.org"],
         default=None,
-        json_schema_extra=dict(example=["cqd.io", "supplychaincarbonpricing.org"]),
     )
     hq_location: Location | None = pyd.Field(
         default=None,
@@ -58,36 +69,35 @@ class Org(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
 class Plant(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
     """Represent a manufacturing plant."""
 
-    model_config = pyd.ConfigDict(populate_by_name=True)
-
     # TODO: Add proper validator
     id: str | None = pyd.Field(
         description="Plus code (aka Open Location Code) of plant's location and "
         "owner's web domain joined with `.`(dot).",
+        example="865P2W3V+3W.interface.com",
         alias="pluscode",
         default=None,
-        json_schema_extra=dict(example="865P2W3V+3W.interface.com"),
     )
     owner: Org | None = pyd.Field(description="Organization that owns the plant", default=None)
     name: str | None = pyd.Field(
         max_length=200,
         description="Manufacturer's name for plant. Recommended < 40 chars",
+        example="Dalton, GA",
         default=None,
-        json_schema_extra=dict(example="Dalton, GA"),
     )
     address: str | None = pyd.Field(
         max_length=200,
         default=None,
         description="Text address, preferably geocoded",
-        json_schema_extra=dict(example="1503 Orchard Hill Rd, LaGrange, GA 30240, United States"),
+        example="1503 Orchard Hill Rd, LaGrange, GA 30240, United States",
     )
     contact_email: pyd.EmailStr | None = pyd.Field(
-        description="Email contact",
-        default=None,
-        json_schema_extra=dict(example="info@interface.com"),
+        description="Email contact", example="info@interface.com", default=None
     )
 
     @classmethod
     def get_asset_type(cls) -> str | None:
         """Return the asset type of this class (see BaseOpenEpdSchema.get_asset_type for details)."""
         return "org"
+
+    class Config(BaseOpenEpdSchema.Config):
+        allow_population_by_field_name = True