cognite-neat 0.117.12__tar.gz → 0.118.0__tar.gz

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: cognite-neat
-Version: 0.117.12
+Version: 0.118.0
 Summary: Knowledge graph transformation
 License: Apache-2.0
 Author: Nikola Vasiljevic

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/cognite/neat/_alpha.py

@@ -22,3 +22,4 @@ class ExperimentalFlags:
     aml_read = ExperimentalFeatureWarning("aml_read")
     csv_read = ExperimentalFeatureWarning("csv_read")
     to_ontology = ExperimentalFeatureWarning("to_ontology")
+    extension = ExperimentalFeatureWarning("extension")

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/cognite/neat/_rules/importers/_dms2rules.py

@@ -1,8 +1,9 @@
+import warnings
 from collections import defaultdict
 from collections.abc import Collection, Iterable, Sequence
 from datetime import datetime
 from pathlib import Path
-from typing import Literal, cast
+from typing import Literal
 
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier
@@ -16,8 +17,13 @@ from cognite.client.data_classes.data_modeling.data_types import Enum as DMSEnum
 from cognite.client.data_classes.data_modeling.views import (
     MultiEdgeConnectionApply,
     MultiReverseDirectRelationApply,
+    ReverseDirectRelation,
+    SingleEdgeConnection,
     SingleEdgeConnectionApply,
+    SingleReverseDirectRelation,
     SingleReverseDirectRelationApply,
+    View,
+    ViewProperty,
     ViewPropertyApply,
 )
 from cognite.client.utils import ms_to_datetime
@@ -28,11 +34,13 @@ from cognite.neat._issues import IssueList, MultiValueError, NeatIssue, catch_is
 from cognite.neat._issues.errors import (
     FileTypeUnexpectedError,
     NeatValueError,
+    PropertyTypeNotSupportedError,
     ResourceMissingIdentifierError,
     ResourceRetrievalError,
 )
 from cognite.neat._issues.warnings import (
     MissingCogniteClientWarning,
+    NeatValueWarning,
     PropertyNotFoundWarning,
     PropertyTypeNotSupportedWarning,
     ResourceNotFoundWarning,
@@ -45,7 +53,7 @@ from cognite.neat._rules.models import (
     DMSInputRules,
     DMSSchema,
 )
-from cognite.neat._rules.models.data_types import DataType, Enum
+from cognite.neat._rules.models.data_types import DataType, Enum, String
 from cognite.neat._rules.models.dms import (
     DMSInputContainer,
     DMSInputEnum,
@@ -63,6 +71,10 @@ from cognite.neat._rules.models.entities import (
     ReverseConnectionEntity,
     ViewEntity,
 )
+from cognite.neat._rules.models.information import (
+    InformationInputClass,
+    InformationInputProperty,
+)
 
 
 class DMSImporter(BaseImporter[DMSInputRules]):
@@ -332,19 +344,27 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             )
             return None
 
-        value_type = self._get_value_type(prop, view_entity, prop_id, enum_collection_by_container_property)
+        container_property = (
+            self._get_container_property_definition(prop) if isinstance(prop, dm.MappedPropertyApply) else None
+        )
+        value_type = self._get_value_type(prop, container_property, enum_collection_by_container_property)
         if value_type is None:
+            self.issue_list.append(
+                PropertyTypeNotSupportedWarning(view_entity.as_id(), "view", prop_id, type(prop).__name__)
+            )
             return None
+        if isinstance(value_type, ViewEntity) and value_type.as_id() not in self._all_views_by_id:
+            self.issue_list.append(ResourceUnknownWarning(prop.source, "view", view_entity.as_id(), "view"))
 
         return DMSInputProperty(
             description=prop.description,
             name=prop.name,
             connection=self._get_connection_type(prop),
             value_type=str(value_type),
-            min_count=self._get_min_count(prop),
-            max_count=self._get_max_count(prop),
+            min_count=self._get_min_count(prop, container_property),
+            max_count=self._get_max_count(prop, container_property),
             immutable=self._get_immutable(prop),
-            default=self._get_default(prop),
+            default=self._get_default(prop, container_property),
             container=(
                 str(ContainerEntity.from_id(prop.container)) if isinstance(prop, dm.MappedPropertyApply) else None
             ),
@@ -357,7 +377,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
             constraint=self._get_constraint(prop, prop_id),
         )
 
-    def _container_prop_unsafe(self, prop: dm.MappedPropertyApply) -> dm.ContainerProperty:
+    def _get_container_property_definition(self, prop: dm.MappedPropertyApply) -> dm.ContainerProperty:
         """This method assumes you have already checked that the container with property exists."""
         return self._all_containers_by_id[prop.container].properties[prop.container_property_identifier]
 
@@ -372,40 +392,48 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         elif isinstance(prop, SingleReverseDirectRelationApply | MultiReverseDirectRelationApply):
             return ReverseConnectionEntity(property=prop.through.property)
         elif isinstance(prop, dm.MappedPropertyApply) and isinstance(
-            self._container_prop_unsafe(prop).type, dm.DirectRelation
+            self._get_container_property_definition(prop).type, dm.DirectRelation
         ):
             return "direct"
         else:
             return None
 
+    @classmethod
     def _get_value_type(
-        self,
-        prop: ViewPropertyApply,
-        view_entity: ViewEntity,
-        prop_id: str,
-        enum_collection_by_container_property: dict[tuple[dm.ContainerId, str], str],
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+        enum_collection_by_container_property: dict[tuple[dm.ContainerId, str], str] | None = None,
     ) -> DataType | ViewEntity | DMSUnknownEntity | None:
         if isinstance(
             prop,
             SingleEdgeConnectionApply
             | MultiEdgeConnectionApply
             | SingleReverseDirectRelationApply
-            | MultiReverseDirectRelationApply,
+            | MultiReverseDirectRelationApply
+            | SingleEdgeConnection
+            | dm.MultiEdgeConnection
+            | SingleReverseDirectRelation
+            | dm.MultiReverseDirectRelation,
         ):
             return ViewEntity.from_id(prop.source)
-        elif isinstance(prop, dm.MappedPropertyApply):
-            container_prop = self._container_prop_unsafe(cast(dm.MappedPropertyApply, prop))
-            if isinstance(container_prop.type, dm.DirectRelation):
+        elif isinstance(prop, dm.MappedPropertyApply | dm.MappedProperty):
+            if isinstance(prop, dm.MappedPropertyApply):
+                if container_property is None:
+                    raise ValueError("container property must be provided when prop is a MappedProperty")
+                prop_type = container_property.type
+            else:
+                prop_type = prop.type
+            if isinstance(prop_type, dm.DirectRelation):
                 if prop.source is None:
                     return DMSUnknownEntity()
-                elif prop.source not in self._all_views_by_id:
-                    self.issue_list.append(ResourceUnknownWarning(prop.source, "view", view_entity.as_id(), "view"))
-                    return ViewEntity.from_id(prop.source)
                 else:
                     return ViewEntity.from_id(prop.source)
-            elif isinstance(container_prop.type, PropertyTypeWithUnit) and container_prop.type.unit:
-                return DataType.load(f"{container_prop.type._type}(unit={container_prop.type.unit.external_id})")
-            elif isinstance(container_prop.type, DMSEnum):
+            elif isinstance(prop_type, PropertyTypeWithUnit) and prop_type.unit:
+                return DataType.load(f"{prop_type._type}(unit={prop_type.unit.external_id})")
+            elif isinstance(prop_type, DMSEnum):
+                if enum_collection_by_container_property is None:
+                    return String()
                 collection = enum_collection_by_container_property.get(
                     (prop.container, prop.container_property_identifier)
                 )
@@ -415,30 +443,46 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                         f"BUG in Neat: Enum for {prop.container}.{prop.container_property_identifier} not found."
                     )
 
-                return Enum(collection=ClassEntity(suffix=collection), unknownValue=container_prop.type.unknown_value)
+                return Enum(collection=ClassEntity(suffix=collection), unknownValue=prop_type.unknown_value)
             else:
-                return DataType.load(container_prop.type._type)
+                return DataType.load(prop_type._type)
         else:
-            self.issue_list.append(
-                PropertyTypeNotSupportedWarning[dm.ViewId](view_entity.as_id(), "view", prop_id, type(prop).__name__)
-            )
             return None
 
-    def _get_min_count(self, prop: ViewPropertyApply) -> int | None:
+    @classmethod
+    def _get_min_count(
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+    ) -> int | None:
         if isinstance(prop, dm.MappedPropertyApply):
-            return int(not self._container_prop_unsafe(prop).nullable)
+            if container_property is None:
+                raise ValueError("container_property must be provided when prop is a MappedPropertyApply")
+            return int(not container_property.nullable)
+        elif isinstance(prop, dm.MappedProperty):
+            return int(not prop.nullable)
         else:
             return None
 
     def _get_immutable(self, prop: ViewPropertyApply) -> bool | None:
         if isinstance(prop, dm.MappedPropertyApply):
-            return self._container_prop_unsafe(prop).immutable
+            return self._get_container_property_definition(prop).immutable
         else:
             return None
 
-    def _get_max_count(self, prop: ViewPropertyApply) -> int | float | None:
-        if isinstance(prop, dm.MappedPropertyApply):
-            prop_type = self._container_prop_unsafe(prop).type
+    @classmethod
+    def _get_max_count(
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+    ) -> int | float | None:
+        if isinstance(prop, dm.MappedPropertyApply | dm.MappedProperty):
+            if isinstance(prop, dm.MappedPropertyApply):
+                if container_property is None:
+                    raise ValueError("get_container must be provided when prop is a MappedPropertyApply")
+                prop_type = container_property.type
+            else:
+                prop_type = prop.type
             if isinstance(prop_type, ListablePropertyType):
                 if prop_type.is_list is False:
                     return 1
@@ -450,17 +494,41 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                     return DMS_PRIMITIVE_LIST_DEFAULT_LIMIT
             else:
                 return 1
-        elif isinstance(prop, MultiEdgeConnectionApply | MultiReverseDirectRelationApply):
+        elif isinstance(
+            prop,
+            MultiEdgeConnectionApply
+            | MultiReverseDirectRelationApply
+            | dm.MultiEdgeConnection
+            | dm.MultiReverseDirectRelation,
+        ):
             return float("inf")
-        elif isinstance(prop, SingleEdgeConnectionApply | SingleReverseDirectRelationApply):
+        elif isinstance(
+            prop,
+            SingleEdgeConnectionApply
+            | SingleReverseDirectRelationApply
+            | SingleEdgeConnection
+            | SingleReverseDirectRelation,
+        ):
             return 1
         else:
-            # Unknown type.
+            warnings.warn(
+                NeatValueWarning(f"Unknown property type {type(prop)}. Assuming max count is inf"), stacklevel=2
+            )
             return None
 
-    def _get_default(self, prop: ViewPropertyApply) -> str | None:
-        if isinstance(prop, dm.MappedPropertyApply):
-            default = self._container_prop_unsafe(prop).default_value
+    @classmethod
+    def _get_default(
+        cls,
+        prop: ViewPropertyApply | ViewProperty,
+        container_property: dm.ContainerProperty | None = None,
+    ) -> str | None:
+        if isinstance(prop, dm.MappedPropertyApply | dm.MappedProperty):
+            if isinstance(prop, dm.MappedPropertyApply):
+                if container_property is None:
+                    raise ValueError("container_property must be provided when prop is a MappedPropertyApply")
+                default = container_property.default_value
+            else:
+                default = prop.default_value
             if default is not None:
                 return str(default)
         return None
@@ -559,3 +627,43 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                         )
                     )
         return enum_by_container_property
+
+    @classmethod
+    def as_information_input_property(
+        cls, entity: ClassEntity, prop_id: str, view_property: ViewProperty
+    ) -> InformationInputProperty:
+        if not isinstance(view_property, dm.MappedProperty | dm.EdgeConnection | ReverseDirectRelation):
+            raise PropertyTypeNotSupportedError(
+                dm.ViewId(str(entity.prefix), str(entity.suffix), entity.version),
+                "view",
+                prop_id,
+                type(view_property).__name__,
+            )
+
+        value_type = cls._get_value_type(view_property)
+        if value_type is None:
+            raise NeatValueError(f"Failed to get value type for {entity} property {prop_id}")
+
+        return InformationInputProperty(
+            class_=entity,
+            property_=prop_id,
+            value_type=str(value_type),
+            name=view_property.name,
+            description=view_property.description,
+            min_count=cls._get_min_count(view_property),
+            max_count=cls._get_max_count(view_property),
+            default=cls._get_default(view_property),
+        )
+
+    @classmethod
+    def as_information_input_class(cls, view: View) -> InformationInputClass:
+        return InformationInputClass(
+            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)
+                for parent in view.implements or []
+            ]
+            or None,
+        )

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/cognite/neat/_rules/models/information/_rules_input.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Any
+from typing import Any, cast
 
 import pandas as pd
 from cognite.client import data_modeling as dm
@@ -103,6 +103,9 @@ class InformationInputProperty(InputComponent[InformationProperty]):
         output["Value Type"] = load_value_type(self.value_type, default_prefix)
         return output
 
+    def copy(self, update: dict[str, Any], default_prefix: str) -> "InformationInputProperty":
+        return cast(InformationInputProperty, type(self)._load({**self.dump(default_prefix), **update}))
+
 
 @dataclass
 class InformationInputClass(InputComponent[InformationClass]):

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/cognite/neat/_rules/transformers/__init__.py

@@ -1,6 +1,7 @@
 from ._base import RulesTransformer, VerifiedRulesTransformer
 from ._converters import (
     AddClassImplements,
+    AddCogniteProperties,
     ChangeViewPrefix,
     ClassicPrepareCore,
     ConversionTransformer,
@@ -29,6 +30,7 @@ from ._verification import VerifyAnyRules, VerifyDMSRules, VerifyInformationRule
 
 __all__ = [
     "AddClassImplements",
+    "AddCogniteProperties",
     "AsParentPropertyId",
     "ChangeViewPrefix",
     "ClassicPrepareCore",

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/cognite/neat/_rules/transformers/_converters.py

@@ -6,10 +6,11 @@ from collections import Counter, defaultdict
 from collections.abc import Collection, Mapping
 from datetime import date, datetime
 from functools import cached_property
+from graphlib import CycleError, TopologicalSorter
 from typing import Any, ClassVar, Literal, TypeVar, cast, overload
 
 from cognite.client.data_classes import data_modeling as dms
-from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, ViewId
+from cognite.client.data_classes.data_modeling import DataModelId, DataModelIdentifier, View, ViewId
 from cognite.client.utils.useful_types import SequenceNotStr
 from pydantic import ValidationError
 from rdflib import Namespace
@@ -25,6 +26,8 @@ from cognite.neat._constants import (
     DMS_RESERVED_PROPERTIES,
     get_default_prefixes_and_namespaces,
 )
+from cognite.neat._issues import IssueList
+from cognite.neat._issues._factory import from_pydantic_errors
 from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import NeatValueWarning
 from cognite.neat._issues.warnings._models import (
@@ -60,8 +63,15 @@ from cognite.neat._rules.models.entities import (
     UnknownEntity,
     ViewEntity,
 )
-from cognite.neat._rules.models.information import InformationClass, InformationMetadata, InformationProperty
+from cognite.neat._rules.models.information import (
+    InformationClass,
+    InformationInputClass,
+    InformationInputProperty,
+    InformationMetadata,
+    InformationProperty,
+)
 from cognite.neat._utils.rdf_ import get_inheritance_path
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
 from cognite.neat._utils.text import NamingStandardization, title, to_camel_case, to_words
 
 from ._base import RulesTransformer, T_VerifiedIn, T_VerifiedOut, VerifiedRulesTransformer
@@ -2017,3 +2027,131 @@ class SubsetInformationRules(VerifiedRulesTransformer[InformationRules, Informat
             return InformationRules.model_validate(subsetted_rules)
         except ValidationError as e:
             raise NeatValueError(f"Cannot subset rules: {e}") from e
+
+
+class AddCogniteProperties(RulesTransformer[ReadRules[InformationInputRules], ReadRules[InformationInputRules]]):
+    """This transformer looks at the implements of the classes and adds all properties
+    from the parent (and ancestors) classes that are not already included in the data model.
+
+    Args:
+        client: The client is used to look up the properties of the parent classes.
+
+    """
+
+    def __init__(self, client: NeatClient) -> None:
+        self._client = client
+
+    @property
+    def description(self) -> str:
+        """Get the description of the transformer."""
+        return "Add Cognite properties for all concepts that implements a Cognite concept."
+
+    def transform(self, rules: ReadRules[InformationInputRules]) -> ReadRules[InformationInputRules]:
+        input_ = rules.rules
+        if input_ is None:
+            raise NeatValueError("Rule read failed. Cannot add cognite properties to None rules.")
+
+        default_space = input_.metadata.space
+        default_version = input_.metadata.version
+
+        dependencies_by_class = self._get_dependencies_by_class(input_.classes, rules.read_context, default_space)
+        properties_by_class = self._get_properties_by_class(input_.properties, rules.read_context, default_space)
+        cognite_implements_concepts = self._get_cognite_concepts(dependencies_by_class)
+        views_by_class_entity = self._get_views_by_class(cognite_implements_concepts, default_space, default_version)
+
+        for class_entity, view in views_by_class_entity.items():
+            for prop_id, view_prop in view.properties.items():
+                if prop_id in properties_by_class[class_entity]:
+                    continue
+                properties_by_class[class_entity][prop_id] = DMSImporter.as_information_input_property(
+                    class_entity, prop_id, view_prop
+                )
+
+        try:
+            topological_order = TopologicalSorter(dependencies_by_class).static_order()
+        except CycleError as e:
+            raise NeatValueError(f"Cycle detected in the class hierarchy: {e}") from e
+
+        new_properties: list[InformationInputProperty] = input_.properties.copy()
+        for class_entity in topological_order:
+            if class_entity not in dependencies_by_class:
+                continue
+            for parent in dependencies_by_class[class_entity]:
+                for prop in properties_by_class[parent].values():
+                    if prop.property_ not in properties_by_class[class_entity]:
+                        new_prop = prop.copy(update={"Class": class_entity}, default_prefix=default_space)
+                        new_properties.append(new_prop)
+                        properties_by_class[class_entity][prop.property_] = new_prop
+
+        new_classes: list[InformationInputClass] = input_.classes.copy()
+        existing_classes = {cls.class_ for cls in input_.classes}
+        for class_entity, view in views_by_class_entity.items():
+            if class_entity not in existing_classes:
+                new_classes.append(DMSImporter.as_information_input_class(view))
+                existing_classes.add(class_entity)
+
+        return ReadRules(
+            rules=InformationInputRules(
+                metadata=input_.metadata,
+                properties=new_properties,
+                classes=new_classes,
+                prefixes=input_.prefixes,
+            ),
+            read_context={},
+        )
+
+    @staticmethod
+    def _get_properties_by_class(
+        properties: list[InformationInputProperty], read_context: dict[str, SpreadsheetRead], default_space: str
+    ) -> dict[ClassEntity, dict[str, InformationInputProperty]]:
+        issues = IssueList()
+        properties_by_class: dict[ClassEntity, dict[str, InformationInputProperty]] = defaultdict(dict)
+        for prop in properties:
+            try:
+                dumped = prop.dump(default_prefix=default_space)
+            except ValidationError as e:
+                issues.extend(from_pydantic_errors(e.errors(), read_context))
+                continue
+            class_entity = cast(ClassEntity, dumped["Class"])
+            properties_by_class[class_entity][prop.property_] = prop
+        if issues.has_errors:
+            raise issues.as_errors(operation="Reading properties")
+        return properties_by_class
+
+    @staticmethod
+    def _get_dependencies_by_class(
+        classes: list[InformationInputClass], read_context: dict[str, SpreadsheetRead], default_space: str
+    ) -> dict[ClassEntity, set[ClassEntity]]:
+        dependencies_by_class: dict[ClassEntity, set[ClassEntity]] = {}
+        issues = IssueList()
+        for raw in classes:
+            try:
+                dumped = raw.dump(default_prefix=default_space)
+            except ValidationError as e:
+                issues.extend(from_pydantic_errors(e.errors(), read_context))
+                continue
+            class_entity = cast(ClassEntity, dumped["Class"])
+            implements = cast(list[ClassEntity] | None, dumped["Implements"])
+            dependencies_by_class[class_entity] = set(implements or [])
+        if issues.has_errors:
+            raise issues.as_errors(operation="Reading classes")
+        return dependencies_by_class
+
+    @staticmethod
+    def _get_cognite_concepts(dependencies_by_class: dict[ClassEntity, set[ClassEntity]]) -> set[ClassEntity]:
+        cognite_implements_concepts = {
+            dependency
+            for dependencies in dependencies_by_class.values()
+            for dependency in dependencies
+            if dependency.prefix in COGNITE_SPACES
+        }
+        if not cognite_implements_concepts:
+            raise NeatValueError("None of the classes implement Cognite Core concepts.")
+        return cognite_implements_concepts
+
+    def _get_views_by_class(
+        self, classes: set[ClassEntity], default_space: str, default_version: str
+    ) -> dict[ClassEntity, View]:
+        view_ids = [class_.as_view_entity(default_space, default_version).as_id() for class_ in classes]
+        views = self._client.loaders.views.retrieve(view_ids, include_ancestor=True, include_connected=True)
+        return {ClassEntity(prefix=view.space, suffix=view.external_id, version=view.version): view for view in views}

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/cognite/neat/_session/_template.py

@@ -1,16 +1,24 @@
-from typing import Literal
+from pathlib import Path
+from typing import Any, Literal
 
 from cognite.client.data_classes.data_modeling import DataModelIdentifier
 
-from cognite.neat._issues import IssueList
+from cognite.neat._alpha import ExperimentalFlags
+from cognite.neat._issues import IssueList, catch_issues
+from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules.exporters import ExcelExporter
+from cognite.neat._rules.importers import ExcelImporter
+from cognite.neat._rules.models import InformationInputRules
 from cognite.neat._rules.models.dms import DMSValidation
 from cognite.neat._rules.transformers import (
+    AddCogniteProperties,
     IncludeReferenced,
     ToDataProductModel,
     ToEnterpriseModel,
     ToSolutionModel,
     VerifiedRulesTransformer,
 )
+from cognite.neat._utils.reader import NeatReader, PathReader
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, session_class_wrapper
@@ -165,3 +173,52 @@ class TemplateAPI:
         if last_rules and not issues.has_errors:
             self._state.last_reference = last_rules
         return issues
+
+    def extension(self, io: Any, output: str | Path | None = None) -> IssueList:
+        """Creates a template for an extension of a Cognite model.
+
+        The input is a spreadsheet of a conceptual model in which the concepts are defined
+        and marked with the Cognite concept they are extending. For example, if you have a pump
+        in the Classes sheet you will see
+        ```
+        Class: Pump
+        Implements: cdf_cdm:CogniteAsset(version=v1)
+        ```
+        The output will be a spreadsheet in which all the properties from the Cognite concept model
+        is added to the spreadsheet. In the example above, the pump concept will have all
+        the properties it inherits from the CogniteAsset concept added to the Properties spreadsheet.
+
+
+        Args:
+            io: The input spreadsheet.
+            output: The output spreadsheet. If None, the output will be the same
+                as the input with `_extension` added to the name.
+        """
+        ExperimentalFlags.extension.warn()
+        reader = NeatReader.create(io)
+        path = reader.materialize_path()
+        if output is None:
+            if isinstance(reader, PathReader):
+                output_path = path.with_name(f"{path.stem}_extension{path.suffix}")
+            else:
+                # The source is not a file, for example, a URL or a stream.
+                output_path = Path.cwd() / f"{path.stem}_extension{path.suffix}"
+        else:
+            output_path = Path(output)
+
+        with catch_issues() as issues:
+            read: ReadRules[InformationInputRules] = ExcelImporter(path).to_rules()
+            if read.rules is not None:
+                # If rules are None there will be issues that are already caught.
+                if not isinstance(read.rules, InformationInputRules):
+                    raise NeatSessionError(f"The input {reader.name} must contain an InformationInputRules object. ")
+                if self._state.client is None:
+                    raise NeatSessionError("Client must be set in the session to run the extension.")
+                modified = AddCogniteProperties(self._state.client).transform(read)
+                if modified.rules is not None:
+                    # If rules are None there will be issues that are already caught.
+                    info = modified.rules.as_verified_rules()
+
+                    ExcelExporter(styling="maximal").export_to_file(info, output_path)
+        issues.action = "Created extension template"
+        return issues

cognite_neat-0.118.0/cognite/neat/_version.py

@@ -0,0 +1,2 @@
+__version__ = "0.118.0"
+__engine__ = "^2.0.4"

{cognite_neat-0.117.12 → cognite_neat-0.118.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite-neat"
-version = "0.117.12"
+version = "0.118.0"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.117.12/cognite/neat/_version.py

@@ -1,2 +0,0 @@
-__version__ = "0.117.12"
-__engine__ = "^2.0.4"