cognite-neat 0.85.12__tar.gz → 0.87.0__tar.gz

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/PKG-INFO

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

cognite_neat-0.87.0/cognite/neat/_version.py

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

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/app/api/routers/core.py

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

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/constants.py

@@ -14,15 +14,17 @@ EXAMPLE_WORKFLOWS = PACKAGE_DIRECTORY / "workflows" / "examples"
 
 DEFAULT_NAMESPACE = Namespace("http://purl.org/cognite/neat#")
 
-PREFIXES = {
-    "rdf": RDF._NS,
-    "rdfs": RDFS._NS,
-    "dct": DCTERMS._NS,
-    "skos": SKOS._NS,
-    "owl": OWL._NS,
-    "xsd": XSD._NS,
-    "pav": Namespace("http://purl.org/pav/"),
-}
+
+def get_default_prefixes() -> dict[str, Namespace]:
+    return {
+        "rdf": RDF._NS,
+        "rdfs": RDFS._NS,
+        "dct": DCTERMS._NS,
+        "skos": SKOS._NS,
+        "owl": OWL._NS,
+        "xsd": XSD._NS,
+        "pav": Namespace("http://purl.org/pav/"),
+    }
 
 
 DEFAULT_URI = ""

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/graph/extractors/_mock_graph_generator.py

@@ -12,7 +12,7 @@ import pandas as pd
 from rdflib import RDF, Literal, Namespace, URIRef
 
 from cognite.neat.graph.models import Triple
-from cognite.neat.rules.analysis import InformationArchitectRulesAnalysis
+from cognite.neat.rules.analysis import InformationAnalysis
 from cognite.neat.rules.models import DMSRules, InformationRules
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import ClassEntity, EntityTypes
@@ -42,7 +42,7 @@ class MockGraphGenerator(BaseExtractor):
         allow_isolated_classes: bool = True,
     ):
         if isinstance(rules, DMSRules):
-            self.rules = rules.as_information_architect_rules()
+            self.rules = rules.as_information_rules()
         elif isinstance(rules, InformationRules):
             self.rules = rules
         else:
@@ -50,8 +50,7 @@ class MockGraphGenerator(BaseExtractor):
 
         if not class_count:
             self.class_count = {
-                class_: 1
-                for class_ in InformationArchitectRulesAnalysis(self.rules).defined_classes(consider_inheritance=True)
+                class_: 1 for class_ in InformationAnalysis(self.rules).defined_classes(consider_inheritance=True)
             }
         elif all(isinstance(key, str) for key in class_count.keys()):
             self.class_count = {
@@ -101,7 +100,7 @@ def generate_triples(
     """
 
     namespace = rules.metadata.namespace
-    defined_classes = InformationArchitectRulesAnalysis(rules).defined_classes(consider_inheritance=True)
+    defined_classes = InformationAnalysis(rules).defined_classes(consider_inheritance=True)
 
     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!"
@@ -115,16 +114,16 @@ def generate_triples(
 
     # Subset data model to only classes that are defined in class count
     rules = (
-        InformationArchitectRulesAnalysis(rules).subset_rules(set(class_count.keys()))
+        InformationAnalysis(rules).subset_rules(set(class_count.keys()))
         if defined_classes != set(class_count.keys())
         else rules
     )
 
-    class_linkage = InformationArchitectRulesAnalysis(rules).class_linkage()
+    class_linkage = InformationAnalysis(rules).class_linkage().to_pandas()
 
     # Remove one of symmetric pairs from class linkage to maintain proper linking
     # among instances of symmetrically linked classes
-    if sym_pairs := InformationArchitectRulesAnalysis(rules).symmetrically_connected_classes():
+    if sym_pairs := InformationAnalysis(rules).symmetrically_connected_classes():
         class_linkage = _remove_higher_occurring_sym_pair(class_linkage, sym_pairs)
 
     # Remove any of symmetric pairs containing classes that are not present class count
@@ -134,7 +133,7 @@ def generate_triples(
     generation_order = _prettify_generation_order(_get_generation_order(class_linkage))
 
     # Generated simple view of data model
-    class_property_pairs = InformationArchitectRulesAnalysis(rules).classes_with_properties(consider_inheritance=True)
+    class_property_pairs = InformationAnalysis(rules).classes_with_properties(consider_inheritance=True)
 
     # pregenerate instance ids for each remaining class
     instance_ids = {

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/graph/loaders/__init__.py

@@ -1,7 +1,8 @@
 from ._base import BaseLoader, CDFLoader
+from ._rdf2asset import AssetLoader
 from ._rdf2dms import DMSLoader
 
-__all__ = ["BaseLoader", "CDFLoader", "DMSLoader"]
+__all__ = ["BaseLoader", "CDFLoader", "DMSLoader", "AssetLoader"]
 
 
 def _repr_html_() -> str:
@@ -11,7 +12,9 @@ def _repr_html_() -> str:
         [
             {
                 "Loader": name,
-                "Description": globals()[name].__doc__.strip().split("\n")[0] if globals()[name].__doc__ else "Missing",
+                "Description": (
+                    globals()[name].__doc__.strip().split("\n")[0] if globals()[name].__doc__ else "Missing"
+                ),
             }
             for name in __all__
             if name not in ("BaseLoader", "CDFLoader")

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/graph/loaders/_base.py

@@ -15,6 +15,11 @@ from cognite.neat.utils.upload import UploadResult, UploadResultList
 T_Output = TypeVar("T_Output")
 
 
+# Sentinel value to indicate in the load method that all instances of a class have been loaded.
+# https://en.wikipedia.org/wiki/Sentinel_value
+class _END_OF_CLASS: ...
+
+
 class BaseLoader(ABC, Generic[T_Output]):
     _new_line = "\n"
     _encoding = "utf-8"
@@ -28,10 +33,10 @@ class BaseLoader(ABC, Generic[T_Output]):
 
     def load(self, stop_on_exception: bool = False) -> Iterable[T_Output | NeatIssue]:
         """Load the graph with data."""
-        return self._load(stop_on_exception)
+        return (item for item in self._load(stop_on_exception) if item is not _END_OF_CLASS)  # type: ignore[misc]
 
     @abstractmethod
-    def _load(self, stop_on_exception: bool = False) -> Iterable[T_Output | NeatIssue]:
+    def _load(self, stop_on_exception: bool = False) -> Iterable[T_Output | NeatIssue | type[_END_OF_CLASS]]:
         """Load the graph with data."""
         pass
 
@@ -58,13 +63,16 @@ class CDFLoader(BaseLoader[T_Output]):
 
         issues = NeatIssueList[NeatIssue]()
         items: list[T_Output] = []
-        for result in self.load(stop_on_exception=False):
+        for result in self._load(stop_on_exception=False):
             if isinstance(result, NeatIssue):
                 issues.append(result)
+            elif result is _END_OF_CLASS:
+                ...
             else:
-                items.append(result)
+                # MyPy does not understand else means the item will be of type T_Output
+                items.append(result)  # type: ignore[arg-type]
 
-            if len(items) >= self._UPLOAD_BATCH_SIZE:
+            if len(items) >= self._UPLOAD_BATCH_SIZE or result is _END_OF_CLASS:
                 yield from self._upload_to_cdf(client, items, dry_run, issues)
                 issues = NeatIssueList[NeatIssue]()
                 items = []

cognite_neat-0.87.0/cognite/neat/graph/loaders/_rdf2asset.py

@@ -0,0 +1,197 @@
+from collections import defaultdict
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass, fields
+from pathlib import Path
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes import AssetWrite
+from cognite.client.data_classes.capabilities import Capability
+
+from cognite.neat.graph._tracking.base import Tracker
+from cognite.neat.graph._tracking.log import LogTracker
+from cognite.neat.graph.issues import loader as loader_issues
+from cognite.neat.graph.stores import NeatGraphStore
+from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.rules.analysis._asset import AssetAnalysis
+from cognite.neat.rules.models import AssetRules
+from cognite.neat.utils.upload import UploadResult
+
+from ._base import _END_OF_CLASS, CDFLoader
+
+
+@dataclass(frozen=True)
+class AssetLoaderMetadataKeys:
+    """Class holding mapping between NEAT metadata key names and their desired names
+    in CDF Asset metadata
+
+    Args:
+        start_time: Start time key name
+        end_time: End time key name
+        update_time: Update time key name
+        resurrection_time: Resurrection time key name
+        identifier: Identifier key name
+        active: Active key name
+        type: Type key name
+    """
+
+    start_time: str = "start_time"
+    end_time: str = "end_time"
+    update_time: str = "update_time"
+    resurrection_time: str = "resurrection_time"
+    identifier: str = "identifier"
+    active: str = "active"
+    type: str = "type"
+
+    def as_aliases(self) -> dict[str, str]:
+        return {str(field.default): getattr(self, field.name) for field in fields(self)}
+
+
+class AssetLoader(CDFLoader[AssetWrite]):
+    """Load Assets from NeatGraph to Cognite Data Fusions.
+
+    Args:
+        graph_store (NeatGraphStore): The graph store to load the data into.
+        rules (AssetRules): The rules to load the assets with.
+        data_set_id (int): The CDF data set id to load the Assets into.
+        use_orphanage (bool): Whether to use an orphanage for assets that are not part
+                              of the hierarchy. Defaults to False.
+        use_labels (bool): Whether to use labels for assets. Defaults to False.
+        asset_external_id_prefix (str | None): The prefix to use for the external id of the assets.
+                                               Defaults to None.
+        metadata_keys (AssetLoaderMetadataKeys | None): Mapping between NEAT metadata key names and
+                                                        their desired names in CDF Asset metadata. Defaults to None.
+        create_issues (Sequence[NeatIssue] | None): A list of issues that occurred during reading. Defaults to None.
+        tracker (type[Tracker] | None): The tracker to use. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        graph_store: NeatGraphStore,
+        rules: AssetRules,
+        data_set_id: int,
+        use_orphanage: bool = False,
+        use_labels: bool = False,
+        asset_external_id_prefix: str | None = None,
+        metadata_keys: AssetLoaderMetadataKeys | None = None,
+        create_issues: Sequence[NeatIssue] | None = None,
+        tracker: type[Tracker] | None = None,
+    ):
+        super().__init__(graph_store)
+
+        self.rules = rules
+        self.data_set_id = data_set_id
+        self.use_labels = use_labels
+        self.use_orphanage = use_orphanage
+
+        self.orphanage_external_id = (
+            f"{asset_external_id_prefix or ''}orphanage-{data_set_id}" if use_orphanage else None
+        )
+
+        self.asset_external_id_prefix = asset_external_id_prefix
+        self.metadata_keys = metadata_keys or AssetLoaderMetadataKeys()
+
+        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._tracker: type[Tracker] = tracker or LogTracker
+
+    def _create_validation_classes(self) -> None:
+        # need to get back class-property pairs where are definition of
+        # asset implementations, extend InformationRulesAnalysis make it generic
+
+        # by default if there is not explicitly stated external_id
+        # use rdf:type and drop the prefix
+
+        # based on those create pydantic model AssetDefinition
+        # which will have .to_asset_write()
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def categorize_assets(self, client: CogniteClient) -> None:
+        """Categorize assets to those to be created, updated, decommissioned, or resurrected"""
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def _load(self, stop_on_exception: bool = False) -> Iterable[AssetWrite | NeatIssue | type[_END_OF_CLASS]]:
+        if self._issues.has_errors and stop_on_exception:
+            raise self._issues.as_exception()
+        elif self._issues.has_errors:
+            yield from self._issues
+            return
+        if not self.rules:
+            # There should already be an error in this case.
+            return
+
+        class_ids = [repr(class_.class_.id) for class_ in self.rules.classes]
+        tracker = self._tracker(type(self).__name__, class_ids, "classes")
+
+        for class_ in self.rules.classes:
+            tracker.start(repr(class_.class_.id))
+
+            property_renaming_config = AssetAnalysis(self.rules).define_property_renaming_config(class_.class_)
+
+            for identifier, properties in self.graph_store.read(class_.class_.suffix):
+                fields = _process_properties(properties, property_renaming_config)
+                # set data set id and external id
+                fields["data_set_id"] = self.data_set_id
+                fields["external_id"] = identifier
+
+                try:
+                    yield AssetWrite.load(fields)
+                except KeyError as e:
+                    error = loader_issues.InvalidInstanceError(type_="asset", identifier=identifier, reason=str(e))
+                    tracker.issue(error)
+                    if stop_on_exception:
+                        raise error.as_exception() from e
+                    yield error
+            yield _END_OF_CLASS
+
+    def load_to_cdf(self, client: CogniteClient, dry_run: bool = False) -> Sequence[AssetWrite]:
+        # generate assets
+        # check for circular asset hierarchy
+        # check for orphaned assets
+        # batch upsert of assets to CDF (otherwise we will hit the API rate limit)
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    @classmethod
+    def _check_for_circular_asset_hierarchy(cls, assets: list[AssetWrite]) -> None:
+        """Check for circular references in the asset rules"""
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    @classmethod
+    def _check_for_orphaned_assets(cls, assets: list[AssetWrite]) -> None:
+        """Check for circular references in the asset rules"""
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def _get_required_capabilities(self) -> list[Capability]:
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def _upload_to_cdf(
+        self,
+        client: CogniteClient,
+        items: list[AssetWrite],
+        dry_run: bool,
+        read_issues: NeatIssueList,
+    ) -> Iterable[UploadResult]:
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def write_to_file(self, filepath: Path) -> None:
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+
+def _process_properties(properties: dict[str, list[str]], property_renaming_config: dict[str, str]) -> dict:
+    metadata: dict[str, str] = defaultdict(str)
+    fields: dict[str, str | dict] = {}
+
+    for original_property, values in properties.items():
+        if renamed_property := property_renaming_config.get(original_property, None):
+            if renamed_property.startswith("metadata."):
+                # Asset metadata contains only string values
+                metadata[original_property] = ", ".join(values)
+            else:
+                # Asset fields can contain only one value
+                fields[renamed_property] = values[0]
+
+    if metadata:
+        fields["metadata"] = metadata
+
+    return fields

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -1,5 +1,4 @@
 import json
-from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from pathlib import Path
 from typing import Any, get_args
@@ -28,7 +27,7 @@ from ._base import CDFLoader
 
 
 class DMSLoader(CDFLoader[dm.InstanceApply]):
-    """Load data from Cognite Data Fusions Data Modeling Service (DMS) into Neat.
+    """Loads Instances to Cognite Data Fusion Data Model Service from NeatGraph.
 
     Args:
         graph_store (NeatGraphStore): The graph store to load the data into.
@@ -106,8 +105,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             yield from issues
             tracker.issue(issues)
             class_name = self.class_by_view_id.get(view.as_id(), view.external_id)
-            triples = self.graph_store.read(class_name)
-            for identifier, properties in _triples2dictionary(triples).items():
+
+            for identifier, properties in self.graph_store.read(class_name):
                 try:
                     yield self._create_node(identifier, properties, pydantic_cls, view_id)
                 except ValueError as e:
@@ -318,15 +317,3 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
 def _get_field_value_types(cls, info):
     return [type_.__name__ for type_ in get_args(cls.model_fields[info.field_name].annotation)]
-
-
-def _triples2dictionary(
-    triples: Iterable[tuple[str, str, str]],
-) -> dict[str, dict[str, list[str]]]:
-    """Converts list of triples to dictionary"""
-    values_by_property_by_identifier: dict[str, dict[str, list[str]]] = defaultdict(lambda: defaultdict(list))
-    for id_, property_, value in triples:
-        # avoid issue with strings "None", "nan", "null" being treated as values
-        if value.lower() not in ["", "None", "nan", "null"]:
-            values_by_property_by_identifier[id_][property_].append(value)
-    return values_by_property_by_identifier

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/graph/queries/_base.py

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

{cognite_neat-0.85.12 → cognite_neat-0.87.0}/cognite/neat/graph/queries/_construct.py

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