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

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

@@ -7,10 +7,10 @@ from pathlib import Path
 from typing import Any, ClassVar, cast
 
 from cognite.client import data_modeling as dm
-from rdflib import RDF, Graph, Namespace, URIRef
+from rdflib import RDF, RDFS, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
-from cognite.neat._constants import NEAT
+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
@@ -81,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",
@@ -194,6 +194,7 @@ 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)
@@ -245,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,11 +288,10 @@ class InferenceImporter(BaseRDFImporter):
 # Internal helper class
 @dataclass
 class _ReadProperties:
-    class_uri: URIRef
-    subclass_uri: URIRef
+    type_uri: URIRef
     property_uri: URIRef
-    data_type: URIRef | None
-    object_type: URIRef | None
+    value_type: URIRef
+    parent_uri: URIRef | None
     max_occurrence: int
     instance_count: int
 
@@ -315,7 +310,6 @@ class SubclassInferenceImporter(BaseRDFImporter):
     Args:
         issue_list: Issue list to store issues
         graph: Knowledge graph
-        max_number_of_instance: Maximum number of instances to be used in inference
     """
 
     overwrite_data_types: ClassVar[Mapping[URIRef, URIRef]] = {
@@ -323,35 +317,25 @@ class SubclassInferenceImporter(BaseRDFImporter):
         data_types.Float.as_xml_uri_ref(): data_types.Double.as_xml_uri_ref(),
     }
 
-    def __init__(
-        self,
-        issue_list: IssueList,
-        graph: Graph,
-        rules: InformationRules,
-        max_number_of_instance: int,
-        non_existing_node_type: UnknownEntity | AnyURI = DEFAULT_NON_EXISTING_NODE_TYPE,
-    ) -> None:
-        super().__init__(
-            issue_list,
-            graph,
-            rules.metadata.as_data_model_id().as_tuple(),  # type: ignore[arg-type]
-            max_number_of_instance,
-            non_existing_node_type,
-            language="en",
-        )
-        self._rules = rules
+    _ordered_class_query = """SELECT DISTINCT ?class (count(?s) as ?instances )
+                           WHERE { ?s a ?class }
+                           group by ?class order by DESC(?instances)"""
 
-    _ordered_subclass_query = f"""SELECT DISTINCT ?class ?subclass (count(?s) as ?instances )
-                           WHERE {{ ?s a ?class . ?s <{NEAT.type}> ?subclass }}
-                           group by ?class ?subclass order by DESC(?instances)"""
+    _type_parent_query = f"""SELECT ?parent ?type
+                            WHERE {{ ?s a ?type .
+                            ?type <{RDFS.subClassOf}> ?parent }}"""
 
-    _properties_query = """SELECT DISTINCT ?property ?dataType ?objectType
+    _properties_query = """SELECT DISTINCT ?property ?valueType
                          WHERE {{
                             ?s a <{type}> .
-                            ?s <{neat_type}> <{subtype}> .
-                            ?s ?property ?value .
-                            BIND(datatype(?value) AS ?dataType) .
-                            OPTIONAL {{?value rdf:type ?objectType}}
+                            ?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)
@@ -360,130 +344,194 @@ class SubclassInferenceImporter(BaseRDFImporter):
                                 SELECT ?subject (COUNT(?object) AS ?count)
                                 WHERE {{
                                   ?subject a <{type}> .
-                                  ?subject <{neat_type}> <{subtype}> .
                                   ?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:
-        properties_by_class_subclass_pair = self._read_class_properties_from_graph()
-        existing_classes = {class_.class_.suffix: class_ for class_ in self._rules.classes}
-        prefixes = self._rules.prefixes.copy()
+        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
-        subclass_uri: URIRef
-        for class_uri, class_properties_iterable in itertools.groupby(
-            properties_by_class_subclass_pair, key=lambda x: x.class_uri
+        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_subclass_by_property = self._get_properties_by_subclass_by_property(class_properties_iterable)
-
-            shared_property_uris = set.intersection(
-                *[
-                    set(properties_by_property.keys())
-                    for properties_by_property in properties_by_subclass_by_property.values()
-                ]
+            properties_by_class_by_property = self._get_properties_by_class_by_property(
+                parent_class_properties_iterable
             )
-            class_suffix = remove_namespace_from_uri(class_uri)
-            self._add_uri_namespace_to_prefixes(class_uri, prefixes)
-            if class_suffix not in existing_classes:
-                classes.append(InformationInputClass(class_=class_suffix))
+
+            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:
-                classes.append(InformationInputClass.load(existing_classes[class_suffix].model_dump()))
+                shared_property_uris = set()
             shared_properties: dict[URIRef, list[_ReadProperties]] = defaultdict(list)
-            for subclass_uri, properties_by_property_uri in properties_by_subclass_by_property.items():
-                subclass_suffix = remove_namespace_from_uri(subclass_uri)
-                self._add_uri_namespace_to_prefixes(subclass_uri, prefixes)
-                if subclass_suffix not in existing_classes:
-                    classes.append(InformationInputClass(class_=subclass_suffix, implements=class_suffix))
+            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[subclass_suffix].model_dump()))
+                    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, subclass_suffix, class_uri, property_uri, prefixes)
+                        self._create_property(read_properties, class_suffix, type_uri, property_uri, prefixes)
                     )
-            for property_uri, read_properties in shared_properties.items():
-                properties.append(
-                    self._create_property(read_properties, class_suffix, class_uri, property_uri, prefixes)
-                )
 
-        return {
-            "metadata": self._rules.metadata.model_dump(),
-            "classes": [cls.dump(self._rules.metadata.prefix) for cls in classes],
-            "properties": [prop.dump(self._rules.metadata.prefix) for prop in properties],
-            "prefixes": self._rules.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_subclass_by_property(
-        class_properties_iterable: Iterable[_ReadProperties],
+    def _get_properties_by_class_by_property(
+        parent_class_properties_iterable: Iterable[_ReadProperties],
     ) -> dict[URIRef, dict[URIRef, list[_ReadProperties]]]:
-        properties_by_subclass_by_property: dict[URIRef, dict[URIRef, list[_ReadProperties]]] = {}
-        for subclass_uri, subclass_properties_iterable in itertools.groupby(
-            class_properties_iterable, key=lambda x: x.subclass_uri
+        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_subclass_by_property[subclass_uri] = defaultdict(list)
-            for read_prop in subclass_properties_iterable:
-                properties_by_subclass_by_property[subclass_uri][read_prop.property_uri].append(read_prop)
-        return properties_by_subclass_by_property
-
-    def _read_class_properties_from_graph(self) -> list[_ReadProperties]:
-        count_by_class_subclass_pair: dict[tuple[URIRef, URIRef], int] = {}
-        # Infers all the classes w in the graph
-        for result_row in self.graph.query(self._ordered_subclass_query):
-            class_uri, subclass_uri, instance_count_literal = cast(tuple[URIRef, URIRef, RdfLiteral], result_row)
-            count_by_class_subclass_pair[(class_uri, subclass_uri)] = instance_count_literal.toPython()
-        analysis = InformationAnalysis(self._rules)
-        existing_class_properties = {
-            (class_entity.suffix, property)
-            for class_entity, properties in analysis.class_property_pairs(consider_inheritance=True).items()
-            for property in properties.keys()
-        }
+            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 (class_uri, subclass_uri), instance_count in count_by_class_subclass_pair.items():
-            property_query = self._properties_query.format(type=class_uri, subtype=subclass_uri, neat_type=NEAT.type)
-            class_suffix = remove_namespace_from_uri(class_uri)
+        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, data_type_uri, object_type_uri = cast(tuple[URIRef, URIRef, URIRef], result_row)
-                if property_uri == RDF.type or property_uri == NEAT.type:
+                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=class_uri, subtype=subclass_uri, property=property_uri, neat_type=NEAT.type
-                )
+                occurrence_query = self._max_occurrence_query.format(type=type_uri, property=property_uri)
                 max_occurrence = 1  # default value
-                result_row, *_ = list(self.graph.query(occurrence_query))
-                if result_row:
-                    max_occurrence_literal, *__ = cast(tuple[RdfLiteral, Any], result_row)
+                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(
-                        class_uri=class_uri,
-                        subclass_uri=subclass_uri,
+                        type_uri=type_uri,
                         property_uri=property_uri,
-                        data_type=data_type_uri,
-                        object_type=object_type_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,
-        class_uri: URIRef,
+        type_uri: URIRef,
         property_uri: URIRef,
         prefixes: dict[str, Namespace],
     ) -> InformationInputProperty:
@@ -497,17 +545,17 @@ class SubclassInferenceImporter(BaseRDFImporter):
             property_=property_name,
             max_count=first.max_occurrence,
             value_type=value_type,
-            instance_source=(f"{uri_to_short_form(class_uri, prefixes)}({uri_to_short_form(property_uri, prefixes)})"),
+            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 = {prop.data_type for prop in read_properties if prop.data_type} | {
-            prop.object_type for prop in read_properties if prop.object_type
-        }
+        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:
@@ -515,3 +563,16 @@ class SubclassInferenceImporter(BaseRDFImporter):
         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

@@ -301,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,
@@ -317,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.
@@ -326,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:
@@ -338,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,
@@ -348,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/transformers/__init__.py

@@ -1,4 +1,4 @@
-from ._base import RulesTransformer
+from ._base import RulesTransformer, VerifiedRulesTransformer
 from ._converters import (
     AddClassImplements,
     ChangeViewPrefix,
@@ -6,12 +6,12 @@ from ._converters import (
     ConversionTransformer,
     ConvertToRules,
     DMSToInformation,
+    DropModelViews,
     IncludeReferenced,
     InformationToDMS,
     MergeDMSRules,
     MergeInformationRules,
     PrefixEntities,
-    ReduceCogniteModel,
     SetIDDMSModel,
     ToCompliantEntities,
     ToDataProductModel,
@@ -30,13 +30,13 @@ __all__ = [
     "ConversionTransformer",
     "ConvertToRules",
     "DMSToInformation",
+    "DropModelViews",
     "IncludeReferenced",
     "InformationToDMS",
     "MapOneToOne",
     "MergeDMSRules",
     "MergeInformationRules",
     "PrefixEntities",
-    "ReduceCogniteModel",
     "RuleMapper",
     "RulesTransformer",
     "SetIDDMSModel",
@@ -45,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): ...