cognite-neat 0.85.11__tar.gz → 0.86.0__tar.gz

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.85.11
+Version: 0.86.0
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

cognite_neat-0.86.0/cognite/neat/_version.py

@@ -0,0 +1 @@
+__version__ = "0.86.0"

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/app/api/routers/core.py

@@ -31,21 +31,21 @@ async def convert_data_model_to_rules(file: UploadFile):
 
     # read as Excel rules
     if suffix == ".xlsx":
-        rules, issues = importers.ExcelImporter(filepath=temp_filepath).to_rules(role=RoleTypes.dms_architect)
+        rules, issues = importers.ExcelImporter(filepath=temp_filepath).to_rules(role=RoleTypes.dms)
 
     # load as OWL
     elif suffix in [".ttl", ".owl"]:
-        rules, issues = importers.OWLImporter(filepath=temp_filepath).to_rules(role=RoleTypes.dms_architect)
+        rules, issues = importers.OWLImporter(filepath=temp_filepath).to_rules(role=RoleTypes.dms)
 
     # load as YAML
     elif suffix in [".yml", ".yaml"]:
-        rules, issues = importers.YAMLImporter.from_file(temp_filepath).to_rules(role=RoleTypes.dms_architect)
+        rules, issues = importers.YAMLImporter.from_file(temp_filepath).to_rules(role=RoleTypes.dms)
 
     # load as JSON
     elif suffix == ".json":
         with temp_filepath.open() as temp:
             json_data = json.load(temp)
-        rules, issues = importers.YAMLImporter(raw_data=json.loads(json_data)).to_rules(role=RoleTypes.dms_architect)
+        rules, issues = importers.YAMLImporter(raw_data=json.loads(json_data)).to_rules(role=RoleTypes.dms)
 
     # Remove the temporary file
     temp_filepath.unlink()

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -42,7 +42,7 @@ class MockGraphGenerator(BaseExtractor):
         allow_isolated_classes: bool = True,
     ):
         if isinstance(rules, DMSRules):
-            self.rules = rules.as_information_architect_rules()
+            self.rules = rules.as_information_rules()
         elif isinstance(rules, InformationRules):
             self.rules = rules
         else:

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -1,8 +1,7 @@
 import json
-from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from pathlib import Path
-from typing import Any
+from typing import Any, get_args
 
 import yaml
 from cognite.client import CogniteClient
@@ -20,7 +19,7 @@ from cognite.neat.graph.issues import loader as loader_issues
 from cognite.neat.graph.stores import NeatGraphStore
 from cognite.neat.issues import NeatIssue, NeatIssueList
 from cognite.neat.rules.models import DMSRules
-from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE
+from cognite.neat.rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
 from cognite.neat.utils.upload import UploadResult
 from cognite.neat.utils.utils import create_sha256_hash
 
@@ -106,8 +105,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             yield from issues
             tracker.issue(issues)
             class_name = self.class_by_view_id.get(view.as_id(), view.external_id)
-            triples = self.graph_store.read(class_name)
-            for identifier, properties in _triples2dictionary(triples).items():
+
+            for identifier, properties in self.graph_store.read(class_name):
                 try:
                     yield self._create_node(identifier, properties, pydantic_cls, view_id)
                 except ValueError as e:
@@ -145,7 +144,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         issues = NeatIssueList[NeatIssue]()
         field_definitions: dict[str, tuple[type, Any]] = {}
         edge_by_property: dict[str, dm.EdgeConnection] = {}
+        validators: dict[str, classmethod] = {}
         direct_relation_by_property: dict[str, dm.DirectRelation] = {}
+        json_fields: list[str] = []
         for prop_name, prop in view.properties.items():
             if isinstance(prop, dm.EdgeConnection):
                 edge_by_property[prop_name] = prop
@@ -163,6 +164,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                             )
                         )
                         continue
+
+                    if data_type == Json:
+                        json_fields.append(prop_name)
                     python_type = data_type.python
                 if prop.type.is_list:
                     python_type = list[python_type]
@@ -175,13 +179,29 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 field_definitions[prop_name] = (python_type, default_value)
 
         def parse_list(cls, value: Any, info: ValidationInfo) -> list[str]:
-            if isinstance(value, list) and cls.model_fields[info.field_name].annotation is not list:
+            if isinstance(value, list) and list.__name__ not in _get_field_value_types(cls, info):
                 if len(value) == 1:
                     return value[0]
                 raise ValueError(f"Got multiple values for {info.field_name}: {value}")
+
             return value
 
-        validators: dict[str, classmethod] = {"parse_list": field_validator("*", mode="before")(parse_list)}  # type: ignore[dict-item,arg-type]
+        def parse_json_string(cls, value: Any, info: ValidationInfo) -> dict:
+            if isinstance(value, dict):
+                return value
+            elif isinstance(value, str):
+                try:
+                    return json.loads(value)
+                except json.JSONDecodeError as error:
+                    raise ValueError(f"Not valid JSON string for {info.field_name}: {value}, error {error}") from error
+            else:
+                raise ValueError(f"Expect valid JSON string or dict for {info.field_name}: {value}")
+
+        if json_fields:
+            validators["parse_json_string"] = field_validator(*json_fields, mode="before")(parse_json_string)  # type: ignore[assignment, arg-type]
+
+        validators["parse_list"] = field_validator("*", mode="before")(parse_list)  # type: ignore[assignment, arg-type]
+
         if direct_relation_by_property:
 
             def parse_direct_relation(cls, value: list, info: ValidationInfo) -> dict | list[dict]:
@@ -280,7 +300,10 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             result.created.update(item.as_id() for item in e.successful)
             yield result
         else:
-            for instance_type, instances in {"Nodes": upserted.nodes, "Edges": upserted.edges}.items():
+            for instance_type, instances in {
+                "Nodes": upserted.nodes,
+                "Edges": upserted.edges,
+            }.items():
                 result = UploadResult[InstanceId](name=instance_type, issues=read_issues)
                 for instance in instances:  # type: ignore[attr-defined]
                     if instance.was_modified and instance.created_time == instance.last_updated_time:
@@ -292,13 +315,5 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 yield result
 
 
-def _triples2dictionary(
-    triples: Iterable[tuple[str, str, str]],
-) -> dict[str, dict[str, list[str]]]:
-    """Converts list of triples to dictionary"""
-    values_by_property_by_identifier: dict[str, dict[str, list[str]]] = defaultdict(lambda: defaultdict(list))
-    for id_, property_, value in triples:
-        # avoid issue with strings "None", "nan", "null" being treated as values
-        if value.lower() not in ["", "None", "nan", "null"]:
-            values_by_property_by_identifier[id_][property_].append(value)
-    return values_by_property_by_identifier
+def _get_field_value_types(cls, info):
+    return [type_.__name__ for type_ in get_args(cls.model_fields[info.field_name].annotation)]

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/graph/queries/_base.py

@@ -1,4 +1,5 @@
 import warnings
+from collections import defaultdict
 from typing import Literal, cast, overload
 
 from rdflib import RDF, Graph, URIRef
@@ -93,12 +94,63 @@ class Queries:
             )
             return []
 
-    def construct_instances_of_class(self, class_: str, properties_optional: bool = True) -> list[tuple[str, str, str]]:
+    def describe(
+        self,
+        instance_id: URIRef,
+        property_renaming_config: dict | None = None,
+    ) -> tuple[str, dict[str, list[str]]]:
+        """DESCRIBE instance for a given class from the graph store
+
+        Args:
+            instance_id: Instance id for which we want to generate query
+            property_rename_config: Dictionary to rename properties, default None
+
+        Returns:
+            Dictionary of instance properties
+        """
+
+        property_values: dict[str, list[str]] = defaultdict(list)
+
+        for subject, predicate, object_ in cast(list[ResultRow], self.graph.query(f"DESCRIBE <{instance_id}>")):
+            # We cannot include the RDF.type in case there is a neat:type property
+            # or if the object is empty
+            if predicate != RDF.type and object_.lower() not in [
+                "",
+                "none",
+                "nan",
+                "null",
+            ]:
+                # we are skipping deep validation with Pydantic to remove namespace here
+                # as it reduce time to process triples by 10-15x
+                identifier, property_, value = cast(  # type: ignore[misc]
+                    (str, str, str),
+                    remove_namespace_from_uri(*(subject, predicate, object_), validation="prefix"),
+                )  # type: ignore[misc, index]
+
+                if property_renaming_config:
+                    predicate = property_renaming_config.get(property_, property_)
+
+                property_values[property_].append(value)
+        if property_values:
+            return (
+                identifier,
+                property_values,
+            )
+        else:
+            return ()  # type: ignore [return-value]
+
+    def construct_instances_of_class(
+        self,
+        class_: str,
+        properties_optional: bool = True,
+        instance_id: URIRef | None = None,
+    ) -> list[tuple[str, str, str]]:
         """CONSTRUCT instances for a given class from the graph store
 
         Args:
             class_: Class entity for which we want to generate query
             properties_optional: Whether to make all properties optional, default True
+            instance_ids: List of instance ids to filter on, default None (all)
 
         Returns:
             List of triples for instances of the given class
@@ -106,10 +158,11 @@ class Queries:
 
         if self.rules and (
             query := build_construct_query(
-                ClassEntity(prefix=self.rules.metadata.prefix, suffix=class_),
-                self.graph,
-                self.rules,
-                properties_optional,
+                class_=ClassEntity(prefix=self.rules.metadata.prefix, suffix=class_),
+                graph=self.graph,
+                rules=self.rules,
+                properties_optional=properties_optional,
+                instance_id=instance_id,
             )
         ):
             result = self.graph.query(query)

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/graph/queries/_construct.py

@@ -18,8 +18,8 @@ from cognite.neat.utils.utils import most_occurring_element
 from ._shared import Triple, hop2property_path
 
 _QUERY_TEMPLATE = """CONSTRUCT {{ {graph_template} }}
-                     WHERE {{     {graph_pattern}
-                                  {filter}
+                     WHERE {{     {bind_instance_id}
+                                  {graph_pattern}
                      }}"""
 
 
@@ -28,7 +28,7 @@ def build_construct_query(
     graph: Graph,
     rules: InformationRules,
     properties_optional: bool = True,
-    class_instances: list[URIRef] | None = None,
+    instance_id: URIRef | None = None,
 ) -> str | None:
     """Builds a CONSTRUCT query for a given class and rules and optionally filters by class instances.
 
@@ -53,6 +53,7 @@ def build_construct_query(
         This is the reason why there is an option to make all properties optional, so that
         the query will return all instances that have at least one property defined.
     """
+
     if (
         transformations := InformationArchitectRulesAnalysis(rules)
         .class_property_pairs(only_rdfpath=True, consider_inheritance=True)
@@ -63,22 +64,20 @@ def build_construct_query(
         )
 
         return _QUERY_TEMPLATE.format(
+            bind_instance_id=(f"BIND(<{instance_id}> AS ?instance)" if instance_id else ""),
             graph_template="\n".join(triples2sparql_statement(templates)),
             graph_pattern="\n".join(triples2sparql_statement(patterns)),
-            filter="" if not class_instances else add_filter(class_instances),
         )
 
     else:
         return None
 
 
-def add_filter(class_instances: list[URIRef]):
-    class_instances_formatted = [f"<{instance}>" for instance in class_instances]
-    return f"FILTER (?instance IN ({', '.join(class_instances_formatted)}))"
-
-
 def to_construct_triples(
-    graph: Graph, transformations: list[InformationProperty], prefixes: dict, properties_optional: bool = True
+    graph: Graph,
+    transformations: list[InformationProperty],
+    prefixes: dict,
+    properties_optional: bool = True,
 ) -> tuple[list[Triple], list[Triple]]:
     """Converts transformations of a class to CONSTRUCT triples which are used to generate CONSTRUCT query
 
@@ -124,7 +123,10 @@ def to_construct_triples(
         # use case AllReferences: binding instance to certain rdf property
         if isinstance(traversal, AllReferences):
             graph_pattern_triple = Triple(
-                subject="BIND(?instance", predicate="AS", object=f"{graph_template_triple.object})", optional=False
+                subject="BIND(?instance",
+                predicate="AS",
+                object=f"{graph_template_triple.object})",
+                optional=False,
             )
 
         # use case SingleProperty: simple property traversal
@@ -133,7 +135,7 @@ def to_construct_triples(
                 subject=graph_template_triple.subject,
                 predicate=traversal.property.id,
                 object=graph_template_triple.object,
-                optional=True if properties_optional else not transformation.is_mandatory,
+                optional=(True if properties_optional else not transformation.is_mandatory),
             )
 
         # use case Hop: property traversal with multiple hops turned into property path
@@ -143,7 +145,7 @@ def to_construct_triples(
                 subject="?instance",
                 predicate=hop2property_path(graph, traversal, prefixes),
                 object=graph_template_triple.object,
-                optional=True if properties_optional else not transformation.is_mandatory,
+                optional=(True if properties_optional else not transformation.is_mandatory),
             )
 
         # other type of rdfpaths are skipped

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/graph/stores/_base.py

@@ -15,6 +15,7 @@ from cognite.neat.graph.extractors import RdfFileExtractor, TripleExtractors
 from cognite.neat.graph.models import Triple
 from cognite.neat.graph.queries import Queries
 from cognite.neat.graph.transformers import Transformers
+from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
 from cognite.neat.rules.models import InformationRules
 from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.utils.auxiliary import local_import
@@ -165,25 +166,32 @@ class NeatGraphStore:
             )
         )
 
-    def read(self, class_: str) -> list[tuple[str, str, str]]:
+    def read(self, class_: str) -> Iterable[tuple[str, dict[str, list[str]]]]:
         """Read instances for given view from the graph store."""
-        # PLACEHOLDER: Implement reading instances for a given view
-        # not yet developed
 
         if not self.rules:
-            warnings.warn(
-                "No rules found for the graph store, returning empty list.",
-                stacklevel=2,
-            )
-            return []
+            warnings.warn("Rules not found in graph store!", stacklevel=2)
+            return None
 
         class_entity = ClassEntity(prefix=self.rules.metadata.prefix, suffix=class_)
 
         if class_entity not in [definition.class_ for definition in self.rules.classes.data]:
             warnings.warn("Desired type not found in graph!", stacklevel=2)
-            return []
+            return None
+
+        if InformationArchitectRulesAnalysis(self.rules).has_hop_transformations():
+            warnings.warn(
+                "Rules contain Hop rdfpath, run ReduceHopTraversal transformer first!",
+                stacklevel=2,
+            )
+            return None
+
+        instance_ids = self.queries.list_instances_ids_of_class(self.rules.metadata.namespace[class_])
+
+        property_renaming_config = InformationArchitectRulesAnalysis(self.rules).define_property_renaming_config()
 
-        return self.queries.construct_instances_of_class(class_)
+        for instance_id in instance_ids:
+            yield self.queries.describe(instance_id, property_renaming_config)
 
     def _parse_file(
         self,

cognite_neat-0.86.0/cognite/neat/graph/transformers/_rdfpath.py

@@ -0,0 +1,7 @@
+from ._base import BaseTransformer
+
+
+class ReduceHopTraversal(BaseTransformer):
+    """ReduceHopTraversal is a transformer that reduces the number of hops to direct connection."""
+
+    ...

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/analysis/_information_rules.py

@@ -8,7 +8,7 @@ import pandas as pd
 from pydantic import ValidationError
 
 from cognite.neat.rules.models import SchemaCompleteness
-from cognite.neat.rules.models._rdfpath import RDFPath
+from cognite.neat.rules.models._rdfpath import Hop, RDFPath
 from cognite.neat.rules.models.asset import AssetClass, AssetProperty, AssetRules
 from cognite.neat.rules.models.entities import (
     AssetEntity,
@@ -401,7 +401,14 @@ class _SharedAnalysis(Generic[T_Rules, T_Property, T_Class]):
 class InformationArchitectRulesAnalysis(_SharedAnalysis[InformationRules, InformationProperty, InformationClass]):
     """Assumes analysis over only the complete schema"""
 
-    ...
+    def has_hop_transformations(self):
+        return any(
+            prop_.transformation and isinstance(prop_.transformation.traversal, Hop) for prop_ in self.rules.properties
+        )
+
+    def define_property_renaming_config(self) -> dict[str, str]:
+        # placeholder comes in new PR
+        return {}
 
 
 class AssetArchitectRulesAnalysis(_SharedAnalysis[AssetRules, AssetProperty, AssetClass]):

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/exporters/_base.py

@@ -28,10 +28,10 @@ class BaseExporter(ABC, Generic[T_Export]):
     def _convert_to_output_role(self, rules: Rules, output_role: RoleTypes | None = None) -> Rules:
         if rules.metadata.role is output_role or output_role is None:
             return rules
-        elif output_role is RoleTypes.dms_architect and isinstance(rules, InformationRules):
-            return rules.as_dms_architect_rules()
-        elif output_role is RoleTypes.information_architect and isinstance(rules, DMSRules):
-            return rules.as_information_architect_rules()
+        elif output_role is RoleTypes.dms and isinstance(rules, InformationRules):
+            return rules.as_dms_rules()
+        elif output_role is RoleTypes.information and isinstance(rules, DMSRules):
+            return rules.as_information_rules()
         else:
             raise NotImplementedError(f"Role {output_role} is not supported for {type(rules).__name__} rules")
 

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/exporters/_rules2dms.py

@@ -118,7 +118,7 @@ class DMSExporter(CDFExporter[DMSSchema]):
         if isinstance(rules, DMSRules):
             dms_rules = rules
         elif isinstance(rules, InformationRules):
-            dms_rules = rules.as_dms_architect_rules()
+            dms_rules = rules.as_dms_rules()
         else:
             raise ValueError(f"{type(rules).__name__} cannot be exported to DMS")
         return dms_rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/exporters/_rules2ontology.py

@@ -95,7 +95,7 @@ class Ontology(OntologyModel):
         if isinstance(input_rules, InformationRules):
             rules = input_rules
         elif isinstance(input_rules, DMSRules):
-            rules = input_rules.as_information_architect_rules()
+            rules = input_rules.as_information_rules()
         else:
             raise ValueError(f"{type(input_rules).__name__} cannot be exported to Ontology")
 

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/importers/_base.py

@@ -55,10 +55,10 @@ class BaseImporter(ABC):
 
         if rules.metadata.role is role or role is None:
             output = rules
-        elif isinstance(rules, DMSRules) or isinstance(rules, AssetRules) and role is RoleTypes.information_architect:
-            output = rules.as_information_architect_rules()
-        elif isinstance(rules, InformationRules) or isinstance(rules, AssetRules) and role is RoleTypes.dms_architect:
-            output = rules.as_dms_architect_rules()
+        elif isinstance(rules, DMSRules) or isinstance(rules, AssetRules) and role is RoleTypes.information:
+            output = rules.as_information_rules()
+        elif isinstance(rules, InformationRules) or isinstance(rules, AssetRules) and role is RoleTypes.dms:
+            output = rules.as_dms_rules()
         else:
             raise NotImplementedError(f"Role {role} is not supported for {type(rules).__name__} rules")
 

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/importers/_inference2rules.py

@@ -75,7 +75,9 @@ class InferenceImporter(BaseImporter):
         self.graph = graph
         self.max_number_of_instance = max_number_of_instance
         self.prefix = prefix
-        self.check_for_json_string = check_for_json_string
+        self.check_for_json_string = (
+            check_for_json_string if graph.store.__class__.__name__ != "OxigraphStore" else False
+        )
 
     @classmethod
     def from_graph_store(
@@ -235,6 +237,7 @@ class InferenceImporter(BaseImporter):
                     query.replace("instance_id", instance)
                 ):  # type: ignore[misc]
                     property_id = remove_namespace_from_uri(property_uri)
+
                     self._add_uri_namespace_to_prefixes(cast(URIRef, property_uri), prefixes)
                     value_type_uri = data_type_uri if data_type_uri else object_type_uri
 

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/importers/_owl2rules/_owl2metadata.py

@@ -51,7 +51,7 @@ def parse_owl_metadata(graph: Graph) -> dict:
 
     raw_metadata = convert_rdflib_content(
         {
-            "role": RoleTypes.information_architect,
+            "role": RoleTypes.information,
             "schema": SchemaCompleteness.partial,
             "prefix": results[1].pop(),
             "namespace": Namespace(results[0].pop()),

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/importers/_spreadsheet2rules.py

@@ -36,9 +36,9 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
         "Properties",
         {
             RoleTypes.domain_expert: "Property",
-            RoleTypes.information_architect: "Property",
-            RoleTypes.asset_architect: "Property",
-            RoleTypes.dms_architect: "View Property",
+            RoleTypes.information: "Property",
+            RoleTypes.asset: "Property",
+            RoleTypes.dms: "View Property",
         },
     ),
     ("Classes", "Classes", "Class"),
@@ -334,9 +334,9 @@ class GoogleSheetImporter(BaseImporter):
 
         if role == RoleTypes.domain_expert:
             output = rules_model.model_validate(sheets)
-        elif role == RoleTypes.information_architect:
+        elif role == RoleTypes.information:
             output = rules_model.model_validate(sheets)
-        elif role == RoleTypes.dms_architect:
+        elif role == RoleTypes.dms:
             output = rules_model.model_validate(sheets)
         else:
             raise ValueError(f"Role {role} is not valid.")

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/models/__init__.py

@@ -8,9 +8,9 @@ from .dms._schema import DMSSchema
 
 RULES_PER_ROLE: dict[RoleTypes, type[DomainRules] | type[InformationRules] | type[AssetRules] | type[DMSRules]] = {
     RoleTypes.domain_expert: DomainRules,
-    RoleTypes.information_architect: InformationRules,
-    RoleTypes.asset_architect: AssetRules,
-    RoleTypes.dms_architect: DMSRules,
+    RoleTypes.information: InformationRules,
+    RoleTypes.asset: AssetRules,
+    RoleTypes.dms: DMSRules,
 }
 
 

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/models/_base.py

@@ -150,9 +150,9 @@ class DataModelType(StrEnum):
 
 class RoleTypes(StrEnum):
     domain_expert = "domain expert"
-    information_architect = "information architect"
-    asset_architect = "asset architect"
-    dms_architect = "DMS Architect"
+    information = "information architect"
+    asset = "asset architect"
+    dms = "DMS Architect"
 
 
 class MatchType(StrEnum):

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/models/asset/_rules.py

@@ -35,7 +35,7 @@ else:
 
 
 class AssetMetadata(InformationMetadata):
-    role: ClassVar[RoleTypes] = RoleTypes.asset_architect
+    role: ClassVar[RoleTypes] = RoleTypes.asset
 
 
 class AssetClass(InformationClass): ...
@@ -148,12 +148,12 @@ class AssetRules(BaseRules):
     def as_domain_rules(self) -> DomainRules:
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(self.as_information_architect_rules()).as_domain_rules()
+        return _AssetRulesConverter(self.as_information_rules()).as_domain_rules()
 
-    def as_dms_architect_rules(self) -> "DMSRules":
+    def as_dms_rules(self) -> "DMSRules":
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(self.as_information_architect_rules()).as_dms_architect_rules()
+        return _AssetRulesConverter(self.as_information_rules()).as_dms_rules()
 
-    def as_information_architect_rules(self) -> InformationRules:
+    def as_information_rules(self) -> InformationRules:
         return InformationRules.model_validate(self.model_dump())

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/models/data_types.py

@@ -237,7 +237,7 @@ class Literal(DataType):
 
 class Timeseries(DataType):
     name = "timeseries"
-    python = dms.TimeSeriesReference
+    python = str
     dms = dms.TimeSeriesReference
     graphql = "TimeSeries"
     xsd = "string"
@@ -246,7 +246,7 @@ class Timeseries(DataType):
 
 class File(DataType):
     name = "file"
-    python = dms.FileReference
+    python = str
     dms = dms.FileReference
     graphql = "File"
     xsd = "string"
@@ -255,7 +255,7 @@ class File(DataType):
 
 class Sequence(DataType):
     name = "sequence"
-    python = dms.SequenceReference
+    python = str
     dms = dms.SequenceReference
     graphql = "Sequence"
     xsd = "string"
@@ -264,7 +264,7 @@ class Sequence(DataType):
 
 class Json(DataType):
     name = "json"
-    python = dms.Json
+    python = dict
     dms = dms.Json
     graphql = "Json"
     xsd = "json"

{cognite_neat-0.85.11 → cognite_neat-0.86.0}/cognite/neat/rules/models/dms/_converter.py

@@ -32,7 +32,7 @@ class _DMSRulesConverter:
     def as_domain_rules(self) -> "DomainRules":
         raise NotImplementedError("DomainRules not implemented yet")
 
-    def as_information_architect_rules(
+    def as_information_rules(
         self,
     ) -> "InformationRules":
         from cognite.neat.rules.models.information._rules import (
@@ -94,8 +94,8 @@ class _DMSRulesConverter:
             metadata=metadata,
             properties=SheetList[InformationProperty](data=properties),
             classes=SheetList[InformationClass](data=classes),
-            last=self.dms.last.as_information_architect_rules() if self.dms.last else None,
-            reference=self.dms.reference.as_information_architect_rules() if self.dms.reference else None,
+            last=self.dms.last.as_information_rules() if self.dms.last else None,
+            reference=self.dms.reference.as_information_rules() if self.dms.reference else None,
         )
 
     @classmethod