cognite-neat 0.77.3__py3-none-any.whl → 0.77.4__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.77.3"
+__version__ = "0.77.4"

cognite/neat/rules/analysis/_information_rules.py

@@ -13,23 +13,13 @@ from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, ParentC
 from cognite.neat.rules.models.information import InformationClass, InformationProperty, InformationRules
 from cognite.neat.utils.utils import get_inheritance_path
 
-from ._base import BaseAnalysis, DataModelingScenario
+from ._base import BaseAnalysis
 
 
 class InformationArchitectRulesAnalysis(BaseAnalysis):
     def __init__(self, rules: InformationRules):
         self.rules = rules
 
-    @property
-    def data_modeling_scenario(self) -> DataModelingScenario:
-        if not self.rules.reference:
-            return DataModelingScenario.from_scratch
-
-        if self.rules.metadata.namespace == self.rules.reference.metadata.namespace:
-            return DataModelingScenario.extend_reference
-        else:
-            return DataModelingScenario.build_solution
-
     @property
     def referred_classes(self) -> set[ClassEntity]:
         return self.directly_referred_classes.union(self.inherited_referred_classes)
@@ -362,7 +352,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
 
-        if not rules.metadata.schema_ is not SchemaCompleteness.complete:
+        if 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()

cognite/neat/rules/exporters/_rules2excel.py

@@ -132,11 +132,11 @@ class ExcelExporter(BaseExporter[Workbook]):
         self._write_sheets(workbook, dumped_user_rules, rules)
         if dumped_last_rules:
             self._write_sheets(workbook, dumped_last_rules, rules, sheet_prefix="Last")
+            self._write_metadata_sheet(workbook, dumped_last_rules["Metadata"], sheet_prefix="Last")
 
         if dumped_reference_rules:
-            prefix = "Ref"
-            self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix=prefix)
-            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=prefix)
+            self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix="Ref")
+            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix="Ref")
 
         if self._styling_level > 0:
             self._adjust_column_widths(workbook)
@@ -291,7 +291,7 @@ class _MetadataCreator:
         prefix = self.new_model_id[0]
         return InformationMetadata(
             data_model_type=DataModelType.solution,
-            schema_=SchemaCompleteness.extended,
+            schema_=SchemaCompleteness.complete,
             extension=ExtensionCategory.addition,
             prefix=prefix,
             namespace=f"http://purl.org/neat/{prefix}/",  # type: ignore[arg-type]

cognite/neat/rules/importers/_dms2rules.py

@@ -109,7 +109,7 @@ class DMSImporter(BaseImporter):
         if result.result == "failure" or issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
-        metadata = cls._create_metadata_from_model(user_model)
+        metadata = cls._create_metadata_from_model(user_model, has_reference=ref_model is not None)
         ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
 
         return cls(schema, issue_list, metadata, ref_metadata)
@@ -131,6 +131,7 @@ class DMSImporter(BaseImporter):
     def _create_metadata_from_model(
         cls,
         model: dm.DataModel[dm.View] | dm.DataModelApply,
+        has_reference: bool = False,
     ) -> DMSMetadata:
         description, creator = DMSMetadata._get_description_and_creator(model.description)
 
@@ -143,6 +144,7 @@ class DMSImporter(BaseImporter):
             updated = now
         return DMSMetadata(
             schema_=SchemaCompleteness.complete,
+            data_model_type=DataModelType.solution if has_reference else DataModelType.enterprise,
             extension=ExtensionCategory.addition,
             space=model.space,
             external_id=model.external_id,
@@ -202,16 +204,21 @@ class DMSImporter(BaseImporter):
                     **self._create_rule_components(
                         ref_model,
                         ref_schema,
-                        self.ref_metadata or self._create_default_metadata(list(ref_schema.views.values())),
+                        self.ref_metadata
+                        or self._create_default_metadata(list(ref_schema.views.values()), is_ref=True),
                         DataModelType.enterprise,
                     )
                 )
-                schema_completeness = SchemaCompleteness.extended
                 data_model_type = DataModelType.solution
 
             user_rules = DMSRules(
                 **self._create_rule_components(
-                    model, self.root_schema, self.metadata, data_model_type, schema_completeness
+                    model,
+                    self.root_schema,
+                    self.metadata,
+                    data_model_type,
+                    schema_completeness,
+                    has_reference=reference is not None,
                 ),
                 reference=reference,
             )
@@ -228,6 +235,7 @@ class DMSImporter(BaseImporter):
         metadata: DMSMetadata | None = None,
         data_model_type: DataModelType | None = None,
         schema_completeness: SchemaCompleteness | None = None,
+        has_reference: bool = False,
     ) -> dict[str, Any]:
         properties = SheetList[DMSProperty]()
         for view_id, view in schema.views.items():
@@ -242,7 +250,7 @@ class DMSImporter(BaseImporter):
             view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
         }
 
-        metadata = metadata or DMSMetadata.from_data_model(data_model)
+        metadata = metadata or DMSMetadata.from_data_model(data_model, has_reference)
         if data_model_type is not None:
             metadata.data_model_type = data_model_type
         if schema_completeness is not None:
@@ -262,12 +270,13 @@ class DMSImporter(BaseImporter):
         )
 
     @classmethod
-    def _create_default_metadata(cls, views: Sequence[dm.View | dm.ViewApply]) -> DMSMetadata:
+    def _create_default_metadata(cls, views: Sequence[dm.View | dm.ViewApply], is_ref: bool = False) -> DMSMetadata:
         now = datetime.now().replace(microsecond=0)
         space = Counter(view.space for view in views).most_common(1)[0][0]
         return DMSMetadata(
             schema_=SchemaCompleteness.complete,
             extension=ExtensionCategory.addition,
+            data_model_type=DataModelType.enterprise if is_ref else DataModelType.solution,
             space=space,
             external_id="Unknown",
             version="0.1.0",

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

@@ -134,6 +134,7 @@ class DTDLImporter(BaseImporter):
 
         metadata = self._default_metadata()
         metadata["schema"] = self._schema_completeness.value
+
         if self.title:
             metadata["title"] = to_pascal(self.title)
         try:

cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -22,6 +22,7 @@ from cognite.neat.rules.models import (
     SchemaCompleteness,
 )
 from cognite.neat.rules.models.dms import DMSRulesInput
+from cognite.neat.rules.models.information import InformationRulesInput
 from cognite.neat.utils.auxiliary import local_import
 from cognite.neat.utils.spreadsheet import SpreadsheetRead, read_individual_sheet
 
@@ -110,17 +111,27 @@ class SpreadsheetReader:
         self.required = required
         self.metadata = metadata
         self._sheet_prefix = sheet_prefix
+        self._seen_files: set[Path] = set()
+        self._seen_sheets: set[str] = set()
 
     @property
     def metadata_sheet_name(self) -> str:
         return f"{self._sheet_prefix}Metadata"
 
+    @property
+    def seen_sheets(self) -> set[str]:
+        if not self._seen_files:
+            raise ValueError("No files have been read yet.")
+        return self._seen_sheets
+
     def sheet_names(self, role: RoleTypes) -> set[str]:
         names = MANDATORY_SHEETS_BY_ROLE[role]
         return {f"{self._sheet_prefix}{sheet_name}" for sheet_name in names if sheet_name != "Metadata"}
 
     def read(self, filepath: Path) -> None | ReadResult:
         with pd.ExcelFile(filepath) as excel_file:
+            self._seen_files.add(filepath)
+            self._seen_sheets.update(map(str, excel_file.sheet_names))
             metadata: MetadataRaw | None
             if self.metadata is not None:
                 metadata = self.metadata
@@ -212,20 +223,20 @@ class ExcelImporter(BaseImporter):
             issue_list.append(issues.spreadsheet_file.SpreadsheetNotFoundError(self.filepath))
             return self._return_or_raise(issue_list, errors)
 
-        user_read = SpreadsheetReader(issue_list).read(self.filepath)
+        user_reader = SpreadsheetReader(issue_list)
+        user_read = user_reader.read(self.filepath)
         if user_read is None or issue_list.has_errors:
             return self._return_or_raise(issue_list, errors)
 
         last_read: ReadResult | None = None
+        if any(sheet_name.startswith("Last") for sheet_name in user_reader.seen_sheets):
+            last_read = SpreadsheetReader(issue_list, required=False, sheet_prefix="Last").read(self.filepath)
         reference_read: ReadResult | None = None
-        if user_read.schema == SchemaCompleteness.extended:
-            # Last does not have its own metadata sheet. It is the same as the user's metadata sheet.
-            last_read = SpreadsheetReader(
-                issue_list, required=False, metadata=user_read.metadata, sheet_prefix="Last"
-            ).read(self.filepath)
+        if any(sheet_name.startswith("Ref") for sheet_name in user_reader.seen_sheets):
             reference_read = SpreadsheetReader(issue_list, sheet_prefix="Ref").read(self.filepath)
-            if issue_list.has_errors:
-                return self._return_or_raise(issue_list, errors)
+
+        if issue_list.has_errors:
+            return self._return_or_raise(issue_list, errors)
 
         if reference_read and user_read.role != reference_read.role:
             issue_list.append(issues.spreadsheet_file.RoleMismatchError(self.filepath))
@@ -253,6 +264,8 @@ class ExcelImporter(BaseImporter):
             rules: Rules
             if rules_cls is DMSRules:
                 rules = DMSRulesInput.load(sheets).as_rules()
+            elif rules_cls is InformationRules:
+                rules = InformationRulesInput.load(sheets).as_rules()
             else:
                 rules = rules_cls.model_validate(sheets)  # type: ignore[attr-defined]
 

cognite/neat/rules/issues/spreadsheet.py

@@ -10,7 +10,7 @@ from pydantic_core import ErrorDetails
 
 from cognite.neat.utils.spreadsheet import SpreadsheetRead
 
-from .base import DefaultPydanticError, MultiValueError, NeatValidationError, ValidationWarning
+from .base import DefaultPydanticError, MultiValueError, NeatValidationError
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -27,7 +27,7 @@ __all__ = [
     "InvalidRowUnknownSheetError",
     "NonExistingContainerError",
     "NonExistingViewError",
-    "ClassNoPropertiesNoParentsWarning",
+    "ClassNoPropertiesNoParentError",
     "InconsistentContainerDefinitionError",
     "MultiValueTypeError",
     "MultiValueIsListError",
@@ -239,7 +239,26 @@ class NonExistingViewError(InvalidPropertyError):
 
 
 @dataclass(frozen=True)
-class ClassNoPropertiesNoParentsWarning(ValidationWarning):
+class PropertiesDefinedForUndefinedClassesError(NeatValidationError):
+    description = "Properties are defined for undefined classes."
+    fix = "Make sure to define class in the Classes sheet."
+
+    classes: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["classes"] = self.classes
+        return output
+
+    def message(self) -> str:
+        return (
+            f"Classes {', '.join(self.classes)} have properties assigned to them, but"
+            " they are not defined in the Classes sheet."
+        )
+
+
+@dataclass(frozen=True)
+class ClassNoPropertiesNoParentError(NeatValidationError):
     description = "Class has no properties and no parents."
     fix = "Check if the class should have properties or parents."
 
@@ -252,8 +271,44 @@ class ClassNoPropertiesNoParentsWarning(ValidationWarning):
 
     def message(self) -> str:
         if len(self.classes) > 1:
-            return f"Classes {', '.join(self.classes)} have no properties and no parents. This may be a mistake."
-        return f"Class {self.classes[0]} has no properties and no parents. This may be a mistake."
+            return f"Classes {', '.join(self.classes)} have no direct or inherited properties. This may be a mistake."
+        return f"Class {self.classes[0]} have no direct or inherited properties. This may be a mistake."
+
+
+@dataclass(frozen=True)
+class ParentClassesNotDefinedError(NeatValidationError):
+    description = "Parent classes are not defined."
+    fix = "Check if the parent classes are defined in Classes sheet."
+
+    classes: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["classes"] = self.classes
+        return output
+
+    def message(self) -> str:
+        if len(self.classes) > 1:
+            return f"Parent classes {', '.join(self.classes)} are not defined. This may be a mistake."
+        return f"Parent classes {', '.join(self.classes[0])} are not defined. This may be a mistake."
+
+
+@dataclass(frozen=True)
+class ValueTypeNotDefinedError(NeatValidationError):
+    description = "Value types referred by properties are not defined in Rules."
+    fix = "Make sure that all value types are defined in Rules."
+
+    value_types: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["classes"] = self.value_types
+        return output
+
+    def message(self) -> str:
+        if len(self.value_types) > 1:
+            return f"Value types {', '.join(self.value_types)} are not defined. This may be a mistake."
+        return f"Value types {', '.join(self.value_types[0])} are not defined. This may be a mistake."
 
 
 @dataclass(frozen=True)

cognite/neat/rules/models/_base.py

@@ -38,6 +38,12 @@ else:
 METADATA_VALUE_MAX_LENGTH = 5120
 
 
+def _add_alias(data: dict[str, Any], base_model: type[BaseModel]) -> None:
+    for field_name, field_ in base_model.model_fields.items():
+        if field_name not in data and field_.alias in data:
+            data[field_name] = data[field_.alias]
+
+
 def replace_nan_floats_with_default(values: dict, model_fields: dict[str, FieldInfo]) -> dict:
     output = {}
     for field_name, value in values.items():

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

@@ -105,6 +105,8 @@ class _DMSRulesConverter:
         prefix = metadata.space
         return InformationMetadata(
             schema_=metadata.schema_,
+            data_model_type=metadata.data_model_type,
+            extension=metadata.extension,
             prefix=prefix,
             namespace=Namespace(f"https://purl.orgl/neat/{prefix}/"),
             version=metadata.version,

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

@@ -86,7 +86,8 @@ class _DMSExporter:
 
         if self._ref_schema:
             output.reference = self._ref_schema
-
+        if self.rules.last:
+            output.last = self.rules.last.as_schema()
         return output
 
     def _create_spaces(

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

@@ -58,7 +58,7 @@ _DEFAULT_VERSION = "1"
 
 class DMSMetadata(BaseMetadata):
     role: ClassVar[RoleTypes] = RoleTypes.dms_architect
-    data_model_type: DataModelType = Field(DataModelType.solution, alias="dataModelType")
+    data_model_type: DataModelType = Field(DataModelType.enterprise, alias="dataModelType")
     schema_: SchemaCompleteness = Field(alias="schema")
     extension: ExtensionCategory = ExtensionCategory.addition
     space: ExternalIdType
@@ -146,10 +146,11 @@ class DMSMetadata(BaseMetadata):
         return description, creator
 
     @classmethod
-    def from_data_model(cls, data_model: dm.DataModelApply) -> "DMSMetadata":
+    def from_data_model(cls, data_model: dm.DataModelApply, has_reference: bool) -> "DMSMetadata":
         description, creator = cls._get_description_and_creator(data_model.description)
         return cls(
             schema_=SchemaCompleteness.complete,
+            data_model_type=DataModelType.solution if has_reference else DataModelType.enterprise,
             space=data_model.space,
             name=data_model.name or None,
             description=description,

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

@@ -3,9 +3,7 @@ from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Literal, cast, overload
 
-from pydantic import BaseModel
-
-from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness
+from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness, _add_alias
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import (
     ClassEntity,
@@ -44,8 +42,9 @@ class DMSMetadataInput:
             external_id=data.get("external_id"),  # type: ignore[arg-type]
             creator=data.get("creator"),  # type: ignore[arg-type]
             version=data.get("version"),  # type: ignore[arg-type]
-            extension=data.get("extension", "addition"),
-            data_model_type=data.get("data_model_type", "solution"),
+            # safeguard from empty cell, i.e. if key provided by value None
+            extension=data.get("extension", "addition") or "addition",
+            data_model_type=data.get("data_model_type", "solution") or "solution",
             name=data.get("name"),
             description=data.get("description"),
             created=data.get("created"),
@@ -355,9 +354,3 @@ class DMSRulesInput:
             Last=last,
             Reference=reference,
         )
-
-
-def _add_alias(data: dict[str, Any], base_model: type[BaseModel]) -> None:
-    for field_name, field_ in base_model.model_fields.items():
-        if field_name not in data and field_.alias in data:
-            data[field_name] = data[field_.alias]

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

@@ -516,10 +516,11 @@ class DMSSchema:
         defined_spaces = self.spaces.copy()
         defined_containers = self.containers.copy()
         defined_views = self.views.copy()
-        if self.reference:
-            defined_spaces |= self.reference.spaces
-            defined_containers |= self.reference.containers
-            defined_views |= self.reference.views
+        for other_schema in [self.reference, self.last]:
+            if other_schema:
+                defined_spaces |= other_schema.spaces
+                defined_containers |= other_schema.containers
+                defined_views |= other_schema.views
 
         for container in self.containers.values():
             if container.space not in defined_spaces:

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

@@ -37,7 +37,7 @@ class _DMSRulesSerializer:
                 DMSProperty.model_fields[field].alias or field for field in self.properties_fields
             ]
             self.views_fields = [DMSView.model_fields[field].alias or field for field in self.views_fields]
-            self.container_fields = [
+            self.containers_fields = [
                 DMSContainer.model_fields[field].alias or field for field in self.containers_fields
             ]
             self.prop_view = DMSProperty.model_fields[self.prop_view].alias or self.prop_view

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

@@ -5,12 +5,13 @@ from cognite.client import data_modeling as dm
 
 from cognite.neat.rules import issues
 from cognite.neat.rules.issues import IssueList
-from cognite.neat.rules.models._base import ExtensionCategory, SchemaCompleteness
+from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ContainerEntity
 from cognite.neat.rules.models.wrapped_entities import RawFilter
 
 from ._rules import DMSProperty, DMSRules
+from ._schema import DMSSchema
 
 
 class DMSPostValidation:
@@ -26,12 +27,17 @@ class DMSPostValidation:
         self.issue_list = IssueList()
 
     def validate(self) -> IssueList:
-        self._validate_best_practices()
+        self._validate_raw_filter()
         self._consistent_container_properties()
+
         self._referenced_views_and_containers_are_existing()
-        self._validate_extension()
-        self._validate_schema()
-        self._validate_performance()
+        if self.metadata.schema_ is SchemaCompleteness.extended:
+            self._validate_extension()
+        if self.metadata.schema_ is SchemaCompleteness.partial:
+            return self.issue_list
+        dms_schema = self.rules.as_schema()
+        self.issue_list.extend(dms_schema.validate())
+        self._validate_performance(dms_schema)
         return self.issue_list
 
     def _consistent_container_properties(self) -> None:
@@ -106,8 +112,9 @@ class DMSPostValidation:
         self.issue_list.extend(errors)
 
     def _referenced_views_and_containers_are_existing(self) -> None:
-        # There two checks are done in the same method to raise all the errors at once.
         defined_views = {view.view.as_id() for view in self.views}
+        if self.metadata.schema_ is SchemaCompleteness.extended and self.rules.last:
+            defined_views |= {view.view.as_id() for view in self.rules.last.views}
 
         errors: list[issues.NeatValidationError] = []
         for prop_no, prop in enumerate(self.properties):
@@ -125,6 +132,11 @@ class DMSPostValidation:
                 )
         if self.metadata.schema_ is SchemaCompleteness.complete:
             defined_containers = {container.container.as_id() for container in self.containers or []}
+            if self.metadata.data_model_type == DataModelType.solution and self.rules.reference:
+                defined_containers |= {
+                    container.container.as_id() for container in self.rules.reference.containers or []
+                }
+
             for prop_no, prop in enumerate(self.properties):
                 if prop.container and (container_id := prop.container.as_id()) not in defined_containers:
                     errors.append(
@@ -157,19 +169,16 @@ class DMSPostValidation:
     def _validate_extension(self) -> None:
         if self.metadata.schema_ is not SchemaCompleteness.extended:
             return None
-        if not self.rules.reference:
-            raise ValueError("The schema is set to 'extended', but no reference rules are provided to validate against")
-        is_solution = self.metadata.space != self.rules.reference.metadata.space
-        if is_solution:
-            return None
+        if not self.rules.last:
+            raise ValueError("The schema is set to 'extended', but no last rules are provided to validate against")
         if self.metadata.extension is ExtensionCategory.rebuild:
             # Everything is allowed
             return None
-        # Is an extension of an existing model.
         user_schema = self.rules.as_schema()
-        ref_schema = self.rules.reference.as_schema()
         new_containers = user_schema.containers.copy()
-        existing_containers = ref_schema.containers.copy()
+
+        last_schema = self.rules.last.as_schema()
+        existing_containers = last_schema.containers.copy()
 
         for container_id, container in new_containers.items():
             existing_container = existing_containers.get(container_id)
@@ -189,14 +198,12 @@ class DMSPostValidation:
                 )
             )
 
-        if self.metadata.extension is ExtensionCategory.reshape and self.issue_list:
-            return None
-        elif self.metadata.extension is ExtensionCategory.reshape:
+        if self.metadata.extension is ExtensionCategory.reshape:
             # Reshape allows changes to views
             return None
 
         new_views = user_schema.views.copy()
-        existing_views = ref_schema.views.copy()
+        existing_views = last_schema.views.copy()
         for view_id, view in new_views.items():
             existing_view = existing_views.get(view_id)
             if not existing_view or existing_view == view:
@@ -213,14 +220,7 @@ class DMSPostValidation:
                 )
             )
 
-    def _validate_performance(self) -> None:
-        # we can only validate performance on complete schemas due to the need
-        # to access all the container mappings
-        if self.metadata.schema_ is not SchemaCompleteness.complete:
-            return None
-
-        dms_schema = self.rules.as_schema()
-
+    def _validate_performance(self, dms_schema: DMSSchema) -> None:
         for view_id, view in dms_schema.views.items():
             mapped_containers = dms_schema._get_mapped_container_from_view(view_id)
 
@@ -243,7 +243,7 @@ class DMSPostValidation:
                         )
                     )
 
-    def _validate_best_practices(self) -> None:
+    def _validate_raw_filter(self) -> None:
         for view in self.views:
             if view.filter_ and isinstance(view.filter_, RawFilter):
                 self.issue_list.append(
@@ -264,36 +264,3 @@ class DMSPostValidation:
         existing_properties = existing_dumped.get("properties", {})
         changed_properties = [prop for prop in new_properties if new_properties[prop] != existing_properties.get(prop)]
         return changed_attributes, changed_properties
-
-    def _validate_schema(self) -> None:
-        if self.metadata.schema_ is SchemaCompleteness.partial:
-            return None
-        elif self.metadata.schema_ is SchemaCompleteness.complete:
-            rules: DMSRules = self.rules
-        elif self.metadata.schema_ is SchemaCompleteness.extended:
-            if not self.rules.reference:
-                raise ValueError(
-                    "The schema is set to 'extended', but no reference rules are provided to validate against"
-                )
-            # This is an extension of the reference rules, we need to merge the two
-            rules = self.rules.model_copy(deep=True)
-            rules.properties.extend(self.rules.reference.properties.data)
-            existing_views = {view.view.as_id() for view in rules.views}
-            rules.views.extend([view for view in self.rules.reference.views if view.view.as_id() not in existing_views])
-            if rules.containers and self.rules.reference.containers:
-                existing_containers = {container.container.as_id() for container in rules.containers.data}
-                rules.containers.extend(
-                    [
-                        container
-                        for container in self.rules.reference.containers
-                        if container.container.as_id() not in existing_containers
-                    ]
-                )
-            elif not rules.containers and self.rules.reference.containers:
-                rules.containers = self.rules.reference.containers
-        else:
-            raise ValueError("Unknown schema completeness")
-
-        schema = rules.as_schema()
-        errors = schema.validate()
-        self.issue_list.extend(errors)

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

@@ -1,3 +1,10 @@
 from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
+from ._rules_input import InformationRulesInput
 
-__all__ = ["InformationRules", "InformationMetadata", "InformationClass", "InformationProperty"]
+__all__ = [
+    "InformationRules",
+    "InformationMetadata",
+    "InformationClass",
+    "InformationProperty",
+    "InformationRulesInput",
+]