cognite-neat 0.85.12__py3-none-any.whl → 0.87.0__py3-none-any.whl

cognite/neat/rules/analysis/_information.py

@@ -0,0 +1,155 @@
+import logging
+import warnings
+from typing import Any, cast
+
+from pydantic import ValidationError
+
+from cognite.neat.rules.models import SchemaCompleteness
+from cognite.neat.rules.models._rdfpath import Hop, RDFPath, SingleProperty
+from cognite.neat.rules.models.entities import ClassEntity, ReferenceEntity
+from cognite.neat.rules.models.information import (
+    InformationClass,
+    InformationProperty,
+    InformationRules,
+)
+from cognite.neat.utils.utils import get_inheritance_path
+
+from ._base import BaseAnalysis
+
+
+class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, InformationProperty, ClassEntity, str]):
+    """Assumes analysis over only the complete schema"""
+
+    def _get_object(self, property_: InformationProperty) -> ClassEntity | None:
+        return property_.value_type if isinstance(property_.value_type, ClassEntity) else None
+
+    def _get_max_occurrence(self, property_: InformationProperty) -> int | float | None:
+        return property_.max_count
+
+    def _get_reference(self, class_or_property: InformationClass | InformationProperty) -> ReferenceEntity | None:
+        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
+
+    def _get_cls_entity(self, class_: InformationClass | InformationProperty) -> ClassEntity:
+        return class_.class_
+
+    @classmethod
+    def _set_cls_entity(cls, property_: InformationProperty, class_: ClassEntity) -> None:
+        property_.class_ = class_
+
+    def _get_prop_entity(self, property_: InformationProperty) -> str:
+        return property_.property_
+
+    def _get_cls_parents(self, class_: InformationClass) -> list[ClassEntity] | None:
+        return list(class_.parent or []) or None
+
+    def _get_reference_rules(self) -> InformationRules | None:
+        return self.rules.reference
+
+    def _get_properties(self) -> list[InformationProperty]:
+        return list(self.rules.properties)
+
+    def _get_classes(self) -> list[InformationClass]:
+        return list(self.rules.classes)
+
+    def has_hop_transformations(self):
+        return any(
+            prop_.transformation and isinstance(prop_.transformation.traversal, Hop) for prop_ in self.rules.properties
+        )
+
+    def define_property_renaming_config(self, class_: ClassEntity) -> dict[str, str]:
+        property_renaming_configuration = {}
+
+        if definitions := self.class_property_pairs(only_rdfpath=True, consider_inheritance=True).get(class_, None):
+            for property_id, definition in definitions.items():
+                if isinstance(
+                    cast(RDFPath, definition.transformation).traversal,
+                    SingleProperty,
+                ):
+                    graph_property = cast(
+                        SingleProperty,
+                        cast(RDFPath, definition.transformation).traversal,
+                    ).property.suffix
+
+                else:
+                    graph_property = property_id
+
+                property_renaming_configuration[graph_property] = property_id
+
+        return property_renaming_configuration
+
+    def subset_rules(self, desired_classes: set[ClassEntity]) -> InformationRules:
+        """
+        Subset rules to only include desired classes and their properties.
+
+        Args:
+            desired_classes: Desired classes to include in the reduced data model
+
+        Returns:
+            Instance of InformationRules
+
+        !!! note "Inheritance"
+            If desired classes contain a class that is a subclass of another class(es), the parent class(es)
+            will be included in the reduced data model as well even though the parent class(es) are
+            not in the desired classes set. This is to ensure that the reduced data model is
+            consistent and complete.
+
+        !!! note "Partial Reduction"
+            This method does not perform checks if classes that are value types of desired classes
+            properties are part of desired classes. If a class is not part of desired classes, but it
+            is a value type of a property of a class that is part of desired classes, derived reduced
+            rules will be marked as partial.
+
+        !!! note "Validation"
+            This method will attempt to validate the reduced rules with custom validations.
+            If it fails, it will return a partial rules with a warning message, validated
+            only with base Pydantic validators.
+        """
+        if self.rules.metadata.schema_ is not SchemaCompleteness.complete:
+            raise ValueError("Rules are not complete cannot perform reduction!")
+        class_as_dict = self.as_class_dict()
+        class_parents_pairs = self.class_parent_pairs()
+        defined_classes = self.defined_classes(consider_inheritance=True)
+
+        possible_classes = defined_classes.intersection(desired_classes)
+        impossible_classes = desired_classes - possible_classes
+
+        # need to add all the parent classes of the desired classes to the possible classes
+        parents: set[ClassEntity] = set()
+        for class_ in possible_classes:
+            parents = parents.union({parent for parent in get_inheritance_path(class_, class_parents_pairs)})
+        possible_classes = possible_classes.union(parents)
+
+        if not possible_classes:
+            logging.error("None of the desired classes are defined in the data model!")
+            raise ValueError("None of the desired classes are defined in the data model!")
+
+        if impossible_classes:
+            logging.warning(f"Could not find the following classes defined in the data model: {impossible_classes}")
+            warnings.warn(
+                f"Could not find the following classes defined in the data model: {impossible_classes}",
+                stacklevel=2,
+            )
+
+        reduced_data_model: dict[str, Any] = {
+            "metadata": self.rules.metadata.model_copy(),
+            "prefixes": (self.rules.prefixes or {}).copy(),
+            "classes": [],
+            "properties": [],
+        }
+
+        logging.info(f"Reducing data model to only include the following classes: {possible_classes}")
+        for class_ in possible_classes:
+            reduced_data_model["classes"].append(class_as_dict[str(class_.suffix)])
+
+        class_property_pairs = self.classes_with_properties(consider_inheritance=False)
+
+        for class_, properties in class_property_pairs.items():
+            if class_ in possible_classes:
+                reduced_data_model["properties"].extend(properties)
+
+        try:
+            return type(self.rules)(**reduced_data_model)
+        except ValidationError as e:
+            warnings.warn(f"Reduced data model is not complete: {e}", stacklevel=2)
+            reduced_data_model["metadata"].schema_ = SchemaCompleteness.partial
+            return type(self.rules).model_construct(**reduced_data_model)

cognite/neat/rules/exporters/_base.py

@@ -28,10 +28,10 @@ class BaseExporter(ABC, Generic[T_Export]):
     def _convert_to_output_role(self, rules: Rules, output_role: RoleTypes | None = None) -> Rules:
         if rules.metadata.role is output_role or output_role is None:
             return rules
-        elif output_role is RoleTypes.dms_architect and isinstance(rules, InformationRules):
-            return rules.as_dms_architect_rules()
-        elif output_role is RoleTypes.information_architect and isinstance(rules, DMSRules):
-            return rules.as_information_architect_rules()
+        elif output_role is RoleTypes.dms and isinstance(rules, InformationRules):
+            return rules.as_dms_rules()
+        elif output_role is RoleTypes.information and isinstance(rules, DMSRules):
+            return rules.as_information_rules()
         else:
             raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
 

cognite/neat/rules/exporters/_rules2dms.py

@@ -118,7 +118,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
         if isinstance(rules, DMSRules):
             dms_rules = rules
         elif isinstance(rules, InformationRules):
-            dms_rules = rules.as_dms_architect_rules()
+            dms_rules = rules.as_dms_rules()
         else:
             raise ValueError(f"{type(rules).__name__} cannot be exported to DMS")
         return dms_rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)

cognite/neat/rules/exporters/_rules2ontology.py

@@ -10,7 +10,7 @@ from rdflib.collection import Collection as GraphCollection
 
 from cognite.neat.constants import DEFAULT_NAMESPACE as NEAT_NAMESPACE
 from cognite.neat.rules import exceptions
-from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models import DMSRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
@@ -95,7 +95,7 @@ class Ontology(OntologyModel):
         if isinstance(input_rules, InformationRules):
             rules = input_rules
         elif isinstance(input_rules, DMSRules):
-            rules = input_rules.as_information_architect_rules()
+            rules = input_rules.as_information_rules()
         else:
             raise ValueError(f"{type(input_rules).__name__} cannot be exported to Ontology")
 
@@ -109,11 +109,11 @@ class Ontology(OntologyModel):
         if rules.metadata.namespace is None:
             raise exceptions.MissingDataModelPrefixOrNamespace()
 
-        class_dict = InformationArchitectRulesAnalysis(rules).as_class_dict()
+        class_dict = InformationAnalysis(rules).as_class_dict()
         return cls(
             properties=[
                 OWLProperty.from_list_of_properties(definition, rules.metadata.namespace)
-                for definition in InformationArchitectRulesAnalysis(rules).as_property_dict().values()
+                for definition in InformationAnalysis(rules).as_property_dict().values()
             ],
             classes=[
                 OWLClass.from_class(definition, rules.metadata.namespace, rules.prefixes)
@@ -125,7 +125,7 @@ class Ontology(OntologyModel):
                     list(properties.values()),
                     rules.metadata.namespace,
                 )
-                for class_, properties in InformationArchitectRulesAnalysis(rules).class_property_pairs().items()
+                for class_, properties in InformationAnalysis(rules).class_property_pairs().items()
             ]
             + [
                 SHACLNodeShape.from_rules(

cognite/neat/rules/importers/_base.py

@@ -55,10 +55,10 @@ class BaseImporter(ABC):
 
         if rules.metadata.role is role or role is None:
             output = rules
-        elif isinstance(rules, DMSRules) or isinstance(rules, AssetRules) and role is RoleTypes.information_architect:
-            output = rules.as_information_architect_rules()
-        elif isinstance(rules, InformationRules) or isinstance(rules, AssetRules) and role is RoleTypes.dms_architect:
-            output = rules.as_dms_architect_rules()
+        elif isinstance(rules, DMSRules) or isinstance(rules, AssetRules) and role is RoleTypes.information:
+            output = rules.as_information_rules()
+        elif isinstance(rules, InformationRules) or isinstance(rules, AssetRules) and role is RoleTypes.dms:
+            output = rules.as_dms_rules()
         else:
             raise NotImplementedError(f"Role {role} is not supported for {type(rules).__name__} rules")
 

cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py

@@ -1,6 +1,5 @@
 from collections import Counter
 from collections.abc import Callable, Sequence
-from typing import cast
 
 import cognite.neat.rules.issues.importing
 from cognite.neat.rules import issues
@@ -22,7 +21,7 @@ from cognite.neat.rules.importers._dtdl2rules.spec import (
 )
 from cognite.neat.rules.issues import IssueList, ValidationIssue
 from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_NAME, DataType, Json, String
-from cognite.neat.rules.models.entities import ClassEntity, ParentClassEntity
+from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.rules.models.information import InformationClass, InformationProperty
 
 
@@ -89,12 +88,7 @@ class _DTDLConverter:
             name=item.display_name,
             description=item.description,
             comment=item.comment,
-            parent=[
-                cast(ParentClassEntity, parent_entity)
-                for parent in item.extends or []
-                if isinstance(parent_entity := ParentClassEntity.load(parent.as_class_id()), ParentClassEntity)
-            ]
-            or None,
+            parent=[parent.as_class_id() for parent in item.extends or []] or None,
         )
         self.classes.append(class_)
         for sub_item_or_id in item.contents or []:

cognite/neat/rules/importers/_inference2rules.py

@@ -7,7 +7,7 @@ from rdflib import Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
 
 import cognite.neat.rules.issues as issues
-from cognite.neat.constants import DEFAULT_NAMESPACE, PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE, get_default_prefixes
 from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
 from cognite.neat.rules.issues import IssueList
@@ -204,7 +204,7 @@ class InferenceImporter(BaseImporter):
         """
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
-        prefixes: dict[str, Namespace] = PREFIXES.copy()
+        prefixes: dict[str, Namespace] = get_default_prefixes()
 
         query = INSTANCE_PROPERTIES_JSON_DEFINITION if self.check_for_json_string else INSTANCE_PROPERTIES_DEFINITION
         # Adds default namespace to prefixes

cognite/neat/rules/importers/_owl2rules/_owl2metadata.py

@@ -51,7 +51,7 @@ def parse_owl_metadata(graph: Graph) -> dict:
 
     raw_metadata = convert_rdflib_content(
         {
-            "role": RoleTypes.information_architect,
+            "role": RoleTypes.information,
             "schema": SchemaCompleteness.partial,
             "prefix": results[1].pop(),
             "namespace": Namespace(results[0].pop()),

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -36,9 +36,9 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
         "Properties",
         {
             RoleTypes.domain_expert: "Property",
-            RoleTypes.information_architect: "Property",
-            RoleTypes.asset_architect: "Property",
-            RoleTypes.dms_architect: "View Property",
+            RoleTypes.information: "Property",
+            RoleTypes.asset: "Property",
+            RoleTypes.dms: "View Property",
         },
     ),
     ("Classes", "Classes", "Class"),
@@ -334,9 +334,9 @@ class GoogleSheetImporter(BaseImporter):
 
         if role == RoleTypes.domain_expert:
             output = rules_model.model_validate(sheets)
-        elif role == RoleTypes.information_architect:
+        elif role == RoleTypes.information:
             output = rules_model.model_validate(sheets)
-        elif role == RoleTypes.dms_architect:
+        elif role == RoleTypes.dms:
             output = rules_model.model_validate(sheets)
         else:
             raise ValueError(f"Role {role} is not valid.")

cognite/neat/rules/models/__init__.py

@@ -8,9 +8,9 @@ from .dms._schema import DMSSchema
 
 RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[AssetRules] | type[DMSRules]] = {
     RoleTypes.domain_expert: DomainRules,
-    RoleTypes.information_architect: InformationRules,
-    RoleTypes.asset_architect: AssetRules,
-    RoleTypes.dms_architect: DMSRules,
+    RoleTypes.information: InformationRules,
+    RoleTypes.asset: AssetRules,
+    RoleTypes.dms: DMSRules,
 }
 
 

cognite/neat/rules/models/_base.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import math
 import sys
 import types
-from abc import abstractmethod
+from abc import ABC, abstractmethod
 from collections.abc import Callable, Iterator
 from functools import wraps
 from typing import Annotated, Any, ClassVar, Generic, Literal, TypeAlias, TypeVar
@@ -18,7 +18,6 @@ from pydantic import (
     BeforeValidator,
     ConfigDict,
     Field,
-    HttpUrl,
     PlainSerializer,
     constr,
     field_validator,
@@ -150,9 +149,9 @@ class DataModelType(StrEnum):
 
 class RoleTypes(StrEnum):
     domain_expert = "domain expert"
-    information_architect = "information architect"
-    asset_architect = "asset architect"
-    dms_architect = "DMS Architect"
+    information = "information architect"
+    asset = "asset architect"
+    dms = "DMS Architect"
 
 
 class MatchType(StrEnum):
@@ -219,10 +218,6 @@ class RuleModel(BaseModel):
         return headers_by_sheet
 
 
-class URL(BaseModel):
-    url: HttpUrl
-
-
 class BaseMetadata(RuleModel):
     """
     Metadata model for data model
@@ -252,8 +247,13 @@ class BaseMetadata(RuleModel):
         """Returns a unique identifier for the metadata."""
         raise NotImplementedError()
 
+    @abstractmethod
+    def get_prefix(self) -> str:
+        """Returns the prefix for the metadata."""
+        raise NotImplementedError()
+
 
-class BaseRules(RuleModel):
+class BaseRules(RuleModel, ABC):
     """
     Rules is a core concept in `neat`. This represents fusion of data model
     definitions and (optionally) the transformation rules used to transform the data/graph

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

@@ -5,7 +5,7 @@ from pydantic import Field, field_validator, model_validator
 from pydantic.main import IncEx
 from rdflib import Namespace
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import get_default_prefixes
 from cognite.neat.issues import MultiValueError
 from cognite.neat.rules import issues
 from cognite.neat.rules.models._base import BaseRules, RoleTypes, SheetList
@@ -14,7 +14,6 @@ from cognite.neat.rules.models.entities import (
     CdfResourceEntityList,
     ClassEntity,
     MultiValueTypeInfo,
-    ParentClassEntity,
     Undefined,
 )
 from cognite.neat.rules.models.information import (
@@ -35,7 +34,7 @@ else:
 
 
 class AssetMetadata(InformationMetadata):
-    role: ClassVar[RoleTypes] = RoleTypes.asset_architect
+    role: ClassVar[RoleTypes] = RoleTypes.asset
 
 
 class AssetClass(InformationClass): ...
@@ -61,14 +60,14 @@ class AssetProperty(InformationProperty):
         implementation: Details on how given class-property is implemented in the classic CDF
     """
 
-    implementation: CdfResourceEntityList | None = Field(alias="Implementation", default=None)
+    implementation: CdfResourceEntityList = Field(alias="Implementation")
 
 
 class AssetRules(BaseRules):
     metadata: AssetMetadata = Field(alias="Metadata")
     properties: SheetList[AssetProperty] = Field(alias="Properties")
     classes: SheetList[AssetClass] = Field(alias="Classes")
-    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy())
+    prefixes: dict[str, Namespace] = Field(default_factory=get_default_prefixes)
     last: "AssetRules | None" = Field(None, alias="Last")
     reference: "AssetRules | None" = Field(None, alias="Reference")
 
@@ -94,7 +93,7 @@ class AssetRules(BaseRules):
         # update parent classes
         for class_ in self.classes:
             if class_.parent:
-                for parent in cast(list[ParentClassEntity], class_.parent):
+                for parent in class_.parent:
                     if not isinstance(parent.prefix, str):
                         parent.prefix = self.metadata.prefix
             if class_.class_.prefix is Undefined:
@@ -148,12 +147,12 @@ class AssetRules(BaseRules):
     def as_domain_rules(self) -> DomainRules:
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(self.as_information_architect_rules()).as_domain_rules()
+        return _AssetRulesConverter(self.as_information_rules()).as_domain_rules()
 
-    def as_dms_architect_rules(self) -> "DMSRules":
+    def as_dms_rules(self) -> "DMSRules":
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(self.as_information_architect_rules()).as_dms_architect_rules()
+        return _AssetRulesConverter(self.as_information_rules()).as_dms_rules()
 
-    def as_information_architect_rules(self) -> InformationRules:
+    def as_information_rules(self) -> InformationRules:
         return InformationRules.model_validate(self.model_dump())

cognite/neat/rules/models/dms/_converter.py

@@ -11,7 +11,6 @@ from cognite.neat.rules.models.entities import (
     ClassEntity,
     ContainerEntity,
     DMSUnknownEntity,
-    ParentClassEntity,
     ReferenceEntity,
     UnknownEntity,
     ViewEntity,
@@ -32,7 +31,7 @@ class _DMSRulesConverter:
     def as_domain_rules(self) -> "DomainRules":
         raise NotImplementedError("DomainRules not implemented yet")
 
-    def as_information_architect_rules(
+    def as_information_rules(
         self,
     ) -> "InformationRules":
         from cognite.neat.rules.models.information._rules import (
@@ -52,7 +51,7 @@ class _DMSRulesConverter:
                 description=view.description,
                 parent=[
                     # we do not want a version in class as we use URI for the class
-                    ParentClassEntity(prefix=implemented_view.prefix, suffix=implemented_view.suffix)
+                    implemented_view.as_class(skip_version=True)
                     # We only want parents in the same namespace, parent in a different namespace is a reference
                     for implemented_view in view.implements or []
                     if implemented_view.prefix == view.class_.prefix
@@ -94,8 +93,8 @@ class _DMSRulesConverter:
             metadata=metadata,
             properties=SheetList[InformationProperty](data=properties),
             classes=SheetList[InformationClass](data=classes),
-            last=self.dms.last.as_information_architect_rules() if self.dms.last else None,
-            reference=self.dms.reference.as_information_architect_rules() if self.dms.reference else None,
+            last=self.dms.last.as_information_rules() if self.dms.last else None,
+            reference=self.dms.reference.as_information_rules() if self.dms.reference else None,
         )
 
     @classmethod

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

@@ -58,7 +58,7 @@ _DEFAULT_VERSION = "1"
 
 
 class DMSMetadata(BaseMetadata):
-    role: ClassVar[RoleTypes] = RoleTypes.dms_architect
+    role: ClassVar[RoleTypes] = RoleTypes.dms
     data_model_type: DataModelType = Field(DataModelType.enterprise, alias="dataModelType")
     schema_: SchemaCompleteness = Field(alias="schema")
     extension: ExtensionCategory = ExtensionCategory.addition
@@ -165,6 +165,9 @@ class DMSMetadata(BaseMetadata):
             updated=datetime.now(),
         )
 
+    def get_prefix(self) -> str:
+        return self.space
+
 
 class DMSProperty(SheetEntity):
     view: ViewEntity = Field(alias="View")
@@ -382,10 +385,10 @@ class DMSRules(BaseRules):
 
         return _DMSExporter(self, include_pipeline, instance_space).to_schema()
 
-    def as_information_architect_rules(self) -> "InformationRules":
+    def as_information_rules(self) -> "InformationRules":
         from ._converter import _DMSRulesConverter
 
-        return _DMSRulesConverter(self).as_information_architect_rules()
+        return _DMSRulesConverter(self).as_information_rules()
 
     def as_domain_expert_rules(self) -> DomainRules:
         from ._converter import _DMSRulesConverter

cognite/neat/rules/models/domain.py

@@ -5,7 +5,7 @@ from pydantic import Field, field_serializer, field_validator, model_serializer
 from pydantic_core.core_schema import SerializationInfo
 
 from cognite.neat.rules.models.data_types import DataType
-from cognite.neat.rules.models.entities import ClassEntity, ParentEntityList
+from cognite.neat.rules.models.entities import ClassEntity, ClassEntityList
 
 from ._base import (
     BaseMetadata,
@@ -24,6 +24,9 @@ class DomainMetadata(BaseMetadata):
     def as_identifier(self) -> str:
         return "DomainRules"
 
+    def get_prefix(self) -> str:
+        return "domain"
+
 
 class DomainProperty(SheetEntity):
     class_: ClassEntity = Field(alias="Class")
@@ -51,7 +54,7 @@ class DomainClass(SheetEntity):
     class_: ClassEntity = Field(alias="Class")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(None, alias="Description")
-    parent: ParentEntityList | None = Field(alias="Parent Class")
+    parent: ClassEntityList | None = Field(alias="Parent Class")
 
 
 class DomainRules(BaseRules):

cognite/neat/rules/models/entities.py

@@ -252,13 +252,6 @@ class ClassEntity(Entity):
         return ContainerEntity(space=space, externalId=str(self.suffix))
 
 
-class ParentClassEntity(ClassEntity):
-    type_: ClassVar[EntityTypes] = EntityTypes.parent_class
-
-    def as_class_entity(self) -> ClassEntity:
-        return ClassEntity(prefix=self.prefix, suffix=self.suffix, version=self.version)
-
-
 class UnknownEntity(ClassEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.undefined
     prefix: _UndefinedType = Undefined
@@ -555,8 +548,8 @@ def _generate_cdf_resource_list(v: Any) -> list[AssetEntity | RelationshipEntity
     return results  # type: ignore
 
 
-ParentEntityList = Annotated[
-    list[ParentClassEntity],
+ClassEntityList = Annotated[
+    list[ClassEntity],
     BeforeValidator(_split_str),
     PlainSerializer(
         _join_str,

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

@@ -79,7 +79,7 @@ class _InformationRulesConverter:
             prefixes=self.rules.prefixes,
         )
 
-    def as_dms_architect_rules(self) -> "DMSRules":
+    def as_dms_rules(self) -> "DMSRules":
         from cognite.neat.rules.models.dms._rules import (
             DMSContainer,
             DMSProperty,
@@ -112,8 +112,8 @@ class _InformationRulesConverter:
             for cls_ in self.rules.classes
         ]
 
-        last_dms_rules = self.rules.last.as_dms_architect_rules() if self.rules.last else None
-        ref_dms_rules = self.rules.reference.as_dms_architect_rules() if self.rules.reference else None
+        last_dms_rules = self.rules.last.as_dms_rules() if self.rules.last else None
+        ref_dms_rules = self.rules.reference.as_dms_rules() if self.rules.reference else None
 
         class_by_entity = {cls_.class_: cls_ for cls_ in self.rules.classes}
         if self.rules.last: