cognite-neat 0.81.11__py3-none-any.whl → 0.82.0__py3-none-any.whl

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.81.11"
+__version__ = "0.82.0"

cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -2,7 +2,6 @@
 It is a bit ugly and needs some proper refactoring, but it is not a priority at the moment.
 """
 
-import logging
 import random
 import warnings
 from collections import OrderedDict
@@ -87,11 +86,11 @@ def generate_triples(
     stop_on_exception: bool = False,
     allow_isolated_classes: bool = True,
 ) -> list[Triple]:
-    """Generate mock triples based on data model defined transformation rules and desired number
+    """Generate mock triples based on data model defined in rules and desired number
     of class instances
 
     Args:
-        transformation_rules : Transformation rules defining the data model
+        rules : Rules defining the data model
         class_count: Target class count for each class in the ontology
         stop_on_exception: To stop if exception is encountered or not, default is False
         allow_isolated_classes: To allow generation of instances for classes that are not
@@ -107,11 +106,9 @@ def generate_triples(
     if non_existing_classes := set(class_count.keys()) - defined_classes:
         msg = f"Class count contains classes {non_existing_classes} for which properties are not defined in Data Model!"
         if stop_on_exception:
-            logging.error(msg)
             raise ValueError(msg)
         else:
             msg += " These classes will be ignored."
-            logging.warning(msg)
             warnings.warn(msg, stacklevel=2)
             for class_ in non_existing_classes:
                 class_count.pop(class_)
@@ -279,14 +276,12 @@ def _generate_mock_object_property_triples(
     if property_definition.value_type not in instance_ids:
         msg = f"Class {property_definition.value_type} not found in class count! "
         if stop_on_exception:
-            logging.error(msg)
             raise ValueError(msg)
         else:
             msg += (
                 f"Skipping creating triples for property {property_definition.name} "
                 f"of class {class_.suffix} which expects values of this type!"
             )
-            logging.warning(msg)
             warnings.warn(msg, stacklevel=2)
             return []
 
@@ -354,7 +349,6 @@ def _generate_triples_per_class(
             )
 
         else:
-            logging.error(f"Property type {property_.value_type} not supported!")
             raise ValueError(f"Property type {property_.value_type} not supported!")
 
     return triples

cognite/neat/graph/loaders/_rdf2dms.py

@@ -93,7 +93,7 @@ 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.queries.triples_of_type_instances(class_name)
+            triples = self.graph_store.read(class_name)
             for identifier, properties in _triples2dictionary(triples).items():
                 try:
                     yield self._create_node(identifier, properties, pydantic_cls, view_id)

cognite/neat/graph/queries/__init__.py

@@ -0,0 +1,3 @@
+from ._base import Queries
+
+__all__ = ["Queries"]

cognite/neat/graph/queries/_base.py

@@ -0,0 +1,99 @@
+import warnings
+from typing import cast
+
+from rdflib import RDF, Graph, URIRef
+from rdflib.query import ResultRow
+
+from cognite.neat.rules.models.entities import ClassEntity
+from cognite.neat.rules.models.information import InformationRules
+from cognite.neat.utils.utils import remove_namespace
+
+from ._construct import build_construct_query
+
+
+class Queries:
+    """Helper class for storing standard queries for the graph store."""
+
+    def __init__(self, graph: Graph, rules: InformationRules | None = None):
+        self.graph = graph
+        self.rules = rules
+
+    def list_instances_ids_of_class(self, class_uri: URIRef, limit: int = -1) -> list[URIRef]:
+        """Get instances ids for a given class
+
+        Args:
+            class_uri: Class for which instances are to be found
+            limit: Max number of instances to return, by default -1 meaning all instances
+
+        Returns:
+            List of class instance URIs
+        """
+        query_statement = "SELECT DISTINCT ?subject WHERE { ?subject a <class> .} LIMIT X".replace(
+            "class", class_uri
+        ).replace("LIMIT X", "" if limit == -1 else f"LIMIT {limit}")
+        return [cast(tuple, res)[0] for res in list(self.graph.query(query_statement))]
+
+    def list_instances_of_type(self, class_uri: URIRef) -> list[ResultRow]:
+        """Get all triples for instances of a given class
+
+        Args:
+            class_uri: Class for which instances are to be found
+
+        Returns:
+            List of triples for instances of the given class
+        """
+        query = (
+            f"SELECT ?instance ?prop ?value "
+            f"WHERE {{ ?instance rdf:type <{class_uri}> . ?instance ?prop ?value . }} order by ?instance "
+        )
+
+        # Select queries gives an iterable of result rows
+        return cast(list[ResultRow], list(self.graph.query(query)))
+
+    def triples_of_type_instances(self, rdf_type: str) -> list[tuple[str, str, str]]:
+        """Get all triples of a given type.
+
+        This method assumes the graph has been transformed into the default namespace.
+        """
+
+        if self.rules:
+            query = (
+                f"SELECT ?instance ?prop ?value "
+                f"WHERE {{ ?instance a <{self.rules.metadata.namespace[rdf_type]}> . ?instance ?prop ?value . }} "
+                "order by ?instance"
+            )
+
+            result = self.graph.query(query)
+
+            # We cannot include the RDF.type in case there is a neat:type property
+            return [remove_namespace(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
+        else:
+            warnings.warn("No rules found for the graph store, returning empty list.", stacklevel=2)
+            return []
+
+    def construct_instances_of_class(self, class_: str, properties_optional: bool = True) -> 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
+
+        Returns:
+            List of triples for instances of the given class
+        """
+
+        if self.rules and (
+            query := build_construct_query(
+                ClassEntity(prefix=self.rules.metadata.prefix, suffix=class_),
+                self.graph,
+                self.rules,
+                properties_optional,
+            )
+        ):
+            result = self.graph.query(query)
+
+            # We cannot include the RDF.type in case there is a neat:type property
+            return [remove_namespace(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
+        else:
+            warnings.warn("No rules found for the graph store, returning empty list.", stacklevel=2)
+            return []

cognite/neat/graph/queries/_construct.py

@@ -0,0 +1,185 @@
+import re
+from typing import cast
+
+from rdflib import Graph, URIRef
+
+from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.models._rdfpath import (
+    AllReferences,
+    Hop,
+    RDFPath,
+    SingleProperty,
+    Traversal,
+)
+from cognite.neat.rules.models.entities import ClassEntity
+from cognite.neat.rules.models.information import InformationProperty, InformationRules
+from cognite.neat.utils.utils import most_occurring_element
+
+from ._shared import Triple, hop2property_path
+
+_QUERY_TEMPLATE = """CONSTRUCT {{ {graph_template} }}
+                     WHERE {{     {graph_pattern}
+                                  {filter}
+                     }}"""
+
+
+def build_construct_query(
+    class_: ClassEntity,
+    graph: Graph,
+    rules: InformationRules,
+    properties_optional: bool = True,
+    class_instances: list[URIRef] | None = None,
+) -> str | None:
+    """Builds a CONSTRUCT query for a given class and rules and optionally filters by class instances.
+
+    Args:
+        class_ : The class entity for which the query is generated.
+        graph : The graph containing instances of classes.
+        rules : The information rules to use for query generation.
+        properties_optional : Whether to make all properties optional. Defaults to True.
+        class_instances : List of class instances to filter by. Defaults to None (no filter, return all instances).
+
+    Returns:
+        str: CONSTRUCT query.
+
+    !!! note "On CONSTRUCT Query"
+        CONSTRUCT query is composed of two parts: graph template and graph pattern.
+        Graph template is used the shape of instance acquired using graph pattern.
+        This allows us to create a new graph with the new shape without actually modifying
+        the original graph, or creating new instances.
+
+        The CONSTRUCT query is far less forgiving than the SELECT query. It will not return
+        anything if one of the properties that define the "shape" of the class instance is missing.
+        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)
+        .get(class_, None)
+    ):
+        templates, patterns = to_construct_triples(
+            graph, list(transformations.values()), rules.prefixes, properties_optional
+        )
+
+        return _QUERY_TEMPLATE.format(
+            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
+) -> tuple[list[Triple], list[Triple]]:
+    """Converts transformations of a class to CONSTRUCT triples which are used to generate CONSTRUCT query
+
+    Args:
+        graph: Graph containing instances of classes (used for property inference for hops)
+        transformations : List of transformations to use to form triples
+        prefixes : Dictionary of prefixes for namespaces
+        properties_optional : Flag indicating if properties should be optional. Defaults to True.
+
+    Returns:
+        tuple: Tuple of triples that define graph template and graph pattern parts of CONSTRUCT query
+
+
+    !!! note "Purely inherited transformations"
+        Assumption that neat makes is that in case of purely inherited transformations
+        we will type instance with class to which transformation belongs to.
+
+        Otherwise we will type instance with class that is most occurring in non-inherited
+        transformations.
+
+    """
+    # TODO: Add handling of UNIONs in rules
+
+    templates = []
+    patterns = []
+    non_inherited_starting_rdf_types = []
+
+    for transformation in transformations:
+        traversal = cast(RDFPath, transformation.transformation).traversal
+
+        # keeping track of starting rdf types of non-inherited transformations/properties
+        if isinstance(traversal, Traversal) and not transformation.inherited:
+            non_inherited_starting_rdf_types.append(traversal.class_.id)
+
+        graph_template_triple = Triple(
+            subject="?instance",
+            predicate=f"{transformation.class_.prefix}:{transformation.property_}",
+            object=f'?{re.sub(r"[^_a-zA-Z0-9/_]", "_", str(transformation.property_).lower())}',
+            optional=False,
+        )
+        templates.append(graph_template_triple)
+
+        # 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
+            )
+
+        # use case SingleProperty: simple property traversal
+        elif isinstance(traversal, SingleProperty):
+            graph_pattern_triple = Triple(
+                subject=graph_template_triple.subject,
+                predicate=traversal.property.id,
+                object=graph_template_triple.object,
+                optional=True if properties_optional else not transformation.is_mandatory,
+            )
+
+        # use case Hop: property traversal with multiple hops turned into property path
+        # see: https://www.oxfordsemantic.tech/faqs/what-is-a-property-path
+        elif isinstance(traversal, Hop):
+            graph_pattern_triple = Triple(
+                subject="?instance",
+                predicate=hop2property_path(graph, traversal, prefixes),
+                object=graph_template_triple.object,
+                optional=True if properties_optional else not transformation.is_mandatory,
+            )
+
+        # other type of rdfpaths are skipped
+        else:
+            continue
+
+        patterns.append(graph_pattern_triple)
+
+    # Add first triple for graph pattern stating type of object
+    # we use most occurring here to pull out most occurring rdf type of the starting
+    # node of the transformation, or the class itself to which the transformation is
+    # defined for.
+    # This is safeguard in case there are multiple classes in the graph pattern
+    patterns.insert(
+        0,
+        Triple(
+            subject="?instance",
+            predicate="a",
+            object=(
+                most_occurring_element(non_inherited_starting_rdf_types)
+                if non_inherited_starting_rdf_types
+                else str(transformation.class_)
+            ),
+            optional=False,
+        ),
+    )
+
+    return templates, patterns
+
+
+def triples2sparql_statement(triples: list[Triple]):
+    return [
+        (
+            f"OPTIONAL {{ {triple.subject} {triple.predicate} {triple.object} . }}"
+            if triple.optional
+            else f"{triple.subject} {triple.predicate} {triple.object} ."
+        )
+        for triple in triples
+    ]

cognite/neat/graph/queries/_shared.py

@@ -0,0 +1,159 @@
+import sys
+from collections.abc import Iterable
+from typing import ClassVar, cast
+
+from pydantic import BaseModel, ConfigDict, Field
+from rdflib import Graph, Literal, Namespace
+from rdflib.term import URIRef
+
+from cognite.neat.constants import PREFIXES
+from cognite.neat.rules.models._rdfpath import (
+    Hop,
+    Step,
+)
+from cognite.neat.utils.utils import remove_namespace, uri_to_short_form
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class Triple(BaseModel):
+    model_config: ClassVar[ConfigDict] = ConfigDict(
+        populate_by_name=True, arbitrary_types_allowed=True, strict=False, extra="allow"
+    )
+
+    subject: str | URIRef
+    predicate: str | URIRef
+    object: str | URIRef | Literal | None = None
+    optional: bool = Field(
+        description="Indicates whether a triple is optional, used when building SPARQL query",
+        default=False,
+    )
+
+    @classmethod
+    def from_rdflib_triple(cls, triple: tuple[URIRef, URIRef, URIRef | Literal]) -> Self:
+        return cls(subject=triple[0], predicate=triple[1], object=triple[2])
+
+
+def generate_prefix_header(prefixes: dict[str, Namespace] = PREFIXES) -> str:
+    """Generate prefix header which is added to SPARQL query and allows for shorten query statements
+
+    Parameters
+    ----------
+    prefixes : dict
+        Dict containing prefix - namespace pairs, default PREFIXES
+
+    Returns
+    -------
+    str
+        Prefix header
+    """
+    return "".join(f"PREFIX {key}:<{value}>\n" for key, value in prefixes.items())
+
+
+def get_predicate_id(
+    graph: Graph, subject_type_id: str, object_type_id: str, prefixes: dict[str, Namespace] = PREFIXES
+) -> URIRef:
+    """Returns predicate (aka property) URI (i.e., ID) that connects subject and object
+
+    Parameters
+    ----------
+    graph : Graph
+        Data model graph or data model instance (aka knowledge graph)
+    subject_type_id : str
+        ID of subject type (aka subject class)
+    object_type_id : str
+        ID of object type (aka object class)
+    prefixes : dict, optional
+        Dict containing prefix - namespace pairs, default PREFIXES
+
+    Returns
+    -------
+    URIRef
+        ID of predicate (aka property) connecting subject and object
+    """
+    query = """
+
+        SELECT ?predicateTypeID
+        WHERE {
+            ?subjectInstanceID a subjectTypeID .
+            ?objectInstanceID a objectTypeID .
+            ?subjectInstanceID ?predicateTypeID ?objectInstanceID .
+        } LIMIT 1"""
+
+    query = query.replace("insertPrefixes", generate_prefix_header(prefixes))
+    final_query = query.replace("subjectTypeID", subject_type_id).replace("objectTypeID", object_type_id)
+    res = list(cast(tuple, graph.query(final_query)))
+
+    if len(res) != 1:
+        raise ValueError("Subject and Object must have exactly 1 relation!")
+
+    return res[0][0]
+
+
+def hop2property_path(graph: Graph, hop: Hop, prefixes: dict[str, Namespace]) -> str:
+    """Converts hop to property path string
+
+    Parameters
+    ----------
+    graph : Graph
+        Graph containing instances of classes
+    hop : Hop
+        Hop to convert
+    prefixes : dict[str, Namespace]
+        Dictionary of prefixes to use for compression and predicate querying
+
+    Returns
+    -------
+    str
+        Property path string for hop traversal (e.g. ^rdf:type/rdfs:subClassOf)
+    """
+
+    # setting previous step to origin, as we are starting from there
+    previous_step = Step(class_=hop.class_, direction="origin")
+
+    # add triples for all steps until destination
+    property_path = ""
+    for current_step in hop.traversal:
+        sub_entity, obj_entity = (
+            (current_step, previous_step) if current_step.direction == "source" else (previous_step, current_step)
+        )
+
+        predicate_raw = get_predicate_id(graph, sub_entity.class_.id, obj_entity.class_.id, prefixes)
+
+        predicate = uri_to_short_form(predicate_raw, prefixes)
+
+        predicate = f"^{predicate}" if current_step.direction == "source" else predicate
+        property_path += f"{predicate}/"
+
+        previous_step = current_step
+
+    if previous_step.property:
+        return property_path + previous_step.property.id
+    else:
+        # removing "/" at the end of property path if there is no property at the end
+        return property_path[:-1]
+
+
+def triples2dictionary(triples: Iterable[tuple[URIRef, URIRef, str | URIRef]]) -> dict[URIRef, dict[str, list[str]]]:
+    """Converts list of triples to dictionary"""
+    dictionary: dict[URIRef, dict[str, list[str]]] = {}
+    for triple in triples:
+        id_: str
+        property_: str
+        value: str
+        uri: URIRef
+
+        id_, property_, value = remove_namespace(*triple)  # type: ignore[misc]
+        uri = triple[0]
+
+        if uri not in dictionary:
+            dictionary[uri] = {"external_id": [id_]}
+
+        if property_ not in dictionary[uri]:
+            dictionary[uri][property_] = [value]
+        else:
+            dictionary[uri][property_].append(value)
+    return dictionary

cognite/neat/graph/stores/_base.py

@@ -5,17 +5,17 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import cast
 
-from rdflib import RDF, Graph, Namespace, URIRef
+from rdflib import Graph, Namespace, URIRef
 from rdflib.plugins.stores.sparqlstore import SPARQLUpdateStore
-from rdflib.query import ResultRow
 
 from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.graph._shared import MIMETypes
 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.models.entities import ClassEntity
 from cognite.neat.rules.models.information import InformationRules
-from cognite.neat.utils import remove_namespace
 from cognite.neat.utils.auxiliary import local_import
 
 from ._provenance import Change, Provenance
@@ -42,6 +42,8 @@ class NeatGraphStore:
         graph: Graph,
         rules: InformationRules | None = None,
     ):
+        self.rules: InformationRules | None = None
+
         _start = datetime.now(timezone.utc)
         self.graph = graph
         self.provenance = Provenance(
@@ -54,15 +56,32 @@ class NeatGraphStore:
                 )
             ]
         )
-        self.rules = rules
 
-        if self.rules and self.rules.prefixes:
-            self._upsert_prefixes(self.rules.prefixes)
-            self.base_namespace = self.rules.metadata.namespace
+        if rules:
+            self.add_rules(rules)
         else:
             self.base_namespace = DEFAULT_NAMESPACE
 
-        self.queries = _Queries(self)
+        self.queries = Queries(self.graph, self.rules)
+
+    def add_rules(self, rules: InformationRules) -> None:
+        """This method is used to add rules to the graph store and it is the only correct
+        way to add rules to the graph store, after the graph store has been initialized."""
+
+        self.rules = rules
+        self.base_namespace = self.rules.metadata.namespace
+        self.queries = Queries(self.graph, self.rules)
+        self.provenance.append(
+            Change.record(
+                activity=f"{type(self)}.rules",
+                start=datetime.now(timezone.utc),
+                end=datetime.now(timezone.utc),
+                description=f"Added rules to graph store as {type(self.rules).__name__}",
+            )
+        )
+
+        if self.rules.prefixes:
+            self._upsert_prefixes(self.rules.prefixes)
 
     def _upsert_prefixes(self, prefixes: dict[str, Namespace]) -> None:
         """Adds prefixes to the graph store."""
@@ -144,6 +163,23 @@ class NeatGraphStore:
             )
         )
 
+    def read(self, class_: str) -> list[tuple[str, str, 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 []
+
+        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 self.queries.construct_instances_of_class(class_)
+
     def _parse_file(
         self,
         filepath: Path,
@@ -242,63 +278,3 @@ class NeatGraphStore:
                     description=transformer.description,
                 )
             )
-
-
-class _Queries:
-    """Helper class for storing standard queries for the graph store."""
-
-    def __init__(self, store: NeatGraphStore):
-        self.store = store
-
-    def list_instances_ids_of_class(self, class_uri: URIRef, limit: int = -1) -> list[URIRef]:
-        """Get instances ids for a given class
-
-        Args:
-            class_uri: Class for which instances are to be found
-            limit: Max number of instances to return, by default -1 meaning all instances
-
-        Returns:
-            List of class instance URIs
-        """
-        query_statement = "SELECT DISTINCT ?subject WHERE { ?subject a <class> .} LIMIT X".replace(
-            "class", class_uri
-        ).replace("LIMIT X", "" if limit == -1 else f"LIMIT {limit}")
-        return [cast(tuple, res)[0] for res in list(self.store.graph.query(query_statement))]
-
-    def list_instances_of_type(self, class_uri: URIRef) -> list[ResultRow]:
-        """Get all triples for instances of a given class
-
-        Args:
-            class_uri: Class for which instances are to be found
-
-        Returns:
-            List of triples for instances of the given class
-        """
-        query = (
-            f"SELECT ?instance ?prop ?value "
-            f"WHERE {{ ?instance rdf:type <{class_uri}> . ?instance ?prop ?value . }} order by ?instance "
-        )
-
-        # Select queries gives an iterable of result rows
-        return cast(list[ResultRow], list(self.store.graph.query(query)))
-
-    def triples_of_type_instances(self, rdf_type: str) -> list[tuple[str, str, str]]:
-        """Get all triples of a given type.
-
-        This method assumes the graph has been transformed into the default namespace.
-        """
-
-        if self.store.rules:
-            query = (
-                f"SELECT ?instance ?prop ?value "
-                f"WHERE {{ ?instance a <{self.store.rules.metadata.namespace[rdf_type]}> . ?instance ?prop ?value . }} "
-                "order by ?instance"
-            )
-
-            result = self.store.graph.query(query)
-
-            # We cannot include the RDF.type in case there is a neat:type property
-            return [remove_namespace(*triple) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index]
-        else:
-            warnings.warn("No rules found for the graph store, returning empty list.", stacklevel=2)
-            return []

cognite/neat/rules/analysis/_information_rules.py

@@ -2,13 +2,13 @@ import itertools
 import logging
 import warnings
 from collections import defaultdict
-from typing import Any, cast
+from typing import Any
 
 import pandas as pd
 from pydantic import ValidationError
 
 from cognite.neat.rules.models import SchemaCompleteness
-from cognite.neat.rules.models._rdfpath import TransformationRuleType
+from cognite.neat.rules.models._rdfpath import RDFPath
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes, ParentClassEntity, ReferenceEntity
 from cognite.neat.rules.models.information import InformationClass, InformationProperty, InformationRules
 from cognite.neat.utils.utils import get_inheritance_path
@@ -17,24 +17,11 @@ from ._base import BaseAnalysis
 
 
 class InformationArchitectRulesAnalysis(BaseAnalysis):
+    """Assumes analysis over only the complete schema"""
+
     def __init__(self, rules: InformationRules):
         self.rules = rules
 
-    @property
-    def referred_classes(self) -> set[ClassEntity]:
-        return self.directly_referred_classes.union(self.inherited_referred_classes)
-
-    @property
-    def referred_classes_properties(self) -> list[InformationProperty]:
-        referred_classes_properties = []
-        class_properties_dict = self.classes_with_properties(use_reference=True)
-
-        for class_ in self.referred_classes:
-            if class_ in class_properties_dict:
-                referred_classes_properties.extend(class_properties_dict[class_])
-
-        return referred_classes_properties
-
     @property
     def directly_referred_classes(self) -> set[ClassEntity]:
         return {
@@ -51,19 +38,17 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         dir_referred_classes = self.directly_referred_classes
         inherited_referred_classes = []
         for class_ in dir_referred_classes:
-            inherited_referred_classes.extend(self.class_inheritance_path(class_, use_reference=True))
+            inherited_referred_classes.extend(self.class_inheritance_path(class_))
         return set(inherited_referred_classes)
 
-    def class_parent_pairs(self, use_reference: bool = False) -> dict[ClassEntity, list[ParentClassEntity]]:
+    def class_parent_pairs(self) -> dict[ClassEntity, list[ParentClassEntity]]:
         """This only returns class - parent pairs only if parent is in the same data model"""
         class_subclass_pairs: dict[ClassEntity, list[ParentClassEntity]] = {}
 
-        rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
-
-        if not rules:
+        if not self.rules:
             return class_subclass_pairs
 
-        for definition in rules.classes:
+        for definition in self.rules.classes:
             class_subclass_pairs[definition.class_] = []
 
             if definition.parent is None:
@@ -81,13 +66,12 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         return class_subclass_pairs
 
     def classes_with_properties(
-        self, consider_inheritance: bool = False, use_reference: bool = False
+        self, consider_inheritance: bool = False
     ) -> dict[ClassEntity, list[InformationProperty]]:
         """Returns classes that have been defined in the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Dictionary of classes with a list of properties defined for them
@@ -103,21 +87,19 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         class_property_pairs: dict[ClassEntity, list[InformationProperty]] = defaultdict(list)
 
-        rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
-
-        for property_ in rules.properties:
+        for property_ in self.rules.properties:
             class_property_pairs[property_.class_].append(property_)
 
         if consider_inheritance:
-            class_parent_pairs = self.class_parent_pairs(use_reference=use_reference)
+            class_parent_pairs = self.class_parent_pairs()
             for class_ in class_parent_pairs:
                 self._add_inherited_properties(class_, class_property_pairs, class_parent_pairs)
 
         return class_property_pairs
 
-    def class_inheritance_path(self, class_: ClassEntity | str, use_reference: bool = False) -> list[ClassEntity]:
+    def class_inheritance_path(self, class_: ClassEntity | str) -> list[ClassEntity]:
         class_ = class_ if isinstance(class_, ClassEntity) else ClassEntity.load(class_)
-        class_parent_pairs = self.class_parent_pairs(use_reference)
+        class_parent_pairs = self.class_parent_pairs()
         return get_inheritance_path(class_, class_parent_pairs)
 
     @classmethod
@@ -133,8 +115,13 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             if parent.as_class_entity() in class_property_pairs:
                 for property_ in class_property_pairs[parent.as_class_entity()]:
                     property_ = property_.model_copy()
-                    # this corresponds to importing properties from parent class
+
+                    # This corresponds to importing properties from parent class
+                    # making sure that the property is attached to desired child class
                     property_.class_ = class_
+                    property_.inherited = True
+
+                    # need same if we have RDF path to make sure that the starting class is the
 
                     if class_ in class_property_pairs:
                         class_property_pairs[class_].append(property_)
@@ -142,14 +129,13 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
                         class_property_pairs[class_] = [property_]
 
     def class_property_pairs(
-        self, only_rdfpath: bool = False, consider_inheritance: bool = False, use_reference: bool = False
+        self, only_rdfpath: bool = False, consider_inheritance: bool = False
     ) -> dict[ClassEntity, dict[str, InformationProperty]]:
         """Returns a dictionary of classes with a dictionary of properties associated with them.
 
         Args:
             only_rdfpath : To consider only properties which have rule `rdfpath` set. Defaults False
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference : Whether to use reference rules or not. Defaults False
 
         Returns:
             Dictionary of classes with a dictionary of properties associated with them.
@@ -178,7 +164,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         class_property_pairs = {}
 
-        for class_, properties in self.classes_with_properties(consider_inheritance, use_reference).items():
+        for class_, properties in self.classes_with_properties(consider_inheritance).items():
             processed_properties = {}
             for property_ in properties:
                 if property_.property_ in processed_properties:
@@ -191,18 +177,17 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
                     )
                     continue
 
-                if (only_rdfpath and property_.rule_type == TransformationRuleType.rdfpath) or not only_rdfpath:
+                if (only_rdfpath and isinstance(property_.transformation, RDFPath)) or not only_rdfpath:
                     processed_properties[property_.property_] = property_
             class_property_pairs[class_] = processed_properties
 
         return class_property_pairs
 
-    def class_linkage(self, consider_inheritance: bool = False, use_reference: bool = False) -> pd.DataFrame:
+    def class_linkage(self, consider_inheritance: bool = False) -> pd.DataFrame:
         """Returns a dataframe with the class linkage of the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Dataframe with the class linkage of the data model
@@ -210,7 +195,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         class_linkage = pd.DataFrame(columns=["source_class", "target_class", "connecting_property", "max_occurrence"])
 
-        class_property_pairs = self.classes_with_properties(consider_inheritance, use_reference)
+        class_property_pairs = self.classes_with_properties(consider_inheritance)
         properties = list(itertools.chain.from_iterable(class_property_pairs.values()))
 
         for property_ in properties:
@@ -230,56 +215,50 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
 
         return class_linkage
 
-    def connected_classes(self, consider_inheritance: bool = False, use_reference: bool = False) -> set[ClassEntity]:
+    def connected_classes(self, consider_inheritance: bool = False) -> set[ClassEntity]:
         """Return a set of classes that are connected to other classes.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of classes that are connected to other classes
         """
-        class_linkage = self.class_linkage(consider_inheritance, use_reference)
+        class_linkage = self.class_linkage(consider_inheritance)
         return set(class_linkage.source_class.values).union(set(class_linkage.target_class.values))
 
-    def defined_classes(self, consider_inheritance: bool = False, use_reference: bool = False) -> set[ClassEntity]:
+    def defined_classes(self, consider_inheritance: bool = False) -> set[ClassEntity]:
         """Returns classes that have properties defined for them in the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of classes that have been defined in the data model
         """
-        class_property_pairs = self.classes_with_properties(consider_inheritance, use_reference)
+        class_property_pairs = self.classes_with_properties(consider_inheritance)
         properties = list(itertools.chain.from_iterable(class_property_pairs.values()))
 
         return {property.class_ for property in properties}
 
-    def disconnected_classes(self, consider_inheritance: bool = False, use_reference: bool = False) -> set[ClassEntity]:
+    def disconnected_classes(self, consider_inheritance: bool = False) -> set[ClassEntity]:
         """Return a set of classes that are disconnected (i.e. isolated) from other classes.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of classes that are disconnected from other classes
         """
-        return self.defined_classes(consider_inheritance, use_reference) - self.connected_classes(
-            consider_inheritance, use_reference
-        )
+        return self.defined_classes(consider_inheritance) - self.connected_classes(consider_inheritance)
 
     def symmetrically_connected_classes(
-        self, consider_inheritance: bool = False, use_reference: bool = False
+        self, consider_inheritance: bool = False
     ) -> set[tuple[ClassEntity, ClassEntity]]:
         """Returns a set of pairs of symmetrically linked classes.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Set of pairs of symmetrically linked classes
@@ -293,7 +272,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
         # TODO: Find better name for this method
         sym_pairs: set[tuple[ClassEntity, ClassEntity]] = set()
 
-        class_linkage = self.class_linkage(consider_inheritance, use_reference)
+        class_linkage = self.class_linkage(consider_inheritance)
         if class_linkage.empty:
             return sym_pairs
 
@@ -321,13 +300,12 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             class_dict[str(definition.class_.suffix)] = definition
         return class_dict
 
-    def subset_rules(self, desired_classes: set[ClassEntity], use_reference: bool = False) -> InformationRules:
+    def subset_rules(self, desired_classes: set[ClassEntity]) -> InformationRules:
         """
         Subset rules to only include desired classes and their properties.
 
         Args:
             desired_classes: Desired classes to include in the reduced data model
-            use_reference: Whether to use reference rules or not. Defaults False
 
         Returns:
             Instance of InformationRules
@@ -350,9 +328,7 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             only with base Pydantic validators.
         """
 
-        rules = cast(InformationRules, self.rules.reference if use_reference else self.rules)
-
-        if rules.metadata.schema_ is not SchemaCompleteness.complete:
+        if self.rules.metadata.schema_ is not SchemaCompleteness.complete:
             raise ValueError("Rules are not complete cannot perform reduction!")
         class_as_dict = self.as_class_dict()
         class_parents_pairs = self.class_parent_pairs()
@@ -380,8 +356,8 @@ class InformationArchitectRulesAnalysis(BaseAnalysis):
             )
 
         reduced_data_model: dict[str, Any] = {
-            "metadata": rules.metadata.model_copy(),
-            "prefixes": (rules.prefixes or {}).copy(),
+            "metadata": self.rules.metadata.model_copy(),
+            "prefixes": (self.rules.prefixes or {}).copy(),
             "classes": [],
             "properties": [],
         }

cognite/neat/rules/importers/_inference2rules.py

@@ -17,7 +17,7 @@ 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, uri_to_short_form
 
 ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
@@ -176,6 +176,10 @@ class InferenceImporter(BaseImporter):
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
                         "reference": property_uri,
+                        "transformation": (
+                            f"{uri_to_short_form(class_definition['reference'], prefixes)}"
+                            f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
+                        ),
                         "comment": (
                             f"Class <{class_id}> has property <{property_id}> with "
                             f"value type <{value_type_id}> which occurs <1> times in the graph"

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

@@ -23,13 +23,8 @@ from cognite.neat.rules.models._base import (
     SheetList,
 )
 from cognite.neat.rules.models._rdfpath import (
-    AllReferences,
-    Hop,
-    RawLookup,
-    SingleProperty,
-    SPARQLQuery,
+    RDFPath,
     TransformationRuleType,
-    Traversal,
     parse_rule,
 )
 from cognite.neat.rules.models._types import (
@@ -156,9 +151,7 @@ class InformationProperty(SheetEntity):
         default: Default value of the property
         reference: Reference to the source of the information, HTTP URI
         match_type: The match type of the resource being described and the source entity.
-        rule_type: Rule type for the transformation from source to target representation
-                   of knowledge graph. Defaults to None (no transformation)
-        rule: Actual rule for the transformation from source to target representation of
+        transformation: Actual rule for the transformation from source to target representation of
               knowledge graph. Defaults to None (no transformation)
     """
 
@@ -174,11 +167,13 @@ class InformationProperty(SheetEntity):
     default: Any | None = Field(alias="Default", default=None)
     reference: URLEntity | ReferenceEntity | None = Field(alias="Reference", default=None, union_mode="left_to_right")
     match_type: MatchType | None = Field(alias="Match Type", default=None)
-    rule_type: str | TransformationRuleType | None = Field(alias="Rule Type", default=None)
-    rule: str | AllReferences | SingleProperty | Hop | RawLookup | SPARQLQuery | Traversal | None = Field(
-        alias="Rule", default=None
-    )
+    transformation: str | RDFPath | None = Field(alias="Transformation", default=None)
     comment: str | None = Field(alias="Comment", default=None)
+    inherited: bool = Field(
+        default=False,
+        alias="Inherited",
+        description="Flag to indicate if the property is inherited, only use for internal purposes",
+    )
 
     @field_serializer("max_count", when_used="json-unless-none")
     def serialize_max_count(self, value: int | float | None) -> int | float | None | str:
@@ -193,15 +188,10 @@ class InformationProperty(SheetEntity):
         return value
 
     @model_validator(mode="after")
-    def is_valid_rule(self):
-        # TODO: Can we skip rule_type and simply try to parse the rule and if it fails, raise an error?
-        if self.rule_type:
-            self.rule_type = self.rule_type.lower()
-            if not self.rule:
-                raise exceptions.RuleTypeProvidedButRuleMissing(
-                    self.property_, self.class_, self.rule_type
-                ).to_pydantic_custom_error()
-            self.rule = parse_rule(self.rule, self.rule_type)
+    def generate_valid_transformation(self):
+        # TODO: Currently only supporting RDFpath
+        if self.transformation:
+            self.transformation = parse_rule(self.transformation, TransformationRuleType.rdfpath)
         return self
 
     @model_validator(mode="after")

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

@@ -84,8 +84,7 @@ class InformationPropertyInput:
     default: Any | None = None
     reference: str | None = None
     match_type: str | None = None
-    rule_type: str | None = None
-    rule: str | None = None
+    transformation: str | None = None
 
     @classmethod
     @overload
@@ -122,8 +121,7 @@ class InformationPropertyInput:
             default=data.get("default", None),
             reference=data.get("reference", None),
             match_type=data.get("match_type", None),
-            rule_type=data.get("rule_type", None),
-            rule=data.get("rule", None),
+            transformation=data.get("transformation", None),
         )
 
     def dump(self, default_prefix: str) -> dict[str, Any]:
@@ -158,8 +156,7 @@ class InformationPropertyInput:
             "Default": self.default,
             "Reference": self.reference,
             "Match Type": self.match_type,
-            "Rule Type": self.rule_type,
-            "Rule": self.rule,
+            "Transformation": self.transformation,
         }
 
 

cognite/neat/utils/utils.py

@@ -3,7 +3,7 @@ import logging
 import re
 import sys
 import time
-from collections import OrderedDict
+from collections import Counter, OrderedDict
 from collections.abc import Iterable
 from datetime import datetime
 from functools import wraps
@@ -386,3 +386,8 @@ def string_to_ideal_type(input_string: str) -> int | bool | float | datetime | s
                 except ValueError:
                     # Return the input string if no conversion is possible
                     return input_string
+
+
+def most_occurring_element(list_of_elements: list):
+    counts = Counter(list_of_elements)
+    return counts.most_common(1)[0][0]

{cognite_neat-0.81.11.dist-info → cognite_neat-0.82.0.dist-info}/METADATA

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

{cognite_neat-0.81.11.dist-info → cognite_neat-0.82.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 cognite/neat/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
-cognite/neat/_version.py,sha256=j--riKojvVEPIAPPLvKSvPrl9iDUa3FZVs9awN4iAfo,24
+cognite/neat/_version.py,sha256=3E7u1ATSjtoHo9Pq3zuZICzm_iPH64qoru2bGBZuNbw,23
 cognite/neat/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/app/api/asgi/metrics.py,sha256=nxFy7L5cChTI0a-zkCiJ59Aq8yLuIJp5c9Dg0wRXtV0,152
 cognite/neat/app/api/configuration.py,sha256=2U5M6M252swvQPQyooA1EBzFUZNtcTmuSaywfJDgckM,4232
@@ -64,16 +64,20 @@ cognite/neat/graph/extractors/_classic_cdf/_relationships.py,sha256=w16hu_REIFEV
 cognite/neat/graph/extractors/_classic_cdf/_sequences.py,sha256=o4yxkf81FGFrKkflvlyDYie05fTYsT_LcRFM63OTVCI,3406
 cognite/neat/graph/extractors/_classic_cdf/_timeseries.py,sha256=KTYmL8vhXijlmkN1UFQrGpaCllpRekr1y55SoLhlLbg,4559
 cognite/neat/graph/extractors/_dexpi.py,sha256=CYSLt0Fl7Y2RCqOfIAT0N8Cjs-Yu2lRLvB13axtAaWw,9384
-cognite/neat/graph/extractors/_mock_graph_generator.py,sha256=gziG2FFsLk-HmA9uxAeT9RCjVpFxjkCTLiC4tq2zgvw,14961
+cognite/neat/graph/extractors/_mock_graph_generator.py,sha256=1TjgbxDVwgZjivIqx1lLKwggn_zHqWLiYM26esgDAMs,14694
 cognite/neat/graph/extractors/_rdf_file.py,sha256=w4-XgPgNsmZOkNxjO1ZQCcopTntmmtxfDBkQxn1se6E,463
 cognite/neat/graph/issues/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/graph/issues/loader.py,sha256=v8YDsehkUT1QUG61JM9BDV_lqowMUnDmGmbay0aFzN4,3085
 cognite/neat/graph/loaders/__init__.py,sha256=hHC9sfFfbnGSVFTYeuNTIEu4tdLSJ2mWV07fereLelo,125
 cognite/neat/graph/loaders/_base.py,sha256=bdYC6CwsHVqnQa1QzOhL68qQhF1OtrsearqH6D-z3E4,4037
-cognite/neat/graph/loaders/_rdf2dms.py,sha256=w0y2ECKw7RrQndGyTVIWeFF2WDxs9yvl_eWNqg-tKO8,13018
+cognite/neat/graph/loaders/_rdf2dms.py,sha256=6B3fdsaygSOYClq5vgNPMF4HJkO_Xt1OlrrbTsU0Bdc,12989
 cognite/neat/graph/models.py,sha256=AtLgZh2qyRP6NRetjQCy9qLMuTQB0CH52Zsev-qa2sk,149
+cognite/neat/graph/queries/__init__.py,sha256=BgDd-037kvtWwAoGAy8eORVNMiZ5-E9sIV0txIpeaN4,50
+cognite/neat/graph/queries/_base.py,sha256=20A7GDBdmc35VmHVz5n0YCGPcnBAmUX-bM2ImHPManc,3844
+cognite/neat/graph/queries/_construct.py,sha256=FxzSQqzCpo7lKVYerlLAY03oqCeFM5L6MozfBUblzr4,7341
+cognite/neat/graph/queries/_shared.py,sha256=EwW2RbPttt7-z7QTgfKWlthA2Nq5d3bYyyewFkCA7R4,5043
 cognite/neat/graph/stores/__init__.py,sha256=G-VG_YwfRt1kuPao07PDJyZ3w_0-eguzLUM13n-Z_RA,64
-cognite/neat/graph/stores/_base.py,sha256=-MwqfVCBd4j4xWaI7zOvypsGqtbET-2eKQKf36DO0A0,11001
+cognite/neat/graph/stores/_base.py,sha256=b4qidXCl9190LrvLXTms2lDqv1ErwvvcGzQkY6mU9hI,10096
 cognite/neat/graph/stores/_oxrdflib.py,sha256=A5zeRm5_e8ui_ihGpgstRDg_N7qcLZ3QZBRGrOXSGI0,9569
 cognite/neat/graph/stores/_provenance.py,sha256=Hr9WBhFj-eoet4czL8XSBGYnu9Yn66YsTgH_G0n3QpY,3293
 cognite/neat/graph/transformers/__init__.py,sha256=wXrNSyJNGnis3haaCKVPZ5y5kKSUsOUHnh-860ekatk,555
@@ -178,7 +182,7 @@ cognite/neat/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 cognite/neat/rules/_shared.py,sha256=5dc2dfwqjNB_Us27x7oRNkEoEETT0gQChoiIU8mcvyQ,170
 cognite/neat/rules/analysis/__init__.py,sha256=J2yL0QWSvXOWLbaYPyA0HXHh3aqOWmkwobScdgVQpw8,115
 cognite/neat/rules/analysis/_base.py,sha256=PmN5NLgGsovsHtsnvUzc_zuarWl-Xwk1azWcYKKuWdA,669
-cognite/neat/rules/analysis/_information_rules.py,sha256=F-LBLYyEz6B3J3v1KQ_2G79LzgMXPmcSIw6S8SMGaxs,19179
+cognite/neat/rules/analysis/_information_rules.py,sha256=fdSMyInsPJdgLHKwSkj2N9bcEXld9ETxUIXWqeDH8L4,17478
 cognite/neat/rules/examples/__init__.py,sha256=nxIwueAcHgZhkYriGxnDLQmIyiT8PByPHbScjYKDKe0,374
 cognite/neat/rules/examples/wind-energy.owl,sha256=NuomCA9FuuLF0JlSuG3OKqD4VBcHgSjDKFLV17G1zV8,65934
 cognite/neat/rules/exceptions.py,sha256=YLnsbXXJdDSr_szQoioEtOdqDV8PR7RdQjpMP2SWeCs,123868
@@ -197,7 +201,7 @@ cognite/neat/rules/importers/_dtdl2rules/_unit_lookup.py,sha256=wW4saKva61Q_i17g
 cognite/neat/rules/importers/_dtdl2rules/dtdl_converter.py,sha256=ysmWUxZ0npwrTB0uiH5jA0v37sfCwowGaYk17IyxPUU,12663
 cognite/neat/rules/importers/_dtdl2rules/dtdl_importer.py,sha256=QDyGt5YBaxzF4v_oCFSgKRSpwVdVruDU3-VW0DEiHbY,6718
 cognite/neat/rules/importers/_dtdl2rules/spec.py,sha256=tim_MfN1J0F3Oeqk3BMgIA82d_MZvhRuRMsLK3B4PYc,11897
-cognite/neat/rules/importers/_inference2rules.py,sha256=JgXmhc_6ME9RrA0gVPn9WoVE7NvCrpjdS4_ELW-2e7g,11205
+cognite/neat/rules/importers/_inference2rules.py,sha256=vN3l6gfca19FHGzPb9fwolZaq4Z8KkeiR-iK1up8Kqk,11478
 cognite/neat/rules/importers/_owl2rules/__init__.py,sha256=tdGcrgtozdQyST-pTlxIa4cLBNTLvtk1nNYR4vOdFSw,63
 cognite/neat/rules/importers/_owl2rules/_owl2classes.py,sha256=QpTxvrTGczIa48X8lgXGnMN1AWPhHK0DR6uNq175xak,7357
 cognite/neat/rules/importers/_owl2rules/_owl2metadata.py,sha256=nwnUaBNAAYMoBre2UmsnkJXUuaqGEpR3U3txDrH2w6g,7527
@@ -233,8 +237,8 @@ cognite/neat/rules/models/domain.py,sha256=wZ-DeIPFnacbNlxSrRuLzUpnhHdTpzNc22z0s
 cognite/neat/rules/models/entities.py,sha256=lkLsKg8U3Xto30PCB85ScDpv2SPRVq1ukVEQHzH53_g,18868
 cognite/neat/rules/models/information/__init__.py,sha256=HR6g8xgyU53U7Ck8pPdbT70817Q4NC1r1pCRq5SA8iw,291
 cognite/neat/rules/models/information/_converter.py,sha256=r0a2uyzv8m82xzAkYt_-ZXdMN5u46SA_mn95Oo7ng-s,11424
-cognite/neat/rules/models/information/_rules.py,sha256=ZVTOn5fEB-AbrXL8A6SN9DwOmF9FhgyS7FzibrkT6ZM,13546
-cognite/neat/rules/models/information/_rules_input.py,sha256=xmcQQl2vBYSG_IbxOwb6x4CdN3nIg_TY2-3RAeGDYic,10418
+cognite/neat/rules/models/information/_rules.py,sha256=hQihDlji-DV3pmAPxIZpUBP9PVCcZxJXN2KyZZecFeM,13089
+cognite/neat/rules/models/information/_rules_input.py,sha256=ExCjcD0pvsThXYDf3uWYLzSLqN_2OtXFggbW_RB8hr4,10343
 cognite/neat/rules/models/information/_serializer.py,sha256=yti9I_xJruxrib66YIBInhze___Io-oPTQH6uWDumPE,3503
 cognite/neat/rules/models/information/_validation.py,sha256=Is2GzL2lZU3A5zPu3NjvlXfmIU2_Y10C5Nxi5Denz4g,7528
 cognite/neat/rules/models/wrapped_entities.py,sha256=ThhjnNNrpgz0HeORIQ8Q894trxP73P7T_TuZj6qH2CU,7157
@@ -251,7 +255,7 @@ cognite/neat/utils/exceptions.py,sha256=-w4cAcvcoWLf-_ZwAl7QV_NysfqtQzIOd1Ti-mpx
 cognite/neat/utils/spreadsheet.py,sha256=LI0c7dlW0zXHkHw0NvB-gg6Df6cDcE3FbiaHBYLXdzQ,2714
 cognite/neat/utils/text.py,sha256=4bg1_Q0lg7KsoxaDOvXrVyeY78BJN8i-27BlyDzUCls,3082
 cognite/neat/utils/upload.py,sha256=XaAKqyMhz6qXbUrttGNIXZxFRPJvrnbMpDRF8GEiK2g,2707
-cognite/neat/utils/utils.py,sha256=p5qiqL4p4yC2z1pJWRaw-GSITOvBMCvj8zSo58NNsCo,14031
+cognite/neat/utils/utils.py,sha256=1LEwR8gpHw_6pvEeLkW_cDU_lUun4qSsw_Rr3JsKwgA,14172
 cognite/neat/utils/xml.py,sha256=ppLT3lQKVp8wOP-m8-tFY8uB2P4R76l7R_-kUtsABng,992
 cognite/neat/workflows/__init__.py,sha256=oiKub_U9f5cA0I1nKl5dFkR4BD8_6Be9eMzQ_50PwP0,396
 cognite/neat/workflows/_exceptions.py,sha256=ugI_X1XNpikAiL8zIggBjcx6q7WvOpRIgvxHrj2Rhr4,1348
@@ -297,8 +301,8 @@ cognite/neat/workflows/steps_registry.py,sha256=fkTX14ZA7_gkUYfWIlx7A1XbCidvqR23
 cognite/neat/workflows/tasks.py,sha256=dqlJwKAb0jlkl7abbY8RRz3m7MT4SK8-7cntMWkOYjw,788
 cognite/neat/workflows/triggers.py,sha256=_BLNplzoz0iic367u1mhHMHiUrCwP-SLK6_CZzfODX0,7071
 cognite/neat/workflows/utils.py,sha256=gKdy3RLG7ctRhbCRwaDIWpL9Mi98zm56-d4jfHDqP1E,453
-cognite_neat-0.81.11.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.81.11.dist-info/METADATA,sha256=MmBADLlk7wOEvD_MHykgRKYfjDJIoVYbf8WeGTeF9ac,9291
-cognite_neat-0.81.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-cognite_neat-0.81.11.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
-cognite_neat-0.81.11.dist-info/RECORD,,
+cognite_neat-0.82.0.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.82.0.dist-info/METADATA,sha256=AHFZCjG5ms8ip8WkI3RnErG7lBXVEd19m9x_gDS9W8A,9290
+cognite_neat-0.82.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+cognite_neat-0.82.0.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
+cognite_neat-0.82.0.dist-info/RECORD,,