cognite-neat 0.121.1__py3-none-any.whl → 0.122.0__py3-none-any.whl

cognite/neat/core/_data_model/catalog/__init__.py

@@ -1,8 +1,8 @@
-"""Shortcut to rules catalog files"""
+"""Shortcut to data model catalog"""
 
 from pathlib import Path
 
 _CATALOG = Path(__file__).parent
-imf_attributes = _CATALOG / "info-rules-imf.xlsx"
+imf_attributes = _CATALOG / "conceptual-imf-data-model.xlsx"
 hello_world_pump = _CATALOG / "hello_world_pump.xlsx"
 classic_model = _CATALOG / "classic_model.xlsx"

cognite/neat/core/_data_model/exporters/__init__.py

@@ -1,9 +1,9 @@
 from ._base import BaseExporter, CDFExporter
-from ._rules2dms import DMSExporter
-from ._rules2excel import ExcelExporter
-from ._rules2instance_template import InstanceTemplateExporter
-from ._rules2ontology import GraphExporter, OWLExporter, SemanticDataModelExporter, SHACLExporter
-from ._rules2yaml import YAMLExporter
+from ._data_model2dms import DMSExporter
+from ._data_model2excel import ExcelExporter
+from ._data_model2instance_template import InstanceTemplateExporter
+from ._data_model2ontology import GraphExporter, OWLExporter, SemanticDataModelExporter, SHACLExporter
+from ._data_model2yaml import YAMLExporter
 
 __all__ = [
     "BaseExporter",
@@ -34,6 +34,6 @@ def _repr_html_() -> str:
     )._repr_html_()
 
     return (
-        "<strong>Exporter</strong> An exporter converts Neat's representation of a data model called <em>Rules</em>"
+        "<strong>Exporter</strong> An exporter converts Neat's representation of a data model"
         f" into a schema/data model for a target format.<br />{table}"
     )

cognite/neat/core/_data_model/exporters/_base.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Generic, TypeVar, Union, get_args, get_origin
 
 from cognite.neat.core._client import NeatClient
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._data_model._shared import T_VerifiedRules
+from cognite.neat.core._data_model._shared import T_VerifiedDataModel
 from cognite.neat.core._utils.auxiliary import class_html_doc
 from cognite.neat.core._utils.upload import UploadResult, UploadResultList
 
@@ -17,16 +17,16 @@ if TYPE_CHECKING:
 T_Export = TypeVar("T_Export")
 
 
-class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
+class BaseExporter(ABC, Generic[T_VerifiedDataModel, T_Export]):
     _new_line = "\n"
     _encoding = "utf-8"
 
     @abstractmethod
-    def export_to_file(self, rules: T_VerifiedRules, filepath: Path) -> None:
+    def export_to_file(self, data_model: T_VerifiedDataModel, filepath: Path) -> None:
         raise NotImplementedError
 
     @abstractmethod
-    def export(self, rules: T_VerifiedRules) -> T_Export:
+    def export(self, data_model: T_VerifiedDataModel) -> T_Export:
         raise NotImplementedError
 
     @classmethod
@@ -54,12 +54,14 @@ class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
         return (source_type,)
 
 
-class CDFExporter(BaseExporter[T_VerifiedRules, T_Export], ABC):
+class CDFExporter(BaseExporter[T_VerifiedDataModel, T_Export], ABC):
     @abstractmethod
     def export_to_cdf_iterable(
-        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False
+        self, data_model: T_VerifiedDataModel, client: NeatClient, dry_run: bool = False
     ) -> Iterable[UploadResult]:
         raise NotImplementedError
 
-    def export_to_cdf(self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False) -> UploadResultList:
-        return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run))
+    def export_to_cdf(
+        self, data_model: T_VerifiedDataModel, client: NeatClient, dry_run: bool = False
+    ) -> UploadResultList:
+        return UploadResultList(self.export_to_cdf_iterable(data_model, client, dry_run))

cognite/neat/core/_data_model/exporters/{_rules2dms.py → _data_model2dms.py}

@@ -28,7 +28,7 @@ from cognite.neat.core._client.data_classes.data_modeling import (
     ViewApplyDict,
 )
 from cognite.neat.core._client.data_classes.schema import DMSSchema
-from cognite.neat.core._data_model.models.dms import DMSRules
+from cognite.neat.core._data_model.models.physical import PhysicalDataModel
 from cognite.neat.core._issues import IssueList
 from cognite.neat.core._issues.warnings import (
     PrincipleOneModelOneSpaceWarning,
@@ -74,8 +74,8 @@ class ItemCategorized(Generic[T_ID, T_WriteClass]):
         yield from (self.as_id(item) for item in self.to_create + self.to_update + self.to_delete + self.unchanged)
 
 
-class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
-    """Export rules to Cognite Data Fusion's Data Model Storage (DMS) service.
+class DMSExporter(CDFExporter[PhysicalDataModel, DMSSchema]):
+    """Export data model to Cognite Data Fusion's Data Model Storage (DMS) service.
 
     Args:
         export_components (frozenset[Literal["all", "spaces", "data_models", "views", "containers"]], optional):
@@ -120,31 +120,31 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
     def description(self) -> str:
         return "Export verified DMS Model to CDF."
 
-    def export_to_file(self, rules: DMSRules, filepath: Path) -> None:
-        """Export the rules to a file(s).
+    def export_to_file(self, data_model: PhysicalDataModel, filepath: Path) -> None:
+        """Export the data_model to a file(s).
 
         If the file is a directory, the components will be exported to separate files, otherwise they will be
         exported to a zip file.
 
         Args:
             filepath: Directory or zip file path to export to.
-            rules:
+            data_model:
         """
         if filepath.is_dir():
-            self._export_to_directory(filepath, rules)
+            self._export_to_directory(filepath, data_model)
         else:
-            self._export_to_zip_file(filepath, rules)
+            self._export_to_zip_file(filepath, data_model)
 
-    def _export_to_directory(self, directory: Path, rules: DMSRules) -> None:
-        schema = self.export(rules)
+    def _export_to_directory(self, directory: Path, data_model: PhysicalDataModel) -> None:
+        schema = self.export(data_model)
         exclude = self._create_exclude_set()
         schema.to_directory(directory, exclude=exclude, new_line=self._new_line, encoding=self._encoding)
 
-    def _export_to_zip_file(self, filepath: Path, rules: DMSRules) -> None:
+    def _export_to_zip_file(self, filepath: Path, data_model: PhysicalDataModel) -> None:
         if filepath.suffix not in {".zip"}:
             warnings.warn("File extension is not .zip, adding it to the file name", stacklevel=2)
             filepath = filepath.with_suffix(".zip")
-        schema = self.export(rules)
+        schema = self.export(data_model)
         exclude = self._create_exclude_set()
         schema.to_zip(filepath, exclude=exclude)
 
@@ -155,14 +155,18 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
             exclude = {"spaces", "data_models", "views", "containers", "node_types"} - set(self.export_components)
         return exclude
 
-    def export(self, rules: DMSRules) -> DMSSchema:
+    def export(self, data_model: PhysicalDataModel) -> DMSSchema:
         # We do not want to include CogniteCore/CogniteProcess Industries in the schema
-        return rules.as_schema(instance_space=self.instance_space, remove_cdf_spaces=self.remove_cdf_spaces)
+        return data_model.as_schema(instance_space=self.instance_space, remove_cdf_spaces=self.remove_cdf_spaces)
 
     def delete_from_cdf(
-        self, rules: DMSRules, client: NeatClient, dry_run: bool = False, skip_space: bool = False
+        self,
+        data_model: PhysicalDataModel,
+        client: NeatClient,
+        dry_run: bool = False,
+        skip_space: bool = False,
     ) -> Iterable[UploadResult]:
-        schema = self.export(rules)
+        schema = self.export(data_model)
 
         # 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
@@ -202,9 +206,9 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
             yield result
 
     def export_to_cdf_iterable(
-        self, rules: DMSRules, client: NeatClient, dry_run: bool = False
+        self, data_model: PhysicalDataModel, client: NeatClient, dry_run: bool = False
     ) -> Iterable[UploadResult]:
-        schema = self.export(rules)
+        schema = self.export(data_model)
 
         # The CDF UI does not deal well with a child view overwriting a parent property with the same name
         # This is a workaround to remove the duplicated properties

cognite/neat/core/_data_model/exporters/{_rules2excel.py → _data_model2excel.py}

@@ -16,7 +16,7 @@ from rdflib import Namespace
 
 from cognite.neat.core._constants import BASE_MODEL, get_base_concepts
 from cognite.neat.core._data_model._constants import get_internal_properties
-from cognite.neat.core._data_model._shared import VerifiedRules
+from cognite.neat.core._data_model._shared import VerifiedDataModel
 from cognite.neat.core._data_model.models import (
     SheetRow,
 )
@@ -30,7 +30,7 @@ from cognite.neat.core._data_model.models.conceptual._verified import (
 from cognite.neat.core._data_model.models.data_types import (
     _DATA_TYPE_BY_DMS_TYPE,
 )
-from cognite.neat.core._data_model.models.dms._rules import DMSRules
+from cognite.neat.core._data_model.models.physical._verified import PhysicalDataModel
 from cognite.neat.core._utils.spreadsheet import (
     find_column_with_value,
     generate_data_validation,
@@ -41,16 +41,16 @@ from ._base import BaseExporter
 MAX_COLUMN_WIDTH = 70.0
 
 
-class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
-    """Export rules to Excel.
+class ExcelExporter(BaseExporter[VerifiedDataModel, Workbook]):
+    """Export data_model to Excel.
 
     Args:
         styling: The styling to use for the Excel file. Defaults to "default". See below for details
             on the different styles.
         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
+            data_model 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.
+            (space, external_id) for Conceptual and Physical Data Model respectively.
 
         sheet_prefix: The prefix to use for the sheet names in the Excel file. Defaults to an empty string.
 
@@ -68,14 +68,14 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     _helper_sheet_name: str = "_helper"
     _main_header_by_sheet_name: ClassVar[dict[str, str]] = {
         "Properties": "Definition of Properties",
-        "Classes": "Definition of Classes",
+        "Concepts": "Definition of Concepts",
         "Views": "Definition of Views",
         "Containers": "Definition of Containers",
         "Nodes": "Definition of Nodes",
         "Enum": "Definition of Enum Collections",
     }
     _helper_sheet_column_indexes_by_names: ClassVar[dict[str, int]] = {
-        "Class": 1,
+        "Concept": 1,
         "View": 1,
         "Implements": 2,
         "Value Type": 3,
@@ -92,7 +92,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         styling: Style = "default",
         new_model_id: tuple[str, str] | None = None,
         sheet_prefix: str | None = None,
-        reference_rules_with_prefix: tuple[VerifiedRules, str] | None = None,
+        reference_data_model_with_prefix: tuple[VerifiedDataModel, str] | None = None,
         add_empty_rows: bool = False,
         hide_internal_columns: bool = True,
         include_properties: Literal["same-space", "all"] = "all",
@@ -106,7 +106,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         self.styling = styling
         self._styling_level = self.style_options.index(styling)
         self.new_model_id = new_model_id
-        self.reference_rules_with_prefix = reference_rules_with_prefix
+        self.reference_data_model_with_prefix = reference_data_model_with_prefix
         self.add_empty_rows = add_empty_rows
         self.hide_internal_columns = hide_internal_columns
         self.include_properties = include_properties
@@ -118,9 +118,9 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     def description(self) -> str:
         return "Export verified model to Excel."
 
-    def export_to_file(self, rules: VerifiedRules, filepath: Path) -> None:
-        """Exports transformation rules to excel file."""
-        data = self.export(rules)
+    def export_to_file(self, data_model: VerifiedDataModel, filepath: Path) -> None:
+        """Exports transformation data_model to excel file."""
+        data = self.export(data_model)
         try:
             data.save(filepath)
         finally:
@@ -145,14 +145,14 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        rules_model = DMSRules if role == RoleTypes.dms else ConceptualDataModel
+        data_model_model = PhysicalDataModel if role == RoleTypes.dms else ConceptualDataModel
 
-        headers_by_sheet = rules_model.headers_by_sheet(by_alias=True)
+        headers_by_sheet = data_model_model.headers_by_sheet(by_alias=True)
         headers_by_sheet.pop("Metadata")
 
         self._write_metadata_sheet(
             workbook,
-            cast(BaseVerifiedMetadata, rules_model.model_fields["metadata"].annotation).default().model_dump(),
+            cast(BaseVerifiedMetadata, data_model_model.model_fields["metadata"].annotation).default().model_dump(),
         )
 
         for sheet_name, headers in headers_by_sheet.items():
@@ -175,23 +175,23 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
 
         return workbook
 
-    def export(self, rules: VerifiedRules) -> Workbook:
+    def export(self, data_model: VerifiedDataModel) -> Workbook:
         workbook = Workbook()
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        dumped_user_rules: dict[str, Any] = rules.dump(by_alias=True)
+        dumped_user_data_model: dict[str, Any] = data_model.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 self.reference_rules_with_prefix:
-            reference_rules, prefix = self.reference_rules_with_prefix
-            dumped_reference_rules = reference_rules.dump(entities_exclude_defaults=False, by_alias=True)
-            self._write_sheets(workbook, dumped_reference_rules, reference_rules, sheet_prefix=prefix)
-            self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=prefix)
+        self._write_metadata_sheet(workbook, dumped_user_data_model["Metadata"], sheet_prefix=self.sheet_prefix)
+        self._write_sheets(workbook, dumped_user_data_model, data_model, sheet_prefix=self.sheet_prefix)
+        if self.reference_data_model_with_prefix:
+            reference_data_model, prefix = self.reference_data_model_with_prefix
+            dumped_reference_data_model = reference_data_model.dump(entities_exclude_defaults=False, by_alias=True)
+            self._write_sheets(workbook, dumped_reference_data_model, reference_data_model, sheet_prefix=prefix)
+            self._write_metadata_sheet(workbook, dumped_reference_data_model["Metadata"], sheet_prefix=prefix)
 
-        if isinstance(rules, ConceptualDataModel) and rules.prefixes:
-            self._write_prefixes_sheet(workbook, rules.prefixes)
+        if isinstance(data_model, ConceptualDataModel) and data_model.prefixes:
+            self._write_prefixes_sheet(workbook, data_model.prefixes)
 
         if self._styling_level > 0:
             self._adjust_column_widths(workbook)
@@ -199,9 +199,9 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         if self.hide_internal_columns:
             self._hide_internal_columns(workbook)
 
-        # Only add drop downs if the rules are DMSRules
+        # Only add drop downs if the data_model are Physical Data Model
         if self.add_drop_downs:
-            self._add_drop_downs(rules.metadata.role, workbook)
+            self._add_drop_downs(data_model.metadata.role, workbook)
 
         return workbook
 
@@ -227,7 +227,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         workbook: Workbook,
     ) -> None:
         """Adds drop down menus to specific columns for fast and accurate data entry
-        for both DMS and Information rules.
+        for both Conceptual and Physical Data Model.
 
         Args:
             role: The role for which the drop downs are created. Can be either "dms" or "information".
@@ -241,8 +241,8 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
 
         !!! note "Why 100*100 rows?"
             This is due to the fact that we need to add drop down menus for all properties
-            in the sheet. The maximum number of properties per view/class is 100. So considering
-            maximum number of views/classes is 100, we need to add 100*100 rows.
+            in the sheet. The maximum number of properties per view/concept is 100. So considering
+            maximum number of views/concepts is 100, we need to add 100*100 rows.
         """
 
         self._make_helper_sheet(role, workbook, 100)
@@ -254,7 +254,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
 
         self._add_data_validation(
             workbook,
-            sheet_name="Views" if role == RoleTypes.dms else "Classes",
+            sheet_name="Views" if role == RoleTypes.dms else "Concepts",
             column_name="Implements",
             data_validator_name="implements",
             data_validators=data_validators,
@@ -275,8 +275,8 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
         self._add_data_validation(
             workbook,
             sheet_name="Properties",
-            column_name="View" if role == RoleTypes.dms else "Class",
-            data_validator_name="views_or_classes",
+            column_name="View" if role == RoleTypes.dms else "Concept",
+            data_validator_name="views_or_concepts",
             data_validators=data_validators,
             validation_range=100,
             total_rows=100 * 100,
@@ -364,26 +364,26 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                 )
             concept_counter += 1
 
-        views_or_classes_sheet = "Views" if role == RoleTypes.dms else "Classes"
-        view_or_class_column = "View" if role == RoleTypes.dms else "Class"
+        views_or_concepts_sheet = "Views" if role == RoleTypes.dms else "Concepts"
+        view_or_concept_column = "View" if role == RoleTypes.dms else "Concept"
 
         for i in range(no_rows):
             workbook[self._helper_sheet_name].cell(
                 row=i + 1,
-                column=self._helper_sheet_column_indexes_by_names[view_or_class_column],
-                value=f'=IF(ISBLANK({views_or_classes_sheet}!A{i + 3}), "", {views_or_classes_sheet}!A{i + 3})',
+                column=self._helper_sheet_column_indexes_by_names[view_or_concept_column],
+                value=f'=IF(ISBLANK({views_or_concepts_sheet}!A{i + 3}), "", {views_or_concepts_sheet}!A{i + 3})',
             )
 
             workbook[self._helper_sheet_name].cell(
                 row=concept_counter + i + 1,
                 column=self._helper_sheet_column_indexes_by_names["Implements"],
-                value=f'=IF(ISBLANK({views_or_classes_sheet}!A{i + 3}), "", {views_or_classes_sheet}!A{i + 3})',
+                value=f'=IF(ISBLANK({views_or_concepts_sheet}!A{i + 3}), "", {views_or_concepts_sheet}!A{i + 3})',
             )
 
             workbook[self._helper_sheet_name].cell(
                 row=value_type_counter + i + 1,
                 column=self._helper_sheet_column_indexes_by_names["Value Type"],
-                value=f'=IF(ISBLANK({views_or_classes_sheet}!A{i + 3}), "", {views_or_classes_sheet}!A{i + 3})',
+                value=f'=IF(ISBLANK({views_or_concepts_sheet}!A{i + 3}), "", {views_or_concepts_sheet}!A{i + 3})',
             )
 
             if role == RoleTypes.dms:
@@ -507,11 +507,11 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     def _write_sheets(
         self,
         workbook: Workbook,
-        dumped_rules: dict[str, Any],
-        rules: VerifiedRules,
+        dumped_data_model: dict[str, Any],
+        data_model: VerifiedDataModel,
         sheet_prefix: str = "",
     ) -> None:
-        for sheet_name, headers in rules.headers_by_sheet(by_alias=True).items():
+        for sheet_name, headers in data_model.headers_by_sheet(by_alias=True).items():
             if sheet_name in ("Metadata", "Prefixes", "Reference", "Last"):
                 continue
 
@@ -519,17 +519,17 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
 
             fill_colors = itertools.cycle(["CADCFC", "FFFFFF"])
             fill_color = next(fill_colors)
-            last_class: str | None = None
+            last_concept: str | None = None
             item: dict[str, Any]
-            for item in dumped_rules.get(sheet_name) or []:
+            for item in dumped_data_model.get(sheet_name) or []:
                 if "Neat ID" in item:
                     # Move the Neat ID to the end of the columns
                     item["Neat ID"] = item.pop("Neat ID")
                 row = list(item.values())
-                class_ = row[0]
+                concept = row[0]
 
                 is_properties = sheet_name == "Properties"
-                is_new_class = class_ != last_class and last_class is not None
+                is_new_class = concept != last_concept and last_concept is not None
                 if self._styling_level > 2 and is_new_class and is_properties:
                     if self.add_empty_rows:
                         sheet.append([""] * len(headers))
@@ -540,8 +540,8 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                     fill_color = next(fill_colors)
 
                 if is_properties and self.include_properties == "same-space":
-                    space = class_.split(":")[0] if ":" in class_ else rules.metadata.space
-                    if space != rules.metadata.space:
+                    space = concept.split(":")[0] if ":" in concept else data_model.metadata.space
+                    if space != data_model.metadata.space:
                         continue
 
                 sheet.append(row)
@@ -550,7 +550,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                         cell.fill = PatternFill(fgColor=fill_color, patternType="solid")
                         side = Side(style="thin", color="000000")
                         cell.border = Border(left=side, right=side, top=side, bottom=side)
-                last_class = class_
+                last_concept = concept
 
             self._style_sheet_header(sheet, headers)
 

cognite/neat/core/_data_model/exporters/{_rules2instance_template.py → _data_model2instance_template.py}

@@ -9,19 +9,19 @@ from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.datavalidation import DataValidation
 
 from cognite.neat.core._data_model._constants import EntityTypes
-from cognite.neat.core._data_model.analysis import RulesAnalysis
+from cognite.neat.core._data_model.analysis import DataModelAnalysis
 from cognite.neat.core._data_model.models.conceptual._verified import (
     ConceptualDataModel,
 )
-from cognite.neat.core._data_model.models.entities._single_value import ClassEntity
+from cognite.neat.core._data_model.models.entities._single_value import ConceptEntity
 
 from ._base import BaseExporter
 
 
 class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
     """
-    Converts Information Rules to a templated spreadsheet meant for capturing
-    instances based on class definitions in the rules.
+    Converts conceptual data model to a templated spreadsheet meant for capturing
+    instances based on concept definitions in the data model.
 
     Args:
         no_rows: number of rows for processing, by default 1000
@@ -50,33 +50,33 @@ class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
 
     def export(
         self,
-        rules: ConceptualDataModel,
+        data_model: ConceptualDataModel,
     ) -> Workbook:
         workbook = Workbook()
 
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        for class_, properties in RulesAnalysis(rules).properties_by_id_by_class().items():
-            workbook.create_sheet(title=class_.suffix)
+        for concept, properties in DataModelAnalysis(data_model).properties_by_id_by_concept().items():
+            workbook.create_sheet(title=concept.suffix)
 
             # Add header rows
-            workbook[class_.suffix].append(["identifier", *list(properties.keys())])
+            workbook[concept.suffix].append(["identifier", *list(properties.keys())])
 
             if self.auto_identifier_type == "uuid":
-                _add_uuid_identifiers(workbook, class_.suffix, self.no_rows)
+                _add_uuid_identifiers(workbook, concept.suffix, self.no_rows)
             else:
                 # Default to index-based identifier
-                _add_index_identifiers(workbook, class_.suffix, self.no_rows)
+                _add_index_identifiers(workbook, concept.suffix, self.no_rows)
 
             for i, property_ in enumerate(properties.values()):
                 if property_.type_ == EntityTypes.object_property and self.add_drop_down_list:
                     _add_drop_down_list(
                         workbook,
-                        class_.suffix,
+                        concept.suffix,
                         get_column_letter(i + 2),
                         self.no_rows,
-                        cast(ClassEntity, property_.value_type).suffix,
+                        cast(ConceptEntity, property_.value_type).suffix,
                         "A",
                     )
 
@@ -85,9 +85,9 @@ class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
 
         return workbook
 
-    def export_to_file(self, rules: ConceptualDataModel, filepath: Path) -> None:
+    def export_to_file(self, data_model: ConceptualDataModel, filepath: Path) -> None:
         """Exports graph capturing sheet to excel file."""
-        data = self.export(rules)
+        data = self.export(data_model)
         try:
             data.save(filepath)
         finally: