cognite-neat 0.97.3__py3-none-any.whl → 0.98.0__py3-none-any.whl

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

@@ -1,7 +1,6 @@
 import math
 import sys
 from collections.abc import Hashable
-from datetime import datetime
 from typing import TYPE_CHECKING, Any, ClassVar
 
 import pandas as pd
@@ -9,20 +8,16 @@ from pydantic import Field, field_serializer, field_validator, model_validator
 from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace, URIRef
 
-from cognite.neat._constants import DEFAULT_NAMESPACE, get_default_prefixes
+from cognite.neat._constants import get_default_prefixes
 from cognite.neat._issues.errors import NeatValueError, PropertyDefinitionError
 from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
     BaseRules,
     ClassRef,
-    DataModelType,
-    ExtensionCategory,
-    ExtensionCategoryType,
-    MatchType,
+    DataModelAspect,
     PropertyRef,
     RoleTypes,
-    SchemaCompleteness,
     SheetList,
     SheetRow,
 )
@@ -35,10 +30,6 @@ from cognite.neat._rules.models._types import (
     ClassEntityType,
     InformationPropertyType,
     MultiValueTypeType,
-    NamespaceType,
-    PrefixType,
-    StrListType,
-    VersionType,
 )
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import (
@@ -46,10 +37,8 @@ from cognite.neat._rules.models.entities import (
     ClassEntityList,
     Entity,
     MultiValueTypeInfo,
-    ReferenceEntity,
     Undefined,
     UnknownEntity,
-    URLEntity,
 )
 
 if TYPE_CHECKING:
@@ -64,62 +53,11 @@ else:
 
 class InformationMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.information
-    data_model_type: DataModelType = Field(DataModelType.enterprise, alias="dataModelType")
-    schema_: SchemaCompleteness = Field(SchemaCompleteness.partial, alias="schema")
-    extension: ExtensionCategoryType | None = ExtensionCategory.addition
-
-    prefix: PrefixType
-    namespace: NamespaceType
-
-    name: str = Field(
-        alias="title",
-        description="Human readable name of the data model",
-        min_length=1,
-        max_length=255,
-    )
-    description: str | None = Field(None, min_length=1, max_length=1024)
-    version: VersionType
-
-    created: datetime = Field(
-        description=("Date of the data model creation"),
-    )
-
-    updated: datetime = Field(
-        description=("Date of the data model update"),
-    )
-    creator: StrListType = Field(
-        description=(
-            "List of contributors to the data model creation, "
-            "typically information architects are considered as contributors."
-        ),
-    )
-    license: str | None = None
-    rights: str | None = None
-
-    @model_validator(mode="after")
-    def extension_none_but_schema_extend(self) -> Self:
-        if self.extension is None:
-            self.extension = ExtensionCategory.addition
-            return self
-        return self
-
-    @field_validator("schema_", mode="plain")
-    def as_enum_schema(cls, value: str) -> SchemaCompleteness:
-        return SchemaCompleteness(value.strip())
+    aspect: ClassVar[DataModelAspect] = DataModelAspect.logical
 
-    @field_validator("extension", mode="plain")
-    def as_enum_extension(cls, value: str) -> ExtensionCategory:
-        return ExtensionCategory(value.strip())
-
-    @field_validator("data_model_type", mode="plain")
-    def as_enum_model_type(cls, value: str) -> DataModelType:
-        return DataModelType(value.strip())
-
-    def as_identifier(self) -> str:
-        return f"{self.prefix}:{self.name}"
-
-    def get_prefix(self) -> str:
-        return self.prefix
+    # Linking to Conceptual and Physical data model aspects
+    physical: URIRef | None = Field(None, description="Link to the logical data model aspect")
+    conceptual: URIRef | None = Field(None, description="Link to the logical data model aspect")
 
 
 def _get_metadata(context: Any) -> InformationMetadata | None:
@@ -135,42 +73,33 @@ class InformationClass(SheetRow):
     Args:
         class_: The class ID of the class.
         description: A description of the class.
-        parent: The parent class of the class.
-        reference: Reference of the source of the information for given resource
-        match_type: The match type of the resource being described and the source entity.
+        implements: Which classes the current class implements.
     """
 
     class_: ClassEntityType = Field(alias="Class")
     name: str | None = Field(alias="Name", default=None)
     description: str | None = Field(alias="Description", default=None)
-    parent: ClassEntityList | None = Field(alias="Parent Class", default=None)
-    reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
-    match_type: MatchType | None = Field(alias="Match Type", default=None)
-    comment: str | None = Field(alias="Comment", default=None)
+    implements: ClassEntityList | None = Field(alias="Implements", default=None)
 
     def _identifier(self) -> tuple[Hashable, ...]:
         return (self.class_,)
 
-    @field_serializer("reference", when_used="always")
-    def set_reference(self, value: Any, info: SerializationInfo) -> str | None:
-        if isinstance(info.context, dict) and info.context.get("as_reference") is True:
-            return self.class_.dump()
-        return str(value) if value is not None else None
-
     @field_serializer("class_", when_used="unless-none")
     def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
         if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
             return value.dump(prefix=metadata.prefix, version=metadata.version)
         return str(value)
 
-    @field_serializer("parent", when_used="unless-none")
+    @field_serializer("implements", when_used="unless-none")
     def remove_default_prefixes(self, value: Any, info: SerializationInfo) -> str:
         if isinstance(value, list) and (metadata := _get_metadata(info.context)):
             return ",".join(
-                parent.dump(prefix=metadata.prefix, version=metadata.version)
-                if isinstance(parent, Entity)
-                else str(parent)
-                for parent in value
+                (
+                    class_.dump(prefix=metadata.prefix, version=metadata.version)
+                    if isinstance(class_, Entity)
+                    else str(class_)
+                )
+                for class_ in value
             )
         return ",".join(str(value) for value in value)
 
@@ -191,8 +120,6 @@ class InformationProperty(SheetRow):
         min_count: Minimum count of the property values. Defaults to 0
         max_count: Maximum count of the property values. Defaults to None
         default: Default value of the property
-        reference: Reference to the source of the information, HTTP URI
-        match_type: The match type of the resource being described and the source entity.
         transformation: Actual rule for the transformation from source to target representation of
               knowledge graph. Defaults to None (no transformation)
     """
@@ -207,10 +134,7 @@ class InformationProperty(SheetRow):
     min_count: int | None = Field(alias="Min Count", default=None)
     max_count: int | float | None = Field(alias="Max Count", default=None)
     default: Any | None = Field(alias="Default", default=None)
-    reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
-    match_type: MatchType | None = Field(alias="Match Type", default=None)
     transformation: RDFPath | None = Field(alias="Transformation", default=None)
-    comment: str | None = Field(alias="Comment", default=None)
     inherited: bool = Field(
         default=False,
         exclude=True,
@@ -281,19 +205,6 @@ class InformationProperty(SheetRow):
             return None
         return value
 
-    @field_serializer("reference", when_used="always")
-    def set_reference(self, value: Any, info: SerializationInfo) -> str | None:
-        # When rules as dumped as reference, we set the reference to the class
-        if isinstance(info.context, dict) and info.context.get("as_reference") is True:
-            return str(
-                ReferenceEntity(
-                    prefix=str(self.class_.prefix),
-                    suffix=self.class_.suffix,
-                    property=self.property_,
-                )
-            )
-        return str(value) if value is not None else None
-
     @field_serializer("class_", "value_type", when_used="unless-none")
     def remove_default_prefix(self, value: Any, info: SerializationInfo) -> str:
         if (metadata := _get_metadata(info.context)) and isinstance(value, Entity):
@@ -331,8 +242,6 @@ class InformationRules(BaseRules):
     properties: SheetList[InformationProperty] = Field(alias="Properties")
     classes: SheetList[InformationClass] = Field(alias="Classes")
     prefixes: dict[str, Namespace] = Field(default_factory=get_default_prefixes, alias="Prefixes")
-    last: "InformationRules | None" = Field(None, alias="Last")
-    reference: "InformationRules | None" = Field(None, alias="Reference")
 
     @field_validator("prefixes", mode="before")
     def parse_str(cls, values: Any) -> Any:
@@ -355,10 +264,10 @@ class InformationRules(BaseRules):
             if property_.class_.prefix is Undefined:
                 property_.class_.prefix = self.metadata.prefix
 
-        # update parent classes
+        # update implements
         for class_ in self.classes:
-            if class_.parent:
-                for parent in class_.parent:
+            if class_.implements:
+                for parent in class_.implements:
                     if not isinstance(parent.prefix, str):
                         parent.prefix = self.metadata.prefix
             if class_.class_.prefix is Undefined:
@@ -387,14 +296,10 @@ class InformationRules(BaseRules):
             "type": "Logical Data Model",
             "intended for": "Information Architect",
             "name": self.metadata.name,
-            "external_id": self.metadata.prefix,
+            "external_id": self.metadata.external_id,
             "version": self.metadata.version,
             "classes": len(self.classes),
             "properties": len(self.properties),
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
-
-    @property
-    def id_(self) -> URIRef:
-        return DEFAULT_NAMESPACE[f"data-model/verified/info/{self.metadata.prefix}/{self.metadata.version}"]

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

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any, Literal
+from typing import Any
 
 import pandas as pd
 from rdflib import Namespace, URIRef
@@ -25,19 +25,16 @@ from ._rules import (
 
 @dataclass
 class InformationInputMetadata(InputComponent[InformationMetadata]):
-    schema_: Literal["complete", "partial", "extended"]
-    prefix: str
-    namespace: str
+    space: str
+    external_id: str
     version: str
     creator: str
-    data_model_type: Literal["solution", "enterprise"] = "enterprise"
-    extension: Literal["addition", "reshape", "rebuild"] = "addition"
     name: str | None = None
     description: str | None = None
     created: datetime | str | None = None
     updated: datetime | str | None = None
-    license: str | None = None
-    rights: str | None = None
+    physical: str | None = None
+    conceptual: str | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationMetadata]:
@@ -51,6 +48,25 @@ class InformationInputMetadata(InputComponent[InformationMetadata]):
             output["updated"] = datetime.now()
         return output
 
+    @property
+    def prefix(self) -> str:
+        return self.space
+
+    @property
+    def identifier(self) -> URIRef:
+        """Globally unique identifier for the data model.
+
+        !!! note
+            Unlike namespace, the identifier does not end with "/" or "#".
+
+        """
+        return DEFAULT_NAMESPACE[f"data-model/unverified/logical/{self.space}/{self.external_id}/{self.version}"]
+
+    @property
+    def namespace(self) -> Namespace:
+        """Namespace for the data model used for the entities in the data model."""
+        return Namespace(f"{self.identifier}/")
+
 
 @dataclass
 class InformationInputProperty(InputComponent[InformationProperty]):
@@ -59,12 +75,9 @@ class InformationInputProperty(InputComponent[InformationProperty]):
     value_type: DataType | ClassEntity | MultiValueTypeInfo | UnknownEntity | str
     name: str | None = None
     description: str | None = None
-    comment: str | None = None
     min_count: int | None = None
     max_count: int | float | None = None
     default: Any | None = None
-    reference: str | None = None
-    match_type: str | None = None
     transformation: str | None = None
     # Only used internally
     inherited: bool = False
@@ -85,10 +98,7 @@ class InformationInputClass(InputComponent[InformationClass]):
     class_: ClassEntity | str
     name: str | None = None
     description: str | None = None
-    comment: str | None = None
-    parent: str | list[ClassEntity] | None = None
-    reference: str | None = None
-    match_type: str | None = None
+    implements: str | list[ClassEntity] | None = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationClass]:
@@ -101,12 +111,12 @@ class InformationInputClass(InputComponent[InformationClass]):
     def dump(self, default_prefix: str, **kwargs) -> dict[str, Any]:  # type: ignore[override]
         output = super().dump()
         parent: list[ClassEntity] | None = None
-        if isinstance(self.parent, str):
-            parent = [ClassEntity.load(parent, prefix=default_prefix) for parent in self.parent.split(",")]
-        elif isinstance(self.parent, list):
-            parent = [ClassEntity.load(parent_, prefix=default_prefix) for parent_ in self.parent]
+        if isinstance(self.implements, str):
+            parent = [ClassEntity.load(parent, prefix=default_prefix) for parent in self.implements.split(",")]
+        elif isinstance(self.implements, list):
+            parent = [ClassEntity.load(parent_, prefix=default_prefix) for parent_ in self.implements]
         output["Class"] = ClassEntity.load(self.class_, prefix=default_prefix)
-        output["Parent Class"] = parent
+        output["Implements"] = parent
         return output
 
 
@@ -116,8 +126,6 @@ class InformationInputRules(InputRules[InformationRules]):
     properties: list[InformationInputProperty] = field(default_factory=list)
     classes: list[InformationInputClass] = field(default_factory=list)
     prefixes: dict[str, Namespace] | None = None
-    last: "InformationInputRules | None" = None
-    reference: "InformationInputRules | None" = None
 
     @classmethod
     def _get_verified_cls(cls) -> type[InformationRules]:
@@ -125,26 +133,12 @@ class InformationInputRules(InputRules[InformationRules]):
 
     def dump(self) -> dict[str, Any]:
         default_prefix = self.metadata.prefix
-        reference: dict[str, Any] | None = None
-        if isinstance(self.reference, InformationInputRules):
-            reference = self.reference.dump()
-        elif isinstance(self.reference, InformationRules):
-            # We need to load through the InformationRulesInput to set the correct default space and version
-            reference = InformationInputRules.load(self.reference.model_dump()).dump()
-        last: dict[str, Any] | None = None
-        if isinstance(self.last, InformationInputRules):
-            last = self.last.dump()
-        elif isinstance(self.last, InformationRules):
-            # We need to load through the InformationRulesInput to set the correct default space and version
-            last = InformationInputRules.load(self.last.model_dump()).dump()
 
         return dict(
             Metadata=self.metadata.dump(),
             Properties=[prop.dump(default_prefix) for prop in self.properties],
             Classes=[class_.dump(default_prefix) for class_ in self.classes],
             Prefixes=self.prefixes,
-            Last=last,
-            Reference=reference,
         )
 
     def _repr_html_(self) -> str:
@@ -152,14 +146,11 @@ class InformationInputRules(InputRules[InformationRules]):
             "type": "Logical Data Model",
             "intended for": "Information Architect",
             "name": self.metadata.name,
-            "external_id": self.metadata.prefix,
+            "external_id": self.metadata.external_id,
+            "space": self.metadata.space,
             "version": self.metadata.version,
             "classes": len(self.classes),
             "properties": len(self.properties),
         }
 
         return pd.DataFrame([summary]).T.rename(columns={0: ""})._repr_html_()  # type: ignore
-
-    @property
-    def id_(self) -> URIRef:
-        return DEFAULT_NAMESPACE[f"data-model/unverified/info/{self.metadata.prefix}/{self.metadata.version}"]

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

@@ -4,10 +4,9 @@ from typing import cast
 
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.errors import NeatValueError, ResourceNotDefinedError
+from cognite.neat._issues.warnings._models import UndefinedClassWarning
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.models._base_rules import DataModelType, SchemaCompleteness
 from cognite.neat._rules.models.entities import ClassEntity, UnknownEntity
-from cognite.neat._utils.rdf_ import get_inheritance_path
 
 from ._rules import InformationRules
 
@@ -24,72 +23,60 @@ class InformationPostValidation:
         self.issue_list = IssueList()
 
     def validate(self) -> IssueList:
-        if self.metadata.schema_ == SchemaCompleteness.partial:
-            return self.issue_list
-
-        if self.metadata.data_model_type == DataModelType.solution and not self.rules.reference:
-            raise ValueError("Reference data model is missing")
-
-        if self.metadata.schema_ == SchemaCompleteness.extended and not self.rules.last:
-            raise ValueError("Last version is missing")
-
-        self._dangling_classes()
-        self._referenced_parent_classes_exist()
+        self._namespaces_reassigned()
+        self._classes_without_properties()
+        self._parent_class_defined()
         self._referenced_classes_exist()
         self._referenced_value_types_exist()
-        self._namespaces_reassigned()
 
         return self.issue_list
 
-    def _dangling_classes(self) -> None:
+    def _classes_without_properties(self) -> None:
         # needs to be complete for this validation to pass
         defined_classes = {class_.class_ for class_ in self.classes}
         referred_classes = {property_.class_ for property_ in self.properties}
         class_parent_pairs = self._class_parent_pairs()
-        dangling_classes = set()
 
         if classes_without_properties := defined_classes.difference(referred_classes):
             for class_ in classes_without_properties:
-                # USE CASE: class has no direct properties and no parents
-                if class_ not in class_parent_pairs:
-                    dangling_classes.add(class_)
                 # USE CASE: class has no direct properties and no parents with properties
-                elif class_ not in class_parent_pairs and not any(
-                    parent in referred_classes for parent in get_inheritance_path(class_, class_parent_pairs)
-                ):
-                    dangling_classes.add(class_)
-
-        for class_ in dangling_classes:
-            self.issue_list.append(
-                NeatValueError(f"Class {class_} has no properties and is not a parent of any class with properties")
-            )
+                # and it is a class in the prefix of data model, as long as it is in the
+                # same prefix, meaning same space
+                if not class_parent_pairs[class_] and class_.prefix == self.metadata.prefix:
+                    self.issue_list.append(
+                        ResourceNotDefinedError[ClassEntity](
+                            resource_type="class",
+                            identifier=class_,
+                            location="Classes sheet",
+                        )
+                    )
 
-    def _referenced_parent_classes_exist(self) -> None:
-        # needs to be complete for this validation to pass
+    def _parent_class_defined(self) -> None:
+        """This is a validation to check if the parent class of a class is defined in the classes sheet."""
         class_parent_pairs = self._class_parent_pairs()
         classes = set(class_parent_pairs.keys())
         parents = set(itertools.chain.from_iterable(class_parent_pairs.values()))
 
         if undefined_parents := parents.difference(classes):
             for parent in undefined_parents:
-                # Todo: include row and column number
-                self.issue_list.append(
-                    ResourceNotDefinedError[ClassEntity](
-                        resource_type="class",
-                        identifier=parent,
-                        location="Classes sheet",
+                if parent.prefix != self.metadata.prefix:
+                    self.issue_list.append(UndefinedClassWarning(class_id=str(parent)))
+                else:
+                    self.issue_list.append(
+                        ResourceNotDefinedError[ClassEntity](
+                            resource_type="class",
+                            identifier=parent,
+                            location="Classes sheet",
+                        )
                     )
-                )
 
     def _referenced_classes_exist(self) -> None:
         # needs to be complete for this validation to pass
         defined_classes = {class_.class_ for class_ in self.classes}
-        referred_classes = {property_.class_ for property_ in self.properties}
+        classes_with_explicit_properties = {property_.class_ for property_ in self.properties}
 
         # USE CASE: models are complete
-        if self.metadata.schema_ == SchemaCompleteness.complete and (
-            missing_classes := referred_classes.difference(defined_classes)
-        ):
+        if missing_classes := classes_with_explicit_properties.difference(defined_classes):
             for class_ in missing_classes:
                 self.issue_list.append(
                     ResourceNotDefinedError[ClassEntity](
@@ -99,19 +86,6 @@ class InformationPostValidation:
                     )
                 )
 
-        # USE CASE: models are extended (user + last = complete)
-        if self.metadata.schema_ == SchemaCompleteness.extended:
-            defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
-            if missing_classes := referred_classes.difference(defined_classes):
-                for class_ in missing_classes:
-                    self.issue_list.append(
-                        ResourceNotDefinedError[ClassEntity](
-                            resource_type="class",
-                            identifier=class_,
-                            location="Classes sheet",
-                        )
-                    )
-
     def _referenced_value_types_exist(self) -> None:
         # adding UnknownEntity to the set of defined classes to handle the case where a property references an unknown
         defined_classes = {class_.class_ for class_ in self.classes} | {UnknownEntity()}
@@ -121,10 +95,7 @@ class InformationPostValidation:
             if property_.type_ == EntityTypes.object_property
         }
 
-        # USE CASE: models are complete
-        if self.metadata.schema_ == SchemaCompleteness.complete and (
-            missing_value_types := referred_object_types.difference(defined_classes)
-        ):
+        if missing_value_types := referred_object_types.difference(defined_classes):
             # Todo: include row and column number
             for missing in missing_value_types:
                 self.issue_list.append(
@@ -135,56 +106,17 @@ class InformationPostValidation:
                     )
                 )
 
-        # USE CASE: models are extended (user + last = complete)
-        if self.metadata.schema_ == SchemaCompleteness.extended:
-            defined_classes |= {class_.class_ for class_ in cast(InformationRules, self.rules.last).classes}
-            if missing_value_types := referred_object_types.difference(defined_classes):
-                # Todo: include row and column number
-                for missing in missing_value_types:
-                    self.issue_list.append(
-                        ResourceNotDefinedError(
-                            resource_type="class",
-                            identifier=cast(ClassEntity, missing),
-                            location="Classes sheet",
-                        )
-                    )
-
     def _class_parent_pairs(self) -> dict[ClassEntity, list[ClassEntity]]:
-        class_subclass_pairs: dict[ClassEntity, list[ClassEntity]] = {}
-
+        class_parent_pairs: dict[ClassEntity, list[ClassEntity]] = {}
         classes = self.rules.model_copy(deep=True).classes
 
-        # USE CASE: Solution model being extended (user + last + reference = complete)
-        if (
-            self.metadata.schema_ == SchemaCompleteness.extended
-            and self.metadata.data_model_type == DataModelType.solution
-        ):
-            classes += (
-                cast(InformationRules, self.rules.last).model_copy(deep=True).classes
-                + cast(InformationRules, self.rules.reference).model_copy(deep=True).classes
-            )
-
-        # USE CASE: Solution model being created from scratch (user + reference = complete)
-        elif (
-            self.metadata.schema_ == SchemaCompleteness.complete
-            and self.metadata.data_model_type == DataModelType.solution
-        ):
-            classes += cast(InformationRules, self.rules.reference).model_copy(deep=True).classes
-
-        # USE CASE: Enterprise model being extended (user + last = complete)
-        elif (
-            self.metadata.schema_ == SchemaCompleteness.extended
-            and self.metadata.data_model_type == DataModelType.enterprise
-        ):
-            classes += cast(InformationRules, self.rules.last).model_copy(deep=True).classes
-
         for class_ in classes:
-            class_subclass_pairs[class_.class_] = []
-            if class_.parent is None:
+            class_parent_pairs[class_.class_] = []
+            if class_.implements is None:
                 continue
-            class_subclass_pairs[class_.class_].extend(class_.parent)
+            class_parent_pairs[class_.class_].extend(class_.implements)
 
-        return class_subclass_pairs
+        return class_parent_pairs
 
     def _namespaces_reassigned(self) -> None:
         prefixes = self.rules.prefixes.copy()

cognite/neat/_rules/transformers/__init__.py

@@ -1,9 +1,7 @@
 from ._base import RulesPipeline, RulesTransformer
 from ._converters import (
-    AssetToInformation,
     ConvertToRules,
     DMSToInformation,
-    InformationToAsset,
     InformationToDMS,
     ReduceCogniteModel,
     SetIDDMSModel,
@@ -12,7 +10,7 @@ from ._converters import (
 )
 from ._mapping import MapOneToOne, RuleMapper
 from ._pipelines import ImporterPipeline
-from ._verification import VerifyAnyRules, VerifyAssetRules, VerifyDMSRules, VerifyInformationRules
+from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRules
 
 __all__ = [
     "ImporterPipeline",
@@ -23,7 +21,6 @@ __all__ = [
     "ConvertToRules",
     "AssetToInformation",
     "DMSToInformation",
-    "VerifyAssetRules",
     "VerifyDMSRules",
     "VerifyInformationRules",
     "VerifyAnyRules",