cognite-neat 0.87.6__py3-none-any.whl → 0.88.1__py3-none-any.whl

cognite/neat/rules/issues/ontology.py

@@ -0,0 +1,298 @@
+from abc import ABC
+from dataclasses import dataclass
+from typing import ClassVar
+
+from .base import NeatValidationError, ValidationWarning
+
+__all__ = [
+    "OntologyError",
+    "OntologyWarning",
+]
+
+
+@dataclass(frozen=True)
+class OntologyError(NeatValidationError, ABC): ...
+
+
+@dataclass(frozen=True)
+class OntologyWarning(ValidationWarning, ABC): ...
+
+
+@dataclass(frozen=True)
+class OntologyMultiLabeledPropertyWarning(OntologyWarning):
+    """This warning occurs when a property is given multiple labels, typically if the
+    same property is defined for different classes but different name is given
+
+    Args:
+        property_id: property id that raised warning due to multiple labels
+        names: list of names of property
+
+    Notes:
+        This would be automatically fixed by taking the first label (aka name) of the property.
+    """
+
+    description = (
+        "This warning occurs when a property is given multiple labels,"
+        " typically if the same property is defined for different "
+        "classes but different name is given."
+    )
+    fix = "This would be automatically fixed by taking the first label (aka name) of the property."
+
+    property_id: str
+    names: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            "Property should have single preferred label (human readable name)."
+            f"Currently property '{self.property_id}' has multiple preferred labels: {', '.join(self.names or [])} !"
+            f"Only the first name, i.e. '{self.names[0] if self.names else ''}' will be considered!"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiDefinitionPropertyWarning(OntologyWarning):
+    """This warning occurs when a property is given multiple human readable definitions,
+    typically if the same property is defined for different classes where each definition
+    is different.
+
+    Args:
+        property_id: property id that raised warning due to multiple definitions
+
+    Notes:
+        This would be automatically fixed by concatenating all definitions.
+    """
+
+    description = (
+        "This warning occurs when a property is given multiple human readable definitions,"
+        " typically if the same property is defined for different "
+        "classes where each definition is different."
+    )
+    fix = "This would be automatically fixed by concatenating all definitions."
+
+    property_id: str
+
+    def message(self):
+        message = (
+            f"Multiple definitions (aka comments) of property '{self.property_id}' detected."
+            " Definitions will be concatenated."
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiTypePropertyWarning(OntologyWarning):
+    """This warning occurs when a same property is define for two object/classes where
+    its expected value type is different in one definition, e.g. acts as an edge, while in
+    other definition acts as and attribute
+
+    Args:
+        property_id: property id that raised warning due to multi type definition
+        types: list of types of property
+
+    Notes:
+        If a property takes different value types for different objects, simply define
+        new property. It is bad practice to have multi type property!
+    """
+
+    description = (
+        "This warning occurs when a same property is define for two object/classes where"
+        " its expected value type is different in one definition, e.g. acts as an edge, while in "
+        "other definition acts as and attribute"
+    )
+    fix = "If a property takes different value types for different objects, simply define new property"
+
+    property_id: str
+    types: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            "It is bad practice to have multi type property! "
+            f"Currently property '{self.property_id}' is defined as multi type property: {', '.join(self.types or [])}"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiRangePropertyWarning(OntologyWarning):
+    """This warning occurs when a property takes range of values which consists of union
+    of multiple value types
+
+    Args:
+        property_id: property id that raised warning due to multi range definition
+        range_of_values: list of ranges that property takes
+
+    Notes:
+        If a property takes different range of values, simply define new property.
+    """
+
+    description = (
+        "This warning occurs when a property takes range of values which consists of union of multiple value types."
+    )
+    fix = "If a property takes different range of values, simply define new property"
+    property_id: str
+    range_of_values: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            "It is bad practice to have property that take various range of values! "
+            f"Currently property '{self.property_id}' has multiple ranges: {', '.join(self.range_of_values or [])}"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class OntologyMultiDomainPropertyWarning(OntologyWarning):
+    """This warning occurs when a property is reused for more than one classes
+
+    Args:
+        property_id: property id that raised warning due to reuse definition
+        classes: list of classes that use the same property
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+        No need to fix this, but make sure that property type is consistent across different
+        classes and that ideally takes the same range of values
+    """
+
+    description = "This warning occurs when a property is reused for more than one classes."
+    fix = (
+        "No need to fix this, but make sure that property type is consistent"
+        " across different classes and that ideally takes the same range of values"
+    )
+    property_id: str
+    classes: list[str] | None = None
+
+    def message(self) -> str:
+        message = (
+            f"Currently property '{self.property_id}' is defined for multiple classes: {', '.join(self.classes or [])}"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class PropertiesDefinedMultipleTimesError(OntologyError):
+    """This error is raised during export of Transformation Rules to DMS schema when
+    when properties are defined multiple times for the same class.
+
+    Args:
+        report: report on properties which are defined multiple times
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+       Make sure to check validation report of Transformation Rules and fix DMS related warnings.
+    """
+
+    description = (
+        "This error is raised during export of Transformation Rules to "
+        "DMS schema when properties are defined multiple times for the same class."
+    )
+    fix = "Make sure to check validation report of Transformation Rules and fix DMS related warnings."
+
+    report: str
+
+    def message(self) -> str:
+        message = f"Following properties defined multiple times for the same class(es): {self.report}"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class PropertyDefinitionsNotForSamePropertyError(OntologyError):
+    """This error is raised if property definitions are not for linked to the same
+    property id when exporting rules to ontological representation.
+
+    Args:
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+    """
+
+    description = "This error is raised if property definitions are not for linked to the same property id"
+
+    def message(self):
+        message = "All definitions should have the same property_id! Aborting."
+
+        message += f"\nDescription: {self.description}"
+        return message
+
+
+@dataclass(frozen=True)
+class PrefixMissingError(OntologyError):
+    """Prefix, which is in the 'Metadata' sheet, is missing.
+
+    Args:
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    """
+
+    description = "Prefix is missing from the 'Metadata' sheet."
+    example = "There is no prefix in the 'Metadata' sheet."
+    fix = "Specify the prefix if prefix in the 'Metadata' sheet."
+
+    def message(self) -> str:
+        message = "Missing prefix stored in 'Metadata' sheet."
+        message += f"\nDescription: {self.description}"
+        message += f"\nExample: {self.example}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class MissingDataModelPrefixOrNamespaceWarning(ValidationWarning):
+    """Prefix and/or namespace are missing in the 'Metadata' sheet
+
+    Args:
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+    Add missing prefix and/or namespace in the 'Metadata' sheet
+    """
+
+    description = "Either prefix or namespace or both are missing in the 'Metadata' sheet"
+    fix = "Add missing prefix and/or namespace in the 'Metadata' sheet"
+
+    def message(self) -> str:
+        message = (
+            "Instances sheet is present but prefix and/or namespace are missing in 'Metadata' sheet."
+            "Instances sheet will not be processed!"
+        )
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class MetadataSheetNamespaceNotDefinedError(OntologyError):
+    """namespace, which is in the 'Metadata' sheet, is not defined
+
+    Args:
+        namespace: namespace that raised exception
+        verbose: flag that indicates whether to provide enhanced exception message, by default False
+
+    Notes:
+        Check if `namespace` in the `Metadata` sheet is properly constructed as valid URL
+        containing only allowed characters.
+
+    """
+
+    description = "namespace, which is in the 'Metadata' sheet, is missing"
+    example: ClassVar[str] = "Example of a valid namespace 'http://www.w3.org/ns/sparql#'"
+    fix = "Define the 'namespace' in the 'Metadata' sheet."
+
+    def message(self) -> str:
+        message = "Missing namespace  in 'Metadata' sheet."
+        message += f"\nDescription: {self.description}"
+        message += f"\nExample: {self.example}"
+        message += f"\nFix: {self.fix}"
+        return message

cognite/neat/rules/issues/spreadsheet.py

@@ -38,6 +38,7 @@ __all__ = [
     "MultiDefaultError",
     "MultiIndexError",
     "MultiUniqueConstraintError",
+    "RegexViolationError",
 ]
 
 
@@ -277,6 +278,24 @@ class PropertiesDefinedForUndefinedClassesError(NeatValidationError):
         )
 
 
+@dataclass(frozen=True)
+class RegexViolationError(NeatValidationError):
+    description = "Value, {value} failed regex, {regex}, validation."
+    fix = "Make sure that the name follows the regex pattern."
+
+    value: str
+    regex: str
+
+    def dump(self) -> dict[str, str]:
+        output = super().dump()
+        output["value"] = self.value
+        output["regex"] = self.regex
+        return output
+
+    def message(self) -> str:
+        return self.description.format(value=self.value, regex=self.regex)
+
+
 @dataclass(frozen=True)
 class ClassNoPropertiesNoParentError(NeatValidationError):
     description = "Class has no properties and no parents."
@@ -295,6 +314,35 @@ class ClassNoPropertiesNoParentError(NeatValidationError):
         return f"Class {self.classes[0]} have no direct or inherited properties. This may be a mistake."
 
 
+@dataclass(frozen=True)
+class DefaultValueTypeNotProperError(NeatValidationError):
+    """This exceptions is raised when default value type is not proper, i.e. it is not
+    according to the expected value type set in Rules.
+
+
+    Args:
+        default_value_type: default value type that raised exception
+        expected_value_type: expected value type that raised exception
+
+    """
+
+    description = (
+        "This exceptions is raised when default value type is not proper, i.e. it is not "
+        "according to the expected value type set in Rules."
+    )
+    property_id: str
+    default_value_type: str
+    expected_value_type: str
+
+    def message(self) -> str:
+        message = (
+            f"Default value for property {self.property_id} is of type {self.default_value_type} "
+            f"which is different from the expected value type {self.expected_value_type}!"
+        )
+        message += f"\nDescription: {self.description}"
+        return message
+
+
 @dataclass(frozen=True)
 class AssetRulesHaveCircularDependencyError(NeatValidationError):
     description = "Asset rules have circular dependencies."

cognite/neat/rules/issues/tables.py

@@ -0,0 +1,72 @@
+from dataclasses import dataclass
+
+from .base import NeatValidationError
+
+
+@dataclass(frozen=True)
+class NotValidRDFPathError(NeatValidationError):
+    """Provided `rdfpath` is not valid, i.e. it cannot be converted to SPARQL query.
+
+    Args:
+        rdf_path: `rdfpath` that raised exception
+
+    Notes:
+        Get familiar with `rdfpath` to avoid this exception.
+    """
+
+    description = "Provided `rdfpath` is not valid, i.e. it cannot be converted to SPARQL query"
+    fix = "Get familiar with `rdfpath` and check if provided path is valid!"
+    rdf_path: str
+
+    def message(self) -> str:
+        message = f"{self.rdf_path} is not a valid rdfpath!"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class NotValidTableLookUpError(NeatValidationError):
+    """Provided `table lookup` is not valid, i.e. it cannot be converted to CDF lookup.
+
+    Args:
+        table_look_up: `table_look_up`, a part of `rawlookup`, that raised exception
+
+    Notes:
+        Get familiar with `rawlookup` and `rdfpath` to avoid this exception.
+    """
+
+    description = "Provided table lookup is not valid, i.e. it cannot be converted to CDF lookup"
+    fix = "Get familiar with RAW look up and RDF paths and check if provided rawlookup is valid"
+    table_look_up: str
+
+    def message(self) -> str:
+        message = f"{self.table_look_up} is not a valid table lookup"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message
+
+
+@dataclass(frozen=True)
+class NotValidRAWLookUpError(NeatValidationError):
+    """Provided `rawlookup` is not valid, i.e. it cannot be converted to SPARQL query and CDF lookup
+
+    Args:
+        raw_look_up: `rawlookup` rule that raised exception
+
+    Notes:
+        Get familiar with `rawlookup` and `rdfpath` to avoid this exception.
+    """
+
+    description = "Provided rawlookup is not valid, i.e. it cannot be converted to SPARQL query and CDF lookup"
+    fix = "Get familiar with `rawlookup` and `rdfpath` to avoid this exception"
+    raw_look_up: str
+
+    def message(self):
+        message = f"Invalid rawlookup expected traversal | table lookup, got {self.raw_look_up}"
+
+        message += f"\nDescription: {self.description}"
+        message += f"\nFix: {self.fix}"
+        return message

cognite/neat/rules/models/_rdfpath.py

@@ -8,7 +8,7 @@ from typing import ClassVar, Literal
 
 from pydantic import BaseModel, field_validator, model_serializer
 
-from cognite.neat.rules import exceptions
+from cognite.neat.rules.issues.tables import NotValidRAWLookUpError, NotValidRDFPathError, NotValidTableLookUpError
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -313,7 +313,7 @@ def parse_traversal(raw: str) -> SelfReferenceProperty | SingleProperty | Hop:
     elif result := HOP_REGEX_COMPILED.match(raw):
         return Hop.from_string(class_=result.group("origin"), traversal=result.group(_traversal))
     else:
-        raise exceptions.NotValidRDFPath(raw).to_pydantic_custom_error()
+        raise NotValidRDFPathError(raw).as_pydantic_exception()
 
 
 def parse_table_lookup(raw: str) -> TableLookup:
@@ -323,7 +323,7 @@ def parse_table_lookup(raw: str) -> TableLookup:
             key=result.group(Lookup.key),
             value=result.group(Lookup.value),
         )
-    raise exceptions.NotValidTableLookUp(raw).to_pydantic_custom_error()
+    raise NotValidTableLookUpError(raw).as_pydantic_exception()
 
 
 def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPath:
@@ -334,7 +334,7 @@ def parse_rule(rule_raw: str, rule_type: TransformationRuleType | None) -> RDFPa
         case TransformationRuleType.rawlookup:
             rule_raw = rule_raw.replace(" ", "")
             if Counter(rule_raw).get("|") != 1:
-                raise exceptions.NotValidRAWLookUp(rule_raw).to_pydantic_custom_error()
+                raise NotValidRAWLookUpError(rule_raw).as_pydantic_exception()
             traversal, table_lookup = rule_raw.split("|")
             return RawLookup(
                 traversal=parse_traversal(traversal),

cognite/neat/rules/models/_types/_field.py

@@ -1,7 +1,6 @@
-import re
 import warnings
 from collections.abc import Callable
-from typing import Annotated, Any, cast
+from typing import Annotated, Any
 
 import rdflib
 from pydantic import (
@@ -17,11 +16,10 @@ from pydantic import (
 from pydantic.functional_serializers import PlainSerializer
 from pydantic_core import PydanticCustomError
 
-from cognite.neat.rules import exceptions
 from cognite.neat.rules.issues.importing import MoreThanOneNonAlphanumericCharacterWarning
-
-from ._base import (
-    MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX,
+from cognite.neat.rules.issues.spreadsheet import RegexViolationError
+from cognite.neat.utils.regex_patterns import (
+    PATTERNS,
     PREFIX_COMPLIANCE_REGEX,
     PROPERTY_ID_COMPLIANCE_REGEX,
     VERSION_COMPLIANCE_REGEX,
@@ -74,11 +72,7 @@ NamespaceType = Annotated[
 PrefixType = Annotated[
     str,
     StringConstraints(pattern=PREFIX_COMPLIANCE_REGEX),
-    _custom_error(
-        lambda _, value: exceptions.PrefixesRegexViolation(
-            cast(list[str], [value]), PREFIX_COMPLIANCE_REGEX
-        ).to_pydantic_custom_error()
-    ),
+    _custom_error(lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX).as_pydantic_exception()),
 ]
 
 ExternalIdType = Annotated[
@@ -89,18 +83,14 @@ ExternalIdType = Annotated[
 VersionType = Annotated[
     str,
     StringConstraints(pattern=VERSION_COMPLIANCE_REGEX),
-    _custom_error(
-        lambda _, value: exceptions.VersionRegexViolation(
-            version=cast(str, value), regex_expression=VERSION_COMPLIANCE_REGEX
-        ).to_pydantic_custom_error()
-    ),
+    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX).as_pydantic_exception()),
 ]
 
 
 def _property_validation(value: str) -> str:
-    if not re.match(PROPERTY_ID_COMPLIANCE_REGEX, value):
-        _raise(exceptions.PropertyIDRegexViolation(value, PROPERTY_ID_COMPLIANCE_REGEX).to_pydantic_custom_error())
-    if re.search(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX, value):
+    if not PATTERNS.property_id_compliance.match(value):
+        _raise(RegexViolationError(value, PROPERTY_ID_COMPLIANCE_REGEX).as_pydantic_exception())
+    if PATTERNS.more_than_one_alphanumeric.search(value):
         warnings.warn(MoreThanOneNonAlphanumericCharacterWarning("property", value), stacklevel=2)
     return value
 

cognite/neat/rules/models/information/_rules.py

@@ -9,7 +9,8 @@ from rdflib import Namespace
 
 from cognite.neat.constants import get_default_prefixes
 from cognite.neat.issues import MultiValueError
-from cognite.neat.rules import exceptions, issues
+from cognite.neat.rules import issues
+from cognite.neat.rules.issues.spreadsheet import DefaultValueTypeNotProperError
 from cognite.neat.rules.models._base import (
     BaseMetadata,
     BaseRules,
@@ -227,11 +228,11 @@ class InformationProperty(SheetEntity):
                         self.default = self.value_type.python(self.default)
 
                 except Exception:
-                    exceptions.DefaultValueTypeNotProper(
+                    raise DefaultValueTypeNotProperError(
                         self.property_,
                         type(self.default),
-                        self.value_type.python,
-                    )
+                        str(self.value_type.python),
+                    ).as_exception() from None
         return self
 
     @property

cognite/neat/utils/rdf_.py

@@ -1,6 +1,8 @@
 import re
-from typing import Any, Literal, TypeAlias, cast, overload
+from collections.abc import Iterable
+from typing import Any, Literal, TypeAlias, overload
 
+from cognite.client.utils.useful_types import SequenceNotStr
 from pydantic import HttpUrl, TypeAdapter, ValidationError
 from rdflib import Literal as RdfLiteral
 from rdflib import Namespace, URIRef
@@ -10,7 +12,8 @@ Triple: TypeAlias = tuple[URIRef, URIRef, RdfLiteral | URIRef]
 
 @overload
 def remove_namespace_from_uri(
-    *URI: URIRef | str,
+    URI: URIRef | str,
+    *,
     special_separator: str = "#_",
     validation: Literal["full", "prefix"] = "prefix",
 ) -> str: ...
@@ -18,17 +21,19 @@ def remove_namespace_from_uri(
 
 @overload
 def remove_namespace_from_uri(
-    *URI: tuple[URIRef | str, ...],
+    URI: SequenceNotStr[URIRef | str],
+    *,
     special_separator: str = "#_",
     validation: Literal["full", "prefix"] = "prefix",
-) -> tuple[str, ...]: ...
+) -> list[str]: ...
 
 
 def remove_namespace_from_uri(
-    *URI: URIRef | str | tuple[URIRef | str, ...],
+    URI: URIRef | str | SequenceNotStr[URIRef | str],
+    *,
     special_separator: str = "#_",
     validation: Literal["full", "prefix"] = "prefix",
-) -> tuple[str, ...] | str:
+) -> str | list[str]:
     """Removes namespace from URI
 
     Args
@@ -51,11 +56,14 @@ def remove_namespace_from_uri(
         >>> remove_namespace_from_uri("http://www.example.org/index.html#section2", "http://www.example.org/index.html#section3")
         ('section2', 'section3')
     """
+    is_single = False
+    uris: Iterable[str | URIRef]
     if isinstance(URI, str | URIRef):
         uris = (URI,)
-    elif isinstance(URI, tuple):
+        is_single = True
+    elif isinstance(URI, SequenceNotStr):
         # Assume that all elements in the tuple are of the same type following type hint
-        uris = cast(tuple[URIRef | str, ...], URI)
+        uris = URI
     else:
         raise TypeError(f"URI must be of type URIRef or str, got {type(URI)}")
 
@@ -73,7 +81,7 @@ def remove_namespace_from_uri(
             else:
                 output.append(str(u))
 
-    return tuple(output) if len(output) > 1 else output[0]
+    return output[0] if is_single else output
 
 
 def get_namespace(URI: URIRef, special_separator: str = "#_") -> str:

cognite/neat/utils/regex_patterns.py

@@ -0,0 +1,52 @@
+import re
+from functools import cached_property
+
+MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX = r"([_-]{2,})"
+PREFIX_COMPLIANCE_REGEX = r"^([a-zA-Z]+)([a-zA-Z0-9]*[_-]{0,1}[a-zA-Z0-9_-]*)([a-zA-Z0-9]*)$"
+
+VIEW_ID_COMPLIANCE_REGEX = (
+    r"(?!^(Query|Mutation|Subscription|String|Int32|Int64|Int|Float32|Float64|Float|"
+    r"Timestamp|JSONObject|Date|Numeric|Boolean|PageInfo|File|Sequence|TimeSeries)$)"
+    r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+)
+DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
+    r"(?!^(space|externalId|createdTime|lastUpdatedTime|deletedTime|edge_id|"
+    r"node_id|project_id|property_group|seq|tg_table_name|extensions)$)"
+    r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+)
+CLASS_ID_COMPLIANCE_REGEX = r"(?!^(Class|class)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+PROPERTY_ID_COMPLIANCE_REGEX = r"^(\*)|(?!^(Property|property)$)(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+VERSION_COMPLIANCE_REGEX = r"^[a-zA-Z0-9]([.a-zA-Z0-9_-]{0,41}[a-zA-Z0-9])?$"
+
+
+class _Patterns:
+    @cached_property
+    def more_than_one_alphanumeric(self) -> re.Pattern:
+        return re.compile(MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX)
+
+    @cached_property
+    def prefix_compliance(self) -> re.Pattern[str]:
+        return re.compile(PREFIX_COMPLIANCE_REGEX)
+
+    @cached_property
+    def view_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(VIEW_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def dms_property_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(DMS_PROPERTY_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def class_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(CLASS_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def property_id_compliance(self) -> re.Pattern[str]:
+        return re.compile(PROPERTY_ID_COMPLIANCE_REGEX)
+
+    @cached_property
+    def version_compliance(self) -> re.Pattern[str]:
+        return re.compile(VERSION_COMPLIANCE_REGEX)
+
+
+PATTERNS = _Patterns()