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

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.121.0"
+__version__ = "0.121.1"
 __engine__ = "^2.0.4"

cognite/neat/core/_constants.py

@@ -12,7 +12,7 @@ from cognite import neat
 from cognite.neat.core._issues.errors._general import NeatValueError
 
 if TYPE_CHECKING:
-    from cognite.neat.core._rules.models.dms import DMSProperty
+    from cognite.neat.core._data_model.models.dms import DMSProperty
 
 
 def _is_in_notebook() -> bool:
@@ -198,7 +198,7 @@ BASE_MODEL = Literal["CogniteCore"]
 
 def get_asset_read_only_properties_with_connection() -> "list[DMSProperty]":
     """Gets the asset read-only properties with connection, i.e. Root and Path."""
-    from cognite.neat.core._rules.models.dms import DMSProperty
+    from cognite.neat.core._data_model.models.dms import DMSProperty
 
     return [DMSProperty.model_validate(item) for item in (_ASSET_ROOT_PROPERTY, _ASSET_PATH_PROPERTY)]
 

cognite/neat/core/{_rules → _data_model}/_constants.py

@@ -18,7 +18,7 @@ class EntityTypes(StrEnum):
     parent_class = "parent_class"
     property_ = "property"
     dms_property = "dms_property"
-    information_property = "information_property"
+    conceptual_property = "conceptual_property"
     object_property = "ObjectProperty"
     data_property = "DatatypeProperty"
     annotation_property = "AnnotationProperty"
@@ -161,7 +161,7 @@ class _Patterns:
         if entity == EntityTypes.class_:
             return self.class_id_compliance
 
-        elif entity == EntityTypes.information_property:
+        elif entity == EntityTypes.conceptual_property:
             return self.information_property_id_compliance
 
         elif entity == EntityTypes.view:

cognite/neat/core/{_rules → _data_model}/_shared.py

@@ -1,20 +1,20 @@
 from dataclasses import dataclass
 from typing import Generic, TypeAlias, TypeVar
 
-from cognite.neat.core._rules.models import (
+from cognite.neat.core._data_model.models import (
+    ConceptualDataModel,
     DMSRules,
-    InformationRules,
 )
-from cognite.neat.core._rules.models.dms._rules_input import DMSInputRules
-from cognite.neat.core._rules.models.information._rules_input import (
-    InformationInputRules,
+from cognite.neat.core._data_model.models.conceptual._unverified import (
+    UnverifiedConceptualDataModel,
 )
+from cognite.neat.core._data_model.models.dms._rules_input import DMSInputRules
 from cognite.neat.core._utils.spreadsheet import SpreadsheetRead
 
-VerifiedRules: TypeAlias = InformationRules | DMSRules
+VerifiedRules: TypeAlias = ConceptualDataModel | DMSRules
 
 T_VerifiedRules = TypeVar("T_VerifiedRules", bound=VerifiedRules)
-InputRules: TypeAlias = DMSInputRules | InformationInputRules
+InputRules: TypeAlias = DMSInputRules | UnverifiedConceptualDataModel
 T_InputRules = TypeVar("T_InputRules", bound=InputRules)
 
 
@@ -36,8 +36,8 @@ class ReadRules(Generic[T_InputRules]):
         return self.rules.display_name
 
 
-ReadInputRules: TypeAlias = ReadRules[DMSInputRules] | ReadRules[InformationInputRules]
+ReadInputRules: TypeAlias = ReadRules[DMSInputRules] | ReadRules[UnverifiedConceptualDataModel]
 T_ReadInputRules = TypeVar("T_ReadInputRules", bound=ReadInputRules)
 
-Rules: TypeAlias = InformationRules | DMSRules | ReadRules[DMSInputRules] | ReadRules[InformationInputRules]
+Rules: TypeAlias = ConceptualDataModel | DMSRules | ReadRules[DMSInputRules] | ReadRules[UnverifiedConceptualDataModel]
 T_Rules = TypeVar("T_Rules", bound=Rules)

cognite/neat/core/{_rules → _data_model}/analysis/_base.py

@@ -11,23 +11,23 @@ import pandas as pd
 from cognite.client import data_modeling as dm
 from rdflib import URIRef
 
-from cognite.neat.core._issues.errors import NeatValueError
-from cognite.neat.core._issues.warnings import NeatValueWarning
-from cognite.neat.core._rules.models import DMSRules, InformationRules
-from cognite.neat.core._rules.models.dms import DMSProperty
-from cognite.neat.core._rules.models.dms._rules import DMSView
-from cognite.neat.core._rules.models.entities import (
+from cognite.neat.core._data_model.models import ConceptualDataModel, DMSRules
+from cognite.neat.core._data_model.models.conceptual import (
+    ConceptualClass,
+    ConceptualProperty,
+)
+from cognite.neat.core._data_model.models.dms import DMSProperty
+from cognite.neat.core._data_model.models.dms._rules import DMSView
+from cognite.neat.core._data_model.models.entities import (
     ClassEntity,
     MultiValueTypeInfo,
     ViewEntity,
 )
-from cognite.neat.core._rules.models.entities._single_value import (
+from cognite.neat.core._data_model.models.entities._single_value import (
     UnknownEntity,
 )
-from cognite.neat.core._rules.models.information import (
-    InformationClass,
-    InformationProperty,
-)
+from cognite.neat.core._issues.errors import NeatValueError
+from cognite.neat.core._issues.warnings import NeatValueWarning
 
 T_Hashable = TypeVar("T_Hashable", bound=Hashable)
 
@@ -111,12 +111,16 @@ class ViewQueryDict(dict, MutableMapping[dm.ViewId, ViewQuery]):
 
 
 class RulesAnalysis:
-    def __init__(self, information: InformationRules | None = None, dms: DMSRules | None = None) -> None:
+    def __init__(
+        self,
+        information: ConceptualDataModel | None = None,
+        dms: DMSRules | None = None,
+    ) -> None:
         self._information = information
         self._dms = dms
 
     @property
-    def information(self) -> InformationRules:
+    def information(self) -> ConceptualDataModel:
         if self._information is None:
             raise NeatValueError("Information rules are required for this analysis")
         return self._information
@@ -171,7 +175,7 @@ class RulesAnalysis:
 
     def properties_by_class(
         self, include_ancestors: bool = False, include_different_space: bool = False
-    ) -> dict[ClassEntity, list[InformationProperty]]:
+    ) -> dict[ClassEntity, list[ConceptualProperty]]:
         """Get a dictionary of classes and their properties.
 
         Args:
@@ -182,7 +186,7 @@ class RulesAnalysis:
             dict[ClassEntity, list[InformationProperty]]: Values properties with class as key.
 
         """
-        properties_by_classes: dict[ClassEntity, list[InformationProperty]] = defaultdict(list)
+        properties_by_classes: dict[ClassEntity, list[ConceptualProperty]] = defaultdict(list)
         for prop in self.information.properties:
             properties_by_classes[prop.class_].append(prop)
 
@@ -268,16 +272,16 @@ class RulesAnalysis:
         }
 
     @property
-    def _class_by_neat_id(self) -> dict[URIRef, InformationClass]:
+    def _class_by_neat_id(self) -> dict[URIRef, ConceptualClass]:
         """Get a dictionary of class neat IDs to
         class entities."""
 
         return {cls.neatId: cls for cls in self.information.classes if cls.neatId}
 
-    def class_by_suffix(self) -> dict[str, InformationClass]:
+    def class_by_suffix(self) -> dict[str, ConceptualClass]:
         """Get a dictionary of class suffixes to class entities."""
         # TODO: Remove this method
-        class_dict: dict[str, InformationClass] = {}
+        class_dict: dict[str, ConceptualClass] = {}
         for definition in self.information.classes:
             entity = definition.class_
             if entity.suffix in class_dict:
@@ -293,7 +297,7 @@ class RulesAnalysis:
         return class_dict
 
     @property
-    def class_by_class_entity(self) -> dict[ClassEntity, InformationClass]:
+    def class_by_class_entity(self) -> dict[ClassEntity, ConceptualClass]:
         """Get a dictionary of class entities to class entities."""
         rules = self.information
         return {cls.class_: cls for cls in rules.classes}
@@ -304,9 +308,9 @@ class RulesAnalysis:
         rules = self.dms
         return {view.view: view for view in rules.views}
 
-    def property_by_id(self) -> dict[str, list[InformationProperty]]:
+    def property_by_id(self) -> dict[str, list[ConceptualProperty]]:
         """Get a dictionary of property IDs to property entities."""
-        property_dict: dict[str, list[InformationProperty]] = defaultdict(list)
+        property_dict: dict[str, list[ConceptualProperty]] = defaultdict(list)
         for prop in self.information.properties:
             property_dict[prop.property_].append(prop)
         return property_dict
@@ -315,11 +319,11 @@ class RulesAnalysis:
         self,
         has_instance_source: bool = False,
         include_ancestors: bool = False,
-    ) -> dict[ClassEntity, dict[str, InformationProperty]]:
+    ) -> dict[ClassEntity, dict[str, ConceptualProperty]]:
         """Get a dictionary of class entities to dictionaries of property IDs to property entities."""
-        class_property_pairs: dict[ClassEntity, dict[str, InformationProperty]] = {}
+        class_property_pairs: dict[ClassEntity, dict[str, ConceptualProperty]] = {}
         for class_, properties in self.properties_by_class(include_ancestors).items():
-            processed_properties: dict[str, InformationProperty] = {}
+            processed_properties: dict[str, ConceptualProperty] = {}
             for prop in properties:
                 if prop.property_ in processed_properties:
                     warnings.warn(
@@ -372,7 +376,7 @@ class RulesAnalysis:
 
         properties_by_class = self.properties_by_class(include_ancestors)
 
-        prop: InformationProperty
+        prop: ConceptualProperty
         for prop in itertools.chain.from_iterable(properties_by_class.values()):
             if not isinstance(prop.value_type, ClassEntity):
                 continue
@@ -419,14 +423,14 @@ class RulesAnalysis:
         return sym_pairs
 
     @overload
-    def _properties_by_neat_id(self, format: Literal["info"] = "info") -> dict[URIRef, InformationProperty]: ...
+    def _properties_by_neat_id(self, format: Literal["info"] = "info") -> dict[URIRef, ConceptualProperty]: ...
 
     @overload
     def _properties_by_neat_id(self, format: Literal["dms"] = "dms") -> dict[URIRef, DMSProperty]: ...
 
     def _properties_by_neat_id(
         self, format: Literal["info", "dms"] = "info"
-    ) -> dict[URIRef, InformationProperty] | dict[URIRef, DMSProperty]:
+    ) -> dict[URIRef, ConceptualProperty] | dict[URIRef, DMSProperty]:
         if format == "info":
             return {prop.neatId: prop for prop in self.information.properties if prop.neatId}
         elif format == "dms":
@@ -435,11 +439,11 @@ class RulesAnalysis:
             raise NeatValueError(f"Invalid format: {format}")
 
     @property
-    def classes_by_neat_id(self) -> dict[URIRef, InformationClass]:
+    def classes_by_neat_id(self) -> dict[URIRef, ConceptualClass]:
         return {class_.neatId: class_ for class_ in self.information.classes if class_.neatId}
 
     @property
-    def multi_value_properties(self) -> list[InformationProperty]:
+    def multi_value_properties(self) -> list[ConceptualProperty]:
         return [prop_ for prop_ in self.information.properties if isinstance(prop_.value_type, MultiValueTypeInfo)]
 
     @property

cognite/neat/core/{_rules → _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._rules._shared import T_VerifiedRules
+from cognite.neat.core._data_model._shared import T_VerifiedRules
 from cognite.neat.core._utils.auxiliary import class_html_doc
 from cognite.neat.core._utils.upload import UploadResult, UploadResultList
 

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

@@ -28,12 +28,12 @@ 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._issues import IssueList
 from cognite.neat.core._issues.warnings import (
     PrincipleOneModelOneSpaceWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat.core._rules.models.dms import DMSRules
 from cognite.neat.core._shared import T_ID
 from cognite.neat.core._utils.upload import UploadResult
 

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

@@ -15,17 +15,22 @@ from openpyxl.worksheet.worksheet import Worksheet
 from rdflib import Namespace
 
 from cognite.neat.core._constants import BASE_MODEL, get_base_concepts
-from cognite.neat.core._rules._constants import get_internal_properties
-from cognite.neat.core._rules._shared import VerifiedRules
-from cognite.neat.core._rules.models import (
+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.models import (
     SheetRow,
 )
-from cognite.neat.core._rules.models._base_rules import BaseMetadata, RoleTypes
-from cognite.neat.core._rules.models.data_types import (
+from cognite.neat.core._data_model.models._base_verified import (
+    BaseVerifiedMetadata,
+    RoleTypes,
+)
+from cognite.neat.core._data_model.models.conceptual._verified import (
+    ConceptualDataModel,
+)
+from cognite.neat.core._data_model.models.data_types import (
     _DATA_TYPE_BY_DMS_TYPE,
 )
-from cognite.neat.core._rules.models.dms._rules import DMSRules
-from cognite.neat.core._rules.models.information._rules import InformationRules
+from cognite.neat.core._data_model.models.dms._rules import DMSRules
 from cognite.neat.core._utils.spreadsheet import (
     find_column_with_value,
     generate_data_validation,
@@ -140,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 InformationRules
+        rules_model = DMSRules if role == RoleTypes.dms else ConceptualDataModel
 
         headers_by_sheet = rules_model.headers_by_sheet(by_alias=True)
         headers_by_sheet.pop("Metadata")
 
         self._write_metadata_sheet(
             workbook,
-            cast(BaseMetadata, rules_model.model_fields["metadata"].annotation).default().model_dump(),
+            cast(BaseVerifiedMetadata, rules_model.model_fields["metadata"].annotation).default().model_dump(),
         )
 
         for sheet_name, headers in headers_by_sheet.items():
@@ -185,7 +190,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
             self._write_sheets(workbook, dumped_reference_rules, reference_rules, sheet_prefix=prefix)
             self._write_metadata_sheet(workbook, dumped_reference_rules["Metadata"], sheet_prefix=prefix)
 
-        if isinstance(rules, InformationRules) and rules.prefixes:
+        if isinstance(rules, ConceptualDataModel) and rules.prefixes:
             self._write_prefixes_sheet(workbook, rules.prefixes)
 
         if self._styling_level > 0:

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

@@ -8,15 +8,17 @@ from openpyxl.styles import Alignment, Border, Font, NamedStyle, PatternFill, Si
 from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.datavalidation import DataValidation
 
-from cognite.neat.core._rules._constants import EntityTypes
-from cognite.neat.core._rules.analysis import RulesAnalysis
-from cognite.neat.core._rules.models.entities._single_value import ClassEntity
-from cognite.neat.core._rules.models.information._rules import InformationRules
+from cognite.neat.core._data_model._constants import EntityTypes
+from cognite.neat.core._data_model.analysis import RulesAnalysis
+from cognite.neat.core._data_model.models.conceptual._verified import (
+    ConceptualDataModel,
+)
+from cognite.neat.core._data_model.models.entities._single_value import ClassEntity
 
 from ._base import BaseExporter
 
 
-class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
+class InstanceTemplateExporter(BaseExporter[ConceptualDataModel, Workbook]):
     """
     Converts Information Rules to a templated spreadsheet meant for capturing
     instances based on class definitions in the rules.
@@ -48,7 +50,7 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
 
     def export(
         self,
-        rules: InformationRules,
+        rules: ConceptualDataModel,
     ) -> Workbook:
         workbook = Workbook()
 
@@ -83,7 +85,7 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
 
         return workbook
 
-    def export_to_file(self, rules: InformationRules, filepath: Path) -> None:
+    def export_to_file(self, rules: ConceptualDataModel, filepath: Path) -> None:
         """Exports graph capturing sheet to excel file."""
         data = self.export(rules)
         try:

cognite/neat/core/{_rules → _data_model}/exporters/_rules2ontology.py

@@ -9,21 +9,21 @@ from rdflib import DCTERMS, OWL, RDF, RDFS, XSD, BNode, Graph, Literal, Namespac
 from rdflib.collection import Collection as GraphCollection
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE as NEAT_NAMESPACE
+from cognite.neat.core._data_model._constants import EntityTypes
+from cognite.neat.core._data_model.analysis import RulesAnalysis
+from cognite.neat.core._data_model.models.conceptual import (
+    ConceptualClass,
+    ConceptualDataModel,
+    ConceptualMetadata,
+    ConceptualProperty,
+)
+from cognite.neat.core._data_model.models.data_types import DataType
+from cognite.neat.core._data_model.models.entities import ClassEntity
 from cognite.neat.core._issues import MultiValueError
 from cognite.neat.core._issues.errors import (
     PropertyDefinitionDuplicatedError,
 )
 from cognite.neat.core._issues.warnings import PropertyDefinitionDuplicatedWarning
-from cognite.neat.core._rules._constants import EntityTypes
-from cognite.neat.core._rules.analysis import RulesAnalysis
-from cognite.neat.core._rules.models.data_types import DataType
-from cognite.neat.core._rules.models.entities import ClassEntity
-from cognite.neat.core._rules.models.information import (
-    InformationClass,
-    InformationMetadata,
-    InformationProperty,
-    InformationRules,
-)
 from cognite.neat.core._utils.rdf_ import remove_namespace_from_uri
 
 from ._base import BaseExporter
@@ -35,15 +35,15 @@ else:
     from typing_extensions import Self
 
 
-class GraphExporter(BaseExporter[InformationRules, Graph], ABC):
-    def export_to_file(self, rules: InformationRules, filepath: Path) -> None:
+class GraphExporter(BaseExporter[ConceptualDataModel, Graph], ABC):
+    def export_to_file(self, rules: ConceptualDataModel, filepath: Path) -> None:
         self.export(rules).serialize(destination=filepath, encoding=self._encoding, newline=self._new_line)
 
 
 class OWLExporter(GraphExporter):
     """Exports verified information rules to an OWL ontology."""
 
-    def export(self, rules: InformationRules) -> Graph:
+    def export(self, rules: ConceptualDataModel) -> Graph:
         return Ontology.from_rules(rules).as_owl()
 
     @property
@@ -54,7 +54,7 @@ class OWLExporter(GraphExporter):
 class SHACLExporter(GraphExporter):
     """Exports rules to a SHACL graph."""
 
-    def export(self, rules: InformationRules) -> Graph:
+    def export(self, rules: ConceptualDataModel) -> Graph:
         return Ontology.from_rules(rules).as_shacl()
 
     @property
@@ -65,7 +65,7 @@ class SHACLExporter(GraphExporter):
 class SemanticDataModelExporter(GraphExporter):
     """Exports verified information model to a semantic data model."""
 
-    def export(self, rules: InformationRules) -> Graph:
+    def export(self, rules: ConceptualDataModel) -> Graph:
         return Ontology.from_rules(rules).as_semantic_data_model()
 
     @property
@@ -96,7 +96,7 @@ class Ontology(OntologyModel):
     prefixes: dict[str, Namespace]
 
     @classmethod
-    def from_rules(cls, rules: InformationRules) -> Self:
+    def from_rules(cls, rules: ConceptualDataModel) -> Self:
         """
         Generates an ontology from a set of transformation rules.
 
@@ -225,7 +225,7 @@ class Ontology(OntologyModel):
         return (self.as_owl() + self.as_shacl()).serialize()
 
 
-class OWLMetadata(InformationMetadata):
+class OWLMetadata(ConceptualMetadata):
     @property
     def triples(self) -> list[tuple]:
         # Mandatory triples originating from Metadata mandatory fields
@@ -259,7 +259,7 @@ class OWLClass(OntologyModel):
     namespace: Namespace
 
     @classmethod
-    def from_class(cls, definition: InformationClass, namespace: Namespace, prefixes: dict) -> Self:
+    def from_class(cls, definition: ConceptualClass, namespace: Namespace, prefixes: dict) -> Self:
         if definition.implements and isinstance(definition.implements, list):
             sub_class_of = []
             for parent_class in definition.implements:
@@ -333,7 +333,7 @@ class OWLProperty(OntologyModel):
     namespace: Namespace
 
     @classmethod
-    def from_list_of_properties(cls, definitions: list[InformationProperty], namespace: Namespace) -> "OWLProperty":
+    def from_list_of_properties(cls, definitions: list[ConceptualProperty], namespace: Namespace) -> "OWLProperty":
         """Here list of properties is a list of properties with the same id, but different definitions."""
         property_ids = {definition.property_ for definition in definitions}
         if len(property_ids) != 1:
@@ -573,7 +573,10 @@ class SHACLNodeShape(OntologyModel):
 
     @classmethod
     def from_rules(
-        cls, class_definition: InformationClass, property_definitions: list[InformationProperty], namespace: Namespace
+        cls,
+        class_definition: ConceptualClass,
+        property_definitions: list[ConceptualProperty],
+        namespace: Namespace,
     ) -> "SHACLNodeShape":
         if class_definition.implements:
             parent = [namespace[str(parent.suffix) + "Shape"] for parent in class_definition.implements]
@@ -628,7 +631,7 @@ class SHACLPropertyShape(OntologyModel):
         return self.path_triples + self.node_kind_triples + self.cardinality_triples
 
     @classmethod
-    def from_property(cls, definition: InformationProperty, namespace: Namespace) -> "SHACLPropertyShape":
+    def from_property(cls, definition: ConceptualProperty, namespace: Namespace) -> "SHACLPropertyShape":
         # TODO requires PR to fix MultiValueType and UnknownValueType
         if isinstance(definition.value_type, ClassEntity):
             expected_value_type = namespace[f"{definition.value_type.suffix}Shape"]

cognite/neat/core/{_rules → _data_model}/exporters/_rules2yaml.py

@@ -5,7 +5,7 @@ from typing import Literal, get_args
 
 import yaml
 
-from cognite.neat.core._rules._shared import VerifiedRules
+from cognite.neat.core._data_model._shared import VerifiedRules
 
 from ._base import BaseExporter
 

cognite/neat/core/{_rules → _data_model}/exporters/_validation.py

@@ -1,14 +1,14 @@
 from collections import defaultdict
 from collections.abc import Iterable
 
-from cognite.neat.core._rules.models.entities import ClassEntity
-from cognite.neat.core._rules.models.information import InformationProperty
+from cognite.neat.core._data_model.models.conceptual import ConceptualProperty
+from cognite.neat.core._data_model.models.entities import ClassEntity
 
 
 def duplicated_properties(
-    properties: Iterable[InformationProperty],
-) -> dict[tuple[ClassEntity, str], list[tuple[int, InformationProperty]]]:
-    class_properties_by_id: dict[tuple[ClassEntity, str], list[tuple[int, InformationProperty]]] = defaultdict(list)
+    properties: Iterable[ConceptualProperty],
+) -> dict[tuple[ClassEntity, str], list[tuple[int, ConceptualProperty]]]:
+    class_properties_by_id: dict[tuple[ClassEntity, str], list[tuple[int, ConceptualProperty]]] = defaultdict(list)
     for prop_no, prop in enumerate(properties):
         class_properties_by_id[(prop.class_, prop.property_)].append((prop_no, prop))
     return {k: v for k, v in class_properties_by_id.items() if len(v) > 1}

cognite/neat/core/{_rules → _data_model}/importers/__init__.py

@@ -2,7 +2,7 @@ from ._base import BaseImporter
 from ._dms2rules import DMSImporter
 from ._dtdl2rules import DTDLImporter
 from ._rdf import IMFImporter, InferenceImporter, OWLImporter, SubclassInferenceImporter
-from ._spreadsheet2rules import ExcelImporter, GoogleSheetImporter
+from ._spreadsheet2rules import ExcelImporter
 from ._yaml2rules import YAMLImporter
 
 __all__ = [
@@ -10,7 +10,6 @@ __all__ = [
     "DMSImporter",
     "DTDLImporter",
     "ExcelImporter",
-    "GoogleSheetImporter",
     "IMFImporter",
     "InferenceImporter",
     "OWLImporter",
@@ -23,7 +22,6 @@ RulesImporters = (
     | IMFImporter
     | DMSImporter
     | ExcelImporter
-    | GoogleSheetImporter
     | DTDLImporter
     | YAMLImporter
     | InferenceImporter

cognite/neat/core/{_rules → _data_model}/importers/_base.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Any, Generic
 from rdflib import URIRef
 
 from cognite.neat.core._constants import DEFAULT_NAMESPACE
-from cognite.neat.core._rules._shared import ReadRules, T_InputRules
+from cognite.neat.core._data_model._shared import ReadRules, T_InputRules
 from cognite.neat.core._utils.auxiliary import class_html_doc
 
 if TYPE_CHECKING:

cognite/neat/core/{_rules → _data_model}/importers/_dms2rules.py

@@ -33,6 +33,34 @@ from cognite.neat.core._constants import (
     DMS_DIRECT_RELATION_LIST_DEFAULT_LIMIT,
     DMS_PRIMITIVE_LIST_DEFAULT_LIMIT,
 )
+from cognite.neat.core._data_model._shared import ReadRules
+from cognite.neat.core._data_model.importers._base import BaseImporter
+from cognite.neat.core._data_model.models import (
+    DMSInputRules,
+    DMSSchema,
+)
+from cognite.neat.core._data_model.models.conceptual import (
+    UnverifiedConceptualClass,
+    UnverifiedConceptualProperty,
+)
+from cognite.neat.core._data_model.models.data_types import DataType, Enum, String
+from cognite.neat.core._data_model.models.dms import (
+    DMSInputContainer,
+    DMSInputEnum,
+    DMSInputMetadata,
+    DMSInputNode,
+    DMSInputProperty,
+    DMSInputView,
+)
+from cognite.neat.core._data_model.models.entities import (
+    ClassEntity,
+    ContainerEntity,
+    DMSNodeEntity,
+    DMSUnknownEntity,
+    EdgeEntity,
+    ReverseConnectionEntity,
+    ViewEntity,
+)
 from cognite.neat.core._issues import (
     IssueList,
     MultiValueError,
@@ -55,34 +83,6 @@ from cognite.neat.core._issues.warnings import (
     ResourcesDuplicatedWarning,
     ResourceUnknownWarning,
 )
-from cognite.neat.core._rules._shared import ReadRules
-from cognite.neat.core._rules.importers._base import BaseImporter
-from cognite.neat.core._rules.models import (
-    DMSInputRules,
-    DMSSchema,
-)
-from cognite.neat.core._rules.models.data_types import DataType, Enum, String
-from cognite.neat.core._rules.models.dms import (
-    DMSInputContainer,
-    DMSInputEnum,
-    DMSInputMetadata,
-    DMSInputNode,
-    DMSInputProperty,
-    DMSInputView,
-)
-from cognite.neat.core._rules.models.entities import (
-    ClassEntity,
-    ContainerEntity,
-    DMSNodeEntity,
-    DMSUnknownEntity,
-    EdgeEntity,
-    ReverseConnectionEntity,
-    ViewEntity,
-)
-from cognite.neat.core._rules.models.information import (
-    InformationInputClass,
-    InformationInputProperty,
-)
 
 
 class DMSImporter(BaseImporter[DMSInputRules]):
@@ -639,7 +639,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
     @classmethod
     def as_information_input_property(
         cls, entity: ClassEntity, prop_id: str, view_property: ViewProperty
-    ) -> InformationInputProperty:
+    ) -> UnverifiedConceptualProperty:
         if not isinstance(view_property, dm.MappedProperty | dm.EdgeConnection | ReverseDirectRelation):
             raise PropertyTypeNotSupportedError(
                 dm.ViewId(str(entity.prefix), str(entity.suffix), entity.version),
@@ -652,7 +652,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         if value_type is None:
             raise NeatValueError(f"Failed to get value type for {entity} property {prop_id}")
 
-        return InformationInputProperty(
+        return UnverifiedConceptualProperty(
             class_=entity,
             property_=prop_id,
             value_type=str(value_type),
@@ -664,13 +664,17 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         )
 
     @classmethod
-    def as_information_input_class(cls, view: View) -> InformationInputClass:
-        return InformationInputClass(
+    def as_information_input_class(cls, view: View) -> UnverifiedConceptualClass:
+        return UnverifiedConceptualClass(
             class_=ClassEntity(prefix=view.space, suffix=view.external_id, version=view.version),
             name=view.name,
             description=view.description,
             implements=[
-                ClassEntity(prefix=parent.space, suffix=parent.external_id, version=parent.version)
+                ClassEntity(
+                    prefix=parent.space,
+                    suffix=parent.external_id,
+                    version=parent.version,
+                )
                 for parent in view.implements or []
             ]
             or None,