cognite-neat 0.109.3__py3-none-any.whl → 0.110.0__py3-none-any.whl

cognite/neat/_rules/exporters/_rules2excel.py

@@ -13,6 +13,7 @@ from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
 from openpyxl.worksheet.worksheet import Worksheet
 from rdflib import Namespace
 
+from cognite.neat._rules._constants import get_internal_properties
 from cognite.neat._rules._shared import VerifiedRules
 from cognite.neat._rules.models import (
     ExtensionCategory,
@@ -64,13 +65,6 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
     style_options = get_args(Style)
     dump_options = get_args(DumpOptions)
 
-    _internal_columns: ClassVar[list[str]] = [
-        "physical",
-        "logical",
-        "conceptual",
-        "Neat ID",
-    ]
-
     def __init__(
         self,
         styling: Style = "default",
@@ -131,7 +125,7 @@ class ExcelExporter(BaseExporter[VerifiedRules, Workbook]):
                 if sheet.lower() == "metadata":
                     continue
                 ws = workbook[sheet]
-                for col in self._internal_columns:
+                for col in get_internal_properties():
                     column_letter = find_column_with_value(ws, col)
                     if column_letter:
                         ws.column_dimensions[column_letter].hidden = True

cognite/neat/_rules/exporters/_rules2instance_template.py

@@ -9,7 +9,7 @@ from openpyxl.utils import get_column_letter
 from openpyxl.worksheet.datavalidation import DataValidation
 
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.models.entities._single_value import ClassEntity
 from cognite.neat._rules.models.information._rules import InformationRules
 
@@ -55,7 +55,7 @@ class InstanceTemplateExporter(BaseExporter[InformationRules, Workbook]):
         # Remove default sheet named "Sheet"
         workbook.remove(workbook["Sheet"])
 
-        for class_, properties in InformationAnalysis(rules).class_property_pairs().items():
+        for class_, properties in RulesAnalysis(rules).properties_by_id_by_class().items():
             workbook.create_sheet(title=class_.suffix)
 
             # Add header rows

cognite/neat/_rules/exporters/_rules2ontology.py

@@ -15,7 +15,7 @@ from cognite.neat._issues.errors import (
 )
 from cognite.neat._issues.warnings import PropertyDefinitionDuplicatedWarning
 from cognite.neat._rules._constants import EntityTypes
-from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.models.data_types import DataType
 from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information import (
@@ -121,11 +121,12 @@ class Ontology(OntologyModel):
                 )
             raise MultiValueError(errors)
 
-        class_dict = InformationAnalysis(rules).as_class_dict()
+        analysis = RulesAnalysis(rules)
+        class_dict = analysis.class_by_suffix()
         return cls(
             properties=[
                 OWLProperty.from_list_of_properties(definition, rules.metadata.namespace)
-                for definition in InformationAnalysis(rules).as_property_dict().values()
+                for definition in analysis.property_by_id().values()
             ],
             classes=[
                 OWLClass.from_class(definition, rules.metadata.namespace, rules.prefixes)
@@ -137,7 +138,7 @@ class Ontology(OntologyModel):
                     list(properties.values()),
                     rules.metadata.namespace,
                 )
-                for class_, properties in InformationAnalysis(rules).class_property_pairs().items()
+                for class_, properties in analysis.properties_by_id_by_class().items()
             ]
             + [
                 SHACLNodeShape.from_rules(

cognite/neat/_rules/importers/_base.py

@@ -1,15 +1,11 @@
-import warnings
 from abc import ABC, abstractmethod
-from collections.abc import Iterator
-from contextlib import contextmanager, suppress
+from contextlib import suppress
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Generic, Literal
+from typing import TYPE_CHECKING, Any, Generic
 
-from pydantic import ValidationError
 from rdflib import URIRef
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
-from cognite.neat._issues import IssueList, NeatError, NeatWarning
 from cognite.neat._rules._shared import ReadRules, T_InputRules
 from cognite.neat._utils.auxiliary import class_html_doc
 
@@ -64,44 +60,3 @@ class BaseImporter(ABC, Generic[T_InputRules]):
     @property
     def source_uri(self) -> URIRef:
         return DEFAULT_NAMESPACE["UNKNOWN"]
-
-
-class _FutureResult:
-    def __init__(self) -> None:
-        self._result: Literal["success", "failure", "pending"] = "pending"
-
-    @property
-    def result(self) -> Literal["success", "failure", "pending"]:
-        return self._result
-
-
-@contextmanager
-def _handle_issues(
-    issues: IssueList,
-    error_cls: type[NeatError] = NeatError,
-    warning_cls: type[NeatWarning] = NeatWarning,
-    error_args: dict[str, Any] | None = None,
-) -> Iterator[_FutureResult]:
-    """This is an internal help function to handle issues and warnings.
-
-    Args:
-        issues: The issues list to append to.
-        error_cls: The class used to convert errors to issues.
-        warning_cls:  The class used to convert warnings to issues.
-
-    Returns:
-        FutureResult: A future result object that can be used to check the result of the context manager.
-    """
-    with warnings.catch_warnings(record=True) as warning_logger:
-        warnings.simplefilter("always")
-        future_result = _FutureResult()
-        try:
-            yield future_result
-        except ValidationError as e:
-            issues.extend(error_cls.from_errors(e.errors(), **(error_args or {})))  # type: ignore[arg-type]
-            future_result._result = "failure"
-        else:
-            future_result._result = "success"
-        finally:
-            if warning_logger:
-                issues.extend([warning_cls.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]

cognite/neat/_rules/importers/_dms2rules.py

@@ -19,7 +19,7 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.utils import ms_to_datetime
 
 from cognite.neat._client import NeatClient
-from cognite.neat._issues import IssueList, MultiValueError, NeatIssue
+from cognite.neat._issues import IssueList, MultiValueError, NeatIssue, catch_issues
 from cognite.neat._issues.errors import (
     FileTypeUnexpectedError,
     NeatValueError,
@@ -35,7 +35,7 @@ from cognite.neat._issues.warnings import (
     ResourceUnknownWarning,
 )
 from cognite.neat._rules._shared import ReadRules
-from cognite.neat._rules.importers._base import BaseImporter, _handle_issues
+from cognite.neat._rules.importers._base import BaseImporter
 from cognite.neat._rules.models import (
     DMSInputRules,
     DMSSchema,
@@ -131,11 +131,10 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
     @classmethod
     def from_data_model(cls, client: NeatClient, model: dm.DataModel[dm.View]) -> "DMSImporter":
-        issue_list = IssueList()
-        with _handle_issues(issue_list) as result:
+        with catch_issues() as issue_list:
             schema = client.schema.retrieve_data_model(model)
 
-        if result.result == "failure" or issue_list.has_errors:
+        if issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
         metadata = cls._create_metadata_from_model(model)
@@ -187,10 +186,9 @@ class DMSImporter(BaseImporter[DMSInputRules]):
 
     @classmethod
     def from_directory(cls, directory: str | Path, client: NeatClient | None = None) -> "DMSImporter":
-        issue_list = IssueList()
-        with _handle_issues(issue_list) as _:
+        with catch_issues() as issue_list:
             schema = DMSSchema.from_directory(directory)
-        # If there were errors during the import, the to_rules
+        # If there were errors during the import, the to_rules will raise them.
         return cls(
             schema, issue_list, referenced_containers=cls._lookup_referenced_containers(schema, issue_list, client)
         )
@@ -202,8 +200,7 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                 DMSSchema(),
                 [FileTypeUnexpectedError(Path(zip_file), frozenset([".zip"]))],
             )
-        issue_list = IssueList()
-        with _handle_issues(issue_list) as _:
+        with catch_issues() as issue_list:
             schema = DMSSchema.from_zip(zip_file)
         return cls(
             schema, issue_list, referenced_containers=cls._lookup_referenced_containers(schema, issue_list, client)

cognite/neat/_rules/importers/_dtdl2rules/dtdl_importer.py

@@ -19,7 +19,7 @@ from cognite.neat._rules.importers._dtdl2rules.dtdl_converter import _DTDLConver
 from cognite.neat._rules.importers._dtdl2rules.spec import DTDL_CLS_BY_TYPE_BY_SPEC, DTDLBase, Interface
 from cognite.neat._rules.models import InformationInputRules
 from cognite.neat._rules.models.information import InformationInputMetadata
-from cognite.neat._utils.text import humanize_collection, to_pascal
+from cognite.neat._utils.text import humanize_collection, to_pascal_case
 
 
 class DTDLImporter(BaseImporter[InformationInputRules]):
@@ -130,7 +130,7 @@ class DTDLImporter(BaseImporter[InformationInputRules]):
         metadata = self._default_metadata()
 
         if self.name:
-            metadata["name"] = to_pascal(self.name)
+            metadata["name"] = to_pascal_case(self.name)
         try:
             most_common_prefix = converter.get_most_common_prefix()
         except ValueError:

cognite/neat/_rules/importers/_rdf/_inference2rules.py

@@ -13,11 +13,12 @@ from rdflib import Literal as RdfLiteral
 from cognite.neat._constants import NEAT, get_default_prefixes_and_namespaces
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import PropertyValueTypeUndefinedWarning
-from cognite.neat._rules.analysis import InformationAnalysis
+from cognite.neat._rules.analysis import RulesAnalysis
 from cognite.neat._rules.models import InformationRules, data_types
 from cognite.neat._rules.models.data_types import AnyURI
 from cognite.neat._rules.models.entities._single_value import UnknownEntity
 from cognite.neat._rules.models.information import (
+    InformationClass,
     InformationInputClass,
     InformationInputProperty,
     InformationMetadata,
@@ -256,7 +257,7 @@ class InferenceImporter(BaseRDFImporter):
                 property_["value_type"].remove(str(self.non_existing_node_type))
 
             if len(property_["value_type"]) > 1:
-                property_["value_type"] = " | ".join([str(t) for t in property_["value_type"]])
+                property_["value_type"] = ", ".join([str(t) for t in property_["value_type"]])
             else:
                 property_["value_type"] = next(iter(property_["value_type"]))
 
@@ -402,7 +403,8 @@ class SubclassInferenceImporter(BaseRDFImporter):
         else:
             existing_classes = {}
         classes: list[InformationInputClass] = []
-        properties: list[InformationInputProperty] = []
+        properties_by_class_suffix_by_property_id_lowered: dict[str, dict[str, InformationInputProperty]] = {}
+
         # Help for IDE
         type_uri: URIRef
         parent_uri: URIRef
@@ -440,26 +442,51 @@ class SubclassInferenceImporter(BaseRDFImporter):
                         InformationInputClass(
                             class_=class_suffix,
                             implements=parent_suffix,
+                            instance_source=type_uri,
                         )
                     )
                 else:
                     classes.append(InformationInputClass.load(existing_classes[class_suffix].model_dump()))
+
+                properties_by_id: dict[str, InformationInputProperty] = {}
                 for property_uri, read_properties in properties_by_property_uri.items():
                     if property_uri in shared_property_uris:
                         shared_properties[property_uri].extend(read_properties)
                         continue
-                    properties.append(
-                        self._create_property(read_properties, class_suffix, type_uri, property_uri, prefixes)
-                    )
-
+                    property_id = remove_namespace_from_uri(property_uri)
+                    self._add_uri_namespace_to_prefixes(property_uri, prefixes)
+                    if existing_prop := properties_by_id.get(property_id.casefold()):
+                        if not isinstance(existing_prop.instance_source, list):
+                            existing_prop.instance_source = (
+                                [existing_prop.instance_source] if existing_prop.instance_source else []
+                            )
+                        existing_prop.instance_source.append(property_uri)
+                        continue
+                    else:
+                        properties_by_id[property_id.casefold()] = self._create_property(
+                            read_properties, class_suffix, property_uri, property_id, prefixes
+                        )
+                properties_by_class_suffix_by_property_id_lowered[class_suffix] = properties_by_id
             if parent_suffix:
+                properties_by_id = {}
                 for property_uri, read_properties in shared_properties.items():
-                    properties.append(
-                        self._create_property(
-                            read_properties, parent_suffix, read_properties[0].type_uri, property_uri, prefixes
+                    property_id = remove_namespace_from_uri(property_uri)
+                    self._add_uri_namespace_to_prefixes(property_uri, prefixes)
+                    if existing_prop := properties_by_id.get(property_id.casefold()):
+                        if not isinstance(existing_prop.instance_source, list):
+                            existing_prop.instance_source = (
+                                [existing_prop.instance_source] if existing_prop.instance_source else []
+                            )
+                        existing_prop.instance_source.append(property_uri)
+                    else:
+                        properties_by_id[property_uri.casefold()] = self._create_property(
+                            read_properties, parent_suffix, property_uri, property_id, prefixes
                         )
-                    )
-        return classes, properties
+        return classes, [
+            prop
+            for properties in properties_by_class_suffix_by_property_id_lowered.values()
+            for prop in properties.values()
+        ]
 
     @staticmethod
     def _get_properties_by_class_by_property(
@@ -481,26 +508,36 @@ class SubclassInferenceImporter(BaseRDFImporter):
             type_uri, instance_count_literal = cast(tuple[URIRef, RdfLiteral], result_row)
             count_by_type[type_uri] = instance_count_literal.toPython()
         if self._rules:
-            analysis = InformationAnalysis(self._rules)
+            analysis = RulesAnalysis(self._rules)
             existing_class_properties = {
-                (class_entity.suffix, prop.property_)
-                for class_entity, properties in analysis.classes_with_properties(
-                    consider_inheritance=True, allow_different_namespace=True
+                (class_entity.suffix, prop.property_): prop
+                for class_entity, properties in analysis.properties_by_class(
+                    include_ancestors=True, include_different_space=True
                 ).items()
                 for prop in properties
             }
+            existing_classes = {cls_.class_.suffix: cls_ for cls_ in self._rules.classes}
         else:
-            existing_class_properties = set()
+            existing_class_properties = {}
+            existing_classes = {}
         properties_by_class_by_subclass: list[_ReadProperties] = []
+        existing_class: InformationClass | None
         for type_uri, instance_count in count_by_type.items():
             property_query = self._properties_query.format(type=type_uri, unknown_type=NEAT.UnknownType)
             class_suffix = remove_namespace_from_uri(type_uri)
+            if (existing_class := existing_classes.get(class_suffix)) and existing_class.instance_source is None:
+                existing_class.instance_source = type_uri
+
             for result_row in self.graph.query(property_query):
                 property_uri, value_type_uri = cast(tuple[URIRef, URIRef], result_row)
                 if property_uri == RDF.type:
                     continue
                 property_str = remove_namespace_from_uri(property_uri)
-                if (class_suffix, property_str) in existing_class_properties:
+                if existing_property := existing_class_properties.get((class_suffix, property_str)):
+                    if existing_property.instance_source is None:
+                        existing_property.instance_source = [property_uri]
+                    elif existing_property.instance_source and property_uri not in existing_property.instance_source:
+                        existing_property.instance_source.append(property_uri)
                     continue
                 occurrence_query = self._max_occurrence_query.format(type=type_uri, property=property_uri)
                 max_occurrence = 1  # default value
@@ -531,21 +568,18 @@ class SubclassInferenceImporter(BaseRDFImporter):
         self,
         read_properties: list[_ReadProperties],
         class_suffix: str,
-        type_uri: URIRef,
         property_uri: URIRef,
+        property_id: str,
         prefixes: dict[str, Namespace],
     ) -> InformationInputProperty:
         first = read_properties[0]
         value_type = self._get_value_type(read_properties, prefixes)
-        property_name = remove_namespace_from_uri(property_uri)
-        self._add_uri_namespace_to_prefixes(property_uri, prefixes)
-
         return InformationInputProperty(
             class_=class_suffix,
-            property_=property_name,
+            property_=property_id,
             max_count=first.max_occurrence,
             value_type=value_type,
-            instance_source=(f"{uri_to_short_form(type_uri, prefixes)}({uri_to_short_form(property_uri, prefixes)})"),
+            instance_source=[property_uri],
         )
 
     def _get_value_type(
@@ -562,7 +596,7 @@ class SubclassInferenceImporter(BaseRDFImporter):
             return UnknownEntity()
         for uri_ref in value_types:
             self._add_uri_namespace_to_prefixes(uri_ref, prefixes)
-        return " | ".join(remove_namespace_from_uri(uri_ref) for uri_ref in value_types)
+        return ", ".join(remove_namespace_from_uri(uri_ref) for uri_ref in value_types)
 
     def _default_metadata(self) -> dict[str, Any]:
         now = datetime.now(timezone.utc)

cognite/neat/_rules/importers/_rdf/_shared.py

@@ -136,7 +136,7 @@ def parse_properties(graph: Graph, query: str, language: str, issue_list: IssueL
                 properties[id_]["value_type"].append(res["value_type"])
 
     for prop in properties.values():
-        prop["value_type"] = "|".join(prop["value_type"])
+        prop["value_type"] = ", ".join(prop["value_type"])
 
     if not properties:
         issue_list.append(NeatValueError("Unable to parse properties"))

cognite/neat/_rules/importers/_spreadsheet2rules.py

@@ -37,15 +37,15 @@ SOURCE_SHEET__TARGET_FIELD__HEADERS = [
         "Properties",
         "Properties",
         {
-            RoleTypes.information: "Property",
-            RoleTypes.dms: "View Property",
+            RoleTypes.information: ["Class", "Property"],
+            RoleTypes.dms: ["View", "View Property"],
         },
     ),
-    ("Classes", "Classes", "Class"),
-    ("Containers", "Containers", "Container"),
-    ("Views", "Views", "View"),
-    ("Enum", "Enum", "Collection"),
-    ("Nodes", "Nodes", "Node"),
+    ("Classes", "Classes", ["Class"]),
+    ("Containers", "Containers", ["Container"]),
+    ("Views", "Views", ["View"]),
+    ("Enum", "Enum", ["Collection"]),
+    ("Nodes", "Nodes", ["Node"]),
 ]
 
 
@@ -231,7 +231,10 @@ class SpreadsheetReader:
 
             try:
                 sheets[target_sheet_name], read_info_by_sheet[source_sheet_name] = read_individual_sheet(
-                    excel_file, source_sheet_name, return_read_info=True, expected_headers=[headers]
+                    excel_file,
+                    source_sheet_name,
+                    return_read_info=True,
+                    expected_headers=headers,
                 )
             except Exception as e:
                 self.issue_list.append(FileReadError(cast(Path, excel_file.io), str(e)))
@@ -273,7 +276,7 @@ class ExcelImporter(BaseImporter[T_InputRules]):
 
         rules_cls = INPUT_RULES_BY_ROLE[original_role]
         rules = cast(T_InputRules, rules_cls.load(sheets))
-        return ReadRules(rules, {"read_info_by_sheet": read_info_by_sheet})
+        return ReadRules(rules, read_info_by_sheet)
 
     @property
     def description(self) -> str:

cognite/neat/_rules/models/dms/_rules.py

@@ -295,7 +295,9 @@ class DMSView(SheetRow):
         None, alias="Filter", description="Explicitly define the filter for the view."
     )
     in_model: bool = Field(
-        True, alias="In Model", description="Indicates whether the view being defined is a part of the data model."
+        True,
+        alias="In Model",
+        description="Indicates whether the view being defined is a part of the data model.",
     )
     logical: URIRefType | None = Field(
         None,

cognite/neat/_rules/models/dms/_rules_input.py

@@ -193,6 +193,10 @@ class DMSInputView(InputComponent[DMSView]):
     neatId: str | URIRef | None = None
     logical: str | URIRef | None = None
 
+    def __post_init__(self):
+        if self.in_model is None:
+            self.in_model = True
+
     @classmethod
     def _get_verified_cls(cls) -> type[DMSView]:
         return DMSView

cognite/neat/_rules/models/dms/_validation.py

@@ -17,7 +17,7 @@ from cognite.neat._client import NeatClient
 from cognite.neat._client.data_classes.data_modeling import ViewApplyDict
 from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._constants import COGNITE_MODELS, DMS_CONTAINER_PROPERTY_SIZE_LIMIT, DMS_VIEW_CONTAINER_SIZE_LIMIT
-from cognite.neat._issues import IssueList, NeatError, NeatIssueList
+from cognite.neat._issues import IssueList, NeatError
 from cognite.neat._issues.errors import (
     CDFMissingClientError,
     PropertyDefinitionDuplicatedError,
@@ -42,6 +42,7 @@ from cognite.neat._rules.models.entities import ContainerEntity, RawFilter
 from cognite.neat._rules.models.entities._single_value import (
     ViewEntity,
 )
+from cognite.neat._utils.spreadsheet import SpreadsheetRead
 
 from ._rules import DMSProperty, DMSRules
 
@@ -54,13 +55,19 @@ class DMSValidation:
     # For example, changing the filter is allowed, but changing the properties is not.
     changeable_view_attributes: ClassVar[set[str]] = {"filter"}
 
-    def __init__(self, rules: DMSRules, client: NeatClient | None = None) -> None:
+    def __init__(
+        self,
+        rules: DMSRules,
+        client: NeatClient | None = None,
+        read_info_by_spreadsheet: dict[str, SpreadsheetRead] | None = None,
+    ) -> None:
         self._rules = rules
         self._client = client
         self._metadata = rules.metadata
         self._properties = rules.properties
         self._containers = rules.containers
         self._views = rules.views
+        self._read_info_by_spreadsheet = read_info_by_spreadsheet or {}
 
     def imported_views_and_containers_ids(
         self, include_views_with_no_properties: bool = True
@@ -87,7 +94,7 @@ class DMSValidation:
 
         return imported_views, imported_containers
 
-    def validate(self) -> NeatIssueList:
+    def validate(self) -> IssueList:
         imported_views, imported_containers = self.imported_views_and_containers_ids(
             include_views_with_no_properties=False
         )
@@ -212,13 +219,16 @@ class DMSValidation:
         for prop_no, prop in enumerate(self._properties):
             if prop.container and prop.container_property:
                 container_properties_by_id[(prop.container, prop.container_property)].append((prop_no, prop))
-
+        properties_sheet = self._read_info_by_spreadsheet.get("Properties")
         errors = IssueList()
         for (container, prop_name), properties in container_properties_by_id.items():
             if len(properties) == 1:
                 continue
             container_id = container.as_id()
+
             row_numbers = {prop_no for prop_no, _ in properties}
+            if properties_sheet:
+                row_numbers = {properties_sheet.adjusted_row_number(row_no) for row_no in row_numbers}
             value_types = {prop.value_type for _, prop in properties if prop.value_type}
             # The container type 'direct' is an exception. On a container the type direct can point to any
             # node. The value type is typically set on the view.

cognite/neat/_rules/models/entities/_loaders.py

@@ -23,7 +23,7 @@ def load_value_type(
     elif isinstance(raw, str):
         # property holding xsd data type
         # check if it is multi value type
-        if "|" in raw:
+        if "," in raw:
             value_type = MultiValueTypeInfo.load(raw)
             value_type.set_default_prefix(default_prefix)
             return value_type

cognite/neat/_rules/models/entities/_multi_value.py

@@ -18,7 +18,7 @@ class MultiValueTypeInfo(BaseModel):
     types: list[DataType | ClassEntity]
 
     def __str__(self) -> str:
-        return " | ".join([str(t) for t in self.types])
+        return ", ".join([str(t) for t in self.types])
 
     @model_serializer(when_used="unless-none", return_type=str)
     def as_str(self) -> str:
@@ -52,7 +52,7 @@ class MultiValueTypeInfo(BaseModel):
 
     @classmethod
     def _parse(cls, raw: str) -> dict:
-        if not (types := [type_.strip() for type_ in raw.split("|")]):
+        if not (types := [type_.strip() for type_ in raw.split(",")]):
             return {"types": [UnknownEntity()]}
         else:
             return {

cognite/neat/_rules/models/information/_rules.py

@@ -8,7 +8,7 @@ from pydantic_core.core_schema import SerializationInfo
 from rdflib import Namespace, URIRef
 
 from cognite.neat._constants import get_default_prefixes_and_namespaces
-from cognite.neat._issues.errors import NeatValueError, PropertyDefinitionError
+from cognite.neat._issues.errors import PropertyDefinitionError
 from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models._base_rules import (
     BaseMetadata,
@@ -18,11 +18,6 @@ from cognite.neat._rules.models._base_rules import (
     SheetList,
     SheetRow,
 )
-from cognite.neat._rules.models._rdfpath import (
-    RDFPath,
-    TransformationRuleType,
-    parse_rule,
-)
 from cognite.neat._rules.models._types import (
     ClassEntityType,
     InformationPropertyType,
@@ -78,7 +73,11 @@ class InformationClass(SheetRow):
         default=None,
         description="List of classes (comma separated) that the current class implements (parents).",
     )
-
+    instance_source: URIRefType | None = Field(
+        alias="Instance Source",
+        default=None,
+        description="The link to to the rdf.type that have the instances for this class.",
+    )
     physical: URIRefType | None = Field(
         None,
         description="Link to the class representation in the physical data model aspect",
@@ -153,11 +152,10 @@ class InformationProperty(SheetRow):
         "which means that the property can hold any number of values (listable).",
     )
     default: Any | None = Field(alias="Default", default=None, description="Default value of the property.")
-    instance_source: RDFPath | None = Field(
+    instance_source: list[URIRefType] | None = Field(
         alias="Instance Source",
         default=None,
-        description="The link to to the instance property for the model. "
-        "The rule is provided in a RDFPath query syntax which is converted to downstream solution query (e.g. SPARQL).",
+        description="The URIRef(s) in the graph to get the value of the property.",
     )
     inherited: bool = Field(
         default=False,
@@ -182,13 +180,10 @@ class InformationProperty(SheetRow):
         return value
 
     @field_validator("instance_source", mode="before")
-    def generate_rdfpath(cls, value: str | RDFPath | None) -> RDFPath | None:
-        if value is None or isinstance(value, RDFPath):
-            return value
-        elif isinstance(value, str):
-            return parse_rule(value, TransformationRuleType.rdfpath)
-        else:
-            raise NeatValueError(f"Invalid RDF Path: {value!s}")
+    def split_on_comma(cls, value: Any) -> Any:
+        if isinstance(value, str):
+            return [v.strip() for v in value.split(",")]
+        return value
 
     @model_validator(mode="after")
     def set_type_for_default(self):
@@ -214,6 +209,12 @@ class InformationProperty(SheetRow):
                     ) from None
         return self
 
+    @field_serializer("instance_source", when_used="unless-none")
+    def serialize_instance_source(self, value: list[URIRefType] | None) -> str | None:
+        if value is None:
+            return None
+        return ",".join(str(v) for v in value)
+
     @field_serializer("max_count", when_used="json-unless-none")
     def serialize_max_count(self, value: int | float | None) -> int | float | None | str:
         if isinstance(value, float) and math.isinf(value):

cognite/neat/_rules/models/information/_rules_input.py

@@ -84,7 +84,7 @@ class InformationInputProperty(InputComponent[InformationProperty]):
     min_count: int | None = None
     max_count: int | float | None = None
     default: Any | None = None
-    instance_source: str | None = None
+    instance_source: str | list[str] | None = None
     # Only used internally
     inherited: bool = False
     neatId: str | URIRef | None = None
@@ -110,6 +110,7 @@ class InformationInputClass(InputComponent[InformationClass]):
     name: str | None = None
     description: str | None = None
     implements: str | list[ClassEntity] | None = None
+    instance_source: str | None = None
     neatId: str | URIRef | None = None
     # linking
     physical: str | URIRef | None = None