cognite-neat 0.78.0__tar.gz → 0.78.2__tar.gz

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/PKG-INFO

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

cognite_neat-0.78.2/cognite/neat/_version.py

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

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/cognite/neat/rules/importers/_inference2rules.py

@@ -7,6 +7,7 @@ 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
@@ -42,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}'")

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/cognite/neat/rules/importers/_owl2rules/_owl2classes.py

@@ -8,19 +8,17 @@ from cognite.neat.rules.models._base import MatchType
 from cognite.neat.utils.utils import remove_namespace
 
 
-def parse_owl_classes(graph: Graph, make_compliant: bool = False, language: str = "en") -> list[dict]:
+def parse_owl_classes(graph: Graph, language: str = "en") -> list[dict]:
     """Parse owl classes from graph to pandas dataframe.
 
     Args:
         graph: Graph containing owl classes
-        make_compliant: Flag for generating compliant classes, by default False
         language: Language to use for parsing, by default "en"
 
     Returns:
         Dataframe containing owl classes
 
-    !!! note "make_compliant"
-        If `make_compliant` is set to True, in presence of errors, default values will be used instead.
+    !!! note "Compliant OWL classes"
         This makes the method very opinionated, but results in a compliant classes.
     """
 
@@ -48,8 +46,7 @@ def parse_owl_classes(graph: Graph, make_compliant: bool = False, language: str
     processed_df = _clean_up_classes(raw_df)
 
     # make compliant
-    if make_compliant:
-        processed_df = make_classes_compliant(processed_df)
+    processed_df = make_classes_compliant(processed_df)
 
     # Make Parent Class list elements into string joined with comma
     processed_df["Parent Class"] = processed_df["Parent Class"].apply(

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/cognite/neat/rules/importers/_owl2rules/_owl2metadata.py

@@ -12,18 +12,16 @@ from cognite.neat.rules.models._types._base import (
 from cognite.neat.utils.utils import convert_rdflib_content, remove_none_elements_from_set
 
 
-def parse_owl_metadata(graph: Graph, make_compliant: bool = False) -> dict:
+def parse_owl_metadata(graph: Graph) -> dict:
     """Parse owl metadata from graph to dict.
 
     Args:
         graph: Graph containing owl metadata
-        make_compliant: Flag for generating compliant metadata, by default False
 
     Returns:
         Dictionary containing owl metadata
 
-    !!! note "make_compliant"
-        If `make_compliant` is set to True, in presence of errors, default values will be used instead.
+    !!! note "Compliant OWL metadata"
         This makes the method very opinionated, but results in a compliant metadata.
 
 
@@ -72,10 +70,7 @@ def parse_owl_metadata(graph: Graph, make_compliant: bool = False) -> dict:
         }
     )
 
-    if make_compliant:
-        return make_metadata_compliant(raw_metadata)
-
-    return raw_metadata
+    return make_metadata_compliant(raw_metadata)
 
 
 def make_metadata_compliant(metadata: dict) -> dict:

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/cognite/neat/rules/importers/_owl2rules/_owl2properties.py

@@ -10,12 +10,11 @@ from cognite.neat.utils.utils import remove_namespace
 from ._owl2classes import _data_type_property_class, _object_property_class, _thing_class
 
 
-def parse_owl_properties(graph: Graph, make_compliant: bool = False, language: str = "en") -> list[dict]:
+def parse_owl_properties(graph: Graph, language: str = "en") -> list[dict]:
     """Parse owl properties from graph to pandas dataframe.
 
     Args:
         graph: Graph containing owl properties
-        make_compliant: Flag for generating compliant properties, by default False
         language: Language to use for parsing, by default "en"
 
     Returns:
@@ -53,8 +52,7 @@ def parse_owl_properties(graph: Graph, make_compliant: bool = False, language: s
     processed_df = _clean_up_properties(raw_df)
 
     # make compliant
-    if make_compliant:
-        processed_df = make_properties_compliant(processed_df)
+    processed_df = make_properties_compliant(processed_df)
 
     # drop column _property_type, which was a helper column:
     processed_df.drop(columns=["_property_type"], inplace=True)

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/cognite/neat/rules/importers/_owl2rules/_owl2rules.py

@@ -21,25 +21,21 @@ class OWLImporter(BaseImporter):
 
         Args:
             filepath: Path to OWL ontology
-            make_compliant: If True, NEAT will attempt to make the imported rules compliant with CDF
 
     !!! Note
-        OWL Ontologies typically lacks some information that is required for making a complete
-        data model. This means that the methods .to_rules() will typically fail. Instead, it is recommended
-        that you use the .to_spreadsheet() method to generate an Excel file, and then manually add the missing
-        information to the Excel file. The Excel file can then be converted to a `Rules` object.
+        OWL Ontologies are information models which completeness varies. As such, constructing functional
+        data model directly will often be impossible, therefore the produced Rules object will be ill formed.
+        To avoid this, neat will automatically attempt to make the imported rules compliant by adding default
+        values for missing information, attaching dangling properties to default containers based on the
+        property type, etc.
 
-        Alternatively, one can set the `make_compliant` parameter to True to allow neat to attempt to make
-        the imported rules compliant by adding default values for missing information, attaching dangling
-        properties to default containers based on the property type, etc. One has to be aware
-        that NEAT will be opinionated about how to make the ontology compliant, and that the resulting
-        rules may not be what you expect.
+        One has to be aware that NEAT will be opinionated about how to make the ontology
+        compliant, and that the resulting rules may not be what you expect.
 
     """
 
-    def __init__(self, filepath: Path, make_compliant: bool = False):
+    def __init__(self, filepath: Path):
         self.owl_filepath = filepath
-        self.make_compliant = make_compliant
 
     @overload
     def to_rules(self, errors: Literal["raise"], role: RoleTypes | None = None) -> Rules: ...
@@ -67,13 +63,12 @@ class OWLImporter(BaseImporter):
         graph.bind("skos", SKOS)
 
         components = {
-            "Metadata": parse_owl_metadata(graph, make_compliant=self.make_compliant),
-            "Classes": parse_owl_classes(graph, make_compliant=self.make_compliant),
-            "Properties": parse_owl_properties(graph, make_compliant=self.make_compliant),
+            "Metadata": parse_owl_metadata(graph),
+            "Classes": parse_owl_classes(graph),
+            "Properties": parse_owl_properties(graph),
         }
 
-        if self.make_compliant:
-            components = make_components_compliant(components)
+        components = make_components_compliant(components)
 
         rules = InformationRules.model_validate(components)
         return self._to_output(rules, IssueList(), errors, role)

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/cognite/neat/rules/models/entities.py

@@ -213,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)
 

{cognite_neat-0.78.0 → cognite_neat-0.78.2}/cognite/neat/workflows/steps/lib/current/rules_importer.py

@@ -20,6 +20,7 @@ __all__ = [
     "ExcelToRules",
     "OntologyToRules",
     "DMSToRules",
+    "RulesInferenceFromRdfFile",
 ]
 
 
@@ -118,15 +119,6 @@ class OntologyToRules(Step):
             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 converting "
-                "the information model provided in the ontology to data model."
-            ),
-            options=["True", "False"],
-        ),
     ]
 
     def run(self, flow_message: FlowMessage) -> (FlowMessage, MultiRuleData):  # type: ignore[syntax, override]
@@ -135,7 +127,6 @@ class OntologyToRules(Step):
 
         file_name = self.configs.get("File name", 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"
 
         if file_name:
             rules_file_path = self.config.rules_store_path / file_name
@@ -151,7 +142,7 @@ class OntologyToRules(Step):
         if role != "infer" and role is not None:
             role_enum = RoleTypes[role]
 
-        ontology_importer = importers.OWLImporter(filepath=rules_file_path, make_compliant=make_compliant)
+        ontology_importer = importers.OWLImporter(filepath=rules_file_path)
         rules, issues = ontology_importer.to_rules(errors="continue", role=role_enum)
 
         if rules is None:
@@ -259,3 +250,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.78.0 → cognite_neat-0.78.2}/pyproject.toml

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

cognite_neat-0.78.0/cognite/neat/_version.py

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