cognite-neat 0.77.10__tar.gz → 0.78.1__tar.gz

{cognite_neat-0.77.10 → cognite_neat-0.78.1}/PKG-INFO

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

cognite_neat-0.78.1/cognite/neat/_version.py

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

{cognite_neat-0.77.10 → cognite_neat-0.78.1}/cognite/neat/rules/importers/_inference2rules.py

@@ -7,15 +7,17 @@ from rdflib import Literal as RdfLiteral
 
 import cognite.neat.rules.issues as issues
 from cognite.neat.constants import PREFIXES
+from cognite.neat.graph.stores import NeatGraphStoreBase
 from cognite.neat.rules.importers._base import BaseImporter, Rules, _handle_issues
 from cognite.neat.rules.issues import IssueList
 from cognite.neat.rules.models import InformationRules, RoleTypes
 from cognite.neat.rules.models._base import MatchType
+from cognite.neat.rules.models.entities import ClassEntity
 from cognite.neat.rules.models.information import (
     InformationMetadata,
     InformationRulesInput,
 )
-from cognite.neat.utils.utils import get_namespace, remove_namespace
+from cognite.neat.utils.utils import get_namespace, remove_namespace, replace_non_alphanumeric_with_underscore
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -41,13 +43,23 @@ class InferenceImporter(BaseImporter):
     """
 
     def __init__(
-        self, issue_list: IssueList, graph: Graph, max_number_of_instance: int = -1, make_compliant: bool = False
+        self, issue_list: IssueList, graph: Graph, make_compliant: bool = False, max_number_of_instance: int = -1
     ):
         self.issue_list = issue_list
         self.graph = graph
         self.max_number_of_instance = max_number_of_instance
         self.make_compliant = make_compliant
 
+    @classmethod
+    def from_graph_store(
+        cls, store: NeatGraphStoreBase, make_compliant: bool = False, max_number_of_instance: int = -1
+    ):
+        issue_list = IssueList(title="Inferred from graph store")
+
+        return cls(
+            issue_list, store.graph, make_compliant=make_compliant, max_number_of_instance=max_number_of_instance
+        )
+
     @classmethod
     def from_rdf_file(cls, filepath: Path, make_compliant: bool = False, max_number_of_instance: int = -1):
         issue_list = IssueList(title=f"'{filepath.name}'")
@@ -106,7 +118,7 @@ class InferenceImporter(BaseImporter):
             return self._return_or_raise(self.issue_list, errors)
 
         if self.make_compliant and rules:
-            rules = self._make_dms_compliant_rules(rules)
+            self._make_dms_compliant_rules(rules)
 
         return self._to_output(
             rules,
@@ -172,7 +184,7 @@ class InferenceImporter(BaseImporter):
                     definition = {
                         "class_": class_id,
                         "property_": property_id,
-                        "max_occurrence": cast(RdfLiteral, occurrence).value,
+                        "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
                         "reference": property_uri,
                     }
@@ -180,7 +192,6 @@ class InferenceImporter(BaseImporter):
                     # USE CASE 1: If property is not present in properties
                     if id_ not in properties:
                         properties[id_] = definition
-
                     # USE CASE 2: If property is present in properties but with different max count
                     elif id_ in properties and not (properties[id_]["max_count"] == definition["max_count"]):
                         properties[id_]["max_count"] = max(properties[id_]["max_count"], definition["max_count"])
@@ -217,5 +228,36 @@ class InferenceImporter(BaseImporter):
         )
 
     @classmethod
-    def _make_dms_compliant_rules(cls, rules: InformationRules) -> InformationRules:
-        raise NotImplementedError("Compliance with DMS is not supported yet.")
+    def _make_dms_compliant_rules(cls, rules: InformationRules) -> None:
+        cls._fix_property_redefinition(rules)
+        cls._fix_naming_of_entities(rules)
+
+    @classmethod
+    def _fix_property_redefinition(cls, rules: InformationRules) -> None:
+        seen = set()
+        for i, property_ in enumerate(rules.properties.data):
+            prop_id = f"{property_.class_}.{property_.property_}"
+            if prop_id in seen:
+                property_.property_ = f"{property_.property_}_{i+1}"
+                seen.add(f"{property_.class_}.{property_.property_}")
+            else:
+                seen.add(prop_id)
+
+    @classmethod
+    def _fix_naming_of_entities(cls, rules: InformationRules) -> None:
+        # Fixing class ids
+        for class_ in rules.classes:
+            class_.class_ = class_.class_.as_dms_compliant_entity()
+            class_.parent = [parent.as_dms_compliant_entity() for parent in class_.parent] if class_.parent else None
+
+        # Fixing property definitions
+        for property_ in rules.properties:
+            # fix class id
+            property_.class_ = property_.class_.as_dms_compliant_entity()
+
+            # fix property id
+            property_.property_ = replace_non_alphanumeric_with_underscore(property_.property_)
+
+            # fix value type
+            if isinstance(property_.value_type, ClassEntity):
+                property_.value_type = property_.value_type.as_dms_compliant_entity()

{cognite_neat-0.77.10 → cognite_neat-0.78.1}/cognite/neat/rules/models/entities.py

@@ -7,6 +7,8 @@ from typing import Annotated, Any, ClassVar, Generic, TypeVar, cast
 from cognite.client.data_classes.data_modeling.ids import ContainerId, DataModelId, NodeId, PropertyId, ViewId
 from pydantic import AnyHttpUrl, BaseModel, BeforeValidator, Field, PlainSerializer, model_serializer, model_validator
 
+from cognite.neat.utils.utils import replace_non_alphanumeric_with_underscore
+
 if sys.version_info >= (3, 11):
     from enum import StrEnum
     from typing import Self
@@ -211,6 +213,11 @@ class Entity(BaseModel, extra="ignore"):
             return f"{self.suffix!s}"
         return f"{self.prefix}:{self.suffix!s}"
 
+    def as_dms_compliant_entity(self) -> "Self":
+        new_entity = self.model_copy(deep=True)
+        new_entity.suffix = replace_non_alphanumeric_with_underscore(new_entity.suffix)
+        return new_entity
+
 
 T_Entity = TypeVar("T_Entity", bound=Entity)
 
@@ -231,6 +238,11 @@ class ClassEntity(Entity):
         space = default_space if isinstance(self.prefix, _UndefinedType) else self.prefix
         return ContainerEntity(space=space, externalId=str(self.suffix))
 
+    def as_dms_compliant_entity(self) -> "Self":
+        new_entity = self.model_copy(deep=True)
+        new_entity.suffix = replace_non_alphanumeric_with_underscore(new_entity.suffix)
+        return new_entity
+
 
 class ParentClassEntity(ClassEntity):
     type_: ClassVar[EntityTypes] = EntityTypes.parent_class

{cognite_neat-0.77.10 → cognite_neat-0.78.1}/cognite/neat/utils/utils.py

@@ -1,5 +1,6 @@
 import hashlib
 import logging
+import re
 import sys
 import time
 from collections import OrderedDict
@@ -350,3 +351,7 @@ def get_inheritance_path(child: Any, child_parent: dict[Any, list[Any]]) -> list
         for parent in child_parent[child]:
             path.extend(get_inheritance_path(parent, child_parent))
     return path
+
+
+def replace_non_alphanumeric_with_underscore(text):
+    return re.sub(r"\W+", "_", text)

{cognite_neat-0.77.10 → cognite_neat-0.78.1}/cognite/neat/workflows/steps/lib/current/rules_importer.py

@@ -20,6 +20,7 @@ __all__ = [
     "ExcelToRules",
     "OntologyToRules",
     "DMSToRules",
+    "RulesInferenceFromRdfFile",
 ]
 
 
@@ -259,3 +260,97 @@ class DMSToRules(Step):
         output_text = "Rules import and validation passed successfully!"
 
         return FlowMessage(output_text=output_text), MultiRuleData.from_rules(rules)
+
+
+class RulesInferenceFromRdfFile(Step):
+    """This step infers rules from the RDF file which contains knowledge graph."""
+
+    description = "This step infers rules from the RDF file which contains knowledge graph"
+    version = "private-beta"
+    category = CATEGORY
+    configurables: ClassVar[list[Configurable]] = [
+        Configurable(
+            name="File path",
+            value="staging/knowledge_graph.ttl",
+            label=("Relative path to the RDF file to be used for inference"),
+        ),
+        Configurable(
+            name="Report formatter",
+            value=next(iter(FORMATTER_BY_NAME.keys())),
+            label="The format of the report for the validation of the rules",
+            options=list(FORMATTER_BY_NAME),
+        ),
+        Configurable(
+            name="Role",
+            value="infer",
+            label="For what role Rules are intended?",
+            options=["infer", *RoleTypes.__members__.keys()],
+        ),
+        Configurable(
+            name="Make compliant",
+            value="True",
+            label=(
+                "Attempt to make the imported Rules compliant, by fixing "
+                "redefinition of properties and by making ids of entities compliant with"
+                " CDF-allowed set of characters ."
+            ),
+            options=["True", "False"],
+        ),
+        Configurable(
+            name="Maximum number of instances to process",
+            value="-1",
+            label=(
+                "Maximum number of instances to process"
+                " to infer rules from the RDF file. Default -1 means all instances."
+            ),
+        ),
+    ]
+
+    def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
+        if self.configs is None or self.data_store_path is None:
+            raise StepNotInitialized(type(self).__name__)
+
+        file_path = self.configs.get("File path", None)
+        full_path = flow_message.payload.get("full_path", None) if flow_message.payload else None
+        make_compliant = self.configs.get("Make compliant", "True") == "True"
+
+        try:
+            max_number_of_instance = int(self.configs.get("Maximum number of instances to process", -1))
+        except ValueError:
+            error_text = "Maximum number of instances to process should be an integer value"
+            return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
+
+        if file_path:
+            rdf_file_path = self.data_store_path / Path(file_path)
+        elif full_path:
+            rdf_file_path = full_path
+        else:
+            error_text = "Expected either 'File name' in the step config or 'File uploader' step uploading Excel Rules."
+            return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
+
+        # if role is None, it will be inferred from the rules file
+        role = self.configs.get("Role")
+        role_enum = None
+        if role != "infer" and role is not None:
+            role_enum = RoleTypes[role]
+
+        inference_importer = importers.InferenceImporter.from_rdf_file(
+            rdf_file_path, make_compliant=make_compliant, max_number_of_instance=max_number_of_instance
+        )
+        rules, issues = inference_importer.to_rules(errors="continue", role=role_enum)
+
+        if rules is None:
+            output_dir = self.config.staging_path
+            report_writer = FORMATTER_BY_NAME[self.configs["Report formatter"]]()
+            report_writer.write_to_file(issues, file_or_dir_path=output_dir)
+            report_file = report_writer.default_file_name
+            error_text = (
+                "<p></p>"
+                f'<a href="/data/staging/{report_file}?{time.time()}" '
+                f'target="_blank">Failed to validate rules, click here for report</a>'
+            )
+            return FlowMessage(error_text=error_text, step_execution_status=StepExecutionStatus.ABORT_AND_FAIL)
+
+        output_text = "Rules validation passed successfully!"
+
+        return FlowMessage(output_text=output_text), MultiRuleData.from_rules(rules)

{cognite_neat-0.77.10 → cognite_neat-0.78.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.77.10"
+version = "0.78.1"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [

cognite_neat-0.77.10/cognite/neat/_version.py

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