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

openepd/model/common.py

@@ -16,18 +16,23 @@
 from enum import StrEnum
 from typing import Annotated, Any
 
-from openepd.compat.pydantic import pyd
+import pydantic
+import pydantic_core
+
 from openepd.model.base import BaseOpenEpdSchema
-from openepd.model.validation.numbers import RatioFloat
 
 
 class Amount(BaseOpenEpdSchema):
     """A value-and-unit pairing for amounts that do not have an uncertainty."""
 
-    qty: float | None = pyd.Field(description="How much of this in the amount.", ge=0, default=None)
-    unit: str | None = pyd.Field(description="Which unit.  SI units are preferred.", example="kg", default=None)
+    qty: float | None = pydantic.Field(description="How much of this in the amount.", ge=0, default=None)
+    unit: str | None = pydantic.Field(
+        description="Which unit.  SI units are preferred.",
+        examples=["kg"],
+        default=None,
+    )
 
-    @pyd.root_validator
+    @pydantic.model_validator(mode="before")
     def check_qty_or_unit(cls, values: dict[str, Any]):
         """Ensure that qty or unit is provided."""
         if values.get("qty") is None and values.get("unit") is None:
@@ -68,12 +73,13 @@ class Distribution(StrEnum):
 class Measurement(BaseOpenEpdSchema):
     """A scientific value with units and uncertainty."""
 
-    mean: float = pyd.Field(description="Mean (expected) value of the measurement")
-    unit: str | None = pyd.Field(description="Measurement unit")
-    rsd: pyd.PositiveFloat | None = pyd.Field(
-        description="Relative standard deviation, i.e. standard_deviation/mean", default=None
+    mean: float = pydantic.Field(description="Mean (expected) value of the measurement")
+    unit: str | None = pydantic.Field(description="Measurement unit")
+    rsd: pydantic.PositiveFloat | None = pydantic.Field(
+        description="Relative standard deviation, i.e. standard_deviation/mean",
+        default=None,
     )
-    dist: Distribution | None = pyd.Field(
+    dist: Distribution | None = pydantic.Field(
         description="Statistical distribution of the measurement error.", default=None
     )
 
@@ -98,26 +104,29 @@ class Ingredient(BaseOpenEpdSchema):
     gwp_fraction, citation and evidence_type.
     """
 
-    qty: float | None = pyd.Field(
-        description="Number of declared units of this consumed. Negative values indicate an outflow."
+    qty: float | None = pydantic.Field(
+        description="Number of declared units of this consumed. Negative values indicate an outflow.",
+        default=None,
     )
-    link: pyd.AnyUrl | None = pyd.Field(
-        description="Link to this object's OpenEPD declaration. "
-        "An OpenIndustryEPD or OpenLCI link is also acceptable.",
+    link: pydantic.AnyUrl | None = pydantic.Field(
+        description="Link to this object's OpenEPD declaration. An OpenIndustryEPD or OpenLCI link is also acceptable.",
         default=None,
     )
 
-    gwp_fraction: RatioFloat | None = pyd.Field(
+    gwp_fraction: float | None = pydantic.Field(
         default=None,
         description="Fraction of product's A1-A3 GWP this flow represents.  This value, along with the specificity of "
         "the reference, are used to caclulate supply chain specificity.",
+        ge=0,
+        le=1,
     )
-    evidence_type: IngredientEvidenceTypeEnum | None = pyd.Field(
-        default=None, description="Type of evidence used, which can be used to calculate degree of specificity"
+    evidence_type: IngredientEvidenceTypeEnum | None = pydantic.Field(
+        default=None,
+        description="Type of evidence used, which can be used to calculate degree of specificity",
     )
-    citation: str | None = pyd.Field(default=None, description="Text citation describing the data source ")
+    citation: str | None = pydantic.Field(default=None, description="Text citation describing the data source ")
 
-    @pyd.root_validator(skip_on_failure=True)
+    @pydantic.model_validator(mode="before")
     def _validate_evidence(cls, values: dict[str, Any]) -> dict[str, Any]:
         # gwp_fraction should be backed by some type of evidence (fraction coming from product EPD etc) to be accounted
         # for in the calculation of uncertainty
@@ -133,19 +142,20 @@ class Ingredient(BaseOpenEpdSchema):
 class LatLng(BaseOpenEpdSchema):
     """A latitude and longitude."""
 
-    lat: float = pyd.Field(description="Latitude", example=47.6062)
-    lng: float = pyd.Field(description="Longitude", example=-122.3321)
+    lat: float = pydantic.Field(description="Latitude", examples=[47.6062])
+    lng: float = pydantic.Field(description="Longitude", examples=[-122.3321])
 
 
 class Location(BaseOpenEpdSchema):
     """A location on the Earth's surface."""
 
-    pluscode: str | None = pyd.Field(default=None, description="Open Location code of this location")
-    latlng: LatLng | None = pyd.Field(default=None, description="Latitude and longitude of this location")
-    address: str | None = pyd.Field(default=None, description="Text address, preferably geocoded")
-    country: str | None = pyd.Field(default=None, description="2-alpha country code")
-    jurisdiction: str | None = pyd.Field(
-        default=None, description="Province, State, or similar subdivision below the level of a country"
+    pluscode: str | None = pydantic.Field(default=None, description="Open Location code of this location")
+    latlng: LatLng | None = pydantic.Field(default=None, description="Latitude and longitude of this location")
+    address: str | None = pydantic.Field(default=None, description="Text address, preferably geocoded")
+    country: str | None = pydantic.Field(default=None, description="2-alpha country code")
+    jurisdiction: str | None = pydantic.Field(
+        default=None,
+        description="Province, State, or similar subdivision below the level of a country",
     )
 
 
@@ -173,36 +183,69 @@ ATTACHMENT_KNOWN_KEYS: dict[str, str] = {
 }
 
 
-class AttachmentDict(dict[str, pyd.AnyUrl]):
+class AttachmentDict(dict[str, pydantic.AnyUrl]):
     """Special form of dict for attachments."""
 
     @classmethod
-    def __modify_schema__(cls, field_schema: dict[str, Any], field: pyd.fields.ModelField | None):
-        # This may be generalized later to combine, for example, enum descriptions and field descriptions to provide
-        # a better result.
-        field_description = field.field_info.description if field else ""
+    def __get_pydantic_core_schema__(
+        cls, source: type[Any], handler: pydantic.GetCoreSchemaHandler
+    ) -> pydantic_core.core_schema.CoreSchema:
+        return pydantic_core.core_schema.no_info_after_validator_function(
+            cls._validate,
+            pydantic_core.core_schema.dict_schema(),
+            serialization=pydantic_core.core_schema.plain_serializer_function_ser_schema(
+                cls._serialize,
+                info_arg=False,
+                return_schema=pydantic_core.core_schema.dict_schema(),
+            ),
+        )
+
+    @classmethod
+    def _validate(cls, value: Any) -> "AttachmentDict":
+        # Ensure the input is a dict.
+        if not isinstance(value, dict):
+            raise TypeError("AttachmentDict must be a dict")
+
+        return cls(value)
+
+    @classmethod
+    def _serialize(cls, value: "AttachmentDict") -> dict[str, Any]:
+        # Serialize each AnyUrl value to its string representation.
+        return {k: str(v) for k, v in value.items()}
+
+    @classmethod
+    def __get_pydantic_json_schema__(cls, core_schema: dict[str, Any], handler: Any) -> dict[str, Any]:
+        # Obtain the default schema using the handler.
+        schema = handler(core_schema)
+
+        # Get the description from the default schema (if any)
+        field_description = schema.get("description", "")
         if field_description:
             field_description = field_description.strip()
             if not field_description.endswith("."):
                 field_description += "."
             field_description += " "
 
-        field_schema["description"] = field_description + "Extra properties of string -> URL allowed."
-        field_schema["properties"] = {
+        # Update the schema with our custom description and properties.
+        schema["description"] = field_description + "Extra properties of string -> URL allowed."
+        schema["properties"] = {
             k: {"type": "string", "format": "uri", "description": v} for k, v in ATTACHMENT_KNOWN_KEYS.items()
         }
-        field_schema["additionalProperties"] = True
+        schema["additionalProperties"] = True
+        return schema
 
 
-class WithAttachmentsMixin(pyd.BaseModel):
+class WithAttachmentsMixin(pydantic.BaseModel):
     """Mixin for objects that can have attachments."""
 
-    attachments: AttachmentDict = pyd.Field(
+    attachments: AttachmentDict | None = pydantic.Field(
         description="Dict of URLs relevant to this entry",
-        example={
-            "Contact Us": "https://www.c-change-labs.com/en/contact-us/",
-            "LinkedIn": "https://www.linkedin.com/company/c-change-labs/",
-        },
+        examples=[
+            {
+                "Contact Us": "https://www.c-change-labs.com/en/contact-us/",
+                "LinkedIn": "https://www.linkedin.com/company/c-change-labs/",
+            }
+        ],
         default=None,
     )
 
@@ -218,14 +261,16 @@ class WithAttachmentsMixin(pyd.BaseModel):
             self.set_attachment(name, url)
 
 
-class WithAltIdsMixin(pyd.BaseModel):
+class WithAltIdsMixin(pydantic.BaseModel):
     """Mixin for objects that can have alt_ids."""
 
-    alt_ids: dict[Annotated[str, pyd.Field(max_length=200)], str] | None = pyd.Field(
+    alt_ids: dict[Annotated[str, pydantic.Field(max_length=200)], str] | None = pydantic.Field(
         description="Dict identifiers for this entry.",
-        example={
-            "oekobau.dat": "bdda4364-451f-4df2-a68b-5912469ee4c9",
-        },
+        examples=[
+            {
+                "oekobau.dat": "bdda4364-451f-4df2-a68b-5912469ee4c9",
+            }
+        ],
         default=None,
     )
 
@@ -262,7 +307,7 @@ class OpenEPDUnit(StrEnum):
 class RangeBase(BaseOpenEpdSchema):
     """Base class for range types having min and max and order between them."""
 
-    @pyd.root_validator
+    @pydantic.model_validator(mode="before")
     def _validate_range_bounds(cls, values: dict[str, Any]) -> dict[str, Any]:
         min_boundary = values.get("min")
         max_boundary = values.get("max")
@@ -274,28 +319,28 @@ class RangeBase(BaseOpenEpdSchema):
 class RangeFloat(RangeBase):
     """Structure representing a range of floats."""
 
-    min: float | None = pyd.Field(default=None, example=3.1)
-    max: float | None = pyd.Field(default=None, example=5.8)
+    min: float | None = pydantic.Field(default=None, examples=[3.1])
+    max: float | None = pydantic.Field(default=None, examples=[5.8])
 
 
 class RangeInt(RangeBase):
     """Structure representing a range of ints1."""
 
-    min: int | None = pyd.Field(default=None, example=2)
-    max: int | None = pyd.Field(default=None, example=3)
+    min: int | None = pydantic.Field(default=None, examples=[2])
+    max: int | None = pydantic.Field(default=None, examples=[3])
 
 
 class RangeRatioFloat(RangeFloat):
     """Range of ratios (0-1 to 0-10)."""
 
-    min: float | None = pyd.Field(default=None, example=0.2, ge=0, le=1)
-    max: float | None = pyd.Field(default=None, example=0.65, ge=0, le=1)
+    min: float | None = pydantic.Field(default=None, examples=[0.2], ge=0, le=1)
+    max: float | None = pydantic.Field(default=None, examples=[0.65], ge=0, le=1)
 
 
 class RangeAmount(RangeFloat):
     """Structure representing a range of quantities."""
 
-    unit: str | None = pyd.Field(default=None, description="Unit of the range.")
+    unit: str | None = pydantic.Field(default=None, description="Unit of the range.")
 
 
 class EnumGroupingAware:

openepd/model/declaration.py

@@ -17,7 +17,8 @@ import abc
 import datetime
 from enum import StrEnum
 
-from openepd.compat.pydantic import pyd
+import pydantic
+
 from openepd.model.base import BaseOpenEpdSchema, OpenXpdUUID, RootDocument
 from openepd.model.common import Amount
 from openepd.model.geography import Geography
@@ -36,55 +37,60 @@ THIRD_PARTY_VERIFIER_DESCRIPTION = "JSON object for Org that performed a critica
 class BaseDeclaration(RootDocument, abc.ABC):
     """Base class for declaration-related documents (EPDs, Industry-wide EPDs, Generic Estimates)."""
 
-    id: OpenXpdUUID | None = pyd.Field(
+    id: OpenXpdUUID | None = pydantic.Field(
         description="The unique ID for this document.  To ensure global uniqueness, should be registered at "
         "open-xpd-uuid.cqd.io/register or a coordinating registry.",
-        example="1u7zsed8",
+        examples=["1u7zsed8"],
         default=None,
     )
-    date_of_issue: datetime.datetime | None = pyd.Field(
-        example=datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc),
+    date_of_issue: datetime.datetime | None = pydantic.Field(
+        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc)],
         description="Date the document was issued. This should be the first day on which the document is valid.",
+        default=None,
     )
-    valid_until: datetime.datetime | None = pyd.Field(
-        example=datetime.datetime(day=11, month=9, year=2028, tzinfo=datetime.timezone.utc),
+    valid_until: datetime.datetime | None = pydantic.Field(
+        examples=[datetime.datetime(day=11, month=9, year=2028, tzinfo=datetime.timezone.utc)],
         description="Last date the document is valid on, including any extensions.",
+        default=None,
     )
 
-    version: pyd.NonNegativeInt | None = pyd.Field(
+    version: pydantic.NonNegativeInt | None = pydantic.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,
+        examples=[1],
         default=None,
     )
 
-    declared_unit: Amount | None = pyd.Field(
+    declared_unit: Amount | None = pydantic.Field(
         description="SI declared unit for this document.  If a functional unit is "
         "utilized, the declared unit shall refer to the amount of "
-        "product associated with the A1-A3 life cycle stage."
+        "product associated with the A1-A3 life cycle stage.",
+        default=None,
     )
-    kg_per_declared_unit: AmountMass | None = pyd.Field(
+    kg_per_declared_unit: AmountMass | None = pydantic.Field(
         default=None,
         description="Mass of the product, in kilograms, per declared unit",
-        example=Amount(qty=12.5, unit="kg").to_serializable(exclude_unset=True),
+        examples=[Amount(qty=12.5, unit="kg").to_serializable(exclude_unset=True)],
     )
-    compliance: list[Standard] = pyd.Field(
-        description="Standard(s) to which this document is compliant.", default_factory=list
+    compliance: list[Standard] = pydantic.Field(
+        description="Standard(s) to which this document is compliant.",
+        default_factory=list,
     )
 
     # TODO: add product_alt_names? E.g. ILCD has a list of synonymous names
-    product_classes: dict[str, str | list[str]] = pyd.Field(
-        description="List of classifications, including Masterformat and UNSPC", default_factory=dict
+    product_classes: dict[str, str | list[str]] = pydantic.Field(
+        description="List of classifications, including Masterformat and UNSPC",
+        default_factory=dict,
     )
 
-    language: str | None = pyd.Field(
+    language: str | None = pydantic.Field(
         min_length=2,
         max_length=2,
-        strip_whitespace=True,
         description="Language this document is captured in, as an ISO 639-1 code",
-        example="en",
+        examples=["en"],
+        default=None,
     )
-    private: bool | None = pyd.Field(
+    private: bool | None = pydantic.Field(
         default=False,
         description="This document's author does not wish the contents published. "
         "Useful for draft, partial, or confidential declarations.  "
@@ -94,19 +100,20 @@ class BaseDeclaration(RootDocument, abc.ABC):
         "incomplete EPDs.",
     )
 
-    pcr: Pcr | None = pyd.Field(
+    pcr: Pcr | None = pydantic.Field(
         description="JSON object for product category rules. Should point to the "
         "most-specific PCR that applies; the PCR entry should point to any "
         "parent PCR.",
         default=None,
     )
-    lca_discussion: str | None = pyd.Field(
+    lca_discussion: str | None = pydantic.Field(
         max_length=20000,
         description="""A rich text description containing information for experts reviewing the document contents.
-    Text descriptions required by ISO 14025, ISO 21930, EN 15804,, relevant PCRs, or program instructions and which do not
+    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
+        examples=[
+            """# 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
@@ -125,96 +132,118 @@ class BaseDeclaration(RootDocument, abc.ABC):
     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.
-    """,
+    """
+        ],
+        default=None,
     )
 
-    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_small: pydantic.AnyUrl | None = pydantic.Field(
+        description="Pointer to image illustrating the product, which is no more than 200x200 pixels",
+        default=None,
     )
-    product_image: pyd.AnyUrl | pyd.FileUrl | None = pyd.Field(
-        description="pointer to image illustrating the product no more than 10MB", default=None
+    product_image: pydantic.AnyUrl | pydantic.FileUrl | None = pydantic.Field(
+        description="pointer to image illustrating the product no more than 10MB",
+        default=None,
     )
-    declaration_url: str | None = pyd.Field(
+    declaration_url: str | None = pydantic.Field(
         description="Link to data object on original registrar's site",
-        example="https://epd-online.com/EmbeddedEpdList/Download/6029",
+        examples=["https://epd-online.com/EmbeddedEpdList/Download/6029"],
+        default=None,
     )
-    kg_C_per_declared_unit: AmountMass | None = pyd.Field(
+    kg_C_per_declared_unit: AmountMass | None = pydantic.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.",
-        example=Amount(qty=8.76, unit="kgCO2e").to_serializable(exclude_unset=True),
+        examples=[Amount(qty=8.76, unit="kgCO2e").to_serializable(exclude_unset=True)],
     )
-    kg_C_biogenic_per_declared_unit: AmountGWP | None = pyd.Field(
+    kg_C_biogenic_per_declared_unit: AmountGWP | None = pydantic.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.",
-        example=Amount(qty=8.76, unit="kgCO2e").to_serializable(exclude_unset=True),
+        examples=[Amount(qty=8.76, unit="kgCO2e").to_serializable(exclude_unset=True)],
     )
-    product_service_life_years: float | None = pyd.Field(
+    product_service_life_years: float | None = pydantic.Field(
         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).",
-        example=50.0,
+        examples=[50.0],
+        default=None,
     )
 
+    @pydantic.field_validator("language", mode="before")
+    def strip_language(cls, value: str | None) -> str | None:
+        """Strip whitespace from language."""
+        if isinstance(value, str):
+            return value.strip()
+        return value
+
 
-class AverageDatasetMixin(pyd.BaseModel, title="Average Dataset"):
+class AverageDatasetMixin(pydantic.BaseModel, title="Average Dataset"):
     """Fields common for average dataset (Industry-wide EPDs, Generic Estimates)."""
 
-    description: str | None = pyd.Field(
+    description: str | None = pydantic.Field(
         max_length=2000,
         description="1-paragraph description of the average dataset. Supports plain text or github flavored markdown.",
+        default=None,
     )
 
-    geography: list[Geography] | None = pyd.Field(
+    geography: list[Geography] | None = pydantic.Field(
         description="Jurisdiction(s) in which the LCA result is applicable.  An empty array, or absent properties, "
         "implies global applicability.",
+        default=None,
     )
 
-    specs: SpecsRange | None = pyd.Field(
-        default=None, description="Average dataset material performance specifications."
+    specs: SpecsRange | None = pydantic.Field(
+        default=None,
+        description="Average dataset material performance specifications.",
     )
 
 
-class WithProgramOperatorMixin(pyd.BaseModel):
+class WithProgramOperatorMixin(pydantic.BaseModel):
     """Object which has a connection to ProgramOperator."""
 
-    program_operator: Org | None = pyd.Field(description=PROGRAM_OPERATOR_DESCRIPTION)
-    program_operator_doc_id: str | None = pyd.Field(
-        max_length=200, description="Document identifier from Program Operator.", example="123-456.789/b"
+    program_operator: Org | None = pydantic.Field(description=PROGRAM_OPERATOR_DESCRIPTION, default=None)
+    program_operator_doc_id: str | None = pydantic.Field(
+        max_length=200,
+        description="Document identifier from Program Operator.",
+        examples=["123-456.789/b"],
+        default=None,
     )
-    program_operator_version: str | None = pyd.Field(
-        max_length=200, description="Document version number from Program Operator.", example="4.3.0"
+    program_operator_version: str | None = pydantic.Field(
+        max_length=200, description="Document version number from Program Operator.", examples=["4.3.0"], default=None
     )
 
 
-class WithVerifierMixin(pyd.BaseModel):
+class WithVerifierMixin(pydantic.BaseModel):
     """Set of fields related to verifier."""
 
-    third_party_verifier: Org | None = pyd.Field(description=THIRD_PARTY_VERIFIER_DESCRIPTION)
-    third_party_verification_url: pyd.AnyUrl | None = pyd.Field(
+    third_party_verifier: Org | None = pydantic.Field(description=THIRD_PARTY_VERIFIER_DESCRIPTION, default=None)
+    third_party_verification_url: pydantic.AnyUrl | None = pydantic.Field(
         description="Optional link to a verification statement.",
-        example="https://we-verify-epds.com/en/letters/123-456.789b.pdf",
+        examples=["https://we-verify-epds.com/en/letters/123-456.789b.pdf"],
+        default=None,
     )
-    third_party_verifier_email: pyd.EmailStr | None = pyd.Field(
-        description="Email address of the third party verifier", example="john.doe@example.com", default=None
+    third_party_verifier_email: pydantic.EmailStr | None = pydantic.Field(
+        description="Email address of the third party verifier",
+        examples=["john.doe@example.com"],
+        default=None,
     )
 
 
-class WithEpdDeveloperMixin(pyd.BaseModel):
+class WithEpdDeveloperMixin(pydantic.BaseModel):
     """Set of fields related to EPD Developer."""
 
-    epd_developer: Org | None = pyd.Field(
+    epd_developer: Org | None = pydantic.Field(
         description=DEVELOPER_DESCRIPTION,
         default=None,
     )
-    epd_developer_email: pyd.EmailStr | None = pyd.Field(
+    epd_developer_email: pydantic.EmailStr | None = pydantic.Field(
         default=None,
-        example="john.doe@we-do-lca.com",
+        examples=["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.",
     )
@@ -223,18 +252,18 @@ class WithEpdDeveloperMixin(pyd.BaseModel):
 class RefBase(BaseOpenEpdSchema, title="Ref Object"):
     """Base class for reference-style objects."""
 
-    id: OpenXpdUUID | None = pyd.Field(
+    id: OpenXpdUUID | None = pydantic.Field(
         description="The unique ID for this object. To ensure global uniqueness, should be registered at "
         "open-xpd-uuid.cqd.io/register or a coordinating registry.",
-        example="1u7zsed8",
+        examples=["1u7zsed8"],
         default=None,
     )
 
-    name: str | None = pyd.Field(max_length=200, description="Name of the object", default=None)
+    name: str | None = pydantic.Field(max_length=200, description="Name of the object", default=None)
 
-    ref: ReferenceStr | None = pyd.Field(
+    ref: ReferenceStr | None = pydantic.Field(
         default=None,
-        example="https://openepd.buildingtransparency.org/api/generic_estimates/EC300001",
+        examples=["https://openepd.buildingtransparency.org/api/generic_estimates/EC300001"],
         description="Reference to this JSON object",
     )