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

cognite/neat/_rules/exporters/_rules2dms.py

@@ -3,7 +3,6 @@ from collections.abc import Collection, Hashable, Iterable, Sequence
 from pathlib import Path
 from typing import Literal, TypeAlias, cast
 
-from cognite.client import CogniteClient
 from cognite.client.data_classes._base import CogniteResource, CogniteResourceList
 from cognite.client.data_classes.data_modeling import (
     ContainerApplyList,
@@ -15,23 +14,14 @@ from cognite.client.data_classes.data_modeling import (
 )
 from cognite.client.exceptions import CogniteAPIError
 
+from cognite.neat._client import DataModelingLoader, NeatClient
+from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import (
     PrincipleOneModelOneSpaceWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat._rules.models.dms import DMSRules, DMSSchema, PipelineSchema
-from cognite.neat._utils.cdf.loaders import (
-    ContainerLoader,
-    DataModelingLoader,
-    DataModelLoader,
-    RawDatabaseLoader,
-    RawTableLoader,
-    ResourceLoader,
-    SpaceLoader,
-    TransformationLoader,
-    ViewLoader,
-)
+from cognite.neat._rules.models.dms import DMSRules
 from cognite.neat._utils.upload import UploadResult
 
 from ._base import CDFExporter
@@ -119,14 +109,14 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         return rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)
 
     def delete_from_cdf(
-        self, rules: DMSRules, client: CogniteClient, dry_run: bool = False, skip_space: bool = False
+        self, rules: DMSRules, client: NeatClient, dry_run: bool = False, skip_space: bool = False
     ) -> Iterable[UploadResult]:
-        to_export = self._prepare_exporters(rules, client)
+        to_export = self._prepare_exporters(rules)
 
         # we need to reverse order in which we are picking up the items to delete
         # as they are sorted in the order of creation and we need to delete them in reverse order
         for items, loader in reversed(to_export):
-            if skip_space and isinstance(loader, SpaceLoader):
+            if skip_space and isinstance(items, SpaceApplyList):
                 continue
             item_ids = loader.get_ids(items)
             existing_items = loader.retrieve(item_ids)
@@ -166,9 +156,9 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
             )
 
     def export_to_cdf_iterable(
-        self, rules: DMSRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: DMSRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> Iterable[UploadResult]:
-        to_export = self._prepare_exporters(rules, client)
+        to_export = self._prepare_exporters(rules)
 
         result_by_name = {}
         if self.existing_handling == "force":
@@ -176,17 +166,18 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 result_by_name[delete_result.name] = delete_result
 
         redeploy_data_model = False
-        for items, loader in to_export:
+        for items in to_export:
             # The conversion from DMS to GraphQL does not seem to be triggered even if the views
             # are changed. This is a workaround to force the conversion.
-            is_redeploying = loader is DataModelingLoader and redeploy_data_model
+            is_redeploying = isinstance(items, DataModelApplyList) and redeploy_data_model
+            loader = client.loaders.get_loader(items)
 
             to_create, to_delete, to_update, unchanged = self._categorize_items_for_upload(
                 loader, items, is_redeploying
             )
 
             issue_list = IssueList()
-            warning_list = self._validate(loader, items)
+            warning_list = self._validate(loader, items, client)
             issue_list.extend(warning_list)
 
             created: set[Hashable] = set()
@@ -206,6 +197,8 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                     failed_changed.update(loader.get_id(item) for item in to_update)
                 else:
                     raise ValueError(f"Unsupported existing_handling {self.existing_handling}")
+                created.update(loader.get_id(item) for item in to_create)
+                deleted.update(loader.get_id(item) for item in to_delete)
             else:
                 if to_delete:
                     try:
@@ -226,7 +219,7 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                     else:
                         deleted.update(loader.get_id(item) for item in to_delete)
 
-                if isinstance(loader, DataModelingLoader):
+                if isinstance(items, DataModelApplyList):
                     to_create = loader.sort_by_dependencies(to_create)
 
                 try:
@@ -292,11 +285,11 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 issues=issue_list,
             )
 
-            if loader is ViewLoader and (created or changed):
+            if isinstance(items, ViewApplyList) and (created or changed):
                 redeploy_data_model = True
 
     def _categorize_items_for_upload(
-        self, loader: ResourceLoader, items: Sequence[CogniteResource], is_redeploying
+        self, loader: DataModelingLoader, items: Sequence[CogniteResource], is_redeploying
     ) -> tuple[list[CogniteResource], list[CogniteResource], list[CogniteResource], list[CogniteResource]]:
         item_ids = loader.get_ids(items)
         cdf_items = loader.retrieve(item_ids)
@@ -304,7 +297,7 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         to_create, to_update, unchanged, to_delete = [], [], [], []
         for item in items:
             if (
-                isinstance(loader, DataModelingLoader)
+                isinstance(items, DataModelApplyList)
                 and self.include_space is not None
                 and not loader.in_space(item, self.include_space)
             ):
@@ -322,28 +315,24 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 to_update.append(item)
         return to_create, to_delete, to_update, unchanged
 
-    def _prepare_exporters(self, rules, client) -> list[tuple[CogniteResourceList, ResourceLoader]]:
+    def _prepare_exporters(self, rules: DMSRules) -> list[CogniteResourceList]:
         schema = self.export(rules)
-        to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
+        to_export: list[CogniteResourceList] = []
         if self.export_components.intersection({"all", "spaces"}):
-            to_export.append((SpaceApplyList(schema.spaces.values()), SpaceLoader(client)))
+            to_export.append(SpaceApplyList(schema.spaces.values()))
         if self.export_components.intersection({"all", "containers"}):
-            to_export.append((ContainerApplyList(schema.containers.values()), ContainerLoader(client)))
+            to_export.append(ContainerApplyList(schema.containers.values()))
         if self.export_components.intersection({"all", "views"}):
-            to_export.append((ViewApplyList(schema.views.values()), ViewLoader(client, self.existing_handling)))
+            to_export.append(ViewApplyList(schema.views.values()))
         if self.export_components.intersection({"all", "data_models"}):
-            to_export.append((DataModelApplyList([schema.data_model]), DataModelLoader(client)))
-        if isinstance(schema, PipelineSchema):
-            to_export.append((schema.databases, RawDatabaseLoader(client)))
-            to_export.append((schema.raw_tables, RawTableLoader(client)))
-            to_export.append((schema.transformations, TransformationLoader(client)))
+            to_export.append(DataModelApplyList([schema.data_model]))
         return to_export
 
-    def _validate(self, loader: ResourceLoader, items: CogniteResourceList) -> IssueList:
+    def _validate(self, loader: DataModelingLoader, items: CogniteResourceList, client: NeatClient) -> IssueList:
         issue_list = IssueList()
-        if isinstance(loader, DataModelLoader):
+        if isinstance(items, DataModelApplyList):
             models = cast(list[DataModelApply], items)
-            if other_models := self._exist_other_data_models(loader, models):
+            if other_models := self._exist_other_data_models(client, models):
                 warning = PrincipleOneModelOneSpaceWarning(
                     f"There are multiple data models in the same space {models[0].space}. "
                     f"Other data models in the space are {other_models}.",
@@ -355,13 +344,13 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         return issue_list
 
     @classmethod
-    def _exist_other_data_models(cls, loader: DataModelLoader, models: list[DataModelApply]) -> list[DataModelId]:
+    def _exist_other_data_models(cls, client: NeatClient, models: list[DataModelApply]) -> list[DataModelId]:
         if not models:
             return []
         space = models[0].space
         external_id = models[0].external_id
         try:
-            data_models = loader.client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
+            data_models = client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
         except CogniteAPIError as e:
             warnings.warn(ResourceRetrievalWarning(frozenset({space}), "space", str(e)), stacklevel=2)
             return []

cognite/neat/_rules/exporters/_rules2excel.py

@@ -13,17 +13,13 @@ from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
 from rdflib import Namespace
 
-from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._rules._shared import VerifiedRules
 from cognite.neat._rules.models import (
-    DataModelType,
     ExtensionCategory,
     SchemaCompleteness,
     SheetRow,
 )
 from cognite.neat._rules.models.dms import DMSMetadata
-from cognite.neat._rules.models.dms._rules import DMSRules
-from cognite.neat._rules.models.domain import DomainMetadata
 from cognite.neat._rules.models.information import InformationMetadata
 from cognite.neat._rules.models.information._rules import InformationRules
 
@@ -40,23 +36,13 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             on the different styles.
         output_role: The role to use for the exported spreadsheet. If provided, the rules will be converted to
             this role formate before being written to excel. If not provided, the role from the rules will be used.
-        dump_as: This determines how the rules are written to the Excel file. An Excel file has up to three sets of
-           sheets: user, last, and reference. The user sheets are used for inputting rules from a user. The last sheets
-           are used for the last version of the same model as the user, while the reference sheets are used for
-           the model the user is building on. The options are:
-             * "user": The rules are written to the user sheets. This is used when you want to modify the rules
-                directly and potentially change the model. This is useful when you have imported the data model
-                from outside CDF and you want to modify it before you write it to CDF.
-             * "last": The rules are written to the last sheets. This is used when you want to extend the rules,
-               but have validation that you are not breaking the existing model. This is used when you want to
-               change a model that has already been published to CDF and that model is in production.
-             * "reference": The rules are written to the reference sheets. This is typically used when you want to build
-               a new solution on top of an enterprise model.
         new_model_id: The new model ID to use for the exported spreadsheet. This is only applicable if the input
             rules have 'is_reference' set. If provided, the model ID will be used to automatically create the
             new metadata sheet in the Excel file. The model id is expected to be a tuple of (prefix, title)
             (space, external_id) for InformationRules and DMSRules respectively.
 
+        sheet_prefix: The prefix to use for the sheet names in the Excel file. Defaults to an empty string.
+
     The following styles are available:
 
     - "none":    No styling is applied.
@@ -80,16 +66,17 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     dump_options = get_args(DumpOptions)
 
     def __init__(
-        self, styling: Style = "default", dump_as: DumpOptions = "user", new_model_id: tuple[str, str] | None = None
+        self,
+        styling: Style = "default",
+        new_model_id: tuple[str, str] | None = None,
+        sheet_prefix: str | None = None,
     ):
+        self.sheet_prefix = sheet_prefix or ""
         if styling not in self.style_options:
             raise ValueError(f"Invalid styling: {styling}. Valid options are {self.style_options}")
-        if dump_as not in self.dump_options:
-            raise ValueError(f"Invalid dump_as: {dump_as}. Valid options are {self.dump_options}")
         self.styling = styling
         self._styling_level = self.style_options.index(styling)
         self.new_model_id = new_model_id
-        self.dump_as = dump_as
 
     def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
         """Exports transformation rules to excel file."""
@@ -105,43 +92,10 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        dumped_user_rules: dict[str, Any]
-        dumped_last_rules: dict[str, Any] | None = None
-        dumped_reference_rules: dict[str, Any] | None = None
-        if self.dump_as != "user":
-            action = {"last": "update", "reference": "create"}[self.dump_as]
-            metadata_creator = _MetadataCreator(action, self.new_model_id)  # type: ignore[arg-type]
-
-            dumped_user_rules = {
-                "Metadata": metadata_creator.create(rules.metadata),
-            }
-
-            if self.dump_as == "last":
-                dumped_last_rules = rules.dump(by_alias=True)
-                if rules.reference:
-                    dumped_reference_rules = rules.reference.dump(by_alias=True, as_reference=True)
-            elif self.dump_as == "reference":
-                dumped_reference_rules = rules.dump(by_alias=True, as_reference=True)
-        else:
-            dumped_user_rules = rules.dump(by_alias=True)
-            if rules.last:
-                dumped_last_rules = rules.last.dump(by_alias=True)
-            if rules.reference:
-                dumped_reference_rules = rules.reference.dump(by_alias=True, as_reference=True)
-
-        self._write_metadata_sheet(workbook, dumped_user_rules["Metadata"])
-        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:
-            if isinstance(rules.reference, DMSRules):
-                sheet_prefix = "CDM" if rules.reference.metadata.as_data_model_id() in COGNITE_MODELS else "Ref"
-            else:
-                sheet_prefix = "Ref"
-            self._write_sheets(workbook, dumped_reference_rules, rules, sheet_prefix=sheet_prefix)
-            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=sheet_prefix)
+        dumped_user_rules: dict[str, Any] = rules.dump(by_alias=True)
+
+        self._write_metadata_sheet(workbook, dumped_user_rules["Metadata"], sheet_prefix=self.sheet_prefix)
+        self._write_sheets(workbook, dumped_user_rules, rules, sheet_prefix=self.sheet_prefix)
 
         if isinstance(rules, InformationRules) and rules.prefixes:
             self._write_prefixes_sheet(workbook, rules.prefixes)
@@ -274,9 +228,9 @@ class _MetadataCreator:
         new_model_id: tuple[str, str] | None = None,
     ):
         self.action = action
-        self.new_model_id = new_model_id or ("YOUR_PREFIX", "YOUR_TITLE")
+        self.new_model_id = new_model_id or ("YOUR_SPACE", "YOUR_EXTERNAL_ID")
 
-    def create(self, metadata: DomainMetadata | InformationMetadata | DMSMetadata) -> dict[str, Any]:
+    def create(self, metadata: InformationMetadata | DMSMetadata) -> dict[str, Any]:
         now = datetime.now(timezone.utc).replace(microsecond=0, tzinfo=None)
         if self.action == "update":
             output = json.loads(metadata.model_dump_json(by_alias=True))
@@ -290,13 +244,6 @@ class _MetadataCreator:
                 output["creator"] = self.creator_name
             return output
 
-        # Action "create"
-        if isinstance(metadata, DomainMetadata):
-            output = {field_alias: None for field_alias in metadata.model_dump(by_alias=True).keys()}
-            output["role"] = metadata.role.value
-            output["creator"] = self.creator_name
-            return output
-
         new_metadata = self._create_new_info(now)
         if isinstance(metadata, DMSMetadata):
             from cognite.neat._rules.transformers._converters import _InformationRulesConverter
@@ -314,13 +261,9 @@ class _MetadataCreator:
         return created
 
     def _create_new_info(self, now: datetime) -> InformationMetadata:
-        prefix = self.new_model_id[0]
         return InformationMetadata(
-            data_model_type=DataModelType.solution,
-            schema_=SchemaCompleteness.complete,
-            extension=ExtensionCategory.addition,
-            prefix=prefix,
-            namespace=f"http://purl.org/neat/{prefix}/",  # type: ignore[arg-type]
+            space=self.new_model_id[0],
+            external_id=self.new_model_id[1],
             description=None,
             version="1",
             created=now,

cognite/neat/_rules/exporters/_rules2ontology.py

@@ -247,9 +247,9 @@ class OWLClass(OntologyModel):
 
     @classmethod
     def from_class(cls, definition: InformationClass, namespace: Namespace, prefixes: dict) -> Self:
-        if definition.parent and isinstance(definition.parent, list):
+        if definition.implements and isinstance(definition.implements, list):
             sub_class_of = []
-            for parent_class in definition.parent:
+            for parent_class in definition.implements:
                 try:
                     sub_class_of.append(prefixes[str(parent_class.prefix)][str(parent_class.suffix)])
                 except KeyError:
@@ -524,8 +524,8 @@ class SHACLNodeShape(OntologyModel):
     def from_rules(
         cls, class_definition: InformationClass, property_definitions: list[InformationProperty], namespace: Namespace
     ) -> "SHACLNodeShape":
-        if class_definition.parent:
-            parent = [namespace[str(parent.suffix) + "Shape"] for parent in class_definition.parent]
+        if class_definition.implements:
+            parent = [namespace[str(parent.suffix) + "Shape"] for parent in class_definition.implements]
         else:
             parent = None
         return cls(

cognite/neat/_rules/importers/_base.py

@@ -6,7 +6,6 @@ from datetime import datetime
 from typing import Any, Generic, Literal
 
 from pydantic import ValidationError
-from rdflib import Namespace
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._issues import IssueList, NeatError, NeatWarning
@@ -33,11 +32,11 @@ class BaseImporter(ABC, Generic[T_InputRules]):
             creator = getpass.getuser()
 
         return {
-            "prefix": "neat",
             "schema": "partial",
-            "namespace": Namespace("http://purl.org/cognite/neat/"),
+            "space": "neat",
+            "external_id": "NeatImportedDataModel",
             "version": "0.1.0",
-            "title": "Neat Imported Data Model",
+            "name": "Neat Imported Data Model",
             "created": datetime.now().replace(microsecond=0).isoformat(),
             "updated": datetime.now().replace(microsecond=0).isoformat(),
             "creator": creator,

cognite/neat/_rules/importers/_dms2rules.py

@@ -1,10 +1,9 @@
 from collections import Counter
-from collections.abc import Collection, Sequence
+from collections.abc import Collection, Iterable, Sequence
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Literal, cast
 
-from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
 from cognite.client.data_classes.data_modeling.containers import BTreeIndex, InvertedIndex
@@ -19,6 +18,7 @@ from cognite.client.data_classes.data_modeling.views import (
 )
 from cognite.client.utils import ms_to_datetime
 
+from cognite.neat._client import NeatClient
 from cognite.neat._issues import IssueList, NeatIssue
 from cognite.neat._issues.errors import FileTypeUnexpectedError, ResourceMissingIdentifierError, ResourceRetrievalError
 from cognite.neat._issues.warnings import (
@@ -30,10 +30,8 @@ from cognite.neat._issues.warnings import (
 from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers._base import BaseImporter, _handle_issues
 from cognite.neat._rules.models import (
-    DataModelType,
     DMSInputRules,
     DMSSchema,
-    SchemaCompleteness,
 )
 from cognite.neat._rules.models.data_types import DataType, Enum
 from cognite.neat._rules.models.dms import (
@@ -86,10 +84,18 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             self._all_containers_by_id.update(schema.reference.containers.items())
             self._all_views_by_id.update(schema.reference.views.items())
 
+    def update_referenced_containers(self, containers: Iterable[dm.ContainerApply]) -> None:
+        """Update the referenced containers. This is useful to add Cognite containers identified after the root schema
+        is read"""
+        for container in containers:
+            if container.as_id() in self._all_containers_by_id:
+                continue
+            self._all_containers_by_id[container.as_id()] = container
+
     @classmethod
     def from_data_model_id(
         cls,
-        client: CogniteClient,
+        client: NeatClient,
         data_model_id: DataModelIdentifier,
         reference_model_id: DataModelIdentifier | None = None,
     ) -> "DMSImporter":
@@ -141,12 +147,12 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
         issue_list = IssueList()
         with _handle_issues(issue_list) as result:
-            schema = DMSSchema.from_data_model(client, user_model, ref_model)
+            schema = DMSSchema.from_data_model(NeatClient(client), user_model, ref_model)
 
         if result.result == "failure" or issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
-        metadata = cls._create_metadata_from_model(user_model, has_reference=ref_model is not None)
+        metadata = cls._create_metadata_from_model(user_model)
         ref_metadata = cls._create_metadata_from_model(ref_model) if ref_model else None
 
         return cls(schema, issue_list, metadata, ref_metadata)
@@ -168,7 +174,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
     def _create_metadata_from_model(
         cls,
         model: dm.DataModel[dm.View] | dm.DataModelApply,
-        has_reference: bool = False,
     ) -> DMSInputMetadata:
         description, creator = DMSInputMetadata._get_description_and_creator(model.description)
 
@@ -180,9 +185,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             created = now
             updated = now
         return DMSInputMetadata(
-            schema_="complete",
-            data_model_type="solution" if has_reference else "enterprise",
-            extension="addition",
             space=model.space,
             external_id=model.external_id,
             name=model.name or model.external_id,
@@ -226,28 +228,12 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
         model = self.root_schema.data_model
 
-        schema_completeness = SchemaCompleteness.complete
-        data_model_type = DataModelType.enterprise
-        reference: DMSInputRules | None = None
-        if (ref_schema := self.root_schema.reference) and (ref_model := ref_schema.data_model):
-            # Reference should always be an enterprise model.
-            reference = self._create_rule_components(
-                ref_model,
-                ref_schema,
-                self.ref_metadata or self._create_default_metadata(list(ref_schema.views.values()), is_ref=True),
-                DataModelType.enterprise,
-            )
-            data_model_type = DataModelType.solution
-
         user_rules = self._create_rule_components(
             model,
             self.root_schema,
             self.metadata,
-            data_model_type,
-            schema_completeness,
-            has_reference=reference is not None,
         )
-        user_rules.reference = reference
+
         self._end = datetime.now(timezone.utc)
 
         return ReadRules(user_rules, self.issue_list, {})
@@ -257,9 +243,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         data_model: dm.DataModelApply,
         schema: DMSSchema,
         metadata: DMSInputMetadata | None = None,
-        data_model_type: DataModelType | None = None,
-        schema_completeness: SchemaCompleteness | None = None,
-        has_reference: bool = False,
     ) -> DMSInputRules:
         properties: list[DMSInputProperty] = []
         for view_id, view in schema.views.items():
@@ -274,11 +257,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             view.as_id() if isinstance(view, dm.View | dm.ViewApply) else view for view in data_model.views or []
         }
 
-        metadata = metadata or DMSInputMetadata.from_data_model(data_model, has_reference)
-        if data_model_type is not None:
-            metadata.data_model_type = str(data_model_type)  # type: ignore[assignment]
-        if schema_completeness is not None:
-            metadata.schema_ = str(schema_completeness)  # type: ignore[assignment]
+        metadata = metadata or DMSInputMetadata.from_data_model(data_model)
 
         enum = self._create_enum_collections(schema.containers.values())
 
@@ -301,9 +280,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         now = datetime.now().replace(microsecond=0)
         space = Counter(view.space for view in views).most_common(1)[0][0]
         return DMSInputMetadata(
-            schema_="complete",
-            extension="addition",
-            data_model_type="enterprise" if is_ref else "solution",
             space=space,
             external_id="Unknown",
             version="0.1.0",
@@ -351,8 +327,6 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             return None
 
         return DMSInputProperty(
-            class_=str(class_entity),
-            property_=prop_id,
             description=prop.description,
             name=prop.name,
             connection=self._get_connection_type(prop),
@@ -361,10 +335,12 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             nullable=self._get_nullable(prop),
             immutable=self._get_immutable(prop),
             default=self._get_default(prop),
-            container=str(ContainerEntity.from_id(prop.container))
-            if isinstance(prop, dm.MappedPropertyApply)
-            else None,
-            container_property=prop.container_property_identifier if isinstance(prop, dm.MappedPropertyApply) else None,
+            container=(
+                str(ContainerEntity.from_id(prop.container)) if isinstance(prop, dm.MappedPropertyApply) else None
+            ),
+            container_property=(
+                prop.container_property_identifier if isinstance(prop, dm.MappedPropertyApply) else None
+            ),
             view=str(view_entity),
             view_property=prop_id,
             index=self._get_index(prop, prop_id),

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

@@ -99,8 +99,7 @@ class _DTDLConverter:
             class_=item.id_.as_class_id(),
             name=item.display_name,
             description=item.description,
-            comment=item.comment,
-            parent=[parent.as_class_id() for parent in item.extends or []] or None,
+            implements=[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 []:
@@ -135,7 +134,6 @@ class _DTDLConverter:
             property_=item.name,
             name=item.display_name,
             description=item.description,
-            comment=item.comment,
             value_type=value_type,
             min_count=min_count,
             max_count=max_count,
@@ -181,7 +179,6 @@ class _DTDLConverter:
             property_=item.name,
             name=item.display_name,
             description=item.description,
-            comment=item.comment,
             value_type=value_type,
             min_count=0,
             max_count=1,
@@ -201,7 +198,6 @@ class _DTDLConverter:
             property_=item.name,
             name=item.display_name,
             description=item.description,
-            comment=item.comment,
             value_type=value_type,
             min_count=0,
             max_count=1,
@@ -233,7 +229,6 @@ class _DTDLConverter:
                 description=item.description,
                 min_count=item.min_multiplicity or 0,
                 max_count=item.max_multiplicity or 1,
-                comment=item.comment,
                 value_type=value_type,
             )
             self.properties.append(prop)
@@ -255,7 +250,6 @@ class _DTDLConverter:
             class_=item.id_.as_class_id(),
             name=item.display_name,
             description=item.description,
-            comment=item.comment,
         )
         self.classes.append(class_)
 

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

@@ -17,7 +17,7 @@ from cognite.neat._rules._shared import ReadRules
 from cognite.neat._rules.importers._base import BaseImporter
 from cognite.neat._rules.importers._dtdl2rules.dtdl_converter import _DTDLConverter
 from cognite.neat._rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
-from cognite.neat._rules.models import InformationInputRules, SchemaCompleteness
+from cognite.neat._rules.models import InformationInputRules
 from cognite.neat._rules.models.information import InformationInputMetadata
 from cognite.neat._utils.text import humanize_collection, to_pascal
 
@@ -31,7 +31,7 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
 
     Args:
         items (Sequence[DTDLBase]): A sequence of DTDLBase objects.
-        title (str, optional): Title of the data model. Defaults to None.
+        name (str, optional): Name of the data model. Defaults to None.
         read_issues (list[ValidationIssue], optional): A list of issues that occurred during reading. Defaults to None.
         schema (SchemaCompleteness, optional): Schema completeness. Defaults to SchemaCompleteness.partial.
 
@@ -40,14 +40,12 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
     def __init__(
         self,
         items: Sequence[DTDLBase],
-        title: str | None = None,
+        name: str | None = None,
         read_issues: list[NeatIssue] | None = None,
-        schema: SchemaCompleteness = SchemaCompleteness.partial,
     ) -> None:
         self._items = items
-        self.title = title
+        self.name = name
         self._read_issues = IssueList(read_issues)
-        self._schema_completeness = schema
 
     @classmethod
     def _from_file_content(cls, file_content: str, filepath: Path) -> Iterable[DTDLBase | NeatIssue]:
@@ -130,17 +128,16 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
         converter.convert(self._items)
 
         metadata = self._default_metadata()
-        metadata["schema"] = self._schema_completeness.value
 
-        if self.title:
-            metadata["title"] = to_pascal(self.title)
+        if self.name:
+            metadata["name"] = to_pascal(self.name)
         try:
             most_common_prefix = converter.get_most_common_prefix()
         except ValueError:
             # No prefixes are defined so we just use the default prefix...
             ...
         else:
-            metadata["prefix"] = most_common_prefix
+            metadata["space"] = most_common_prefix
 
         rules = InformationInputRules(
             metadata=InformationInputMetadata.load(metadata),