cognite-neat 0.87.4__py3-none-any.whl → 0.88.0__py3-none-any.whl

cognite/neat/app/api/routers/core.py

@@ -1,91 +0,0 @@
-import json
-import shutil
-import tempfile
-from copy import deepcopy
-from pathlib import Path
-from typing import cast
-
-from fastapi import APIRouter, UploadFile
-
-from cognite.neat.app.api.configuration import NEAT_APP
-from cognite.neat.rules import exporters, importers
-from cognite.neat.rules.models import DMSRules, RoleTypes
-
-router = APIRouter()
-
-
-@router.post("/api/core/convert")
-async def convert_data_model_to_rules(file: UploadFile):
-    suffix = Path(cast(str, file.filename)).suffix
-
-    if suffix not in [".xlsx", ".ttl", ".owl", ".json", ".yaml"]:
-        return {
-            "filename": None,
-            "content": None,
-            "issues": [f"File type {suffix} not supported. Supported types are ['.xlsx', '.ttl', '.json', '.yaml']"],
-        }
-
-    with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as temp:
-        shutil.copyfileobj(file.file, temp)  # type: ignore # known issue with mypy
-        temp_filepath = Path(temp.name)
-
-    # read as Excel rules
-    if suffix == ".xlsx":
-        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)
-
-    # load as YAML
-    elif suffix in [".yml", ".yaml"]:
-        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)
-
-    # Remove the temporary file
-    temp_filepath.unlink()
-
-    return {"filename": file.filename, "content": rules.model_dump(by_alias=True) if rules else None, "issues": issues}
-
-
-@router.post("/api/core/rules2dms")
-async def convert_rules_to_dms(rules: DMSRules):
-    dms_schema = exporters.DMSExporter().export(rules)
-    containers = {f"{container.space}:{container.external_id}": container.dump() for container in dms_schema.containers}
-    views = {f"{view.space}:{view.external_id}": view.dump() for view in dms_schema.views}
-
-    if views and containers:
-        _to_visualization_compliant_views(views, containers)
-
-    return {
-        "views": list(views.values()) if views else None,
-        "containers": list(containers.values()) if containers else None,
-    }
-
-
-def _to_visualization_compliant_views(views, containers):
-    for view in views.values():
-        for property in view["properties"].values():
-            # needs coping information from container:
-            if property.get("container", None) and property["container"]["type"] == "container":
-                container_id = f"{property['container']['space']}:{property['container']['externalId']}"
-                container_property_def = deepcopy(
-                    containers[container_id]["properties"][property["containerPropertyIdentifier"]]
-                )
-                property["type"] = container_property_def["type"]
-                container_property_def.pop("type")
-                property.update(container_property_def)
-
-
-@router.post("/api/core/publish-rules")
-async def publish_rules_as_data_model(rules: DMSRules):
-    if NEAT_APP.cdf_client:
-        uploaded = exporters.DMSExporter().export_to_cdf(rules, NEAT_APP.cdf_client)
-        return {"uploaded": uploaded}
-    else:
-        return {"uploaded": []}

cognite/neat/app/api/routers/data_exploration.py

@@ -1,336 +0,0 @@
-import logging
-import time
-import traceback
-from typing import Any, cast
-
-import rdflib
-from fastapi import APIRouter
-
-from cognite.neat.app.api.asgi.metrics import counter
-from cognite.neat.app.api.configuration import CACHE_STORE, NEAT_APP
-from cognite.neat.app.api.data_classes.rest import (
-    DatatypePropertyRequest,
-    NodesAndEdgesRequest,
-    QueryRequest,
-    RuleRequest,
-)
-from cognite.neat.app.api.utils.data_mapping import rdf_result_to_api_response
-from cognite.neat.app.api.utils.query_templates import query_templates
-from cognite.neat.legacy.graph.transformations import query_generator
-from cognite.neat.utils.rdf_ import remove_namespace_from_uri
-from cognite.neat.workflows.steps.data_contracts import RulesData, SolutionGraph, SourceGraph
-
-router = APIRouter()
-
-
-@router.get("/api/list-queries")
-def list_queries():
-    counter.inc()
-    return query_templates
-
-
-@router.post("/api/get-datatype-properties")
-def get_datatype_properties(request: DatatypePropertyRequest):
-    logging.info("Querying datatype properties ordered by usage:")
-    if "get_datatype_properties" in CACHE_STORE and request.cache:
-        return CACHE_STORE["get_datatype_properties"]
-    sparql_query: str = (
-        "SELECT DISTINCT ?property (count(?o) as ?occurrence ) "
-        "WHERE { ?s ?property ?o . FILTER(isLiteral(?o))} "
-        "group by ?property order by DESC(?occurrence)"
-    )
-    if request.limit != -1:
-        query = f"{sparql_query} LIMIT {request.limit}"
-    else:
-        query = sparql_query
-
-    results = get_data_from_graph(query, request.graph_name, request.workflow_name)
-
-    try:
-        datatype_properties = [
-            {
-                "id": row[rdflib.Variable("property")],
-                "count": int(row[rdflib.Variable("occurrence")]),
-                "name": remove_namespace_from_uri(row[rdflib.Variable("property")]),
-            }
-            for row in results["rows"]
-        ]
-    except Exception as e:
-        logging.error(f"Error while parsing datatype properties : {e}")
-
-    merged_result = {
-        "datatype_properties": datatype_properties,
-        "error": "",
-        "elapsed_time_sec": results["elapsed_time_sec"],
-        "query": query,
-    }
-
-    if request.cache:
-        CACHE_STORE["get_datatype_properties"] = merged_result
-    return merged_result
-
-
-@router.post("/api/get-nodes-and-edges")
-def get_nodes_and_edges(request: NodesAndEdgesRequest):
-    logging.info("Querying graph nodes and edges :")
-    if "get_nodes_and_edges" in CACHE_STORE and request.cache:
-        return CACHE_STORE["get_nodes_and_edges"]
-    elapsed_time_sec: float
-    edges_result: dict | list
-    nodes_result: dict | list
-    """
-    "nodes": [
-        {
-            "node_id": "http://purl.org/nordic44#_a63ce14e-fba0-4f9e-8b59-7ef2fe887ff8",
-            "node_class": "http://entsoe.eu/CIM/SchemaExtension/3/2#RateTemperature",
-            "node_name": "-5degreeCelsius"
-        }],
-    "edges": [
-        {
-            "src_object_ref": "http://purl.org/nordic44#_f1769eaa-9aeb-11e5-91da-b8763fd99c5f",
-            "conn": "http://iec.ch/TC57/2013/CIM-schema-cim16#OperationalLimitSet.Terminal",
-            "dst_object_ref": "http://purl.org/nordic44#_2dd90186-bdfb-11e5-94fa-c8f73332c8f4"
-        },
-    """
-    if request.sparql_query:
-        mixed_result = get_data_from_graph(request.sparql_query, request.graph_name, request.workflow_name)
-
-        edges_result = []
-        nodes_result = []
-        try:
-            nodes_result = [
-                {
-                    "node_id": v[rdflib.Variable("node_id")],
-                    "node_class": v[rdflib.Variable("node_class")],
-                    "node_name": v[rdflib.Variable("node_name")],
-                }
-                for v in mixed_result["rows"]
-            ]
-        except Exception as e:
-            logging.error(f"Error while parsing nodes : {e}")
-
-        try:
-            edges_result = [
-                {
-                    "src_object_ref": v[rdflib.Variable("src_object_ref")],
-                    "dst_object_ref": v[rdflib.Variable("dst_object_ref")],
-                }
-                for v in mixed_result["rows"]
-                if rdflib.Variable("src_object_ref") in v and rdflib.Variable("dst_object_ref") in v
-            ]
-        except Exception as e:
-            logging.error(f"Error while parsing edges : {e}")
-
-        query = request.sparql_query
-        elapsed_time_sec = mixed_result["elapsed_time_sec"]
-    else:
-        nodes_filter = ""
-        edges_dst_filter = ""
-        edges_src_filter = ""
-
-        if len(request.node_class_filter) > 0:
-            nodes_filter = "VALUES ?node_class { " + " ".join([f"<{x}>" for x in request.node_class_filter]) + " }"
-
-        if request.node_name_property:
-            nodes_query = f"SELECT DISTINCT ?node_id ?node_class ?node_name WHERE \
-            {{ {nodes_filter} \
-            ?node_id {request.node_name_property} ?node_name . ?node_id a ?node_class }} "
-        else:
-            nodes_query = f"SELECT DISTINCT ?node_id ?node_class (?node_id AS ?node_name) WHERE \
-            {{ {nodes_filter} ?node_id a ?node_class }} "
-
-        if len(request.src_edge_filter) > 0:
-            edges_src_filter = (
-                "VALUES ?src_object_class { " + " ".join([f"<{x}>" for x in request.src_edge_filter]) + " }"
-            )
-        if len(request.dst_edge_filter) > 0:
-            edges_dst_filter = (
-                "VALUES ?dst_object_class { " + " ".join([f"<{x}>" for x in request.dst_edge_filter]) + " }"
-            )
-
-        edges_query = f"SELECT  ?src_object_ref ?conn ?dst_object_ref \
-            WHERE {{ \
-            {edges_src_filter} \
-            {edges_dst_filter} \
-            ?src_object_ref ?conn  ?dst_object_ref . \
-            ?src_object_ref  a ?src_object_class . \
-            ?dst_object_ref  a ?dst_object_class .\
-            }} "
-        nodes_query = f"{nodes_query} LIMIT {request.limit}"
-        edges_query = f"{edges_query} LIMIT {request.limit}"
-        logging.info(f"Nodes query : {nodes_query}")
-        logging.info(f"Edges query : {edges_query}")
-        nodes_result = get_data_from_graph(nodes_query, request.graph_name, request.workflow_name)
-        edges_result = get_data_from_graph(edges_query, request.graph_name, request.workflow_name)
-        elapsed_time_sec = nodes_result["elapsed_time_sec"] + edges_result["elapsed_time_sec"]
-        query = nodes_query + edges_query
-        nodes_result = nodes_result["rows"]
-        edges_result = edges_result["rows"]
-
-    merged_result = {
-        "nodes": nodes_result,
-        "edges": edges_result,
-        "error": "",
-        "elapsed_time_sec": elapsed_time_sec,
-        "query": query,
-    }
-
-    if request.cache:
-        CACHE_STORE["get_nodes_and_edges"] = merged_result
-    return merged_result
-
-
-@router.post("/api/query")
-def query_graph(request: QueryRequest):
-    logging.info(f"Querying graph {request.graph_name} with query {request.query}")
-    sparq_query = request.query
-    return get_data_from_graph(sparq_query, request.graph_name, workflow_name=request.workflow_name)
-
-
-@router.post("/api/execute-rule")
-def execute_rule(request: RuleRequest):
-    if NEAT_APP.workflow_manager is None:
-        return {"error": "NeatApp is not initialized"}
-    logging.debug(
-        f"Executing rule type: { request.rule_type } rule : {request.rule} , workflow : {request.workflow_name} , "
-        f"graph : {request.graph_name}"
-    )
-    workflow = NEAT_APP.workflow_manager.get_workflow(request.workflow_name)
-    if workflow is None:
-        return {"error": f"Workflow {request.workflow_name} not found"}
-
-    api_result = {"error": ""}
-    workflow_context = workflow.get_context()
-    if workflow_context is None:
-        return {"error": "Workflow context is not initialized"}
-    if request.graph_name == "source":
-        if "SourceGraph" in workflow_context:
-            graph = cast(SourceGraph, workflow_context["SourceGraph"]).graph
-        else:
-            logging.info("Source graph is empty , please load the graph first")
-            api_result["error"] = "source graph is empty , please load the graph first"
-    elif request.graph_name == "solution":
-        if "SolutionGraph" in workflow_context:
-            graph = cast(SolutionGraph, workflow_context["SolutionGraph"]).graph
-        else:
-            logging.info("Solution graph is empty , please load the graph first")
-            api_result["error"] = "solution graph is empty , please load the graph first"
-    else:
-        raise Exception("Unknown graph name")
-
-    if request.rule_type == "rdfpath":
-        start_time = time.perf_counter()
-        rules = cast(RulesData, workflow_context["RulesData"]).rules
-        sparql_query = query_generator.build_sparql_query(
-            graph,  # type: ignore[arg-type]
-            request.rule,
-            prefixes=rules.prefixes,
-        )
-    else:
-        logging.error("Unknown rule type")
-        return {"error": "Unknown rule type"}
-    stop_time = time.perf_counter()
-    elapsed_time_sec_1 = stop_time - start_time
-    logging.info(f"Computed query : {sparql_query} in {elapsed_time_sec_1 * 1000} ms")
-
-    api_result = get_data_from_graph(sparql_query, request.graph_name, workflow_name=request.workflow_name)
-    api_result["elapsed_time_sec"] += elapsed_time_sec_1
-    return api_result
-
-
-@router.get("/api/object-properties")
-def get_object_properties(reference: str, graph_name: str = "source", workflow_name: str = "default"):
-    logging.info(f"Querying object-properties from {graph_name} :")
-    query = f"SELECT ?property ?value WHERE {{ <{reference}> ?property ?value }} ORDER BY ?property"
-    return get_data_from_graph(query, graph_name, workflow_name=workflow_name)
-
-
-@router.get("/api/search")
-def search(
-    search_str: str, graph_name: str = "source", search_type: str = "value_exact_match", workflow_name: str = "default"
-):
-    logging.info(f"Search from {graph_name} :")
-    if search_type == "reference":
-        query = (
-            f"SELECT ?class ?reference WHERE {{ {{?reference ?class <{search_str}> . }} "
-            f"UNION {{ <{search_str}> ?class ?reference }} }} limit 10000"
-        )
-
-    elif search_type == "value_exact_match":
-        query = (
-            f"select ?object_ref ?type ?property ?value where "
-            f"{{ ?object_ref ?property ?value . ?object_ref a ?type . "
-            f'FILTER(?value="{search_str}") }} limit 10000'
-        )
-    elif search_type == "value_regexp":
-        query = (
-            f"select ?object_ref ?type ?property ?value where "
-            f"{{ ?object_ref ?property ?value . ?object_ref a ?type .  "
-            f'FILTER regex(?value, "{search_str}","i") }} limit 10000'
-        )
-    return get_data_from_graph(query, graph_name, workflow_name=workflow_name)
-
-
-@router.get("/api/get-classes")
-def get_classes(graph_name: str = "source", workflow_name: str = "default", cache: bool = True):
-    logging.info(f"Querying graph classes from graph name : {graph_name}, cache : {cache}")
-    cache_key = f"classes_{graph_name}"
-    if cache_key in CACHE_STORE and cache:
-        return CACHE_STORE[cache_key]
-    query = (
-        "SELECT ?class (count(?s) as ?instances ) WHERE { ?s a ?class . } " "group by ?class order by DESC(?instances)"
-    )
-    api_result = get_data_from_graph(query, graph_name, workflow_name)
-    CACHE_STORE["get_classes"] = api_result
-    return api_result
-
-
-def get_data_from_graph(sparq_query: str, graph_name: str = "source", workflow_name: str = "default") -> dict[str, Any]:
-    if NEAT_APP.workflow_manager is None:
-        return {"error": "NeatApp is not initialized"}
-    total_elapsed_time = 0.0
-    api_result: dict[str, Any] = {"error": ""}
-    result = None
-
-    try:
-        logging.info(f"Preparing query :{sparq_query} ")
-        start_time = time.perf_counter()
-        workflow = NEAT_APP.workflow_manager.get_workflow(workflow_name)
-        if workflow is None:
-            return {"error": f"Workflow {workflow_name} not found"}
-        workflow_context = workflow.get_context()
-
-        if graph_name == "source":
-            if "SourceGraph" in workflow_context:
-                result = cast(SourceGraph, workflow_context["SourceGraph"]).graph.query(sparq_query)
-            else:
-                logging.info("Source graph is empty , please load the graph first")
-                api_result["error"] = "source graph is empty , please load the graph first"
-        elif graph_name == "solution":
-            if "SolutionGraph" in workflow_context:
-                result = cast(SolutionGraph, workflow_context["SolutionGraph"]).graph.query(sparq_query)
-            else:
-                logging.info("Solution graph is empty , please load the graph first")
-                api_result["error"] = "solution graph is empty , please load the graph first"
-        else:
-            raise Exception("Unknown graph name")
-
-        stop_time = time.perf_counter()
-        elapsed_time_sec_1 = stop_time - start_time
-        logging.info(f"Query prepared in {elapsed_time_sec_1 * 1000} ms")
-
-        start_time = time.perf_counter()
-        if result:
-            api_result = rdf_result_to_api_response(result)
-        stop_time = time.perf_counter()
-        elapsed_time_sec_2 = stop_time - start_time
-        total_elapsed_time = elapsed_time_sec_1 + elapsed_time_sec_2
-    except Exception as e:
-        logging.error(f"Error while executing query :{e}")
-        traceback.print_exc()
-        api_result["error"] = str(e)
-
-    api_result["query"] = sparq_query
-    api_result["elapsed_time_sec"] = total_elapsed_time
-    logging.info(f"Data fetched in {total_elapsed_time * 1000} ms")
-    return api_result

cognite/neat/app/api/routers/rules.py

@@ -1,203 +0,0 @@
-import logging
-from pathlib import Path
-from typing import Any, cast
-
-from fastapi import APIRouter, Response
-from rdflib import Namespace
-
-from cognite.neat.app.api.configuration import NEAT_APP
-from cognite.neat.app.api.data_classes.rest import TransformationRulesUpdateRequest
-from cognite.neat.legacy.rules import exporters as legacy_exporters
-from cognite.neat.legacy.rules import importers as legacy_importers
-from cognite.neat.legacy.rules.models._base import EntityTypes
-from cognite.neat.legacy.rules.models.rules import Class, Classes, Metadata, Properties, Property, Rules
-from cognite.neat.rules import importers
-from cognite.neat.rules.models import RoleTypes
-from cognite.neat.workflows.steps.data_contracts import RulesData
-from cognite.neat.workflows.steps.lib.current.rules_exporter import RulesToExcel
-from cognite.neat.workflows.steps.lib.current.rules_importer import ExcelToRules
-from cognite.neat.workflows.steps.lib.legacy.rules_importer import ImportExcelToRules
-from cognite.neat.workflows.utils import get_file_hash
-
-router = APIRouter()
-
-
-@router.get("/api/rules/list")
-def get_rules_list():
-    rules_dir = Path(NEAT_APP.config.rules_store_path)
-    return {"result": [str(file.name) for file in rules_dir.glob("*.xlsx")]}
-
-
-@router.get("/api/rules")
-def get_rules(
-    sheetname: str = "Properties",
-    url: str | None = None,
-    source_type: str | None = None,
-    orient: str = "columns",
-    workflow_name: str = "default",
-    file_name: str | None = None,
-    version: str | None = None,
-    as_role: str | None = None,
-) -> dict[str, Any]:
-    rules_schema_version = ""
-    if NEAT_APP.cdf_store is None or NEAT_APP.workflow_manager is None:
-        return {"error": "NeatApp is not initialized"}
-    if workflow_name != "undefined":
-        workflow = NEAT_APP.workflow_manager.get_workflow(workflow_name)
-        if workflow is None:
-            return {"error": f"Workflow {workflow_name} is not found"}
-        workflow_definition = workflow.get_workflow_definition()
-        if not file_name:
-            for step in workflow_definition.steps:
-                if step.method == ImportExcelToRules.__name__:
-                    file_name = step.configs["file_name"]
-                    version = step.configs["version"]
-                    break
-                if step.method == RulesToExcel.__name__ or step.method == ExcelToRules.__name__:
-                    rules_schema_version = "v2"
-                    as_role = step.configs.get("as_role", "")
-                    file_name = step.configs.get("File name", "")
-                    if file_name:
-                        break
-                    file_name = step.configs.get("File path", "")
-                    break
-
-    if not file_name:
-        return {"error": "File name is not provided"}
-    rules_file = Path(file_name)
-    if str(rules_file.parent) == ".":
-        path = Path(NEAT_APP.config.rules_store_path) / rules_file
-    else:
-        path = Path(NEAT_APP.config.data_store_path) / rules_file
-
-    src = "local"
-    if url:
-        path = Path(url)
-
-    if path.exists() and not version:
-        logging.info(f"Loading rules from {path}")
-    elif path.exists() and version:
-        hash_ = get_file_hash(path)
-        if hash_ != version:
-            NEAT_APP.cdf_store.load_rules_file_from_cdf(file_name, version)
-            src = "cdf"
-    else:
-        NEAT_APP.cdf_store.load_rules_file_from_cdf(file_name, version)
-        src = "cdf"
-
-    error_text = ""
-    properties = []
-    classes = []
-    remaped_rules = {}
-    try:
-        # Trying to load rules V1
-        if rules_schema_version == "" or rules_schema_version == "v1":
-            rules = cast(
-                Rules, legacy_importers.ExcelImporter(path).to_rules(return_report=False, skip_validation=False)
-            )
-            properties = [
-                {
-                    "class": value.class_id,
-                    "property": value.property_id,
-                    "property_description": value.description,
-                    "property_type": (
-                        value.expected_value_type.versioned_id
-                        if value.property_type == EntityTypes.object_property
-                        else value.expected_value_type.suffix
-                    ),
-                    "cdf_resource_type": value.cdf_resource_type,
-                    "cdf_metadata_type": value.resource_type_property,
-                    "rule_type": value.rule_type,
-                    "rule": value.rule,
-                }
-                for value in rules.properties.values()
-            ]
-
-            classes = [
-                {
-                    "class": value.class_id,
-                    "class_description": value.description,
-                    "cdf_resource_type": value.cdf_resource_type,
-                }
-                for value in rules.classes.values()
-            ]
-            rules_schema_version = "v1"
-            remaped_rules = {"properties": properties, "metadata": rules.metadata.model_dump(), "classes": classes}
-    except Exception as e:
-        error_text = str(e)
-
-    if rules_schema_version == "" or rules_schema_version == "v2":
-        try:
-            role = RoleTypes(as_role) if as_role else None
-            rules_v2, issues = importers.ExcelImporter(path).to_rules(role=role)
-            error_text = ""
-            rules_schema_version = "v2"
-            if rules_v2:
-                remaped_rules = rules_v2.model_dump()
-        except Exception as e:
-            error_text = str(e)
-            rules_schema_version = "unknown"
-
-    return {
-        "rules": remaped_rules,
-        "file_name": path.name,
-        "hash": get_file_hash(path),
-        "error_text": error_text,
-        "src": src,
-        "rules_schema_version": rules_schema_version,
-    }
-
-
-@router.get("/api/rules/from_file")
-def get_original_rules_from_file(file_name: str):
-    # """Endpoint for retrieving raw transformation from file"""
-    path = Path(NEAT_APP.config.rules_store_path) / file_name
-    rules = cast(
-        Rules, legacy_importers.ExcelImporter(filepath=path).to_rules(return_report=False, skip_validation=False)
-    )
-    return Response(content=rules.model_dump_json(), media_type="application/json")
-
-
-@router.get("/api/rules/from_workflow")
-def get_original_rules_from_workflow(workflow_name: str):
-    """Endpoing for retrieving transformation from memmory"""
-    workflow = NEAT_APP.workflow_manager.get_workflow(workflow_name)
-    if workflow is None:
-        return {"error": f"Workflow {workflow_name} is not found"}
-    context = workflow.get_context()
-    rules_data = context["RulesData"]
-    if type(rules_data) != RulesData:
-        return {"error": "RulesData is not found in workflow context"}
-
-    return Response(content=rules_data.rules.model_dump_json(), media_type="application/json")
-
-
-@router.post("/api/rules/model_and_transformations")
-def upsert_rules(request: TransformationRulesUpdateRequest):
-    """Endpoing for updating transformation rules via API . This endpoint is still experimental"""
-    rules = request.rules_object
-    rules["metadata"]["namespace"] = Namespace(rules["metadata"]["namespace"])
-    metadata = Metadata(**rules["metadata"])
-    classes = Classes()
-    for class_, val in rules["classes"].items():
-        classes[class_] = Class(**val)
-    properties = Properties()
-
-    for prop, val in rules["properties"].items():
-        val["resource_type_property"] = []
-        properties[prop] = Property(**val)
-
-    prefixes: dict[str, Namespace] = {}
-    for prefix, val in rules["prefixes"].items():
-        prefixes[prefix] = Namespace(val)
-
-    rules = Rules(metadata=metadata, classes=classes, properties=properties, prefixes=prefixes, instances=[])
-    if request.output_format == "excel":
-        rules_file = Path(request.file_name)
-        if str(rules_file.parent) == ".":
-            path = Path(NEAT_APP.config.rules_store_path) / rules_file
-        else:
-            path = Path(NEAT_APP.config.data_store_path) / rules_file
-
-        legacy_exporters.ExcelExporter(rules=rules).export_to_file(path)
-    return {"status": "ok"}

cognite/neat/legacy/graph/__init__.py

@@ -1,3 +0,0 @@
-from .stores import NeatGraphStoreBase
-
-__all__ = ["NeatGraphStoreBase"]