cognite-neat 0.92.3__py3-none-any.whl → 0.93.0__py3-none-any.whl

cognite/neat/{rules → _rules}/importers/_rdf/_inference2rules.py

@@ -3,23 +3,21 @@ from datetime import datetime
 from pathlib import Path
 from typing import cast
 
-from rdflib import RDF, Graph, Namespace, URIRef
+from rdflib import RDF
 from rdflib import Literal as RdfLiteral
 
-from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
-from cognite.neat.issues import IssueList
-from cognite.neat.issues.errors import FileReadError
-from cognite.neat.issues.warnings import PropertyValueTypeUndefinedWarning
-from cognite.neat.rules._shared import ReadRules
-from cognite.neat.rules.importers._base import BaseImporter
-from cognite.neat.rules.models._base_rules import MatchType
-from cognite.neat.rules.models.entities._single_value import UnknownEntity
-from cognite.neat.rules.models.information import (
-    InformationInputRules,
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
+from cognite.neat._rules.models._base_rules import MatchType
+from cognite.neat._rules.models.data_types import AnyURI
+from cognite.neat._rules.models.entities._single_value import UnknownEntity
+from cognite.neat._rules.models.information import (
     InformationMetadata,
 )
-from cognite.neat.store import NeatGraphStore
-from cognite.neat.utils.rdf_ import get_namespace, remove_namespace_from_uri, uri_to_short_form
+from cognite.neat._store import NeatGraphStore
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+
+from ._base import DEFAULT_NON_EXISTING_NODE_TYPE, BaseRDFImporter
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -36,7 +34,7 @@ INSTANCE_PROPERTIES_DEFINITION = """SELECT ?property (count(?property) as ?occur
                                     GROUP BY ?property ?dataType ?objectType"""
 
 
-class InferenceImporter(BaseImporter[InformationInputRules]):
+class InferenceImporter(BaseRDFImporter):
     """Infers rules from a triple store.
 
     Rules inference through analysis of knowledge graph provided in various formats.
@@ -50,62 +48,32 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
         prefix: Prefix to be used for the inferred model
     """
 
-    def __init__(
-        self,
-        issue_list: IssueList,
-        graph: Graph,
-        max_number_of_instance: int = -1,
-        prefix: str = "inferred",
-    ) -> None:
-        self.issue_list = issue_list
-        self.graph = graph
-        self.max_number_of_instance = max_number_of_instance
-        self.prefix = prefix
-
     @classmethod
     def from_graph_store(
         cls,
         store: NeatGraphStore,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> "InferenceImporter":
-        issue_list = IssueList(title="Inferred from graph store")
-
-        return cls(
-            issue_list,
-            store.graph,
-            max_number_of_instance=max_number_of_instance,
-            prefix=prefix,
-        )
+        return super().from_graph_store(store, prefix, max_number_of_instance, non_existing_node_type)
 
     @classmethod
-    def from_rdf_file(
+    def from_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
     ) -> "InferenceImporter":
-        issue_list = IssueList(title=f"'{filepath.name}'")
-
-        graph = Graph()
-        try:
-            graph.parse(filepath)
-        except Exception as e:
-            issue_list.append(FileReadError(filepath, str(e)))
-
-        return cls(
-            issue_list,
-            graph,
-            max_number_of_instance=max_number_of_instance,
-            prefix=prefix,
-        )
+        return super().from_file(filepath, prefix, max_number_of_instance, non_existing_node_type)
 
     @classmethod
     def from_json_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
@@ -113,8 +81,8 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
     def from_yaml_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("YAML file format is not supported yet.")
 
@@ -122,27 +90,11 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
     def from_xml_file(
         cls,
         filepath: Path,
-        max_number_of_instance: int = -1,
         prefix: str = "inferred",
+        max_number_of_instance: int = -1,
     ) -> "InferenceImporter":
         raise NotImplementedError("JSON file format is not supported yet.")
 
-    def to_rules(
-        self,
-    ) -> ReadRules[InformationInputRules]:
-        """
-        Creates `Rules` object from the data for target role.
-        """
-
-        if self.issue_list.has_errors:
-            # In case there were errors during the import, the to_rules method will return None
-            return ReadRules(None, self.issue_list, {})
-
-        rules_dict = self._to_rules_components()
-
-        rules = InformationInputRules.load(rules_dict)
-        return ReadRules(rules, self.issue_list, {})
-
     def _to_rules_components(
         self,
     ) -> dict:
@@ -157,16 +109,10 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
         """
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
-        prefixes: dict[str, Namespace] = get_default_prefixes()
         count_by_value_type_by_property: dict[str, dict[str, int]] = defaultdict(Counter)
 
-        # Adds default namespace to prefixes
-        prefixes[self._default_metadata().prefix] = self._default_metadata().namespace
-
         # Infers all the classes in the graph
         for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
-            self._add_uri_namespace_to_prefixes(cast(URIRef, class_uri), prefixes)
-
             if (class_id := remove_namespace_from_uri(class_uri)) in classes:
                 # handles cases when class id is already present in classes
                 class_id = f"{class_id}_{len(classes)+1}"
@@ -195,27 +141,24 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
 
                     property_id = remove_namespace_from_uri(property_uri)
 
-                    self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
-
                     if value_type_uri := (data_type_uri or object_type_uri):
-                        self._add_uri_namespace_to_prefixes(cast(URIRef, value_type_uri), prefixes)
-
                         value_type_id = remove_namespace_from_uri(value_type_uri)
 
                     # this handles situations when property points to node that is not present in graph
                     else:
-                        value_type_id = str(UnknownEntity())
-
-                        self.issue_list.append(
-                            PropertyValueTypeUndefinedWarning(
-                                resource_type="Property",
-                                identifier=f"{class_id}{property_id}",
-                                property_name=property_id,
-                                default_action="Remove the property from the rules",
-                                recommended_action="Make sure that graph is complete",
-                            )
+                        value_type_id = str(self.non_existing_node_type)
+
+                        issue = PropertyValueTypeUndefinedWarning(
+                            resource_type="Property",
+                            identifier=f"{class_id}:{property_id}",
+                            property_name=property_id,
+                            default_action="Remove the property from the rules",
+                            recommended_action="Make sure that graph is complete",
                         )
 
+                        if issue not in self.issue_list:
+                            self.issue_list.append(issue)
+
                     id_ = f"{class_id}:{property_id}"
 
                     definition = {
@@ -224,10 +167,6 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
                         "reference": property_uri,
-                        "transformation": (
-                            f"{uri_to_short_form(class_definition['reference'], prefixes)}"
-                            f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
-                        ),
                     }
 
                     count_by_value_type_by_property[id_][value_type_id] += 1
@@ -279,20 +218,8 @@ class InferenceImporter(BaseImporter[InformationInputRules]):
             "metadata": self._default_metadata().model_dump(),
             "classes": list(classes.values()),
             "properties": list(properties.values()),
-            "prefixes": prefixes,
         }
 
-    @classmethod
-    def _add_uri_namespace_to_prefixes(cls, URI: URIRef, prefixes: dict[str, Namespace]):
-        """Add URI to prefixes dict if not already present
-
-        Args:
-            URI: URI from which namespace is being extracted
-            prefixes: Dict of prefixes and namespaces
-        """
-        if Namespace(get_namespace(URI)) not in prefixes.values():
-            prefixes[f"prefix-{len(prefixes)+1}"] = Namespace(get_namespace(URI))
-
     def _default_metadata(self):
         return InformationMetadata(
             name="Inferred Model",

cognite/neat/{rules → _rules}/importers/_rdf/_owl2rules/_owl2classes.py

@@ -2,7 +2,7 @@ from typing import cast
 
 from rdflib import Graph
 
-from cognite.neat.rules.importers._rdf._shared import (
+from cognite.neat._rules.importers._rdf._shared import (
     clean_up_classes,
     make_classes_compliant,
     parse_raw_classes_dataframe,

cognite/neat/{rules → _rules}/importers/_rdf/_owl2rules/_owl2metadata.py

@@ -1,10 +1,10 @@
 from rdflib import Graph, Namespace
 
-from cognite.neat.constants import DEFAULT_NAMESPACE
-from cognite.neat.rules.importers._rdf._shared import make_metadata_compliant
-from cognite.neat.rules.models import RoleTypes, SchemaCompleteness
-from cognite.neat.utils.collection_ import remove_none_elements_from_set
-from cognite.neat.utils.rdf_ import convert_rdflib_content
+from cognite.neat._constants import DEFAULT_NAMESPACE
+from cognite.neat._rules.importers._rdf._shared import make_metadata_compliant
+from cognite.neat._rules.models import RoleTypes, SchemaCompleteness
+from cognite.neat._utils.collection_ import remove_none_elements_from_set
+from cognite.neat._utils.rdf_ import convert_rdflib_content
 
 
 def parse_owl_metadata(graph: Graph) -> dict:

cognite/neat/{rules → _rules}/importers/_rdf/_owl2rules/_owl2properties.py

@@ -2,7 +2,7 @@ from typing import cast
 
 from rdflib import Graph
 
-from cognite.neat.rules.importers._rdf._shared import (
+from cognite.neat._rules.importers._rdf._shared import (
     clean_up_properties,
     make_properties_compliant,
     parse_raw_properties_dataframe,

cognite/neat/_rules/importers/_rdf/_owl2rules/_owl2rules.py

@@ -0,0 +1,39 @@
+"""This module performs importing of various formats to one of serializations for which
+there are loaders to TransformationRules pydantic class."""
+
+from cognite.neat._rules.importers._rdf._base import BaseRDFImporter
+from cognite.neat._rules.importers._rdf._shared import make_components_compliant
+
+from ._owl2classes import parse_owl_classes
+from ._owl2metadata import parse_owl_metadata
+from ._owl2properties import parse_owl_properties
+
+
+class OWLImporter(BaseRDFImporter):
+    """Convert OWL ontology to tables/ transformation rules / Excel file.
+
+        Args:
+            filepath: Path to OWL ontology
+
+    !!! Note
+        OWL Ontologies are information models which completeness varies. As such, constructing functional
+        data model directly will often be impossible, therefore the produced Rules object will be ill formed.
+        To avoid this, neat will automatically attempt to make the imported rules compliant by adding default
+        values for missing information, attaching dangling properties to default containers based on the
+        property type, etc.
+
+        One has to be aware that NEAT will be opinionated about how to make the ontology
+        compliant, and that the resulting rules may not be what you expect.
+
+    """
+
+    def _to_rules_components(
+        self,
+    ) -> dict:
+        components = {
+            "Metadata": parse_owl_metadata(self.graph),
+            "Classes": parse_owl_classes(self.graph),
+            "Properties": parse_owl_properties(self.graph),
+        }
+
+        return make_components_compliant(components)

cognite/neat/{rules → _rules}/importers/_rdf/_shared.py

@@ -4,10 +4,10 @@ import numpy as np
 import pandas as pd
 from rdflib import OWL, Literal, Namespace
 
-from cognite.neat.rules.models._base_rules import MatchType
-from cognite.neat.rules.models.data_types import _XSD_TYPES
-from cognite.neat.utils.rdf_ import remove_namespace_from_uri
-from cognite.neat.utils.regex_patterns import PATTERNS
+from cognite.neat._rules._constants import PATTERNS
+from cognite.neat._rules.models._base_rules import MatchType
+from cognite.neat._rules.models.data_types import _XSD_TYPES
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
 
 def parse_raw_classes_dataframe(query_results: list[tuple]) -> pd.DataFrame:

cognite/neat/{rules → _rules}/importers/_spreadsheet2rules.py

@@ -13,23 +13,23 @@ from cognite.client.utils._importing import local_import
 from pandas import ExcelFile
 from rdflib import Namespace
 
-from cognite.neat.issues import IssueList
-from cognite.neat.issues.errors import (
+from cognite.neat._issues import IssueList
+from cognite.neat._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotFoundNeatError,
     FileReadError,
     PropertyDefinitionDuplicatedError,
 )
-from cognite.neat.issues.warnings import FileMissingRequiredFieldWarning
-from cognite.neat.rules._shared import ReadRules, T_InputRules
-from cognite.neat.rules.models import (
+from cognite.neat._issues.warnings import FileMissingRequiredFieldWarning
+from cognite.neat._rules._shared import ReadRules, T_InputRules
+from cognite.neat._rules.models import (
     INPUT_RULES_BY_ROLE,
     VERIFIED_RULES_BY_ROLE,
     RoleTypes,
     SchemaCompleteness,
 )
-from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
-from cognite.neat.utils.text import humanize_collection
+from cognite.neat._utils.spreadsheet import SpreadsheetRead, read_individual_sheet
+from cognite.neat._utils.text import humanize_collection
 
 from ._base import BaseImporter
 

cognite/neat/{rules → _rules}/importers/_yaml2rules.py

@@ -3,16 +3,16 @@ from typing import Any, cast
 
 import yaml
 
-from cognite.neat.issues import IssueList, NeatIssue
-from cognite.neat.issues.errors import (
+from cognite.neat._issues import IssueList, NeatIssue
+from cognite.neat._issues.errors import (
     FileMissingRequiredFieldError,
     FileNotAFileError,
     FileNotFoundNeatError,
     FileTypeUnexpectedError,
 )
-from cognite.neat.issues.warnings import NeatValueWarning
-from cognite.neat.rules._shared import ReadRules, T_InputRules
-from cognite.neat.rules.models import INPUT_RULES_BY_ROLE, RoleTypes
+from cognite.neat._issues.warnings import NeatValueWarning
+from cognite.neat._rules._shared import ReadRules, T_InputRules
+from cognite.neat._rules.models import INPUT_RULES_BY_ROLE, RoleTypes
 
 from ._base import BaseImporter
 

cognite/neat/{rules → _rules}/models/__init__.py

@@ -1,8 +1,8 @@
-from cognite.neat.rules.models.asset._rules import AssetRules
-from cognite.neat.rules.models.asset._rules_input import AssetInputRules
-from cognite.neat.rules.models.domain import DomainInputRules, DomainRules
-from cognite.neat.rules.models.information._rules import InformationRules
-from cognite.neat.rules.models.information._rules_input import InformationInputRules
+from cognite.neat._rules.models.asset._rules import AssetRules
+from cognite.neat._rules.models.asset._rules_input import AssetInputRules
+from cognite.neat._rules.models.domain import DomainInputRules, DomainRules
+from cognite.neat._rules.models.information._rules import InformationRules
+from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
 from ._base_rules import DataModelType, ExtensionCategory, RoleTypes, SchemaCompleteness, SheetList, SheetRow
 from .dms._rules import DMSRules

cognite/neat/{rules → _rules}/models/_base_input.py

@@ -18,6 +18,8 @@ from dataclasses import Field, dataclass, fields, is_dataclass
 from types import GenericAlias, UnionType
 from typing import Any, Generic, TypeVar, Union, cast, get_args, get_origin, overload
 
+import pandas as pd
+
 from ._base_rules import BaseRules, SchemaModel
 
 if sys.version_info >= (3, 11):
@@ -40,14 +42,14 @@ class InputRules(Generic[T_BaseRules], ABC):
 
     @classmethod
     @overload
-    def load(cls, data: dict[str, Any]) -> Self: ...
+    def load(cls: "type[T_InputRules]", data: dict[str, Any]) -> "T_InputRules": ...
 
     @classmethod
     @overload
-    def load(cls, data: None) -> None: ...
+    def load(cls: "type[T_InputRules]", data: None) -> None: ...
 
     @classmethod
-    def load(cls, data: dict | None) -> Self | None:
+    def load(cls: "type[T_InputRules]", data: dict | None) -> "T_InputRules | None":
         if data is None:
             return None
         return cls._load(data)
@@ -62,14 +64,15 @@ class InputRules(Generic[T_BaseRules], ABC):
             if isinstance(type_, str) and type_.startswith(cls.__name__):
                 type_ = cls
 
+            candidate: type
             if is_dataclass(type_):
-                candidate = type_
+                candidate = type_  # type: ignore[assignment]
             elif isinstance(type_, GenericAlias) and type_.__origin__ is list and is_dataclass(type_.__args__[0]):
-                candidate = type_.__args__[0]
+                candidate = type_.__args__[0]  # type: ignore[assignment]
 
             # this handles prefixes
             elif isinstance(type_, GenericAlias) and type_.__origin__ is dict:
-                candidate = type_
+                candidate = type_  # type: ignore[assignment]
             else:
                 continue
 
@@ -124,6 +127,9 @@ class InputRules(Generic[T_BaseRules], ABC):
         return output
 
 
+T_InputRules = TypeVar("T_InputRules", bound=InputRules)
+
+
 @dataclass
 class InputComponent(ABC, Generic[T_RuleModel]):
     @classmethod
@@ -170,3 +176,6 @@ class InputComponent(ABC, Generic[T_RuleModel]):
             for name, field_ in self._get_verified_cls().model_fields.items()
             if not field_.exclude
         }
+
+    def _repr_html_(self) -> str:
+        return pd.DataFrame([self.dump()])._repr_html_()  # type: ignore[operator]

cognite/neat/{rules → _rules}/models/_base_rules.py

@@ -24,6 +24,8 @@ from pydantic import (
 from pydantic.main import IncEx
 from pydantic_core import core_schema
 
+from cognite.neat._rules.models._types import ClassEntityType, InformationPropertyType
+
 if sys.version_info >= (3, 11):
     from enum import StrEnum
     from typing import Self
@@ -208,7 +210,7 @@ class BaseRules(SchemaModel, ABC):
         as_reference: bool = False,
         mode: Literal["python", "json"] = "python",
         by_alias: bool = False,
-        exclude: IncEx = None,
+        exclude: IncEx | None = None,
         exclude_none: bool = False,
         exclude_unset: bool = False,
         exclude_defaults: bool = False,
@@ -244,7 +246,7 @@ class BaseRules(SchemaModel, ABC):
         if entities_exclude_defaults:
             context["metadata"] = self.metadata
 
-        exclude_input: IncEx
+        exclude_input: IncEx | None
         if self.reference is None:
             exclude_input = exclude
         else:
@@ -348,3 +350,13 @@ ExtensionCategoryType = Annotated[
     ),
     BeforeValidator(lambda v: ExtensionCategory(v) if isinstance(v, str) else v),
 ]
+
+
+# Immutable such that this can be used as a key in a dictionary
+class PropertyRef(BaseModel, frozen=True):
+    class_: ClassEntityType = Field(alias="Class")
+    property_: InformationPropertyType = Field(alias="Property")
+
+
+class ClassRef(BaseModel, frozen=True):
+    class_: ClassEntityType = Field(alias="Class")

cognite/neat/{rules → _rules}/models/_rdfpath.py

@@ -8,7 +8,7 @@ from typing import ClassVar, Literal
 
 from pydantic import BaseModel, field_validator, model_serializer
 
-from cognite.neat.issues.errors import NeatValueError
+from cognite.neat._issues.errors import NeatValueError
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum

cognite/neat/_rules/models/_types.py

@@ -0,0 +1,151 @@
+import warnings
+from collections.abc import Callable
+from typing import Annotated, Any, TypeAlias, TypeVar
+
+import rdflib
+from pydantic import (
+    AfterValidator,
+    BeforeValidator,
+    HttpUrl,
+    StringConstraints,
+    TypeAdapter,
+    ValidationInfo,
+    WrapValidator,
+)
+from pydantic.functional_serializers import PlainSerializer
+
+from cognite.neat._issues.errors import RegexViolationError
+from cognite.neat._issues.warnings import RegexViolationWarning
+from cognite.neat._rules._constants import (
+    DATA_MODEL_COMPLIANCE_REGEX,
+    PATTERNS,
+    PREFIX_COMPLIANCE_REGEX,
+    VERSION_COMPLIANCE_REGEX,
+    EntityTypes,
+)
+from cognite.neat._rules.models.entities._multi_value import MultiValueTypeInfo
+from cognite.neat._rules.models.entities._single_value import (
+    ClassEntity,
+    ContainerEntity,
+    ViewEntity,
+)
+
+Entities: TypeAlias = ClassEntity | ViewEntity | ContainerEntity
+T_Entities = TypeVar("T_Entities", bound=Entities)
+
+
+def _custom_error(exc_factory: Callable[[str | None, Exception], Any]) -> Any:
+    def _validator(value: Any, next_: Any, ctx: ValidationInfo) -> Any:
+        try:
+            return next_(value, ctx)
+        except Exception:
+            raise exc_factory(ctx.field_name, value) from None
+
+    return WrapValidator(_validator)
+
+
+StrOrListType = Annotated[
+    str | list[str],
+    BeforeValidator(lambda value: value.replace(", ", ",").split(",") if isinstance(value, str) and value else value),
+    PlainSerializer(
+        lambda value: ",".join([entry for entry in value if entry]) if isinstance(value, list) else value,
+        return_type=str,
+        when_used="unless-none",
+    ),
+]
+
+StrListType = Annotated[
+    list[str],
+    BeforeValidator(lambda value: [entry.strip() for entry in value.split(",")] if isinstance(value, str) else value),
+    PlainSerializer(
+        lambda value: ",".join([entry for entry in value if entry]), return_type=str, when_used="unless-none"
+    ),
+]
+
+NamespaceType = Annotated[
+    rdflib.Namespace,
+    BeforeValidator(
+        lambda value: (
+            rdflib.Namespace(TypeAdapter(HttpUrl).validate_python(value))
+            if value.endswith("#") or value.endswith("/")
+            else rdflib.Namespace(TypeAdapter(HttpUrl).validate_python(f"{value}/"))
+        )
+    ),
+]
+
+PrefixType = Annotated[
+    str,
+    StringConstraints(pattern=PREFIX_COMPLIANCE_REGEX),
+    _custom_error(lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX)),
+]
+
+DataModelExternalIdType = Annotated[
+    str,
+    StringConstraints(pattern=DATA_MODEL_COMPLIANCE_REGEX),
+    _custom_error(lambda _, value: RegexViolationError(value, DATA_MODEL_COMPLIANCE_REGEX)),
+]
+
+
+VersionType = Annotated[
+    str,
+    BeforeValidator(str),
+    StringConstraints(pattern=VERSION_COMPLIANCE_REGEX),
+    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX)),
+]
+
+
+def _external_id_validation_factory(entity_type: EntityTypes):
+    def _external_id_validation(value: str) -> str:
+        compiled_regex = PATTERNS.entity_pattern(entity_type)
+        if not compiled_regex.match(value):
+            raise RegexViolationError(value, compiled_regex.pattern)
+        if PATTERNS.more_than_one_alphanumeric.search(value):
+            warnings.warn(
+                RegexViolationWarning(
+                    value,
+                    compiled_regex.pattern,
+                    "property",
+                    "MoreThanOneNonAlphanumeric",
+                ),
+                stacklevel=2,
+            )
+        return value
+
+    return _external_id_validation
+
+
+SpaceType = Annotated[
+    str,
+    AfterValidator(_external_id_validation_factory(EntityTypes.space)),
+]
+
+InformationPropertyType = Annotated[
+    str,
+    AfterValidator(_external_id_validation_factory(EntityTypes.information_property)),
+]
+DmsPropertyType = Annotated[
+    str,
+    AfterValidator(_external_id_validation_factory(EntityTypes.dms_property)),
+]
+
+
+def _entity_validation(value: Entities) -> Entities:
+    suffix_regex = PATTERNS.entity_pattern(value.type_)
+    if not suffix_regex.match(value.suffix):
+        raise RegexViolationError(str(value), suffix_regex.pattern)
+    return value
+
+
+ClassEntityType = Annotated[ClassEntity, AfterValidator(_entity_validation)]
+ViewEntityType = Annotated[ViewEntity, AfterValidator(_entity_validation)]
+ContainerEntityType = Annotated[ContainerEntity, AfterValidator(_entity_validation)]
+
+
+def _multi_value_type_validation(value: MultiValueTypeInfo) -> MultiValueTypeInfo:
+    for type_ in value.types:
+        if isinstance(type_, ClassEntity):
+            _entity_validation(type_)
+    return value
+
+
+MultiValueTypeType = Annotated[MultiValueTypeInfo, AfterValidator(_multi_value_type_validation)]