cognite-neat 0.87.6__tar.gz → 0.88.0__tar.gz

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/PKG-INFO

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

cognite_neat-0.88.0/cognite/neat/_version.py

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

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/app/api/data_classes/rest.py

@@ -16,25 +16,6 @@ class RuleRequest(BaseModel):
     rule: str
 
 
-class UploadToCdfRequest(BaseModel):
-    file_name: str = ""
-    file_type: str = "workflow"
-    comments: str = ""
-    author: str = ""
-    tag: str = ""
-
-
-class DownloadFromCdfRequest(BaseModel):
-    file_name: str = ""
-    file_type: str = "workflow"
-    version: str = ""
-
-
-class LoadGraphRequest(BaseModel):
-    graph_source_template_name: str
-    source_location: str
-
-
 class RunWorkflowRequest(BaseModel):
     name: str
     config: dict

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/app/api/explorer.py

@@ -10,7 +10,12 @@ from cognite import neat
 from cognite.neat.app.api.asgi.metrics import prometheus_app
 from cognite.neat.app.api.configuration import NEAT_APP, UI_PATH
 from cognite.neat.app.api.context_manager import lifespan
-from cognite.neat.app.api.routers import configuration, core, crud, data_exploration, metrics, rules, workflows
+from cognite.neat.app.api.routers import (
+    configuration,
+    crud,
+    metrics,
+    workflows,
+)
 from cognite.neat.app.api.utils.logging import EndpointFilter
 
 app = FastAPI(title="Neat", lifespan=lifespan)
@@ -45,10 +50,7 @@ app.mount("/data", StaticFiles(directory=NEAT_APP.config.data_store_path), name=
 app.include_router(configuration.router)
 app.include_router(metrics.router)
 app.include_router(workflows.router)
-app.include_router(rules.router)
 app.include_router(crud.router)
-app.include_router(data_exploration.router)
-app.include_router(core.router)
 
 
 # General routes

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/app/api/routers/crud.py

@@ -14,28 +14,13 @@ from cognite.neat.workflows.utils import get_file_hash
 router = APIRouter()
 
 
-@router.get("/api/cdf/neat-resources")
-def get_neat_resources(resource_type: str | None = None):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    if resource_type is None:
-        return {"error": "Resource type is not specified"}
-    result = NEAT_APP.cdf_store.get_list_of_resources_from_cdf(resource_type=resource_type)
-    logging.debug(f"Got {len(result)} resources")
-    return {"result": result}
-
-
-@router.post("/api/cdf/init-neat-resources")
-def init_neat_cdf_resources(resource_type: str | None = None):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    NEAT_APP.cdf_store.init_cdf_resources(resource_type=resource_type)
-    return {"result": "ok"}
-
-
 @router.post("/api/file/upload/{workflow_name}/{file_type}/{step_id}/{action}")
 async def file_upload_handler(
-    files: list[UploadFile], workflow_name: str, file_type: str, step_id: str, action: str
+    files: list[UploadFile],
+    workflow_name: str,
+    file_type: str,
+    step_id: str,
+    action: str,
 ) -> dict[str, str]:
     if NEAT_APP.cdf_store is None or NEAT_APP.workflow_manager is None:
         return {"error": "NeatApp is not initialized"}
@@ -91,7 +76,12 @@ async def file_upload_handler(
         if workflow is None:
             return {"error": f"Workflow {workflow_name} not found"}
         flow_msg = FlowMessage(
-            payload={"file_name": file_name, "hash": file_version, "full_path": full_path, "file_type": file_type}
+            payload={
+                "file_name": file_name,
+                "hash": file_version,
+                "full_path": full_path,
+                "file_type": file_type,
+            }
         )
         start_step_id = None if step_id == "none" else step_id
 

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/app/api/routers/workflows.py

@@ -1,20 +1,19 @@
 import logging
 import shutil
-from pathlib import Path
 from typing import cast
 
 from fastapi import APIRouter, Depends, HTTPException, Request, UploadFile
 from fastapi.responses import FileResponse, JSONResponse
 
 from cognite.neat.app.api.configuration import NEAT_APP
-from cognite.neat.app.api.data_classes.rest import DownloadFromCdfRequest, RunWorkflowRequest, UploadToCdfRequest
+from cognite.neat.app.api.data_classes.rest import (
+    RunWorkflowRequest,
+)
 from cognite.neat.workflows import WorkflowFullStateReport
 from cognite.neat.workflows.base import WorkflowDefinition
-from cognite.neat.workflows.migration.wf_manifests import migrate_wf_manifest
 from cognite.neat.workflows.model import FlowMessage
-from cognite.neat.workflows.steps.data_contracts import SolutionGraph, SourceGraph
+from cognite.neat.workflows.steps.data_contracts import NeatGraph
 from cognite.neat.workflows.steps.step_model import DataContract
-from cognite.neat.workflows.utils import get_file_hash
 
 router = APIRouter()
 
@@ -27,7 +26,11 @@ def start_workflow(request: RunWorkflowRequest):
     start_status = NEAT_APP.workflow_manager.start_workflow_instance(
         request.name, sync=request.sync, flow_msg=FlowMessage()
     )
-    result = {"workflow_instance": None, "is_success": start_status.is_success, "status_text": start_status.status_text}
+    result = {
+        "workflow_instance": None,
+        "is_success": start_status.is_success,
+        "status_text": start_status.status_text,
+    }
     return {"result": result}
 
 
@@ -58,25 +61,6 @@ def get_workflow_files(workflow_name: str):
     return {"files": workflow.get_list_of_workflow_artifacts()}
 
 
-@router.post("/api/workflow/package/{workflow_name}")
-def package_workflow(workflow_name: str):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    package_file = NEAT_APP.cdf_store.package_workflow(workflow_name)
-    hash_ = get_file_hash(NEAT_APP.config.workflows_store_path / package_file)
-    return {"package": package_file, "hash": hash_}
-
-
-@router.post("/api/workflow/context-cleanup/{workflow_name}")
-def cleanup_workflow_data(workflow_name: str):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    workflow = NEAT_APP.workflow_manager.get_workflow(workflow_name)
-    if workflow is not None:
-        workflow.cleanup_workflow_context()
-    return {"result": "ok"}
-
-
 @router.post("/api/workflow/create")
 def create_new_workflow(request: WorkflowDefinition):
     if NEAT_APP.workflow_manager is None:
@@ -95,30 +79,24 @@ def delete_workflow(workflow_name: str):
     return {"result": "ok"}
 
 
-@router.get("/api/workflow/executions")
-def get_list_of_workflow_executions():
-    return {"executions": NEAT_APP.cdf_store.get_list_of_workflow_executions_from_cdf()}
-
-
-@router.get("/api/workflow/detailed-execution-report/{execution_id}")
-def get_detailed_execution(execution_id: str):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    return {"report": NEAT_APP.cdf_store.get_detailed_workflow_execution_report_from_cdf(execution_id)}
-
-
 @router.post("/api/workflow/reload-workflows")
 def reload_workflows():
     NEAT_APP.workflow_manager.load_workflows_from_storage()
     NEAT_APP.triggers_manager.reload_all_triggers()
-    return {"result": "ok", "workflows": NEAT_APP.workflow_manager.get_list_of_workflows()}
+    return {
+        "result": "ok",
+        "workflows": NEAT_APP.workflow_manager.get_list_of_workflows(),
+    }
 
 
 @router.post("/api/workflow/reload-single-workflow/{workflow_name}")
 def reload_single_workflows(workflow_name: str):
     NEAT_APP.workflow_manager.load_single_workflow_from_storage(workflow_name)
     NEAT_APP.triggers_manager.reload_all_triggers()
-    return {"result": "ok", "workflows": NEAT_APP.workflow_manager.get_list_of_workflows()}
+    return {
+        "result": "ok",
+        "workflows": NEAT_APP.workflow_manager.get_list_of_workflows(),
+    }
 
 
 @router.get("/api/workflow/workflow-definition/{workflow_name}")
@@ -152,58 +130,6 @@ def update_workflow_definition(workflow_name: str, request: WorkflowDefinition):
     return {"result": "ok"}
 
 
-@router.post("/api/workflow/upload-wf-to-cdf/{workflow_name}")
-def upload_workflow_to_cdf(workflow_name: str, request: UploadToCdfRequest):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    NEAT_APP.cdf_store.save_workflow_to_cdf(
-        workflow_name, changed_by=request.author, comments=request.comments, tag=request.tag
-    )
-    return {"result": "ok"}
-
-
-@router.post("/api/workflow/upload-rules-cdf/{workflow_name}")
-def upload_rules_to_cdf(workflow_name: str, request: UploadToCdfRequest):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    file_path = Path(NEAT_APP.config.rules_store_path, request.file_name)
-    NEAT_APP.cdf_store.save_resource_to_cdf(
-        workflow_name, "neat-wf-rules", file_path, changed_by=request.author, comments=request.comments
-    )
-    return {"result": "ok"}
-
-
-@router.post("/api/workflow/download-wf-from-cdf")
-def download_wf_from_cdf(request: DownloadFromCdfRequest):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    NEAT_APP.cdf_store.load_workflows_from_cdf(request.file_name, request.version)
-    return {"result": "ok"}
-
-
-@router.post("/api/workflow/download-rules-from-cdf")
-def download_rules_to_cdf(request: DownloadFromCdfRequest):
-    if NEAT_APP.cdf_store is None:
-        return {"error": "NeatApp is not initialized"}
-    NEAT_APP.cdf_store.load_rules_file_from_cdf(request.file_name, request.version)
-    return {"file_name": request.file_name, "hash": request.version}
-
-
-@router.post("/api/workflow/migrate-workflow")
-def migrate_workflow():
-    return migrate_wf_manifest(NEAT_APP.config.data_store_path)
-
-
-@router.get("/api/workflow/pre-cdf-assets/{workflow_name}")
-def get_pre_cdf_assets(workflow_name: str):
-    if NEAT_APP.workflow_manager is None:
-        return {"error": "Workflow Manager is not initialized"}
-    workflow = NEAT_APP.workflow_manager.get_workflow(workflow_name)
-    if workflow is None:
-        return {"assets": []}
-    return {"assets": workflow.data["CategorizedAssets"]}
-
-
 @router.get("/api/workflow/context/{workflow_name}")
 def get_context(workflow_name: str):
     if NEAT_APP.workflow_manager is None:
@@ -228,8 +154,8 @@ def get_context_object(workflow_name: str, object_name: str):
     if object_name not in context:
         return {"error": f"Item {object_name} is not found in workflow context"}
 
-    if object_name == "SourceGraph" or object_name == "SolutionGraph":
-        return {"object": cast(SourceGraph | SolutionGraph, context[object_name]).graph.diagnostic_report()}
+    if object_name == "NeatGraph":
+        return {"object": cast(NeatGraph, context[object_name]).graph.type_}
 
     cobject = context[object_name]
     if isinstance(cobject, DataContract):
@@ -285,7 +211,11 @@ def http_trigger_start_workflow(workflow_name: str, step_id: str, request: Reque
 
 @router.post("/api/workflow/{workflow_name}/resume/{step_id}/{instance_id}")
 def http_trigger_resume_workflow(
-    workflow_name: str, step_id: str, instance_id: str, request: Request, body: bytes = fast_api_depends
+    workflow_name: str,
+    step_id: str,
+    instance_id: str,
+    request: Request,
+    body: bytes = fast_api_depends,
 ):
     if NEAT_APP.triggers_manager is None:
         return JSONResponse(content={"error": "Triggers Manager is not initialized"}, status_code=400)

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/graph/stores/_base.py

@@ -66,6 +66,11 @@ class NeatGraphStore:
 
         self.queries = Queries(self.graph, self.rules)
 
+    @property
+    def type_(self) -> str:
+        "Return type of the graph store"
+        return type(self.graph.store).__name__
+
     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.

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/rules/importers/_inference2rules.py

@@ -1,4 +1,4 @@
-import re
+from collections import Counter, defaultdict
 from datetime import datetime
 from pathlib import Path
 from typing import Literal, cast, overload
@@ -201,6 +201,7 @@ class InferenceImporter(BaseImporter):
         classes: dict[str, dict] = {}
         properties: dict[str, dict] = {}
         prefixes: dict[str, Namespace] = get_default_prefixes()
+        count_by_value_type_by_property: dict[str, dict[str, int]] = defaultdict(Counter)
 
         query = INSTANCE_PROPERTIES_JSON_DEFINITION if self.check_for_json_string else INSTANCE_PROPERTIES_DEFINITION
         # Adds default namespace to prefixes
@@ -255,12 +256,10 @@ class InferenceImporter(BaseImporter):
                             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"
-                        ),
                     }
 
+                    count_by_value_type_by_property[id_][value_type_id] += 1
+
                     # USE CASE 1: If property is not present in properties
                     if id_ not in properties:
                         properties[id_] = definition
@@ -268,27 +267,41 @@ class InferenceImporter(BaseImporter):
                     # USE CASE 2: first time redefinition, value type change to multi
                     elif id_ in properties and definition["value_type"] not in properties[id_]["value_type"]:
                         properties[id_]["value_type"] = properties[id_]["value_type"] + " | " + definition["value_type"]
-                        properties[id_]["comment"] = (
-                            properties[id_]["comment"] + ", with" + definition["comment"].split("with")[1]
-                        )
 
                     # USE CASE 3: existing but max count is different
                     elif (
                         id_ in properties
                         and definition["value_type"] in properties[id_]["value_type"]
-                        and not (properties[id_]["max_count"] == definition["max_count"])
+                        and properties[id_]["max_count"] != definition["max_count"]
                     ):
                         properties[id_]["max_count"] = max(properties[id_]["max_count"], definition["max_count"])
 
-                        properties[id_]["comment"] = self._update_value_type_occurrence_in_comment(
-                            definition["value_type"], properties[id_]["comment"]
-                        )
-
-                    # USE CASE 4: Just update the comment with occurrence
-                    else:
-                        properties[id_]["comment"] = self._update_value_type_occurrence_in_comment(
-                            definition["value_type"], properties[id_]["comment"]
-                        )
+        # Add comments
+        for id_, property_ in properties.items():
+            if id_ not in count_by_value_type_by_property:
+                continue
+
+            count_by_value_type = count_by_value_type_by_property[id_]
+            count_list = sorted(count_by_value_type.items(), key=lambda item: item[1], reverse=True)
+            # Make the comment more readable by adapting to the number of value types
+            base_string = "<{value_type}> which occurs <{count}> times"
+            if len(count_list) == 1:
+                type_, count = count_list[0]
+                counts_str = f"with value type {base_string.format(value_type=type_, count=count)} in the graph"
+            elif len(count_list) == 1:
+                first = base_string.format(value_type=count_list[0][0], count=count_list[0][1])
+                second = base_string.format(value_type=count_list[1][0], count=count_list[1][1])
+                counts_str = f"with value types {first} and {second} in the graph"
+            else:
+                first_part = ", ".join(
+                    base_string.format(value_type=type_, count=count) for type_, count in count_list[:-1]
+                )
+                last = base_string.format(value_type=count_list[-1][0], count=count_list[-1][1])
+                counts_str = f"with value types {first_part} and {last} in the graph"
+
+            class_id = property_["class_"]
+            property_id = property_["property_"]
+            property_["comment"] = f"Class <{class_id}> has property <{property_id}> {counts_str}"
 
         return {
             "metadata": self._default_metadata().model_dump(),
@@ -319,20 +332,3 @@ class InferenceImporter(BaseImporter):
             prefix=self.prefix,
             namespace=DEFAULT_NAMESPACE,
         )
-
-    @classmethod
-    def _update_value_type_occurrence_in_comment(cls, value_type: str, comment: str) -> str:
-        occurrence = cls._read_value_type_occurrence_from_comment(value_type, comment)
-        return comment.replace(
-            f"with value type <{value_type}> which occurs <{occurrence}> times in the graph",
-            f"with value type <{value_type}> which occurs <{occurrence+1}> times in the graph",
-        )
-
-    @classmethod
-    def _read_value_type_occurrence_from_comment(cls, value_type: str, comment: str) -> int:
-        if result := re.search(
-            rf"with value type <{value_type}> which occurs <(\d+)> times in the graph",
-            comment,
-        ):
-            return int(result.group(1))
-        return 0

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/workflows/steps/data_contracts.py

@@ -1,27 +1,24 @@
 from pathlib import Path
 
 from cognite.client import CogniteClient
-from cognite.client.data_classes import Asset, AssetUpdate, Relationship, RelationshipUpdate
+from cognite.client.data_classes import (
+    Asset,
+    AssetUpdate,
+    Relationship,
+    RelationshipUpdate,
+)
 from cognite.client.data_classes.data_modeling import EdgeApply, NodeApply
 
-from cognite.neat.legacy.graph.stores import NeatGraphStoreBase
-from cognite.neat.legacy.rules.exporters._rules2dms import DMSSchemaComponents
-from cognite.neat.legacy.rules.models.rules import Rules
-from cognite.neat.rules.models import AssetRules, DMSRules, DomainRules, InformationRules
+from cognite.neat.graph.stores import NeatGraphStore
+from cognite.neat.rules.models import (
+    AssetRules,
+    DMSRules,
+    DomainRules,
+    InformationRules,
+)
 from cognite.neat.workflows.steps.step_model import DataContract
 
 
-class RulesData(DataContract):
-    """
-    This represents the TransformationRules object.
-
-    Args:
-        rules: The TransformationRules object.
-    """
-
-    rules: Rules
-
-
 class MultiRuleData(DataContract):
     domain: DomainRules | None = None
     information: InformationRules | None = None
@@ -53,27 +50,15 @@ class PathData(DataContract):
     excel_file_path: Path
 
 
-class SourceGraph(DataContract):
-    """
-    This represents the source graph.
-
-    Args:
-        graph: The source graph.
-    """
-
-    graph: NeatGraphStoreBase
-
-
-class SolutionGraph(DataContract):
+class NeatGraph(DataContract):
     """
-    This represents the solution graph.
+    This represents the neat graph.
 
     Args:
-        graph (NeatGraphStoreBase): The solution graph.
-
+        graph: The neat graph store.
     """
 
-    graph: NeatGraphStoreBase
+    graph: NeatGraphStore
 
 
 class ClientData(DataContract):
@@ -130,14 +115,3 @@ class Edges(DataContract):
     """
 
     edges: list[EdgeApply]
-
-
-class DMSSchemaComponentsData(DataContract):
-    """
-    This represents DMS Schema Model.
-
-    Args:
-        components: DMS Schema Components model.
-    """
-
-    components: DMSSchemaComponents

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/workflows/steps/lib/current/graph_extractor.py

@@ -3,11 +3,15 @@ import logging
 from pathlib import Path
 from typing import ClassVar, cast
 
+from rdflib import URIRef
+
+from cognite.neat.constants import DEFAULT_NAMESPACE
+from cognite.neat.graph.extractors import RdfFileExtractor
 from cognite.neat.graph.extractors._mock_graph_generator import MockGraphGenerator
 from cognite.neat.rules._shared import DMSRules, InformationRules
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage, StepExecutionStatus
-from cognite.neat.workflows.steps.data_contracts import MultiRuleData, SolutionGraph, SourceGraph
+from cognite.neat.workflows.steps.data_contracts import MultiRuleData, NeatGraph
 from cognite.neat.workflows.steps.step_model import Configurable, Step
 
 __all__ = ["GraphFromRdfFile", "GraphFromMockData"]
@@ -29,11 +33,16 @@ class GraphFromMockData(Step):
             value="",
             label="Target number of instances for each class",
         ),
-        Configurable(name="Graph", value="solution", label="The name of target graph.", options=["source", "solution"]),
+        Configurable(
+            name="Graph",
+            value="solution",
+            label="The name of target graph.",
+            options=["source", "solution"],
+        ),
     ]
 
     def run(  # type: ignore[override, syntax]
-        self, rules: MultiRuleData, graph_store: SolutionGraph | SourceGraph
+        self, rules: MultiRuleData, graph_store: NeatGraph
     ) -> FlowMessage:
         if self.configs is None:
             raise StepNotInitialized(type(self).__name__)
@@ -55,17 +64,12 @@ class GraphFromMockData(Step):
                 step_execution_status=StepExecutionStatus.ABORT_AND_FAIL,
             )
 
-        if self.configs["Graph"] == "solution":
-            # Todo Anders: Why is the graph fetched from context when it is passed as an argument?
-            graph_store = cast(SourceGraph | SolutionGraph, self.flow_context["SolutionGraph"])
-        else:
-            graph_store = cast(SourceGraph | SolutionGraph, self.flow_context["SourceGraph"])
-
-        logging.info("Initiated generation of mock triples")
+        extractor = MockGraphGenerator(
+            cast(InformationRules | DMSRules, rules.information or rules.dms),
+            class_count,
+        )
 
-        extractor = MockGraphGenerator(cast(InformationRules | DMSRules, rules.information or rules.dms), class_count)
-
-        graph_store.graph.add_triples(extractor.extract())
+        NeatGraph.graph.write(extractor)
 
         return FlowMessage(output_text=f"Instances loaded to the {graph_store.__class__.__name__}")
 
@@ -104,20 +108,20 @@ class GraphFromRdfFile(Step):
         ),
     ]
 
-    def run(self, source_graph: SourceGraph) -> FlowMessage:  # type: ignore[override, syntax]
+    def run(self, graph_store: NeatGraph) -> FlowMessage:  # type: ignore[override, syntax]
         if self.configs is None or self.data_store_path is None:
             raise StepNotInitialized(type(self).__name__)
-        if source_graph.graph.rdf_store_type.lower() in ("memory", "oxigraph"):
-            if source_file := self.configs["File path"]:
-                source_graph.graph.import_from_file(
-                    self.data_store_path / Path(source_file),
+
+        if source_file := self.configs["File path"]:
+            NeatGraph.graph.write(
+                RdfFileExtractor(  # type: ignore[abstract]
+                    filepath=self.data_store_path / Path(source_file),
                     mime_type=self.configs["MIME type"],  # type: ignore[arg-type]
-                    add_base_iri=self.configs["Add base URI"] == "True",
+                    base_uri=(URIRef(DEFAULT_NAMESPACE) if self.configs["Add base URI"] == "True" else None),
                 )
-                logging.info(f"Loaded {source_file} into source graph.")
-            else:
-                raise ValueError("You need a source_rdf_store.file specified for source_rdf_store.type=memory")
+            )
+
         else:
-            raise NotImplementedError(f"Graph type {source_graph.graph.rdf_store_type} is not supported.")
+            raise ValueError("You need a valid file path to be specified")
 
-        return FlowMessage(output_text="Instances loaded to source graph")
+        return FlowMessage(output_text="Instances loaded to NeatGraph!")

{cognite_neat-0.87.6 → cognite_neat-0.88.0}/cognite/neat/workflows/steps/lib/current/graph_loader.py

@@ -1,13 +1,10 @@
 import time
 from pathlib import Path
-from typing import ClassVar, cast
+from typing import ClassVar
 
 from cognite.neat.workflows._exceptions import StepNotInitialized
 from cognite.neat.workflows.model import FlowMessage
-from cognite.neat.workflows.steps.data_contracts import (
-    SolutionGraph,
-    SourceGraph,
-)
+from cognite.neat.workflows.steps.data_contracts import NeatGraph
 from cognite.neat.workflows.steps.step_model import Configurable, Step
 
 __all__ = [
@@ -26,12 +23,6 @@ class GraphToRdfFile(Step):
     category = CATEGORY
     version = "private-beta"
     configurables: ClassVar[list[Configurable]] = [
-        Configurable(
-            name="Graph",
-            value="source",
-            options=["source", "solution"],
-            label=("The graph to be used for loading RDF File." " Supported options : source, solution"),
-        ),
         Configurable(
             name="File path",
             value="staging/graph_export.ttl",
@@ -40,7 +31,7 @@ class GraphToRdfFile(Step):
     ]
 
     def run(  # type: ignore[override, syntax]
-        self, graph: SourceGraph | SolutionGraph
+        self, graph: NeatGraph
     ) -> FlowMessage:  # type: ignore[syntax]
         if self.configs is None or self.data_store_path is None:
             raise StepNotInitialized(type(self).__name__)
@@ -48,15 +39,7 @@ class GraphToRdfFile(Step):
         storage_path = self.data_store_path / Path(self.configs["File path"])
         relative_graph_file_path = str(storage_path).split("/data/")[1]
 
-        graph_name = self.configs["Graph"] or "source"
-
-        if graph_name == "solution":
-            # Todo Anders: Why is the graph fetched from context when it is passed as an argument?
-            graph = cast(SourceGraph | SolutionGraph, self.flow_context["SolutionGraph"])
-        else:
-            graph = cast(SourceGraph | SolutionGraph, self.flow_context["SourceGraph"])
-
-        graph.graph.serialize(str(storage_path), format="turtle")
+        graph.graph.graph.serialize(str(storage_path), format="turtle")
 
         output_text = (
             "<p></p>"