cognite-neat 0.85.4__tar.gz → 0.85.5__tar.gz

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/PKG-INFO

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

cognite_neat-0.85.5/cognite/neat/_version.py

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

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/constants.py

@@ -22,14 +22,6 @@ PREFIXES = {
     "owl": OWL._NS,
     "xsd": XSD._NS,
     "pav": Namespace("http://purl.org/pav/"),
-    "cim": Namespace("http://iec.ch/TC57/2013/CIM-schema-cim16#"),
-    "icim": Namespace("http://iec.ch/TC57/2013/CIM-schema-cim16-info#"),
-    "entsoe": Namespace("http://entsoe.eu/CIM/SchemaExtension/3/1#"),
-    "entsoe2": Namespace("http://entsoe.eu/CIM/SchemaExtension/3/2#"),
-    "md": Namespace("http://iec.ch/TC57/61970-552/ModelDescription/1#"),
-    "pti": Namespace("http://www.pti-us.com/PTI_CIM-schema-cim16#"),
-    "tnt": Namespace("http://purl.org/cognite/tnt#"),
-    "neat": DEFAULT_NAMESPACE,
 }
 
 

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/graph/loaders/_rdf2dms.py

@@ -82,7 +82,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         except Exception as e:
             issues.append(
                 loader_issues.FailedConvertError(
-                    identifier=rules.metadata.as_identifier(), target_format="read DMS model", reason=str(e)
+                    identifier=rules.metadata.as_identifier(),
+                    target_format="read DMS model",
+                    reason=str(e),
                 )
             )
         return cls(graph_store, data_model, instance_space, {}, issues)
@@ -199,7 +201,11 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         return pydantic_cls, edge_by_property, issues
 
     def _create_node(
-        self, identifier: str, properties: dict[str, list[str]], pydantic_cls: type[Model], view_id: dm.ViewId
+        self,
+        identifier: str,
+        properties: dict[str, list[str]],
+        pydantic_cls: type[Model],
+        view_id: dm.ViewId,
     ) -> dm.InstanceApply:
         created = pydantic_cls.model_validate(properties)
 
@@ -233,7 +239,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 external_id = f"{identifier}.{prop}.{target}"
                 yield dm.EdgeApply(
                     space=self.instance_space,
-                    external_id=external_id if len(external_id) < 256 else create_sha256_hash(external_id),
+                    external_id=(external_id if len(external_id) < 256 else create_sha256_hash(external_id)),
                     type=edge.type,
                     start_node=dm.DirectRelationReference(self.instance_space, identifier),
                     end_node=dm.DirectRelationReference(self.instance_space, target),
@@ -290,5 +296,7 @@ def _triples2dictionary(
     """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:
-        values_by_property_by_identifier[id_][property_].append(value)
+        # 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.4 → cognite_neat-0.85.5}/cognite/neat/legacy/graph/examples/__init__.py

@@ -5,3 +5,6 @@ from pathlib import Path
 # https://github.com/pydata/xarray/blob/main/xarray/tutorial.py
 # Currently there are simple paths to the examples which are then easily loaded in the notebooks
 nordic44_knowledge_graph = Path(__file__).parent / "Knowledge-Graph-Nordic44.xml"
+nordic44_knowledge_graph_dirty = (
+    Path(__file__).parent / "Knowledge-Graph-Nordic44-dirty.xml"
+)

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/legacy/graph/extractors/_dexpi.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 from rdflib import Namespace
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE
 from cognite.neat.graph.extractors._dexpi import DexpiExtractor
 from cognite.neat.legacy.graph.models import Triple
 
@@ -31,7 +31,7 @@ class DexpiXML(BaseExtractor):
         base_namespace: str | None = None,
     ):
         self.filepath = Path(filepath)
-        self.namespace = Namespace(base_namespace) if isinstance(base_namespace, str | Namespace) else PREFIXES["neat"]
+        self.namespace = Namespace(base_namespace) if isinstance(base_namespace, str | Namespace) else DEFAULT_NAMESPACE
 
     def extract(self) -> set[Triple]:
         """

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/legacy/graph/loaders/core/rdf_to_assets.py

@@ -271,7 +271,7 @@ def _class2asset_instance(
     if "name" in remapped_class_instance and remapped_class_instance["name"] == "":
         remapped_class_instance["name"] = empty_name_default
     # To maintain shape across of all assets of specific type we are adding missing metadata
-    # keys as empty strings, this was request by Statnett
+    # keys as empty strings, this was request by a customer
     # Generally this is bad practice, but more of a workaround of their bad data
     if missing_metadata and add_missing_metadata:
         msg = f"Adding missing metadata keys with values set to empty string for {class_}"

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/legacy/rules/examples/__init__.py

@@ -12,7 +12,7 @@ power_grid_containers = _EXAMPLES / "power-grid-containers.yaml"
 power_grid_data_model = _EXAMPLES / "power-grid-model.yaml"
 simple_example = _EXAMPLES / "sheet2cdf-transformation-rules.xlsx"
 source_to_solution_mapping = _EXAMPLES / "source-to-solution-mapping-rules.xlsx"
-nordic44 = _EXAMPLES / "Rules-Nordic44-to-TNT.xlsx"
+nordic44 = _EXAMPLES / "Rules-Nordic44.xlsx"
 nordic44_graphql = _EXAMPLES / "Rules-Nordic44-to-graphql.xlsx"
 skos = _EXAMPLES / "skos-rules.xlsx"
 wind_energy_ontology = _EXAMPLES / "wind-energy.owl"

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/legacy/workflows/examples/Extract_RDF_Graph_and_Generate_Assets/workflow.yaml

@@ -24,7 +24,7 @@ steps:
       pos_y: 77
   - complex_configs: {}
     configs:
-      file_name: Rules-Nordic44-to-TNT.xlsx
+      file_name: Rules-Nordic44.xlsx
       validation_report_file: rules_validation_report.txt
       validation_report_storage_dir: rules_validation_report
       version: ""

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/rules/exporters/_rules2excel.py

@@ -143,9 +143,15 @@ class ExcelExporter(BaseExporter[Workbook]):
 
         return workbook
 
-    def _write_sheets(self, workbook: Workbook, dumped_rules: dict[str, Any], rules: Rules, sheet_prefix: str = ""):
+    def _write_sheets(
+        self,
+        workbook: Workbook,
+        dumped_rules: dict[str, Any],
+        rules: Rules,
+        sheet_prefix: str = "",
+    ):
         for sheet_name, headers in rules.headers_by_sheet(by_alias=True).items():
-            if sheet_name in ("Metadata", "prefixes", "Reference", "Last"):
+            if sheet_name in ("Metadata", "Prefixes", "Reference", "Last"):
                 continue
             sheet = workbook.create_sheet(f"{sheet_prefix}{sheet_name}")
 
@@ -273,7 +279,9 @@ class _MetadataCreator:
 
         new_metadata = self._create_new_info(now)
         if isinstance(metadata, DMSMetadata):
-            from cognite.neat.rules.models.information._converter import _InformationRulesConverter
+            from cognite.neat.rules.models.information._converter import (
+                _InformationRulesConverter,
+            )
 
             output_metadata: DMSMetadata | InformationMetadata = _InformationRulesConverter._convert_metadata_to_dms(
                 new_metadata

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/rules/importers/_inference2rules.py

@@ -91,7 +91,9 @@ class InferenceImporter(BaseImporter):
     ) -> tuple[Rules | None, IssueList]: ...
 
     def to_rules(
-        self, errors: Literal["raise", "continue"] = "continue", role: RoleTypes | None = None
+        self,
+        errors: Literal["raise", "continue"] = "continue",
+        role: RoleTypes | None = None,
     ) -> tuple[Rules | None, IssueList] | Rules:
         """
         Creates `Rules` object from the data for target role.
@@ -103,9 +105,6 @@ class InferenceImporter(BaseImporter):
 
         rules_dict = self._to_rules_components()
 
-        # adding additional prefix
-        rules_dict["prefixes"][rules_dict["metadata"]["prefix"]] = rules_dict["metadata"]["namespace"]
-
         with _handle_issues(self.issue_list) as future:
             rules: InformationRules
             rules = InformationRulesInput.load(rules_dict).as_rules()
@@ -134,7 +133,10 @@ class InferenceImporter(BaseImporter):
         """
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
-        prefixes: dict[str, Namespace] = PREFIXES
+        prefixes: dict[str, Namespace] = PREFIXES.copy()
+
+        # Adds default namespace to prefixes
+        prefixes[self._default_metadata().prefix] = self._default_metadata().namespace
 
         # Infers all the classes in the graph
         for class_uri, no_instances in self.graph.query(ORDERED_CLASSES_QUERY):  # type: ignore[misc]
@@ -246,7 +248,7 @@ class InferenceImporter(BaseImporter):
             created=datetime.now(),
             updated=datetime.now(),
             description="Inferred model from knowledge graph",
-            prefix="neat",
+            prefix="inferred",
             namespace=DEFAULT_NAMESPACE,
         )
 
@@ -262,6 +264,10 @@ class InferenceImporter(BaseImporter):
     def _read_value_type_occurrence_from_comment(cls, value_type: str, comment: str) -> int:
         return int(
             cast(
-                re.Match, re.search(rf"with value type <{value_type}> which occurs <(\d+)> times in the graph", comment)
+                re.Match,
+                re.search(
+                    rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
+                    comment,
+                ),
             ).group(1)
         )

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/rules/issues/spreadsheet.py

@@ -7,6 +7,7 @@ from typing import Any, ClassVar
 from cognite.client.data_classes import data_modeling as dm
 from cognite.client.data_classes.data_modeling import ContainerId, ViewId
 from pydantic_core import ErrorDetails
+from rdflib import Namespace
 
 from cognite.neat.issues import MultiValueError
 from cognite.neat.utils.spreadsheet import SpreadsheetRead
@@ -23,6 +24,7 @@ __all__ = [
     "InvalidRowError",
     "InvalidPropertyError",
     "InvalidClassError",
+    "PrefixNamespaceCollisionError",
     "InvalidContainerError",
     "InvalidViewError",
     "InvalidRowUnknownSheetError",
@@ -44,13 +46,18 @@ class InvalidSheetError(NeatValidationError, ABC):
     @classmethod
     @abstractmethod
     def from_pydantic_error(
-        cls, error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
+        cls,
+        error: ErrorDetails,
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
     ) -> Self:
         raise NotImplementedError
 
     @classmethod
     def from_pydantic_errors(
-        cls, errors: list[ErrorDetails], read_info_by_sheet: dict[str, SpreadsheetRead] | None = None, **kwargs: Any
+        cls,
+        errors: list[ErrorDetails],
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
+        **kwargs: Any,
     ) -> "list[NeatValidationError]":
         output: list[NeatValidationError] = []
         for error in errors:
@@ -100,16 +107,26 @@ class InvalidRowError(InvalidSheetError, ABC):
     def __lt__(self, other: object) -> bool:
         if not isinstance(other, InvalidRowError):
             return NotImplemented
-        return (self.sheet_name, self.row, self.column) < (other.sheet_name, other.row, other.column)
+        return (self.sheet_name, self.row, self.column) < (
+            other.sheet_name,
+            other.row,
+            other.column,
+        )
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, InvalidRowError):
             return NotImplemented
-        return (self.sheet_name, self.row, self.column) == (other.sheet_name, other.row, other.column)
+        return (self.sheet_name, self.row, self.column) == (
+            other.sheet_name,
+            other.row,
+            other.column,
+        )
 
     @classmethod
     def from_pydantic_error(
-        cls, error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
+        cls,
+        error: ErrorDetails,
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
     ) -> Self:
         sheet_name, _, row, column, *__ = error["loc"]
         reader = (read_info_by_sheet or {}).get(str(sheet_name), SpreadsheetRead())
@@ -173,7 +190,9 @@ class InvalidRowUnknownSheetError(InvalidRowError):
 
     @classmethod
     def from_pydantic_error(
-        cls, error: ErrorDetails, read_info_by_sheet: dict[str, SpreadsheetRead] | None = None
+        cls,
+        error: ErrorDetails,
+        read_info_by_sheet: dict[str, SpreadsheetRead] | None = None,
     ) -> Self:
         sheet_name, _, row, column, *__ = error["loc"]
         reader = (read_info_by_sheet or {}).get(str(sheet_name), SpreadsheetRead())
@@ -294,6 +313,27 @@ class ParentClassesNotDefinedError(NeatValidationError):
         return f"Parent classes {', '.join(self.classes[0])} are not defined. This may be a mistake."
 
 
+@dataclass(frozen=True)
+class PrefixNamespaceCollisionError(NeatValidationError):
+    description = "Same namespaces are assigned to different prefixes."
+    fix = "Make sure that each unique namespace is assigned to a unique prefix"
+
+    namespaces: list[Namespace]
+    prefixes: list[str]
+
+    def dump(self) -> dict[str, list[str]]:
+        output = super().dump()
+        output["prefixes"] = self.prefixes
+        output["namespaces"] = self.namespaces
+        return output
+
+    def message(self) -> str:
+        return (
+            f"Namespaces {', '.join(self.namespaces)} are assigned multiple times."
+            f" Impacted prefixes: {', '.join(self.prefixes)}."
+        )
+
+
 @dataclass(frozen=True)
 class ValueTypeNotDefinedError(NeatValidationError):
     description = "Value types referred by properties are not defined in Rules."

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/rules/models/information/_rules.py

@@ -259,7 +259,7 @@ class InformationRules(BaseRules):
     metadata: InformationMetadata = Field(alias="Metadata")
     properties: SheetList[InformationProperty] = Field(alias="Properties")
     classes: SheetList[InformationClass] = Field(alias="Classes")
-    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy())
+    prefixes: dict[str, Namespace] = Field(default_factory=lambda: PREFIXES.copy(), alias="Prefixes")
     last: "InformationRules | None" = Field(None, alias="Last")
     reference: "InformationRules | None" = Field(None, alias="Reference")
 
@@ -267,6 +267,8 @@ class InformationRules(BaseRules):
     def parse_str(cls, values: Any) -> Any:
         if isinstance(values, dict):
             return {key: Namespace(value) if isinstance(value, str) else value for key, value in values.items()}
+        elif values is None:
+            values = PREFIXES.copy()
         return values
 
     @model_validator(mode="after")

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/rules/models/information/_rules_input.py

@@ -5,7 +5,12 @@ from typing import Any, Literal, cast, overload
 
 from rdflib import Namespace
 
-from cognite.neat.rules.models._base import DataModelType, ExtensionCategory, SchemaCompleteness, _add_alias
+from cognite.neat.rules.models._base import (
+    DataModelType,
+    ExtensionCategory,
+    SchemaCompleteness,
+    _add_alias,
+)
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.entities import (
     ClassEntity,
@@ -15,7 +20,12 @@ from cognite.neat.rules.models.entities import (
     UnknownEntity,
 )
 
-from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
+from ._rules import (
+    InformationClass,
+    InformationMetadata,
+    InformationProperty,
+    InformationRules,
+)
 
 
 @dataclass
@@ -105,7 +115,10 @@ class InformationPropertyInput:
         if data is None:
             return None
         if isinstance(data, list) or (isinstance(data, dict) and isinstance(data.get("data"), list)):
-            items = cast(list[dict[str, Any]], data.get("data") if isinstance(data, dict) else data)
+            items = cast(
+                list[dict[str, Any]],
+                data.get("data") if isinstance(data, dict) else data,
+            )
             return [loaded for item in items if (loaded := cls.load(item)) is not None]
 
         _add_alias(data, InformationProperty)
@@ -189,7 +202,10 @@ class InformationClassInput:
         if data is None:
             return None
         if isinstance(data, list) or (isinstance(data, dict) and isinstance(data.get("data"), list)):
-            items = cast(list[dict[str, Any]], data.get("data") if isinstance(data, dict) else data)
+            items = cast(
+                list[dict[str, Any]],
+                data.get("data") if isinstance(data, dict) else data,
+            )
             return [loaded for item in items if (loaded := cls.load(item)) is not None]
         _add_alias(data, InformationClass)
         return cls(
@@ -223,6 +239,7 @@ class InformationRulesInput:
     metadata: InformationMetadataInput
     properties: Sequence[InformationPropertyInput]
     classes: Sequence[InformationClassInput]
+    prefixes: "dict[str, Namespace] | None" = None
     last: "InformationRulesInput | InformationRules | None" = None
     reference: "InformationRulesInput | InformationRules | None" = None
 
@@ -244,6 +261,7 @@ class InformationRulesInput:
             metadata=InformationMetadataInput.load(data.get("metadata")),  # type: ignore[arg-type]
             properties=InformationPropertyInput.load(data.get("properties")),  # type: ignore[arg-type]
             classes=InformationClassInput.load(data.get("classes")),  # type: ignore[arg-type]
+            prefixes=data.get("prefixes"),
             last=InformationRulesInput.load(data.get("last")),
             reference=InformationRulesInput.load(data.get("reference")),
         )
@@ -270,6 +288,7 @@ class InformationRulesInput:
             Metadata=self.metadata.dump(),
             Properties=[prop.dump(default_prefix) for prop in self.properties],
             Classes=[class_.dump(default_prefix) for class_ in self.classes],
+            Prefixes=self.prefixes,
             Last=last,
             Reference=reference,
         )

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/rules/models/information/_validation.py

@@ -1,4 +1,5 @@
 import itertools
+from collections import Counter
 from typing import cast
 
 from cognite.neat.rules import issues
@@ -35,6 +36,7 @@ class InformationPostValidation:
         self._referenced_parent_classes_exist()
         self._referenced_classes_exist()
         self._referenced_value_types_exist()
+        self._namespaces_reassigned()
 
         return self.issue_list
 
@@ -162,3 +164,16 @@ class InformationPostValidation:
             class_subclass_pairs[class_.class_].extend([parent.as_class_entity() for parent in class_.parent])
 
         return class_subclass_pairs
+
+    def _namespaces_reassigned(self) -> None:
+        prefixes = self.rules.prefixes.copy()
+        prefixes[self.rules.metadata.namespace.prefix] = self.rules.metadata.namespace
+
+        if len(set(prefixes.values())) != len(prefixes):
+            reused_namespaces = [value for value, count in Counter(prefixes.values()).items() if count > 1]
+            impacted_prefixes = [key for key, value in prefixes.items() if value in reused_namespaces]
+            self.issue_list.append(
+                issues.spreadsheet.PrefixNamespaceCollisionError(
+                    prefixes=impacted_prefixes, namespaces=reused_namespaces
+                )
+            )

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/workflows/examples/Extract_RDF_Graph_and_Generate_Assets/workflow.yaml

@@ -24,7 +24,7 @@ steps:
       pos_y: 77
   - complex_configs: {}
     configs:
-      file_name: Rules-Nordic44-to-TNT.xlsx
+      file_name: Rules-Nordic44.xlsx
       validation_report_file: rules_validation_report.txt
       validation_report_storage_dir: rules_validation_report
       version: ""

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/cognite/neat/workflows/steps/lib/legacy/graph_store.py

@@ -2,11 +2,15 @@ import logging
 from pathlib import Path
 from typing import ClassVar, cast
 
-from cognite.neat.constants import PREFIXES
+from cognite.neat.constants import DEFAULT_NAMESPACE, PREFIXES
 from cognite.neat.legacy.graph import stores
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage
-from cognite.neat.workflows.steps.data_contracts import RulesData, SolutionGraph, SourceGraph
+from cognite.neat.workflows.steps.data_contracts import (
+    RulesData,
+    SolutionGraph,
+    SourceGraph,
+)
 from cognite.neat.workflows.steps.step_model import Configurable, Step
 
 __all__ = ["ResetGraphStores", "ConfigureGraphStore"]
@@ -71,7 +75,11 @@ class ConfigureDefaultGraphStores(Step):
             label="Defines which stores to configure",
             options=["all", "source", "solution"],
         ),
-        Configurable(name="solution_rdf_store.api_root_url", value="", label="Root url for graphdb or sparql endpoint"),
+        Configurable(
+            name="solution_rdf_store.api_root_url",
+            value="",
+            label="Root url for graphdb or sparql endpoint",
+        ),
     ]
 
     def run(self, rules_data: RulesData | None = None) -> (FlowMessage, SourceGraph, SolutionGraph):  # type: ignore[override, syntax]
@@ -92,7 +100,7 @@ class ConfigureDefaultGraphStores(Step):
                 store_cls = stores.STORE_BY_TYPE[source_store_type]
             except KeyError:
                 return FlowMessage(output_text="Invalid store type")
-            source_graph = store_cls(prefixes=prefixes, base_prefix="neat", namespace=PREFIXES["neat"])
+            source_graph = store_cls(prefixes=prefixes, base_prefix="neat", namespace=DEFAULT_NAMESPACE)
 
             source_graph.init_graph(
                 self.configs["source_rdf_store.query_url"],
@@ -207,13 +215,19 @@ class ConfigureGraphStore(Step):
             label="Local directory that is used as local graph store.Only for oxigraph, file store types",
         ),
         Configurable(
-            name="sparql_query_url", value="", label="Query url for sparql endpoint.Only for sparql store type"
+            name="sparql_query_url",
+            value="",
+            label="Query url for sparql endpoint.Only for sparql store type",
         ),
         Configurable(
-            name="sparql_update_url", value="", label="Update url for sparql endpoint.Only for sparql store type"
+            name="sparql_update_url",
+            value="",
+            label="Update url for sparql endpoint.Only for sparql store type",
         ),
         Configurable(
-            name="db_server_api_root_url", value="", label="Root url for graphdb or sparql endpoint.Only for graphdb"
+            name="db_server_api_root_url",
+            value="",
+            label="Root url for graphdb or sparql endpoint.Only for graphdb",
         ),
         Configurable(
             name="init_procedure",
@@ -255,7 +269,7 @@ class ConfigureGraphStore(Step):
         except KeyError:
             return FlowMessage(output_text="Invalid store type")
 
-        new_graph_store = store_cls(prefixes=prefixes, base_prefix="neat", namespace=PREFIXES["neat"])
+        new_graph_store = store_cls(prefixes=prefixes, base_prefix="neat", namespace=DEFAULT_NAMESPACE)
         new_graph_store.init_graph(
             self.configs["sparql_query_url"],
             self.configs["sparql_update_url"],
@@ -271,7 +285,11 @@ class ConfigureGraphStore(Step):
 
         return (
             FlowMessage(output_text="Graph store configured successfully"),
-            SourceGraph(graph=new_graph_store) if graph_name == "SourceGraph" else SolutionGraph(graph=new_graph_store),
+            (
+                SourceGraph(graph=new_graph_store)
+                if graph_name == "SourceGraph"
+                else SolutionGraph(graph=new_graph_store)
+            ),
         )
 
 

{cognite_neat-0.85.4 → cognite_neat-0.85.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cognite-neat"
-version = "0.85.4"
+version = "0.85.5"
 readme = "README.md"
 description = "Knowledge graph transformation"
 authors = [
@@ -64,7 +64,7 @@ openpyxl = "*"
 deepdiff = "*"
 
 # Notebook
-rich = {version="^13.7.1", extras=["jupyter"], optional=true}
+rich = { version = "^13.7.1", extras = ["jupyter"], optional = true }
 
 # Backport from Python 3.11
 exceptiongroup = { version = "^1.1.3", python = "<3.11" }

cognite_neat-0.85.4/cognite/neat/_version.py

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