cognite-neat 0.107.0__py3-none-any.whl → 0.109.0__py3-none-any.whl

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

@@ -1,18 +1,25 @@
+import itertools
 from collections import Counter, defaultdict
-from collections.abc import Mapping
+from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import ClassVar, cast
+from typing import Any, ClassVar, cast
 
 from cognite.client import data_modeling as dm
-from rdflib import RDF, Namespace, URIRef
+from rdflib import RDF, RDFS, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
-from cognite.neat._issues.warnings import PropertySkippedWarning, PropertyValueTypeUndefinedWarning
-from cognite.neat._rules.models import data_types
+from cognite.neat._constants import NEAT, get_default_prefixes_and_namespaces
+from cognite.neat._issues import IssueList
+from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
+from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.models import InformationRules, data_types
 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 (
+    InformationInputClass,
+    InformationInputProperty,
     InformationMetadata,
 )
 from cognite.neat._store import NeatGraphStore
@@ -74,7 +81,7 @@ class InferenceImporter(BaseRDFImporter):
     def from_graph_store(
         cls,
         store: NeatGraphStore,
-        data_model_id: (dm.DataModelId | tuple[str, str, str]) = DEFAULT_INFERENCE_DATA_MODEL_ID,
+        data_model_id: dm.DataModelId | tuple[str, str, str] = DEFAULT_INFERENCE_DATA_MODEL_ID,
         max_number_of_instance: int = -1,
         non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
         language: str = "en",
@@ -157,7 +164,7 @@ class InferenceImporter(BaseRDFImporter):
         for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
             if (class_id := remove_namespace_from_uri(cast(URIRef, class_uri))) in classes:
                 # handles cases when class id is already present in classes
-                class_id = f"{class_id}_{len(classes)+1}"
+                class_id = f"{class_id}_{len(classes) + 1}"
 
             classes[class_id] = {
                 "class_": class_id,
@@ -187,21 +194,10 @@ class InferenceImporter(BaseRDFImporter):
                     INSTANCE_PROPERTIES_DEFINITION.replace("instance_id", instance)
                 ):  # type: ignore[misc]
                     # this is to skip rdf:type property
+
                     if property_uri == RDF.type:
                         continue
                     property_id = remove_namespace_from_uri(property_uri)
-                    if property_id in {"external_id", "externalId"}:
-                        skip_issue = PropertySkippedWarning(
-                            resource_type="Property",
-                            identifier=f"{class_id}:{property_id}",
-                            property_name=property_id,
-                            reason="External ID is assumed to be the unique identifier of the instance "
-                            "and is not part of the data model schema.",
-                        )
-                        if skip_issue not in self.issue_list:
-                            self.issue_list.append(skip_issue)
-                        continue
-
                     self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
 
                     if isinstance(data_type_uri, URIRef):
@@ -250,13 +246,8 @@ class InferenceImporter(BaseRDFImporter):
                     elif id_ in properties and definition["value_type"] not in properties[id_]["value_type"]:
                         properties[id_]["value_type"].add(definition["value_type"])
 
-                    # USE CASE 3: existing but max count is different
-                    elif (
-                        id_ in properties
-                        and definition["value_type"] in properties[id_]["value_type"]
-                        and properties[id_]["max_count"] != definition["max_count"]
-                    ):
-                        properties[id_]["max_count"] = max(properties[id_]["max_count"], definition["max_count"])
+                    # always update max_count with the upmost value
+                    properties[id_]["max_count"] = max(properties[id_]["max_count"], definition["max_count"])
 
         # Create multi-value properties otherwise single value
         for property_ in properties.values():
@@ -292,3 +283,296 @@ class InferenceImporter(BaseRDFImporter):
     @property
     def source_uri(self) -> URIRef:
         return INSTANCES_ENTITY.id_
+
+
+# Internal helper class
+@dataclass
+class _ReadProperties:
+    type_uri: URIRef
+    property_uri: URIRef
+    value_type: URIRef
+    parent_uri: URIRef | None
+    max_occurrence: int
+    instance_count: int
+
+
+class SubclassInferenceImporter(BaseRDFImporter):
+    """Infer subclasses from a triple store.
+
+    Assumes that the graph already is connected to a schema. The classes should
+    match the RDF.type of the instances in the graph, while the subclasses should
+    match the NEAT.type of the instances in the graph.
+
+    ClassVars:
+        overwrite_data_types: Mapping of data types to be overwritten. The InferenceImporter will overwrite
+            32-bit integer and 32-bit float data types to 64-bit integer and 64-bit float data types
+
+    Args:
+        issue_list: Issue list to store issues
+        graph: Knowledge graph
+    """
+
+    overwrite_data_types: ClassVar[Mapping[URIRef, URIRef]] = {
+        data_types.Integer.as_xml_uri_ref(): data_types.Long.as_xml_uri_ref(),
+        data_types.Float.as_xml_uri_ref(): data_types.Double.as_xml_uri_ref(),
+    }
+
+    _ordered_class_query = """SELECT DISTINCT ?class (count(?s) as ?instances )
+                           WHERE { ?s a ?class }
+                           group by ?class order by DESC(?instances)"""
+
+    _type_parent_query = f"""SELECT ?parent ?type
+                            WHERE {{ ?s a ?type .
+                            ?type <{RDFS.subClassOf}> ?parent }}"""
+
+    _properties_query = """SELECT DISTINCT ?property ?valueType
+                         WHERE {{
+                            ?s a <{type}> .
+                            ?s ?property ?object .
+                            OPTIONAL {{ ?object a ?objectType }}
+                            BIND(
+                               IF(
+                                    isLiteral(?object), datatype(?object),
+                                    IF(BOUND(?objectType), ?objectType, <{unknown_type}>)
+                                ) AS ?valueType
+                            )
+                        }}"""
+
+    _max_occurrence_query = """SELECT (MAX(?count) AS ?maxCount)
+                            WHERE {{
+                              {{
+                                SELECT ?subject (COUNT(?object) AS ?count)
+                                WHERE {{
+                                  ?subject a <{type}> .
+                                  ?subject <{property}> ?object .
+                                }}
+                                GROUP BY ?subject
+                              }}
+                            }}"""
+
+    def __init__(
+        self,
+        issue_list: IssueList,
+        graph: Graph,
+        rules: InformationRules | None = None,
+        data_model_id: dm.DataModelId | tuple[str, str, str] | None = None,
+        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
+    ) -> None:
+        if sum([1 for v in [rules, data_model_id] if v is not None]) != 1:
+            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+        if data_model_id is not None:
+            identifier = data_model_id
+        elif rules is not None:
+            identifier = rules.metadata.as_data_model_id().as_tuple()  # type: ignore[assignment]
+        else:
+            raise ValueError("Exactly one of rules or data_model_id must be provided.")
+        super().__init__(issue_list, graph, identifier, -1, non_existing_node_type, language="en")
+        self._rules = rules
+
+    def _to_rules_components(
+        self,
+    ) -> dict:
+        if self._rules:
+            prefixes = self._rules.prefixes.copy()
+        else:
+            prefixes = get_default_prefixes_and_namespaces()
+
+        parent_by_child = self._read_parent_by_child_from_graph()
+        read_properties = self._read_class_properties_from_graph(parent_by_child)
+        classes, properties = self._create_classes_properties(read_properties, prefixes)
+
+        if self._rules:
+            metadata = self._rules.metadata.model_dump()
+            default_space = self._rules.metadata.prefix
+        else:
+            metadata = self._default_metadata()
+            default_space = metadata["space"]
+        return {
+            "metadata": metadata,
+            "classes": [cls.dump(default_space) for cls in classes],
+            "properties": [prop.dump(default_space) for prop in properties],
+            "prefixes": prefixes,
+        }
+
+    def _create_classes_properties(
+        self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
+    ) -> tuple[list[InformationInputClass], list[InformationInputProperty]]:
+        if self._rules:
+            existing_classes = {class_.class_.suffix: class_ for class_ in self._rules.classes}
+        else:
+            existing_classes = {}
+        classes: list[InformationInputClass] = []
+        properties: list[InformationInputProperty] = []
+        # Help for IDE
+        type_uri: URIRef
+        parent_uri: URIRef
+        for parent_uri, parent_class_properties_iterable in itertools.groupby(
+            sorted(read_properties, key=lambda x: x.parent_uri or NEAT.EmptyType),
+            key=lambda x: x.parent_uri or NEAT.EmptyType,
+        ):
+            properties_by_class_by_property = self._get_properties_by_class_by_property(
+                parent_class_properties_iterable
+            )
+
+            parent_suffix: str | None = None
+            if parent_uri != NEAT.EmptyType:
+                shared_property_uris = set.intersection(
+                    *[
+                        set(properties_by_property.keys())
+                        for properties_by_property in properties_by_class_by_property.values()
+                    ]
+                )
+                parent_suffix = remove_namespace_from_uri(parent_uri)
+                self._add_uri_namespace_to_prefixes(parent_uri, prefixes)
+                if parent_suffix not in existing_classes:
+                    classes.append(InformationInputClass(class_=parent_suffix))
+                else:
+                    classes.append(InformationInputClass.load(existing_classes[parent_suffix].model_dump()))
+            else:
+                shared_property_uris = set()
+            shared_properties: dict[URIRef, list[_ReadProperties]] = defaultdict(list)
+            for type_uri, properties_by_property_uri in properties_by_class_by_property.items():
+                class_suffix = remove_namespace_from_uri(type_uri)
+                self._add_uri_namespace_to_prefixes(type_uri, prefixes)
+
+                if class_suffix not in existing_classes:
+                    classes.append(
+                        InformationInputClass(
+                            class_=class_suffix,
+                            implements=parent_suffix,
+                        )
+                    )
+                else:
+                    classes.append(InformationInputClass.load(existing_classes[class_suffix].model_dump()))
+                for property_uri, read_properties in properties_by_property_uri.items():
+                    if property_uri in shared_property_uris:
+                        shared_properties[property_uri].extend(read_properties)
+                        continue
+                    properties.append(
+                        self._create_property(read_properties, class_suffix, type_uri, property_uri, prefixes)
+                    )
+
+            if parent_suffix:
+                for property_uri, read_properties in shared_properties.items():
+                    properties.append(
+                        self._create_property(
+                            read_properties, parent_suffix, read_properties[0].type_uri, property_uri, prefixes
+                        )
+                    )
+        return classes, properties
+
+    @staticmethod
+    def _get_properties_by_class_by_property(
+        parent_class_properties_iterable: Iterable[_ReadProperties],
+    ) -> dict[URIRef, dict[URIRef, list[_ReadProperties]]]:
+        properties_by_class_by_property: dict[URIRef, dict[URIRef, list[_ReadProperties]]] = {}
+        for class_uri, class_properties_iterable in itertools.groupby(
+            sorted(parent_class_properties_iterable, key=lambda x: x.type_uri), key=lambda x: x.type_uri
+        ):
+            properties_by_class_by_property[class_uri] = defaultdict(list)
+            for read_prop in class_properties_iterable:
+                properties_by_class_by_property[class_uri][read_prop.property_uri].append(read_prop)
+        return properties_by_class_by_property
+
+    def _read_class_properties_from_graph(self, parent_by_child: dict[URIRef, URIRef]) -> list[_ReadProperties]:
+        count_by_type: dict[URIRef, int] = {}
+        # Infers all the classes in the graph
+        for result_row in self.graph.query(self._ordered_class_query):
+            type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
+            count_by_type[type_uri] = instance_count_literal.toPython()
+        if self._rules:
+            analysis = InformationAnalysis(self._rules)
+            existing_class_properties = {
+                (class_entity.suffix, prop.property_)
+                for class_entity, properties in analysis.classes_with_properties(
+                    consider_inheritance=True, allow_different_namespace=True
+                ).items()
+                for prop in properties
+            }
+        else:
+            existing_class_properties = set()
+        properties_by_class_by_subclass: list[_ReadProperties] = []
+        for type_uri, instance_count in count_by_type.items():
+            property_query = self._properties_query.format(type=type_uri, unknown_type=NEAT.UnknownType)
+            class_suffix = remove_namespace_from_uri(type_uri)
+            for result_row in self.graph.query(property_query):
+                property_uri, value_type_uri = cast(tuple[URIRef, URIRef], result_row)
+                if property_uri == RDF.type:
+                    continue
+                property_str = remove_namespace_from_uri(property_uri)
+                if (class_suffix, property_str) in existing_class_properties:
+                    continue
+                occurrence_query = self._max_occurrence_query.format(type=type_uri, property=property_uri)
+                max_occurrence = 1  # default value
+                occurrence_row, *_ = list(self.graph.query(occurrence_query))
+                if occurrence_row:
+                    max_occurrence_literal, *__ = cast(tuple[RdfLiteral, Any], occurrence_row)
+                    max_occurrence = int(max_occurrence_literal.toPython())
+                properties_by_class_by_subclass.append(
+                    _ReadProperties(
+                        type_uri=type_uri,
+                        property_uri=property_uri,
+                        parent_uri=parent_by_child.get(type_uri),
+                        value_type=value_type_uri,
+                        max_occurrence=max_occurrence,
+                        instance_count=instance_count,
+                    )
+                )
+        return properties_by_class_by_subclass
+
+    def _read_parent_by_child_from_graph(self) -> dict[URIRef, URIRef]:
+        parent_by_child: dict[URIRef, URIRef] = {}
+        for result_row in self.graph.query(self._type_parent_query):
+            parent_uri, child_uri = cast(tuple[URIRef, URIRef], result_row)
+            parent_by_child[child_uri] = parent_uri
+        return parent_by_child
+
+    def _create_property(
+        self,
+        read_properties: list[_ReadProperties],
+        class_suffix: str,
+        type_uri: URIRef,
+        property_uri: URIRef,
+        prefixes: dict[str, Namespace],
+    ) -> InformationInputProperty:
+        first = read_properties[0]
+        value_type = self._get_value_type(read_properties, prefixes)
+        property_name = remove_namespace_from_uri(property_uri)
+        self._add_uri_namespace_to_prefixes(property_uri, prefixes)
+
+        return InformationInputProperty(
+            class_=class_suffix,
+            property_=property_name,
+            max_count=first.max_occurrence,
+            value_type=value_type,
+            instance_source=(f"{uri_to_short_form(type_uri, prefixes)}({uri_to_short_form(property_uri, prefixes)})"),
+        )
+
+    def _get_value_type(
+        self, read_properties: list[_ReadProperties], prefixes: dict[str, Namespace]
+    ) -> str | UnknownEntity:
+        value_types = {self.overwrite_data_types.get(prop.value_type, prop.value_type) for prop in read_properties}
+        if len(value_types) == 1:
+            uri_ref = value_types.pop()
+            if uri_ref == NEAT.UnknownType:
+                return UnknownEntity()
+            self._add_uri_namespace_to_prefixes(uri_ref, prefixes)
+            return remove_namespace_from_uri(uri_ref)
+        elif len(value_types) == 0:
+            return UnknownEntity()
+        for uri_ref in value_types:
+            self._add_uri_namespace_to_prefixes(uri_ref, prefixes)
+        return " | ".join(remove_namespace_from_uri(uri_ref) for uri_ref in value_types)
+
+    def _default_metadata(self) -> dict[str, Any]:
+        now = datetime.now(timezone.utc)
+        return InformationMetadata(
+            space=self.data_model_id.space,
+            external_id=self.data_model_id.external_id,
+            version=cast(str, self.data_model_id.version),
+            name="Inferred Model",
+            creator=["NEAT"],
+            created=now,
+            updated=now,
+            description="Inferred model from knowledge graph",
+        ).model_dump()

cognite/neat/_rules/models/_base_rules.py

@@ -21,6 +21,7 @@ from typing import (
 )
 
 import pandas as pd
+from cognite.client import data_modeling as dm
 from pydantic import (
     BaseModel,
     BeforeValidator,
@@ -180,6 +181,12 @@ class BaseMetadata(SchemaModel):
         description="Date of the data model update",
     )
 
+    source_id: URIRefType | None = Field(
+        None,
+        description="Id of source that produced this rules",
+        alias="sourceId",
+    )
+
     @field_validator("*", mode="before")
     def strip_string(cls, value: Any) -> Any:
         if isinstance(value, str):
@@ -213,9 +220,6 @@ class BaseMetadata(SchemaModel):
     def prefix(self) -> str:
         return self.space
 
-    def as_identifier(self) -> str:
-        return f"{self.prefix}:{self.external_id}"
-
     def get_prefix(self) -> str:
         return self.prefix
 
@@ -234,6 +238,12 @@ class BaseMetadata(SchemaModel):
         """Namespace for the data model used for the entities in the data model."""
         return Namespace(f"{self.identifier}/")
 
+    def as_data_model_id(self) -> dm.DataModelId:
+        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
+
+    def as_identifier(self) -> str:
+        return repr(self.as_data_model_id())
+
 
 class BaseRules(SchemaModel, ABC):
     """
@@ -291,6 +301,7 @@ class BaseRules(SchemaModel, ABC):
     def dump(
         self,
         entities_exclude_defaults: bool = True,
+        sort: bool = False,
         mode: Literal["python", "json"] = "python",
         by_alias: bool = False,
         exclude: IncEx | None = None,
@@ -307,6 +318,7 @@ class BaseRules(SchemaModel, ABC):
                 For example, given a class that is dumped as 'my_prefix:MyClass', if the prefix for the rules
                 set in metadata.prefix = 'my_prefix', then this class will be dumped as 'MyClass' when this flag is set.
                 Defaults to True.
+            sort: Whether to sort the entities in the output.
             mode: The mode in which `to_python` should run.
                 If mode is 'json', the output will only contain JSON serializable types.
                 If mode is 'python', the output may contain non-JSON-serializable Python objects.
@@ -316,11 +328,12 @@ class BaseRules(SchemaModel, ABC):
             exclude_unset: Whether to exclude fields that have not been explicitly set.
             exclude_defaults: Whether to exclude fields that are set to their default value.
         """
-        for field_name in self.model_fields.keys():
-            value = getattr(self, field_name)
-            # Ensure deterministic order of properties, classes, views, and so on
-            if isinstance(value, SheetList):
-                value.sort(key=lambda x: x._identifier())
+        if sort:
+            for field_name in self.model_fields.keys():
+                value = getattr(self, field_name)
+                # Ensure deterministic order of properties, classes, views, and so on
+                if isinstance(value, SheetList):
+                    value.sort(key=lambda x: x._identifier())
 
         context: dict[str, Any] = {}
         if entities_exclude_defaults:
@@ -328,7 +341,7 @@ class BaseRules(SchemaModel, ABC):
 
         exclude_input: IncEx | None = exclude
 
-        output = self.model_dump(
+        return self.model_dump(
             mode=mode,
             by_alias=by_alias,
             exclude=exclude_input,
@@ -338,8 +351,6 @@ class BaseRules(SchemaModel, ABC):
             context=context,
         )
 
-        return output
-
 
 class SheetRow(SchemaModel):
     neatId: URIRefType | None = Field(

cognite/neat/_rules/models/dms/_exporter.py

@@ -292,10 +292,11 @@ class _DMSExporter:
         for container in containers:
             container_id = container.as_id()
             if not (container_properties := container_properties_by_id.get(container_id)):
-                warnings.warn(
-                    EmptyContainerWarning(container_id),
-                    stacklevel=2,
-                )
+                if container_id.space not in COGNITE_SPACES:
+                    warnings.warn(
+                        EmptyContainerWarning(container_id),
+                        stacklevel=2,
+                    )
                 container_to_drop.add(container_id)
                 continue
             for prop in container_properties:

cognite/neat/_rules/models/dms/_rules.py

@@ -64,9 +64,6 @@ class DMSMetadata(BaseMetadata):
             space=self.space,
         )
 
-    def as_data_model_id(self) -> dm.DataModelId:
-        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
-
     def as_data_model(self) -> dm.DataModelApply:
         suffix = f"Creator: {', '.join(self.creator)}"
         if self.description:
@@ -83,9 +80,6 @@ class DMSMetadata(BaseMetadata):
             views=[],
         )
 
-    def as_identifier(self) -> str:
-        return repr(self.as_data_model_id())
-
     def get_prefix(self) -> str:
         return self.space
 
@@ -109,8 +103,7 @@ class DMSProperty(SheetRow):
     )
     value_type: DataType | ViewEntity | DMSUnknownEntity = Field(
         alias="Value Type",
-        description="Value type that the property can hold. "
-        "It takes either subset of CDF primitive types or a View id",
+        description="Value type that the property can hold. It takes either subset of CDF primitive types or a View id",
     )
     nullable: bool | None = Field(
         default=None,

cognite/neat/_rules/models/dms/_rules_input.py

@@ -37,6 +37,7 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
     created: datetime | str | None = None
     updated: datetime | str | None = None
     logical: str | URIRef | None = None
+    source_id: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[DMSMetadata]:
@@ -77,6 +78,9 @@ class DMSInputMetadata(InputComponent[DMSMetadata]):
             description = None
         return description, creator
 
+    def as_data_model_id(self) -> dm.DataModelId:
+        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
+
     @property
     def identifier(self) -> URIRef:
         """Globally unique identifier for the data model.

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

@@ -3,6 +3,7 @@ from datetime import datetime
 from typing import Any
 
 import pandas as pd
+from cognite.client import data_modeling as dm
 from rdflib import Namespace, URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
@@ -36,6 +37,7 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
     updated: datetime | str | None = None
     physical: str | URIRef | None = None
     conceptual: str | URIRef | None = None
+    source_id: str | URIRef | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationMetadata]:
@@ -49,6 +51,9 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
             output["updated"] = datetime.now()
         return output
 
+    def as_data_model_id(self) -> dm.DataModelId:
+        return dm.DataModelId(space=self.space, external_id=self.external_id, version=self.version)
+
     @property
     def prefix(self) -> str:
         return self.space

cognite/neat/_rules/transformers/__init__.py

@@ -1,14 +1,17 @@
-from ._base import RulesTransformer
+from ._base import RulesTransformer, VerifiedRulesTransformer
 from ._converters import (
     AddClassImplements,
     ChangeViewPrefix,
     ClassicPrepareCore,
+    ConversionTransformer,
     ConvertToRules,
     DMSToInformation,
+    DropModelViews,
     IncludeReferenced,
     InformationToDMS,
+    MergeDMSRules,
+    MergeInformationRules,
     PrefixEntities,
-    ReduceCogniteModel,
     SetIDDMSModel,
     ToCompliantEntities,
     ToDataProductModel,
@@ -24,13 +27,16 @@ __all__ = [
     "AsParentPropertyId",
     "ChangeViewPrefix",
     "ClassicPrepareCore",
+    "ConversionTransformer",
     "ConvertToRules",
     "DMSToInformation",
+    "DropModelViews",
     "IncludeReferenced",
     "InformationToDMS",
     "MapOneToOne",
+    "MergeDMSRules",
+    "MergeInformationRules",
     "PrefixEntities",
-    "ReduceCogniteModel",
     "RuleMapper",
     "RulesTransformer",
     "SetIDDMSModel",
@@ -39,6 +45,7 @@ __all__ = [
     "ToEnterpriseModel",
     "ToExtensionModel",
     "ToSolutionModel",
+    "VerifiedRulesTransformer",
     "VerifyAnyRules",
     "VerifyDMSRules",
     "VerifyInformationRules",

cognite/neat/_rules/transformers/_base.py

@@ -5,12 +5,14 @@ from types import UnionType
 from typing import Generic, TypeVar, Union, get_args, get_origin
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._rules._shared import ReadRules, Rules
+from cognite.neat._rules._shared import ReadRules, Rules, VerifiedRules
 from cognite.neat._rules.models import DMSInputRules, InformationInputRules
 from cognite.neat._store._provenance import Agent as ProvenanceAgent
 
 T_RulesIn = TypeVar("T_RulesIn", bound=Rules)
 T_RulesOut = TypeVar("T_RulesOut", bound=Rules)
+T_VerifiedIn = TypeVar("T_VerifiedIn", bound=VerifiedRules)
+T_VerifiedOut = TypeVar("T_VerifiedOut", bound=VerifiedRules)
 
 
 class RulesTransformer(ABC, Generic[T_RulesIn, T_RulesOut]):
@@ -62,3 +64,6 @@ class RulesTransformer(ABC, Generic[T_RulesIn, T_RulesOut]):
             return ReadRules[DMSInputRules], ReadRules[InformationInputRules]
 
         return (annotation,)
+
+
+class VerifiedRulesTransformer(RulesTransformer[T_VerifiedIn, T_VerifiedOut], ABC): ...