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

openepd/model/org.py

@@ -13,11 +13,12 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
-from typing import Annotated, Optional
+from typing import Any, Optional
 
 from openlocationcode import openlocationcode
+import pydantic
+from pydantic import ConfigDict
 
-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
@@ -26,18 +27,19 @@ from openepd.model.validation.common import ReferenceStr
 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
+    web_domain: str | None = pydantic.Field(
+        description="A web domain owned by organization. Typically is the org's home website address",
+        default=None,
     )
-    name: str | None = pyd.Field(
+    name: str | None = pydantic.Field(
         max_length=200,
         description="Common name for organization",
-        example="C Change Labs",
+        examples=["C Change Labs"],
         default=None,
     )
-    ref: ReferenceStr | None = pyd.Field(
+    ref: ReferenceStr | None = pydantic.Field(
         default=None,
-        example="https://openepd.buildingtransparency.org/api/orgs/c-change-labs.com",
+        examples=["https://openepd.buildingtransparency.org/api/orgs/c-change-labs.com"],
         description="Reference to this Org's JSON object",
     )
 
@@ -45,19 +47,47 @@ class OrgRef(BaseOpenEpdSchema):
 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(
+    alt_names: list[str] | None = pydantic.Field(
         description="List of other names for organization",
-        example=["C-Change Labs", "C-Change Labs inc."],
+        examples=[["C-Change Labs", "C-Change Labs inc."]],
         default=None,
+        max_length=255,
     )
     # TODO: NEW field, not in the spec
 
-    owner: Optional["OrgRef"] = pyd.Field(description="Organization that controls this organization", default=None)
-    subsidiaries: Annotated[list["OrgRef"], pyd.conlist(pyd.constr(max_length=200), max_items=255)] | None = pyd.Field(
-        description="Organizations controlled by this organization",
-        default=None,
+    @pydantic.field_validator("alt_names", mode="before")
+    def _validate_alt_names(cls, value: Any) -> list[str] | None:
+        if value is None:
+            return value
+
+        if not isinstance(value, list):
+            raise TypeError(f"Expected type list or None, got {type(value)}")
+
+        if any((len(item) > 200) for item in value):
+            raise ValueError("One or more alt_names are longer than 200 characters")
+
+        return value
+
+    owner: Optional["OrgRef"] = pydantic.Field(description="Organization that controls this organization", default=None)
+    subsidiaries: list["OrgRef"] | None = pydantic.Field(
+        description="Organizations controlled by this organization", default=None, max_length=255
     )
-    hq_location: Location | None = pyd.Field(
+
+    @pydantic.field_validator("subsidiaries", mode="before")
+    def _validate_subsidiaries(cls, value: Any) -> list[str] | None:
+        if value is None:
+            return value
+
+        if not isinstance(value, list):
+            raise TypeError(f"Expected type list or None, got {type(value)}")
+
+        for item in value:
+            if len(item.name) > 200:
+                raise ValueError("One or more subsidiaries name are longer than 200 characters")
+
+        return value
+
+    hq_location: Location | None = pydantic.Field(
         default=None,
         description="Location of a place of business, preferably the corporate headquarters.",
     )
@@ -66,21 +96,21 @@ class Org(WithAttachmentsMixin, WithAltIdsMixin, OrgRef):
 class PlantRef(BaseOpenEpdSchema):
     """Represents Plant with minimal data."""
 
-    id: str | None = pyd.Field(
+    id: str | None = pydantic.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",
+        examples=["865P2W3V+3W.interface.com"],
         default=None,
     )
-    name: str | None = pyd.Field(
+    name: str | None = pydantic.Field(
         max_length=200,
         description="Manufacturer's name for plant. Recommended < 40 chars",
-        example="Dalton, GA",
+        examples=["Dalton, GA"],
         default=None,
     )
-    ref: ReferenceStr | None = pyd.Field(
+    ref: ReferenceStr | None = pydantic.Field(
         default=None,
-        example="https://openepd.buildingtransparency.org/api/orgs/c-change-labs.com",
+        examples=["https://openepd.buildingtransparency.org/api/orgs/c-change-labs.com"],
         description="Reference to this Plant's JSON object",
     )
 
@@ -88,36 +118,40 @@ class PlantRef(BaseOpenEpdSchema):
 class Plant(PlantRef, WithAttachmentsMixin, WithAltIdsMixin):
     """Represent a manufacturing plant."""
 
-    pluscode: str | None = pyd.Field(
+    pluscode: str | None = pydantic.Field(
         default=None,
         description="(deprecated) Plus code (aka Open Location Code) of plant's location",
-        deprecated="Pluscode field is deprecated. If users need a pluscode they can obtain it from "
-        "`id` like this: `id.spit('.', maxsplit=1)[0]`",
+        json_schema_extra={
+            "deprecated": "Pluscode field is deprecated. If users need a pluscode they can obtain it from "
+            "`id` like this: `id.spit('.', maxsplit=1)[0]`",
+        },
     )
-    latitude: float | None = pyd.Field(
-        default=None, description="(deprecated) Latitude of the plant location. Use 'location' fields instead."
+    latitude: float | None = pydantic.Field(
+        default=None,
+        description="(deprecated) Latitude of the plant location. Use 'location' fields instead.",
     )
-    longitude: float | None = pyd.Field(
-        default=None, description="(deprecated) Longitude of the plant location. Use 'location' fields instead."
+    longitude: float | None = pydantic.Field(
+        default=None,
+        description="(deprecated) Longitude of the plant location. Use 'location' fields instead.",
     )
-    owner: Org | None = pyd.Field(description="Organization that owns the plant", default=None)
-    address: str | None = pyd.Field(
+    owner: Org | None = pydantic.Field(description="Organization that owns the plant", default=None)
+    address: str | None = pydantic.Field(
         max_length=200,
         default=None,
         description="(deprecated) Text address, preferably geocoded. Use 'location' fields instead",
-        example="1503 Orchard Hill Rd, LaGrange, GA 30240, United States",
+        examples=["1503 Orchard Hill Rd, LaGrange, GA 30240, United States"],
     )
-    contact_email: pyd.EmailStr | None = pyd.Field(
-        description="Email contact", example="info@interface.com", default=None
+    contact_email: pydantic.EmailStr | None = pydantic.Field(
+        description="Email contact", examples=["info@interface.com"], default=None
     )
-    location: Location | None = pyd.Field(description="Location of the plant", default=None)
+    location: Location | None = pydantic.Field(description="Location of the plant", 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"
 
-    @pyd.validator("id")
+    @pydantic.field_validator("id")
     def _validate_id(cls, v: str) -> str:
         if not v:
             return v
@@ -133,5 +167,4 @@ class Plant(PlantRef, WithAttachmentsMixin, WithAltIdsMixin):
             raise ValueError("Incorrect web_domain for plant")
         return v
 
-    class Config(BaseOpenEpdSchema.Config):
-        allow_population_by_field_name = True
+    model_config = ConfigDict(populate_by_name=True)

openepd/model/pcr.py

@@ -17,7 +17,8 @@ import datetime
 from enum import StrEnum
 from typing import Annotated, Optional
 
-from openepd.compat.pydantic import pyd
+import pydantic
+
 from openepd.model.base import BaseOpenEpdSchema, OpenXpdUUID
 from openepd.model.common import Amount, WithAltIdsMixin, WithAttachmentsMixin
 from openepd.model.org import Org
@@ -36,87 +37,92 @@ class PcrStatus(StrEnum):
 class PcrRef(BaseOpenEpdSchema):
     """Reference to a PCR."""
 
-    id: OpenXpdUUID | None = pyd.Field(
+    id: OpenXpdUUID | None = pydantic.Field(
         description="The unique ID for this PCR.  To ensure global uniqueness, should be registered "
         "at open-xpd-uuid.cqd.io/register or a coordinating registry.",
-        example="ec3xpgq2",
+        examples=["ec3xpgq2"],
         default=None,
     )
-    name: str | None = pyd.Field(
+    name: str | None = pydantic.Field(
         max_length=200,
         description="Full document name as listed in source document",
-        example="c-PCR-003 Concrete and concrete elements (EN 16757)",
+        examples=["c-PCR-003 Concrete and concrete elements (EN 16757)"],
     )
-    ref: pyd.AnyUrl | None = pyd.Field(
+    ref: pydantic.AnyUrl | None = pydantic.Field(
         description="Reference to this PCR's JSON object",
-        example="https://openepd.buildingtransparency.org/api/pcrs/1u7zsed8",
+        examples=["https://openepd.buildingtransparency.org/api/pcrs/1u7zsed8"],
     )
 
 
 class Pcr(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
     """Represent a PCR (Product Category Rules)."""
 
-    id: OpenXpdUUID | None = pyd.Field(
+    id: OpenXpdUUID | None = pydantic.Field(
         description="The unique ID for this PCR.  To ensure global uniqueness, should be registered "
         "at open-xpd-uuid.cqd.io/register or a coordinating registry.",
-        example="ec3xpgq2",
+        examples=["ec3xpgq2"],
         default=None,
     )
-    issuer: Org | None = pyd.Field(description="Organization issuing this PCR", default=None)
-    issuer_doc_id: str | None = pyd.Field(
+    issuer: Org | None = pydantic.Field(description="Organization issuing this PCR", default=None)
+    issuer_doc_id: str | None = pydantic.Field(
         max_length=40,
         default=None,
         description="Document ID or code created by issuer",
-        example="c-PCR-003",
+        examples=["c-PCR-003"],
     )
-    name: str | None = pyd.Field(
+    name: str | None = pydantic.Field(
         max_length=200,
         default=None,
         description="Full document name as listed in source document",
-        example="c-PCR-003 Concrete and concrete elements (EN 16757)",
+        examples=["c-PCR-003 Concrete and concrete elements (EN 16757)"],
     )
-    short_name: str | None = pyd.Field(
+    short_name: str | None = pydantic.Field(
         default=None,
         description="A shortened name without boilerplate text.",
-        example="Concrete and Concrete Elements",
+        examples=["Concrete and Concrete Elements"],
     )
-    declared_units: list[Amount] | None = pyd.Field(
+    declared_units: list[Amount] | None = pydantic.Field(
         description="SI declared units for this PCR.  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,
     )
-    version: str | None = pyd.Field(
+    version: str | None = pydantic.Field(
         description="Document version, as expressed in document.",
-        example="1.0.2",
+        examples=["1.0.2"],
         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)],
         default=None,
         description="First day on which the document is valid",
     )
-    valid_until: datetime.datetime | None = pyd.Field(
-        example=datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc),
+    valid_until: datetime.datetime | None = pydantic.Field(
+        examples=[datetime.datetime(day=11, month=9, year=2019, tzinfo=datetime.timezone.utc)],
         default=None,
         description="Last day on which the document is valid",
     )
-    doc: str | None = pyd.Field(default=None, description="URL to original document, preferably directly to a PDF.")
-    parent: Optional["Pcr"] = pyd.Field(
+    doc: str | None = pydantic.Field(
+        default=None,
+        description="URL to original document, preferably directly to a PDF.",
+    )
+    parent: Optional["Pcr"] = pydantic.Field(
         description="The parent PCR, base PCR, `Part A` PCR",
         default=None,
     )
-    status: PcrStatus | None = pyd.Field(
+    status: PcrStatus | None = pydantic.Field(
         default=None,
         description="The current release status of this PCR. "
         "A PCR with valid_until in the past must have status Expired or Sunset; a PCR with valid_until "
         "more than 5 years in the past must have status Sunset. Compliant systems should automatically "
         "update these fields within 24 hours.",
     )
-    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,
     )
-    applicable_in: list[Annotated[str, pyd.Field(min_length=2, max_length=2)]] | None = pyd.Field(
-        max_items=100,
+    applicable_in: list[Annotated[str, pydantic.Field(min_length=2, max_length=2)]] | None = pydantic.Field(
+        max_length=100,
         default=None,
         description="Jurisdiction(s) in which EPD is applicable. An empty array, or absent properties, "
         "implies global applicability. Accepts "
@@ -124,7 +130,7 @@ class Pcr(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         "[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"],
+        examples=[["US", "CA", "MX", "EU27", "NAFTA"]],
     )
 
     @classmethod

openepd/model/specs/asphalt.py

@@ -15,10 +15,10 @@
 #
 from enum import StrEnum
 
-from openepd.compat.pydantic import pyd
+import pydantic
+
 from openepd.model.common import OpenEPDUnit
 from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
-from openepd.model.validation.numbers import RatioFloat
 from openepd.model.validation.quantity import LengthMmStr, TemperatureCStr, validate_quantity_unit_factory
 
 
@@ -45,42 +45,51 @@ class AsphaltV1(BaseOpenEpdHierarchicalSpec):
 
     _EXT_VERSION = "1.1"
 
-    asphalt_aggregate_size_max: LengthMmStr | None = pyd.Field(
-        default=None, example="5mm", description="Max aggregate size"
+    asphalt_aggregate_size_max: LengthMmStr | None = pydantic.Field(
+        default=None, examples=["5mm"], description="Max aggregate size"
     )
 
-    asphalt_rap: RatioFloat | None = pyd.Field(
-        default=None, description="Percent of mixture that has been replaced by recycled " "asphalt pavement (RAP)."
+    asphalt_rap: float | None = pydantic.Field(
+        default=None,
+        description="Percent of mixture that has been replaced by recycled " "asphalt pavement (RAP).",
+        ge=0,
+        le=1,
     )
-    asphalt_ras: RatioFloat | None = pyd.Field(
-        default=None, description="Percent of mixture that has been replaced by recycled " "asphalt shingles (RAS)."
+    asphalt_ras: float | None = pydantic.Field(
+        default=None,
+        description="Percent of mixture that has been replaced by recycled " "asphalt shingles (RAS).",
+        ge=0,
+        le=1,
     )
-    asphalt_ground_tire_rubber: RatioFloat | None = pyd.Field(
-        default=None, description="Percent of mixture that has been replaced " "by ground tire rubber (GTR)."
+    asphalt_ground_tire_rubber: float | None = pydantic.Field(
+        default=None,
+        description="Percent of mixture that has been replaced " "by ground tire rubber (GTR).",
+        ge=0,
+        le=1,
     )
 
-    asphalt_max_temperature: TemperatureCStr | None = pyd.Field(
+    asphalt_max_temperature: TemperatureCStr | None = pydantic.Field(
         default=None,
         description="The upper threshold temperature to which an asphalt "
         "binder can be heated preventing the asphalt mixture "
         "from rutting",
     )
-    asphalt_min_temperature: TemperatureCStr | None = pyd.Field(
+    asphalt_min_temperature: TemperatureCStr | None = pydantic.Field(
         default=None,
         description="The lower threshold temperature for an asphalt "
         "binder to prevent thermal cracking of the asphalt"
         " mixture.",
     )
 
-    asphalt_mix_type: AsphaltMixType | None = pyd.Field(default=None, description="Asphalt mix type")
-    asphalt_gradation: AsphaltGradation | None = pyd.Field(default=None, description="Asphalt gradation")
+    asphalt_mix_type: AsphaltMixType | None = pydantic.Field(default=None, description="Asphalt mix type")
+    asphalt_gradation: AsphaltGradation | None = pydantic.Field(default=None, description="Asphalt gradation")
 
-    asphalt_sbr: bool | None = pyd.Field(default=None, description="Styrene-butadiene rubber (SBR)")
-    asphalt_sbs: bool | None = pyd.Field(default=None, description="Styrene-butadiene-styrene (SBS)")
-    asphalt_ppa: bool | None = pyd.Field(default=None, description="Polyphosphoric acid (PPA)")
-    asphalt_gtr: bool | None = pyd.Field(default=None, description="Ground tire rubber (GTR)")
-    asphalt_pmb: bool | None = pyd.Field(default=None, description="Polymer modified bitumen (PMB)")
+    asphalt_sbr: bool | None = pydantic.Field(default=None, description="Styrene-butadiene rubber (SBR)")
+    asphalt_sbs: bool | None = pydantic.Field(default=None, description="Styrene-butadiene-styrene (SBS)")
+    asphalt_ppa: bool | None = pydantic.Field(default=None, description="Polyphosphoric acid (PPA)")
+    asphalt_gtr: bool | None = pydantic.Field(default=None, description="Ground tire rubber (GTR)")
+    asphalt_pmb: bool | None = pydantic.Field(default=None, description="Polymer modified bitumen (PMB)")
 
-    _aggregate_size_max_validator = pyd.validator("asphalt_aggregate_size_max", allow_reuse=True)(
-        validate_quantity_unit_factory(OpenEPDUnit.m)
-    )
+    @pydantic.field_validator("asphalt_aggregate_size_max", mode="before")
+    def _aggregate_size_max_validator(cls, value):
+        return validate_quantity_unit_factory(OpenEPDUnit.m)(cls, value)

openepd/model/specs/base.py

@@ -17,23 +17,25 @@ import dataclasses
 from types import UnionType
 from typing import Any
 
-from openepd.compat.pydantic import pyd
-from openepd.model.base import BaseOpenEpdSchema, Version
+import pydantic
+from pydantic import ConfigDict
+
+from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.validation.common import validate_version_compatibility, validate_version_format
 from openepd.model.validation.quantity import ExternalValidationConfig, QuantityValidator
-from openepd.model.versioning import WithExtVersionMixin
+from openepd.model.versioning import Version, WithExtVersionMixin
 
 
 class BaseOpenEpdSpec(BaseOpenEpdSchema):
     """Base class for all OpenEPD specs."""
 
-    class Config:
-        use_enum_values = False  # we need to store enums as strings and not values
+    model_config = ConfigDict(use_enum_values=False)
 
 
 class BaseOpenEpdHierarchicalSpec(BaseOpenEpdSpec, WithExtVersionMixin):
     """Base class for new specs (hierarchical, versioned)."""
 
+    # TODO: Refactor work with class-based and instance-based _EXT_VERSION
     def __init__(self, **data: Any) -> None:
         # ensure that all the concrete spec objects fail on creations if they dont have _EXT_VERSION declared to
         # something meaningful
@@ -42,12 +44,13 @@ class BaseOpenEpdHierarchicalSpec(BaseOpenEpdSpec, WithExtVersionMixin):
         Version.parse_version(self._EXT_VERSION)  # validate format correctness
         super().__init__(**{"ext_version": self._EXT_VERSION, **data})
 
-    _version_format_validator = pyd.validator("ext_version", allow_reuse=True, check_fields=False)(
-        validate_version_format
-    )
-    _version_major_match_validator = pyd.validator("ext_version", allow_reuse=True, check_fields=False)(
-        validate_version_compatibility("_EXT_VERSION")
-    )
+    @pydantic.field_validator("ext_version", mode="before")
+    def _version_format_validator(cls, v: str) -> str:
+        return validate_version_format(v)
+
+    @pydantic.field_validator("ext_version", mode="before")
+    def _version_major_match_validator(cls, v: str) -> str:
+        return validate_version_compatibility("_EXT_VERSION")(cls, v)  # type: ignore[arg-type]
 
 
 def setup_external_validators(quantity_validator: QuantityValidator):

openepd/model/specs/concrete.py

@@ -13,98 +13,119 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 #
+import pydantic
 
-from openepd.compat.pydantic import pyd
 from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.specs.base import BaseOpenEpdSpec
-from openepd.model.validation.numbers import RatioFloat
 
 
 class ConcreteTypicalApplication(BaseOpenEpdSpec):
     """Typical Application for Concrete."""
 
-    fnd: bool | None = pyd.Field(
+    fnd: bool | None = pydantic.Field(
         description="Foundation. Typically used in direct contact with soil, e.g. footings, piles, mass concrete, "
         "mat foundations, and similar applications.",
-        example=True,
+        examples=[True],
         default=None,
     )
-    sog: bool | None = pyd.Field(
+    sog: bool | None = pydantic.Field(
         description="Slab on Grade. Typically used in continuously supported horizontal "
         "applications e.g. slab on grade, topping slabs, sidewalks, and roadways.",
-        example=True,
+        examples=[True],
         default=None,
     )
-    hrz: bool | None = pyd.Field(
+    hrz: bool | None = pydantic.Field(
         description="Elevated Horizontal. Typically used in elevated horizontal applications, either on metal deck or "
         "where soffit formwork must be removed, e.g. post-tension plates, rebar plates, beams and slabs, "
         "waffle slabs.",
-        example=True,
+        examples=[True],
         default=None,
     )
-    vrt_wall: bool | None = pyd.Field(description="Vertical Wall.", example=True, default=None)
-    vrt_column: bool | None = pyd.Field(description="Vertical Column.", example=True, default=None)
-    vrt_other: bool | None = pyd.Field(
+    vrt_wall: bool | None = pydantic.Field(description="Vertical Wall.", examples=[True], default=None)
+    vrt_column: bool | None = pydantic.Field(description="Vertical Column.", examples=[True], default=None)
+    vrt_other: bool | None = pydantic.Field(
         description="Vertical Other. Typically used in vertical applications other than "
         "walls or columns, e.g. sloped surfaces where formwork is required "
         "on multiple faces.",
-        example=True,
+        examples=[True],
         default=None,
     )
-    sht: bool | None = pyd.Field(
-        description="Shotcrete. Pneumatically applied, without formwork on all sides.", example=True, default=None
+    sht: bool | None = pydantic.Field(
+        description="Shotcrete. Pneumatically applied, without formwork on all sides.",
+        examples=[True],
+        default=None,
     )
-    cdf: bool | None = pyd.Field(
+    cdf: bool | None = pydantic.Field(
         description="Flowable Fill (CDF). Typically used to fill voids, backfill retaining "
         "walls, as a sub-base, and similar applications. Also called Controlled "
         "Density Fill (CDF) or Controlled Low Strength Materials (CLSM).",
-        example=True,
+        examples=[True],
         default=None,
     )
-    sac: bool | None = pyd.Field(
-        description="Typically used in concrete sidewalks and barrier curbs.", example=True, default=None
+    sac: bool | None = pydantic.Field(
+        description="Typically used in concrete sidewalks and barrier curbs.",
+        examples=[True],
+        default=None,
     )
-    pav: bool | None = pyd.Field(description="Typically used in pervious concrete", example=True, default=None)
-    oil: bool | None = pyd.Field(
+    pav: bool | None = pydantic.Field(description="Typically used in pervious concrete", examples=[True], default=None)
+    oil: bool | None = pydantic.Field(
         description="Concretes for use in creation, maintenance, and decommissioning of "
         "petroleum extraction wells and similar applications. Includes foamed "
         "cement; often called cement in the drilling industry. Differs from "
         "flowable fill and grout in that it contains no sand or other aggregates.",
-        example=True,
+        examples=[True],
         default=None,
     )
-    grt: bool | None = pyd.Field(
+    grt: bool | None = pydantic.Field(
         description="Cement grouting is a slurry that is placed as a flowable liquid. It is "
         "an effective material for filling and strengthening granular soils, "
         "voids in rocks, foundation underpinnings, and other underground voids. "
         "Also called structural grout, these materials typically impart"
         " significant strength to the system",
-        example=True,
+        examples=[True],
         default=None,
     )
-    ota: bool | None = pyd.Field(
-        description="Typical application not covered by other values.", example=True, default=None
+    ota: bool | None = pydantic.Field(
+        description="Typical application not covered by other values.",
+        examples=[True],
+        default=None,
     )
 
 
 class Cementitious(BaseOpenEpdSchema):
     """List of cementitious materials, and proportion by mass."""
 
-    opc: RatioFloat | None = pyd.Field(
-        default=None, description="Ordinary Gray Portland Cement", example=0.5, ge=0, le=1
+    opc: float | None = pydantic.Field(
+        default=None,
+        description="Ordinary Gray Portland Cement",
+        examples=[0.5],
+        ge=0,
+        le=1,
     )
-    wht: RatioFloat | None = pyd.Field(default=None, description="White Portland Cement", example=0.5, ge=0, le=1)
-    ggbs: RatioFloat | None = pyd.Field(
-        default=None, description="Ground Granulated Blast Furnace Slag", example=0.5, ge=0, le=1
+    wht: float | None = pydantic.Field(default=None, description="White Portland Cement", examples=[0.5], ge=0, le=1)
+    ggbs: float | None = pydantic.Field(
+        default=None,
+        description="Ground Granulated Blast Furnace Slag",
+        examples=[0.5],
+        ge=0,
+        le=1,
     )
-    flyAsh: RatioFloat | None = pyd.Field(
-        default=None, description="Fly Ash, including types F, CL, and CH", example=0.5, ge=0, le=1
+    flyAsh: float | None = pydantic.Field(
+        default=None,
+        description="Fly Ash, including types F, CL, and CH",
+        examples=[0.5],
+        ge=0,
+        le=1,
     )
-    siFume: RatioFloat | None = pyd.Field(default=None, description="Silica Fume", example=0.5, ge=0, le=1)
-    gg45: RatioFloat | None = pyd.Field(
-        default=None, description="Ground Glass, 45um or smaller", example=0.5, ge=0, le=1
+    siFume: float | None = pydantic.Field(default=None, description="Silica Fume", examples=[0.5], ge=0, le=1)
+    gg45: float | None = pydantic.Field(
+        default=None,
+        description="Ground Glass, 45um or smaller",
+        examples=[0.5],
+        ge=0,
+        le=1,
     )
-    natPoz: RatioFloat | None = pyd.Field(default=None, description="Natural pozzolan", example=0.5, ge=0, le=1)
-    mk: RatioFloat | None = pyd.Field(default=None, description="Metakaolin", example=0.5, ge=0, le=1)
-    CaCO3: RatioFloat | None = pyd.Field(default=None, description="Limestone", example=0.5, ge=0, le=1)
-    other: RatioFloat | None = pyd.Field(default=None, description="Other SCMs", example=0.5, ge=0, le=1)
+    natPoz: float | None = pydantic.Field(default=None, description="Natural pozzolan", examples=[0.5], ge=0, le=1)
+    mk: float | None = pydantic.Field(default=None, description="Metakaolin", examples=[0.5], ge=0, le=1)
+    CaCO3: float | None = pydantic.Field(default=None, description="Limestone", examples=[0.5], ge=0, le=1)
+    other: float | None = pydantic.Field(default=None, description="Other SCMs", examples=[0.5], ge=0, le=1)