cognite-neat 0.97.3__tar.gz → 0.98.0__tar.gz

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.97.3
+Version: 0.98.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0
@@ -29,6 +29,7 @@ Requires-Dist: google-auth-oauthlib ; extra == "google"
 Requires-Dist: gspread ; extra == "google"
 Requires-Dist: jsonpath-python (>=1.0.6,<2.0.0)
 Requires-Dist: lxml (>=5.3.0,<6.0.0) ; extra == "all"
+Requires-Dist: mixpanel (>=4.10.1,<5.0.0)
 Requires-Dist: mkdocs ; extra == "docs"
 Requires-Dist: mkdocs-autorefs (>=0.5.0,<0.6.0) ; extra == "docs"
 Requires-Dist: mkdocs-git-authors-plugin ; extra == "docs"

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/cognite/neat/_graph/loaders/__init__.py

@@ -1,8 +1,7 @@
 from ._base import BaseLoader, CDFLoader
-from ._rdf2asset import AssetLoader
 from ._rdf2dms import DMSLoader
 
-__all__ = ["BaseLoader", "CDFLoader", "DMSLoader", "AssetLoader"]
+__all__ = ["BaseLoader", "CDFLoader", "DMSLoader"]
 
 
 def _repr_html_() -> str:

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/cognite/neat/_issues/warnings/_models.py

@@ -92,6 +92,15 @@ class NotSupportedHasDataFilterLimitWarning(CDFNotSupportedWarning):
     limit: int = DMS_VIEW_CONTAINER_SIZE_LIMIT
 
 
+@dataclass(unsafe_hash=True)
+class UndefinedClassWarning(UserModelingWarning):
+    """Class {class_id} has no explicit properties defined neither implements other class"""
+
+    fix = "Define properties for class or inherit properties by implementing another class."
+
+    class_id: str
+
+
 @dataclass(unsafe_hash=True)
 class UndefinedViewWarning(UserModelingWarning):
     """Undefined view {value_type} has been referred as value type for property <{view_property}> of view {view_id}."""

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/cognite/neat/_rules/_shared.py

@@ -4,20 +4,15 @@ from typing import Any, Generic, TypeAlias, TypeVar
 
 from cognite.neat._issues import IssueList
 from cognite.neat._rules.models import (
-    AssetRules,
     DMSRules,
-    DomainRules,
     InformationRules,
 )
-from cognite.neat._rules.models.asset._rules_input import AssetInputRules
 from cognite.neat._rules.models.dms._rules_input import DMSInputRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 
-VerifiedRules: TypeAlias = DomainRules | InformationRules | DMSRules | AssetRules
-InputRules: TypeAlias = AssetInputRules | DMSInputRules | InformationInputRules
-Rules: TypeAlias = (
-    AssetInputRules | DMSInputRules | InformationInputRules | DomainRules | InformationRules | DMSRules | AssetRules
-)
+VerifiedRules: TypeAlias = InformationRules | DMSRules
+InputRules: TypeAlias = DMSInputRules | InformationInputRules
+Rules: TypeAlias = DMSInputRules | InformationInputRules | InformationRules | DMSRules
 T_Rules = TypeVar("T_Rules", bound=Rules)
 T_VerifiedRules = TypeVar("T_VerifiedRules", bound=VerifiedRules)
 T_InputRules = TypeVar("T_InputRules", bound=InputRules)

cognite_neat-0.98.0/cognite/neat/_rules/analysis/__init__.py

@@ -0,0 +1,4 @@
+from ._dms import DMSAnalysis
+from ._information import InformationAnalysis
+
+__all__ = ["InformationAnalysis", "DMSAnalysis"]

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/cognite/neat/_rules/analysis/_base.py

@@ -14,7 +14,6 @@ from cognite.neat._rules.models._rdfpath import RDFPath
 from cognite.neat._rules.models.entities import (
     ClassEntity,
     Entity,
-    ReferenceEntity,
 )
 from cognite.neat._rules.models.information import InformationProperty
 from cognite.neat._utils.rdf_ import get_inheritance_path
@@ -76,10 +75,6 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
     def _get_properties(self) -> list[T_Property]:
         raise NotImplementedError
 
-    @abstractmethod
-    def _get_reference(self, class_or_property: T_Class | T_Property) -> ReferenceEntity | None:
-        raise NotImplementedError
-
     @abstractmethod
     def _get_cls_entity(self, class_: T_Class | T_Property) -> T_ClassEntity:
         raise NotImplementedError
@@ -92,10 +87,6 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
     def _get_cls_parents(self, class_: T_Class) -> list[T_ClassEntity] | None:
         raise NotImplementedError
 
-    @abstractmethod
-    def _get_reference_rules(self) -> T_Rules | None:
-        raise NotImplementedError
-
     @classmethod
     @abstractmethod
     def _set_cls_entity(cls, property_: T_Property, class_: T_ClassEntity) -> None:
@@ -111,23 +102,11 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
 
     @property
     def directly_referred_classes(self) -> set[ClassEntity]:
-        ref_rules = self._get_reference_rules()
-        if ref_rules is None:
-            return set()
-        prefix = ref_rules.metadata.get_prefix()
-        return {
-            ref.as_class_entity()
-            for class_ in self._get_classes()
-            if isinstance((ref := self._get_reference(class_)), ReferenceEntity) and ref.prefix == prefix
-        }
+        raise NotImplementedError
 
     @property
     def inherited_referred_classes(self) -> set[ClassEntity]:
-        dir_referred_classes = self.directly_referred_classes
-        inherited_referred_classes = []
-        for class_ in dir_referred_classes:
-            inherited_referred_classes.extend(self.class_inheritance_path(class_))
-        return set(inherited_referred_classes)
+        raise NotImplementedError
 
     # Todo Lru cache this method.
     def class_parent_pairs(self) -> dict[T_ClassEntity, list[T_ClassEntity]]:

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/cognite/neat/_rules/analysis/_dms.py

@@ -1,6 +1,6 @@
 from cognite.neat._constants import DMS_LISTABLE_PROPERTY_LIMIT
 from cognite.neat._rules.models.dms import DMSProperty, DMSRules, DMSView
-from cognite.neat._rules.models.entities import ReferenceEntity, ViewEntity
+from cognite.neat._rules.models.entities import ViewEntity
 
 from ._base import BaseAnalysis
 
@@ -14,21 +14,12 @@ class DMSAnalysis(BaseAnalysis[DMSRules, DMSView, DMSProperty, ViewEntity, str])
     def _get_properties(self) -> list[DMSProperty]:
         return list(self.rules.properties)
 
-    def _get_reference(self, class_or_property: DMSView | DMSProperty) -> ReferenceEntity | None:
-        return class_or_property.reference if isinstance(class_or_property.reference, ReferenceEntity) else None
-
     def _get_cls_entity(self, class_: DMSView | DMSProperty) -> ViewEntity:
         return class_.view
 
-    def _get_prop_entity(self, property_: DMSProperty) -> str:
-        return property_.property_
-
     def _get_cls_parents(self, class_: DMSView) -> list[ViewEntity] | None:
         return list(class_.implements) if class_.implements else None
 
-    def _get_reference_rules(self) -> DMSRules | None:
-        return self.rules.reference
-
     @classmethod
     def _set_cls_entity(cls, property_: DMSProperty, class_: ViewEntity) -> None:
         property_.view = class_
@@ -41,3 +32,6 @@ class DMSAnalysis(BaseAnalysis[DMSRules, DMSView, DMSProperty, ViewEntity, str])
 
     def subset_rules(self, desired_classes: set[ViewEntity]) -> DMSRules:
         raise NotImplementedError()
+
+    def _get_prop_entity(self, property_: DMSProperty) -> str:
+        return property_.view_property

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/cognite/neat/_rules/analysis/_information.py

@@ -12,7 +12,7 @@ from cognite.neat._rules.models._rdfpath import (
     SelfReferenceProperty,
     SingleProperty,
 )
-from cognite.neat._rules.models.entities import ClassEntity, ReferenceEntity
+from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.entities._multi_value import MultiValueTypeInfo
 from cognite.neat._rules.models.information import (
     InformationClass,
@@ -34,9 +34,6 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
     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_
 
@@ -48,10 +45,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
         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
+        return list(class_.implements or []) or None
 
     def _get_properties(self) -> list[InformationProperty]:
         return list(self.rules.properties)
@@ -154,8 +148,6 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
             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)

{cognite_neat-0.97.3 → cognite_neat-0.98.0}/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-0.97.3 → cognite_neat-0.98.0}/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-0.97.3 → cognite_neat-0.98.0}/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-0.97.3 → cognite_neat-0.98.0}/cognite/neat/_rules/importers/_dms2rules.py

@@ -1,5 +1,5 @@
 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
@@ -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,6 +84,14 @@ 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,
@@ -180,9 +186,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 +229,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 +244,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 +258,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 +281,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 +328,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 +336,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-0.97.3 → cognite_neat-0.98.0}/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-0.97.3 → cognite_neat-0.98.0}/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),