openepd 1.4.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

openepd/__version__.py

@@ -17,4 +17,4 @@
 #  Charles Pankow Foundation, Microsoft Sustainability Fund, Interface, MKA Foundation, and others.
 #  Find out more at www.BuildingTransparency.org
 #
-VERSION = "1.4.0"
+VERSION = "1.6.0"

openepd/model/base.py

@@ -18,32 +18,62 @@
 #  Find out more at www.BuildingTransparency.org
 #
 import abc
+from enum import StrEnum
 import json
-from typing import Any, Optional, Type, TypeVar
+from typing import Any, Callable, Generic, Optional, Type, TypeVar
 
-import pydantic
+import pydantic as pyd
 from pydantic.generics import GenericModel
 
-AnySerializable = int | str | bool | float | list | dict | pydantic.BaseModel | None
+from openepd.model.validation.common import validate_version_compatibility, validate_version_format
+from openepd.model.versioning import OpenEpdVersions, Version
+
+AnySerializable = int | str | bool | float | list | dict | pyd.BaseModel | None
 TAnySerializable = TypeVar("TAnySerializable", bound=AnySerializable)
 
+OPENEPD_VERSION_FIELD = "openepd_version"
+"""Field name for the openEPD format version."""
+
+
+class OpenEpdDoctypes(StrEnum):
+    """Enum of supported openEPD document types."""
+
+    Epd = "openEPD"
+
+
+def modify_pydantic_schema(schema_dict: dict, cls: type) -> dict:
+    """
+    Modify the schema dictionary to add the required fields.
+
+    :param schema_dict: schema dictionary
+    :param cls: class for which the schema was generated
+    :return: modified schema dictionary
+    """
+    ext = schema_dict.get("properties", {}).get("ext")
+    # move to bottom
+    if ext is not None:
+        del schema_dict["properties"]["ext"]
+        schema_dict["properties"]["ext"] = ext
+    return schema_dict
 
-class BaseOpenEpdSchema(pydantic.BaseModel):
+
+class BaseOpenEpdSchema(pyd.BaseModel):
     """Base class for all OpenEPD models."""
 
-    ext: dict[str, AnySerializable] | None = pydantic.Field(alias="ext", default=None)
+    ext: dict[str, AnySerializable] | None = pyd.Field(alias="ext", default=None)
 
     class Config:
         allow_mutation = True
         validate_assignment = False
         allow_population_by_field_name = True
         use_enum_values = True
+        schema_extra: Callable | dict = modify_pydantic_schema
 
     def to_serializable(self, *args, **kwargs) -> dict[str, Any]:
         """
         Return a serializable dict representation of the DTO.
 
-        It expects the same arguments as the pydantic.BaseModel.json() method.
+        It expects the same arguments as the pyd.BaseModel.json() method.
         """
         return json.loads(self.json(*args, **kwargs))
 
@@ -83,7 +113,7 @@ class BaseOpenEpdSchema(pydantic.BaseModel):
         value = self.get_ext_field(key, default)
         if value is None:
             return None  # type: ignore
-        if issubclass(target_type, pydantic.BaseModel) and isinstance(value, dict):
+        if issubclass(target_type, pyd.BaseModel) and isinstance(value, dict):
             return target_type.construct(**value)  # type: ignore
         elif isinstance(value, target_type):
             return value
@@ -129,12 +159,6 @@ class BaseOpenEpdGenericSchema(GenericModel, BaseOpenEpdSchema):
     pass
 
 
-class BaseOpenEpdSpec(BaseOpenEpdSchema):
-    """Base class for all OpenEPD specs."""
-
-    pass
-
-
 class OpenEpdExtension(BaseOpenEpdSchema, metaclass=abc.ABCMeta):
     """Base class for OpenEPD extension models."""
 
@@ -148,3 +172,63 @@ class OpenEpdExtension(BaseOpenEpdSchema, metaclass=abc.ABCMeta):
 TOpenEpdExtension = TypeVar("TOpenEpdExtension", bound=OpenEpdExtension)
 TOpenEpdObject = TypeVar("TOpenEpdObject", bound=BaseOpenEpdSchema)
 TOpenEpdObjectClass = TypeVar("TOpenEpdObjectClass", bound=Type[BaseOpenEpdSchema])
+
+
+class RootDocument(abc.ABC, BaseOpenEpdSchema):
+    """Base class for all objects representing openEPD root element. E.g. Epd, IndustryEpd, GenericEstimate, etc."""
+
+    _FORMAT_VERSION: str
+    """Version of this document format. Must be defined in the concrete class."""
+
+    doctype: str = pyd.Field(
+        description='Describes the type and schema of the document. Must always always read "openEPD".',
+        default="OpenEPD",
+    )
+    openepd_version: str = pyd.Field(
+        description="Version of the document format, related to /doctype",
+        default=OpenEpdVersions.get_current().as_str(),
+    )
+
+    _version_format_validator = pyd.validator(OPENEPD_VERSION_FIELD, allow_reuse=True, check_fields=False)(
+        validate_version_format
+    )
+    _version_major_match_validator = pyd.validator(OPENEPD_VERSION_FIELD, allow_reuse=True, check_fields=False)(
+        validate_version_compatibility("_FORMAT_VERSION")
+    )
+
+
+TRootDocument = TypeVar("TRootDocument", bound=RootDocument)
+
+
+class BaseDocumentFactory(Generic[TRootDocument]):
+    """
+    Base class for document factories.
+
+    Extend it to create a factory for a specific document type e.g. for industry epd, epd, etc.
+    """
+
+    DOCTYPE_CONSTRAINT: str = ""
+    VERSION_MAP: dict[Version, type[TRootDocument]] = {}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> TRootDocument:
+        """Create a document from a dictionary."""
+        doctype: str | None = data.get("doctype")
+        if doctype is None:
+            raise ValueError("Doctype not found in the data.")
+        if doctype.lower() != cls.DOCTYPE_CONSTRAINT.lower():
+            raise ValueError(
+                f"Document type {doctype} not supported. This factory supports {cls.DOCTYPE_CONSTRAINT} only."
+            )
+        version = Version.parse_version(data.get(OPENEPD_VERSION_FIELD, ""))
+        for x, doc_cls in cls.VERSION_MAP.items():
+            if x.major == version.major:
+                if version.minor <= x.minor:
+                    return doc_cls(**data)
+                else:
+                    raise ValueError(
+                        f"Unsupported version: {version}. "
+                        f"The highest supported version from branch {x.major}.x is {x}"
+                    )
+        supported_versions = ", ".join(f"{v.major}.x" for v in cls.VERSION_MAP.keys())
+        raise ValueError(f"Version {version} is not supported. Supported versions are: {supported_versions}")

openepd/model/common.py

@@ -17,6 +17,7 @@
 #  Charles Pankow Foundation, Microsoft Sustainability Fund, Interface, MKA Foundation, and others.
 #  Find out more at www.BuildingTransparency.org
 #
+from enum import StrEnum
 from typing import Annotated, Any
 
 import pydantic as pyd
@@ -137,3 +138,18 @@ class WithAltIdsMixin(BaseModel):
         """Set an alt_id if value is not None."""
         if value is not None:
             self.set_alt_id(domain_name, value)
+
+
+class OpenEPDUnit(StrEnum):
+    """OpenEPD allowed units."""
+
+    kg = "kg"
+    m2 = "m2"
+    m = "m"
+    M2_RSI = "m2 * RSI"
+    MJ = "MJ"
+    t_km = "t * km"
+    MPa = "MPa"
+    item = "item"
+    W = "W"
+    use = "use"

openepd/model/epd.py

@@ -22,18 +22,31 @@ from typing import Annotated
 
 import pydantic as pyd
 
-from openepd.model.base import BaseOpenEpdSchema
+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 Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
+class BaseEpd(RootDocument):
+    """
+    Base class for EPD documents.
+
+    This class should not be used directly.  Use Epd or EpdVx instead.
+    """
+
+    pass
+
+
+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 "
@@ -41,10 +54,6 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         example="1u7zsed8",
         default=None,
     )
-    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", example="Mix 12345AC"
     )
@@ -53,7 +62,7 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
     )
     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(
@@ -234,28 +243,28 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
     )
     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 
+        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
 
-    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 
+    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.*
 
     # Product Installation
 
-    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 
+    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 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. 
+    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.
     """,
     )
@@ -278,3 +287,13 @@ class Epd(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         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/org.py

@@ -25,8 +25,8 @@ from openepd.model.base import BaseOpenEpdSchema
 from openepd.model.common import Location, WithAltIdsMixin, WithAttachmentsMixin
 
 
-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
@@ -37,12 +37,18 @@ class Org(WithAttachmentsMixin, WithAltIdsMixin, BaseOpenEpdSchema):
         example="C Change Labs",
         default=None,
     )
+
+
+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,
     )
     # 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_items=255)] | None = pyd.Field(
         description="Organizations controlled by this organization",

openepd/model/specs/README.md

@@ -0,0 +1,19 @@
+# Material Extensions
+
+This package contains openEPD material extensions. They are used to represent the material properties of the openEPD 
+materials, and are a more dynamic, frequently changing part of the standard. 
+
+## Versioning
+
+Extensions are versioned separately from the openEPD standard or openEPD API. 
+
+Each material extension is named after the corresponding EC3 product class, and is located in the relevant place 
+in the specs tree. For example, `RebarSteel` is nested under `Steel`. 
+
+Extensions are versioned as Major.Minor, for example "2.4". 
+
+Rules: 
+1. Minor versions for the same major version should be backwards compatible.
+2. Major versions are not compatible between themselves. 
+3. Pydantic models representing versions are named in a pattern SpecNameV1, where 1 is major version and SpecName is
+   the name of the material extension.

openepd/model/specs/__init__.py

@@ -17,13 +17,19 @@
 #  Charles Pankow Foundation, Microsoft Sustainability Fund, Interface, MKA Foundation, and others.
 #  Find out more at www.BuildingTransparency.org
 #
+
 import pydantic as pyd
 
 from openepd.model.base import BaseOpenEpdSchema
-from openepd.model.specs.concrete import CmuSpec
+from openepd.model.specs import concrete, steel
 
 
 class Specs(BaseOpenEpdSchema):
     """Material specific specs."""
 
-    cmu: CmuSpec | None = pyd.Field(default=None, description="Concrete Masonry Unit-specific (CMU) specs")
+    cmu: concrete.CmuSpec | None = pyd.Field(default=None, description="Concrete Masonry Unit-specific (CMU) specs")
+    CMU: concrete.CmuSpec | None = pyd.Field(default=None, description="Concrete Masonry Unit-specific (CMU) specs")
+    Steel: steel.SteelV1 | None = pyd.Field(default=None, title="SteelV1", description="Steel-specific specs")
+    Concrete: concrete.ConcreteV1 | None = pyd.Field(
+        default=None, title="ConcreteV1", description="Concrete-specific specs"
+    )

openepd/model/specs/base.py

@@ -0,0 +1,60 @@
+#
+#  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 typing import Any
+
+import pydantic as pyd
+
+from openepd.model.base import BaseOpenEpdSchema, Version
+from openepd.model.validation.common import validate_version_compatibility, validate_version_format
+from openepd.model.validation.numbers import QuantityValidator
+from openepd.model.versioning import 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
+
+
+class BaseOpenEpdHierarchicalSpec(BaseOpenEpdSpec, WithExtVersionMixin):
+    """Base class for new specs (hierarchical, versioned)."""
+
+    _QUANTITY_VALIDATOR: QuantityValidator | None = None
+
+    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
+        if not hasattr(self, "_EXT_VERSION") or self._EXT_VERSION is None:
+            raise ValueError(f"Class {self.__class__} must declare an extension version")
+        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")
+    )
+
+
+def setup_external_validators(quantity_validator: QuantityValidator):
+    """Set the implementation unit validator for specs."""
+    BaseOpenEpdHierarchicalSpec._QUANTITY_VALIDATOR = quantity_validator

openepd/model/specs/concrete.py

@@ -18,10 +18,72 @@
 #  Find out more at www.BuildingTransparency.org
 #
 from enum import StrEnum
+from typing import Literal
 
 import pydantic as pyd
 
-from openepd.model.base import BaseOpenEpdSpec
+from openepd.model.base import BaseOpenEpdSchema
+from openepd.model.common import OpenEPDUnit
+from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec, BaseOpenEpdSpec
+from openepd.model.validation.common import together_validator
+from openepd.model.validation.numbers import RatioFloat, validate_unit_factory
+
+
+class AciExposureClass(StrEnum):
+    """ACI Code (US)."""
+
+    F0 = "aci.F0"
+    F1 = "aci.F1"
+    F2 = "aci.F2"
+    F3 = "aci.F3"
+    S0 = "aci.S0"
+    S1 = "aci.S1"
+    S2 = "aci.S2"
+    S3 = "aci.S3"
+    C1 = "aci.C1"
+    C2 = "aci.C2"
+    W0 = "aci.W0"
+    W1 = "aci.W1"
+    W2 = "aci.W2"
+
+
+class CsaExposureClass(StrEnum):
+    """CSA Code (Canada)."""
+
+    N = "csa.N"
+    F2 = "csa.F-2"
+    F_1 = "csa.F-1"
+    C_1 = "csa.C-1"
+    S_3 = "csa.S-3"
+    S_2 = "csa.S-2"
+    S_1 = "csa.S-1"
+    A_1 = "csa.A-1"
+    A_2 = "csa.A-2"
+    A_3 = "csa.A-3"
+    A_4 = "csa.A-4"
+
+
+class EnExposureClass(StrEnum):
+    """EN 206 Class (Europe)."""
+
+    en206_0 = "en206.0"
+    F1 = "en206.F1"
+    F2 = "en206.F2"
+    F3 = "en206.F3"
+    F4 = "en206.F4"
+    A1 = "en206.A1"
+    A2 = "en206.A2"
+    A3 = "en206.A3"
+    D1 = "en206.D1"
+    D2 = "en206.D2"
+    D3 = "en206.D3"
+    S1 = "en206.S1"
+    S2 = "en206.S2"
+    S3 = "en206.S3"
+    C1 = "en206.C1"
+    C2 = "en206.C2"
+    C3 = "en206.C3"
+    C4 = "en206.C4"
 
 
 class CmuWeightClassification(StrEnum):
@@ -35,7 +97,7 @@ class CmuWeightClassification(StrEnum):
     """Lightweight CMU has a density less than 105 lbs/cu. ft."""
 
 
-class CmuOptions(BaseOpenEpdSpec):
+class CmuOptions(BaseOpenEpdSchema):
     """Concrete Masonry Unit options."""
 
     load_bearing: bool | None = pyd.Field(
@@ -148,3 +210,107 @@ class CmuSpec(BaseOpenEpdSpec):
     options: CmuOptions = pyd.Field(
         description="Options for CMU. List of true/false properties", default_factory=CmuOptions
     )
+
+
+class Cementitious(BaseOpenEpdSchema):
+    """List of cementitious materials, and proportion by mass."""
+
+    opc: RatioFloat | None = pyd.Field(default=None, description="Ordinary Gray Portland Cement")
+    wht: RatioFloat | None = pyd.Field(default=None, description="White Portland Cement")
+    ggbs: RatioFloat | None = pyd.Field(default=None, description="Ground Granulated Blast Furnace Slag")
+    flyAsh: RatioFloat | None = pyd.Field(default=None, description="Fly Ash, including types F, CL, and CH")
+    siFume: RatioFloat | None = pyd.Field(default=None, description="Silica Fume")
+    gg45: RatioFloat | None = pyd.Field(default=None, description="Ground Glass, 45um or smaller")
+    natPoz: RatioFloat | None = pyd.Field(default=None, description="Natural pozzolan")
+    mk: RatioFloat | None = pyd.Field(default=None, description="Metakaolin")
+    CaCO3: RatioFloat | None = pyd.Field(default=None, description="Limestone")
+    other: RatioFloat | None = pyd.Field(default=None, description="Other SCMs")
+
+
+class TypicalApplication(BaseOpenEpdSchema):
+    """Concrete typical application."""
+
+    fnd: bool | None = pyd.Field(description="Foundation", default=None)
+    sog: bool | None = pyd.Field(description="Slab on Grade", default=None)
+    hrz: bool | None = pyd.Field(description="Elevated Horizontal", default=None)
+    vrt_wall: bool | None = pyd.Field(description="Vertical Wall", default=None)
+    vrt_column: bool | None = pyd.Field(description="Vertical Column", default=None)
+    vrt_other: bool | None = pyd.Field(description="Vertical Other", default=None)
+    sht: bool | None = pyd.Field(description="Shotcrete", default=None)
+    cdf: bool | None = pyd.Field(description="Flowable Fill (CDF,default=None)", default=None)
+    sac: bool | None = pyd.Field(description="Sidewalk and Curb", default=None)
+    pav: bool | None = pyd.Field(description="Paving", default=None)
+    oil: bool | None = pyd.Field(description="Oil Patch", default=None)
+    grt: bool | None = pyd.Field(description="Cement Grout", default=None)
+    ota: bool | None = pyd.Field(description="Other", default=None)
+
+
+class ConcreteV1(BaseOpenEpdHierarchicalSpec):
+    """Concrete spec."""
+
+    _EXT_VERSION = "1.0"
+
+    class Options(BaseOpenEpdSchema):
+        lightweight: bool | None = pyd.Field(description="Lightweight", default=None)
+        plc: bool | None = pyd.Field(description="Portland Limestone Cement", default=None)
+        scc: bool | None = pyd.Field(description="Self Compacting", default=None)
+        finishable: bool | None = pyd.Field(description="Finishable", default=None)
+        air: bool | None = pyd.Field(description="Air Entrainment", default=None)
+        co2: bool | None = pyd.Field(description="CO2 Curing", default=None)
+        white: bool | None = pyd.Field(description="White Cement", default=None)
+        fiber_reinforced: bool | None = pyd.Field(description="Fiber reinforced", default=None)
+
+    strength_28d: str | None = pyd.Field(
+        default=None, title="Concrete Strength 28d", description="Concrete strength after 28 days"
+    )
+
+    strength_early: str | None = pyd.Field(
+        default=None,
+        title="Early Strength",
+        description="A strength spec which is to be reached earlier than 28 days (e.g. 3d)",
+    )
+    strength_early_d: Literal[3, 7, 14] | None = pyd.Field(
+        default=None, title="Test Days for Early Strength", description="Test Day for the Early Strength"
+    )
+    strength_late: str | None = pyd.Field(
+        default=None,
+        title="Late Strength",
+        description="A strength spec which is to be reached later than 28 days (e.g. 42d)",
+    )
+    strength_late_d: Literal[42, 56, 72, 96, 120] | None = pyd.Field(
+        default=None, title="Test Day for the Late Strength", description="Test Day for the Late Strength"
+    )
+    slump: str | None = pyd.Field(description="Minimum test slump", default=None)
+    w_c_ratio: RatioFloat | None = pyd.Field(description="Ratio of water to cement", default=None)
+    aci_exposure_classes: list[AciExposureClass] = pyd.Field(
+        description="List of ACI318-19 exposure classes this product meets", default=None
+    )
+    csa_exposure_classes: list[CsaExposureClass] = pyd.Field(
+        description="List of CSA A23.1 exposure classes this product meets", default=None
+    )
+    en_exposure_classes: list[EnExposureClass] = pyd.Field(
+        description="List of EN206 exposure classes this product meets", default=None
+    )
+
+    application: TypicalApplication | None = pyd.Field(description="Typical Application", default=None)
+
+    options: Options = pyd.Field(description="Concrete options", default=None)
+
+    cementitious: Cementitious | None = pyd.Field(
+        default=None,
+        title="Cementitious Materials",
+        description="List of cementitious materials, and proportion by mass",
+    )
+    _compressive_strength_unit_validator = pyd.validator("strength_28d", allow_reuse=True)(
+        validate_unit_factory(OpenEPDUnit.MPa)
+    )
+
+    @pyd.root_validator
+    def _late_validator(cls, values):
+        together_validator("strength_late", "strength_late_d", values)
+        return values
+
+    @pyd.root_validator
+    def _early_validator(cls, values):
+        together_validator("strength_early", "strength_early_d", values)
+        return values

openepd/model/specs/steel.py

@@ -0,0 +1,146 @@
+#
+#  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 enum import StrEnum
+
+import pydantic as pyd
+
+from openepd.model.base import BaseOpenEpdSchema
+from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
+from openepd.model.standard import Standard
+from openepd.model.validation.numbers import RatioFloat
+
+
+class SteelMakingRoute(BaseOpenEpdSchema):
+    """Steel making route."""
+
+    bof: bool | None = pyd.Field(default=None, description="Basic oxygen furnace")
+    eaf: bool | None = pyd.Field(default=None, description="Electric arc furnace")
+    ohf: bool | None = pyd.Field(default=None, description="Open hearth furnace")
+
+
+class SteelComposition(StrEnum):
+    """Steel composition enum."""
+
+    CARBON = "Carbon"
+    ALLOY = "Alloy"
+    STAINLESS = "Stainless"
+    TOOL = "Tool"
+    OTHER = "Other"
+
+
+class FabricatedOptionsMixin(pyd.BaseModel):
+    """Fabricated options mixin."""
+
+    fabricated: bool | None = pyd.Field(default=None, description="Fabricated")
+
+
+class WireMeshSteelV1(BaseOpenEpdHierarchicalSpec):
+    """Spec for wire mesh steel."""
+
+    class Options(BaseOpenEpdSchema, FabricatedOptionsMixin):
+        """Wire Mesh Options."""
+
+        pass
+
+    options: Options = pyd.Field(description="Rebar Steel options", default_factory=Options)
+
+
+class RebarSteelV1(BaseOpenEpdHierarchicalSpec):
+    """Rebar steel spec."""
+
+    _EXT_VERSION = "1.0"
+
+    class Options(BaseOpenEpdSchema, FabricatedOptionsMixin):
+        """Rebar Steel Options."""
+
+        epoxy: bool | None = pyd.Field(default=None, description="Epoxy Coated")
+
+    options: Options = pyd.Field(description="Rebar Steel options", default_factory=Options)
+
+
+class PlateSteelV1(BaseOpenEpdHierarchicalSpec):
+    """Plate Steel Spec."""
+
+    class Options(BaseOpenEpdSchema, FabricatedOptionsMixin):
+        """Plate Steel Options."""
+
+        pass
+
+    options: Options = pyd.Field(description="Plate Steel options", default_factory=Options)
+
+
+class HollowV1(BaseOpenEpdHierarchicalSpec):
+    """Hollow Sections Spec."""
+
+    class Options(FabricatedOptionsMixin, BaseOpenEpdSchema):
+        """Hollow Sections Options."""
+
+        pass
+
+    options: Options = pyd.Field(description="Hollow Steel options", default_factory=Options)
+
+
+class HotRolledV1(BaseOpenEpdHierarchicalSpec):
+    """Hot Rolled spec."""
+
+    class Options(FabricatedOptionsMixin, BaseOpenEpdSchema):
+        """Hot Rolled options."""
+
+        pass
+
+    options: Options = pyd.Field(description="Hollow Steel options", default_factory=Options)
+
+
+class SteelV1(BaseOpenEpdHierarchicalSpec):
+    """Steel spec."""
+
+    _EXT_VERSION = "1.0"
+
+    class Options(BaseOpenEpdSchema):
+        """Steel spec options."""
+
+        galvanized: bool | None = pyd.Field(default=None, description="Galvanized")
+        cold_finished: bool | None = pyd.Field(default=None, description="Cold Finished")
+
+    form_factor: str | None = pyd.Field(description="Product's form factor", example="Steel >> RebarSteel")
+    steel_composition: SteelComposition | None = pyd.Field(default=None, description="Basic chemical composition")
+    recycled_content: RatioFloat | None = pyd.Field(
+        default=None,
+        description="Scrap steel inputs from other processes.  Includes "
+        "Post-Consumer content, if any.  This percentage may be "
+        "used to evaluate the EPD w.r.t. targets or limits that are"
+        " different for primary and recycled content.",
+    )
+    ASTM: list[Standard] = pyd.Field(description="ASTM standard to which this product complies", default_factory=list)
+    SAE: list[Standard] = pyd.Field(
+        description="AISA/SAE standard to which this product complies", default_factory=list
+    )
+    EN: list[Standard] = pyd.Field(description="EN 10027 number(s)", default_factory=list)
+
+    options: Options | None = pyd.Field(description="Steel options", default_factory=Options)
+    making_route: SteelMakingRoute | None = pyd.Field(default=None, description="Steel making route")
+
+    # Nested specs
+
+    WireMeshSteel: WireMeshSteelV1 | None = None
+    RebarSteel: RebarSteelV1 | None = None
+    PlateSteel: PlateSteelV1 | None = None
+    Hollow: HollowV1 | None = None
+    HotRolled: HotRolledV1 | None = None

openepd/model/validation/__init__.py

@@ -0,0 +1,19 @@
+#
+#  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
+#

openepd/model/validation/common.py

@@ -0,0 +1,52 @@
+#
+#  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 typing import Any, Callable, Type
+
+from openepd.model.versioning import Version
+
+
+def together_validator(field1: str, field2: Any, values: dict[str, Any]) -> Any:
+    """Shared validator to ensure that two fields are provided together or not provided at all."""
+    value1 = values.get(field1)
+    value2 = values.get(field2)
+    if value1 is not None and value2 is None or value1 is None and value2 is not None:
+        raise ValueError(f"Both or neither {field1} and {field2} days must be provided together")
+
+
+def validate_version_format(v: str) -> str:
+    """Ensure that the extension version is valid."""
+    Version.parse_version(v)  # will raise an error if not valid
+    return v
+
+
+def validate_version_compatibility(class_version_attribute_name: str) -> Callable[[Type, str], str]:
+    """Ensure that the object which is passed for parsing and validation is compatible with the class."""
+
+    # we need closure to pass property name, since actual class will only be available in runtime
+    def internal_validate_version_compatibility(cls: Type, v: str) -> str:
+        if not hasattr(cls, class_version_attribute_name):
+            raise ValueError(f"Class {cls} must declare a class var extension var named {class_version_attribute_name}")
+
+        class_version = getattr(cls, class_version_attribute_name)
+        if Version.parse_version(v).major != Version.parse_version(class_version).major:
+            raise ValueError(f"Extension version {v} does not match class version {class_version}")
+        return v
+
+    return internal_validate_version_compatibility

openepd/model/validation/numbers.py

@@ -0,0 +1,66 @@
+#
+#  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 abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Annotated
+
+import pydantic as pyd
+
+from openepd.model.common import OpenEPDUnit
+
+if TYPE_CHECKING:
+    from openepd.model.specs.base import BaseOpenEpdHierarchicalSpec
+
+RatioFloat = Annotated[float, pyd.Field(ge=0, le=1, example=0.5)]
+"""Float field which represents a percentage ratio between 0 and 1."""
+
+
+class QuantityValidator(ABC):
+    """
+    Interface for quantity validator.
+
+    The openEPD models are mapped using the simple types. Caller code should provide their own implementation of this
+    and set it with `set_unit_validator` function.
+    """
+
+    @abstractmethod
+    def validate(self, value: str, dimensionality: str) -> None:
+        """
+        Validate the given string value against the given dimensionality.
+
+        Args:
+            value: The value to validate, like "102.4 kg"
+            dimensionality: The dimensionality to validate against, like "kg"
+        Returns:
+            None if the value is valid, raises an error otherwise.
+        Raises:
+            ValueError: If the value is not valid.
+        """
+        pass
+
+
+def validate_unit_factory(dimensionality: OpenEPDUnit | str):
+    """Create validator for unit field."""
+
+    def validator(cls: "BaseOpenEpdHierarchicalSpec", value: str) -> str:
+        if hasattr(cls, "_QUNATITY_VALIDATOR") and cls._QUANTITY_VALIDATOR is not None:
+            cls._QUANTITY_VALIDATOR.validate(value, dimensionality)
+        return value
+
+    return validator

openepd/model/versioning.py

@@ -0,0 +1,129 @@
+#
+#  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 abc import ABC
+from enum import ReprEnum
+from typing import ClassVar, NamedTuple
+
+import pydantic as pyd
+from pydantic import BaseModel
+
+
+class WithExtVersionMixin(ABC, BaseModel):
+    """Mixin for extensions supporting versions: recommended way."""
+
+    _EXT_VERSION: ClassVar[str]
+    """Exact version (major, minor) of the spec extension"""
+
+    def __init_subclass__(cls):
+        """Set the default value for the ext_version field from _EXT_VERSION class var."""
+        super().__init_subclass__()
+        if hasattr(cls, "_EXT_VERSION"):
+            cls.__fields__["ext_version"].default = cls._EXT_VERSION
+
+    ext_version: str = pyd.Field(description="Extension version", example="3.22", default=None)
+
+
+class Version(NamedTuple):
+    """Version of the object or specification."""
+
+    major: int
+    minor: int
+
+    @staticmethod
+    def parse_version(version: str) -> "Version":
+        """Parse the version of extension or the format.
+
+        Version is expected to be major.minor
+
+        :param version: The extension version.
+        :return: A tuple of major and minor version numbers.
+        """
+        splits = version.split(".", 1) if isinstance(version, str) else None
+        if len(splits) != 2:
+            raise ValueError(f"Invalid version: {version}")
+        if not splits[0].isdigit() or not splits[1].isdigit():
+            raise ValueError(f"Invalid version: {version}")
+        return Version(major=int(splits[0]), minor=int(splits[1]))
+
+    def __str__(self) -> str:
+        return self.as_str()
+
+    def __repr__(self) -> str:
+        return f"[Version] {self.as_str()}"
+
+    def as_str(self) -> str:
+        """Return the version as a string."""
+        return f"{self.major}.{self.minor}"
+
+
+class OpenEpdVersions(Version, ReprEnum):
+    """
+    Enum of supported openEPD versions.
+
+    When adding a new version - make sure to add a new major version to the list of supported versions.
+    When doing non-breaking change - update minor version in a corresponding enum value.
+    """
+
+    Version0 = Version(major=0, minor=1)
+
+    @classmethod
+    def get_supported_versions(cls) -> list[Version]:
+        """Return a list of supported versions."""
+        return [x.value for x in cls]
+
+    @classmethod
+    def supported_versions_str(cls, major_only: bool = False) -> str:
+        """
+        Return a comma separated list of the supported versions.
+
+        This is a utility method, might be helpful for logging, building error messages, etc.
+
+        :param major_only: If True, minor component will be replaced with 'x'. E.g. `2.x` instead of `2.1`
+        """
+        if major_only:
+            return ", ".join(f"{x.major}.x" for x in cls.get_supported_versions())
+        return ", ".join(str(x) for x in cls.get_supported_versions())
+
+    @classmethod
+    def get_most_recent_version(cls, branch: int | None = 0) -> Version:
+        """
+        Return the most recent version of the openEPD format.
+
+        If branch is specified - returns the most recent version of the specified branch, otherwise returns
+        the most recent version among all branches.
+        """
+        if branch is None:
+            highest: Version = max(cls, key=lambda x: x.value.major)  # type: ignore
+            if highest:
+                return highest
+        for x in cls:
+            if x.value.major == branch:
+                return x.value
+        raise ValueError(
+            f"No version {branch}.x is not supported. Supported versions are: {', '.join(str(x.value) for x in cls)}"
+        )
+
+    @classmethod
+    def get_current(cls) -> Version:
+        """Return the most recent stable version of the format."""
+        return cls.get_most_recent_version()
+
+    def __repr__(self):
+        return f"[OpenEpdVesion] {self.name} - {self.value}"

{openepd-1.4.0.dist-info → openepd-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openepd
-Version: 1.4.0
+Version: 1.6.0
 Summary: Python library to work with OpenEPD format
 Home-page: https://github.com/cchangelabs/openepd
 License: Apache-2.0

{openepd-1.4.0.dist-info → openepd-1.6.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 openepd/__init__.py,sha256=rqQJWF5jpYAgRbbAycUfWMGsr5kGtfjmwzsTeqbElJw,837
-openepd/__version__.py,sha256=YSSiSbKfBLxnHr7oWf0EFSpUYGsAKTT6yx-ax_ef7Uc,855
+openepd/__version__.py,sha256=dydPFQzMC85AwH6lLCuy1P3UT2PsGjNSUOyDiyVRnhA,855
 openepd/api/__init__.py,sha256=rqQJWF5jpYAgRbbAycUfWMGsr5kGtfjmwzsTeqbElJw,837
 openepd/api/base_sync_client.py,sha256=JcNpWsGoIK_1Eg27CAQd7nIjbcfD56jQ1nS6B48Q0cI,21142
 openepd/api/category/__init__.py,sha256=rqQJWF5jpYAgRbbAycUfWMGsr5kGtfjmwzsTeqbElJw,837
@@ -27,18 +27,26 @@ openepd/bundle/model.py,sha256=NWbpxorLzQ_OIFozV34wz76OWM_ORGTBkS0288chv0k,2647
 openepd/bundle/reader.py,sha256=z4v_UWyaosktN3DdmnRx8GpLq4DkejjoUsckFfCgUac,6904
 openepd/bundle/writer.py,sha256=AfvzzdAr9ybIbtiZfuX2mAGfddamTxXxUTxtHHrs2Gc,8353
 openepd/model/__init__.py,sha256=rqQJWF5jpYAgRbbAycUfWMGsr5kGtfjmwzsTeqbElJw,837
-openepd/model/base.py,sha256=vjcsMoNQNJuCK1ngh1RbOlYVzWgCw2LF9fhPaH_q2_o,5564
+openepd/model/base.py,sha256=wLZUQSc6nOvoiESgxjEHTdGEV417SUolsXMNm2mA-po,8883
 openepd/model/category.py,sha256=_6yFyldaDrkZk2_9ZAO2oRTz7ocvkg4T-D_aw5ncgvo,1840
-openepd/model/common.py,sha256=SSTIvCjCkJEKf3FVnUvAw9SfFbkSdestq6YBX20eBQw,5386
-openepd/model/epd.py,sha256=xB11K3MQweB20yrv_iTUxgjn3fWC5hkt4c45KJa-xHk,13944
+openepd/model/common.py,sha256=j-M_2T_Kl_Ea8l50pJT7LNatBW1fKrRcw4XNpeNvLU0,5635
+openepd/model/epd.py,sha256=BxcKJd_LuApB2v_LGN0-hYLNaUNoqMu9ZH_V1Ffil-g,14269
+openepd/model/factory.py,sha256=qQZNb4yFN1EQWHHVS-fHnJ2gB-vsKz9hVmXXJE7YaRU,1918
 openepd/model/lcia.py,sha256=2GOdcY6ASJu653SFwTakT9boYF-3CYCHLupyxTPUQ30,16711
-openepd/model/org.py,sha256=ov3nrSk36imug7ADarNWHIXW9jiFbmboswoXVQCNeDI,3662
+openepd/model/org.py,sha256=quoYMrA6WXqs7ZRjdO1Bm47No4jGLqxz0QmnnqKgw7c,3741
 openepd/model/pcr.py,sha256=t861yFntmy3ewrnGLP47cv3afV-aCCVRlrbpGeRh-7I,4604
-openepd/model/specs/__init__.py,sha256=jdMXv4_FcVUrDafCqulELDx6T2KuZQyRUtgAuLZMVR4,1137
-openepd/model/specs/concrete.py,sha256=cwXv2O2FV6y5g76k_1Ao6uUlKrj0me7JzDOmL9CK2O8,6532
+openepd/model/specs/README.md,sha256=W5LSMpZuW5x36cKS4HRfeFsClsRf8J9yHMMICghdc0s,862
+openepd/model/specs/__init__.py,sha256=3DXyeFzH1bw4rf1KCFXPXl3X-ErMu0NpjvqqhorpnLc,1514
+openepd/model/specs/base.py,sha256=hOE_hCuiY7xhR0yW_Pbxe_LQAnMWq8sq3rTqQqbeVOc,2564
+openepd/model/specs/concrete.py,sha256=jdhuThy8QFaEs9HdJ53O7ua4Fw-ES2_YzoLDchyU8s0,13165
+openepd/model/specs/steel.py,sha256=FoMYE6y_uvWg9Edkb7WV0f_hQNmviwtI1SM-UmdRh8E,4985
 openepd/model/standard.py,sha256=YjxpC9nyz6LM8m3z1s5S0exJ1qvA3n59-FBoScg-FL0,1519
+openepd/model/validation/__init__.py,sha256=rqQJWF5jpYAgRbbAycUfWMGsr5kGtfjmwzsTeqbElJw,837
+openepd/model/validation/common.py,sha256=nNwLtj5Uu7TsFmJXuD8aRcx1hB_nf-LQBfEvHOZM1Ao,2420
+openepd/model/validation/numbers.py,sha256=AItjDAz9LODxLOH7shqfMMufT9ep_8ys2bVelIbME7g,2349
+openepd/model/versioning.py,sha256=Z31TgCW0POsmXLrH-Rmpy-MrIw_bU_9wwh8T4Mq1yTM,4628
 openepd/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-openepd-1.4.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-openepd-1.4.0.dist-info/METADATA,sha256=dROT7H1EeFmmI5bluVzrSzC1yyOANMC9dY7yTfncLrk,7762
-openepd-1.4.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-openepd-1.4.0.dist-info/RECORD,,
+openepd-1.6.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+openepd-1.6.0.dist-info/METADATA,sha256=_zIXgd030Dco2ykLRwhes7xe6ygQhgmtjiyEXqVvUo0,7762
+openepd-1.6.0.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+openepd-1.6.0.dist-info/RECORD,,