midpoint - go

backend/app/main.py

@@ -1,81 +1,34 @@
 from __future__ import annotations
 
 from contextlib import asynccontextmanager
-import logging
-import asyncio
 
 from fastapi import FastAPI, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
 
 from .models import (
-    EdgesResponse,
     GraphResponse,
     NeighborsRequest,
     NeighborsResponse,
-    NodesResponse,
     SparqlQueryRequest,
     StatsResponse,
 )
 from .pipelines.layout_dag_radial import CycleError
-from .pipelines.owl_imports_combiner import (
-    build_combined_graph,
-    output_location_to_path,
-    resolve_output_location,
-    serialize_graph_to_ttl,
-)
 from .pipelines.selection_neighbors import fetch_neighbor_ids_for_selection
 from .pipelines.snapshot_service import GraphSnapshotService
-from .rdf_store import RDFStore
-from .sparql_engine import RdflibEngine, SparqlEngine, create_sparql_engine
+from .sparql_engine import SparqlEngine, create_sparql_engine
 from .settings import Settings
 
 
 settings = Settings()
-logger = logging.getLogger(__name__)
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    rdflib_preloaded_graph = None
-
-    if settings.combine_owl_imports_on_start:
-        entry_location = settings.combine_entry_location or settings.ttl_path
-        output_location = resolve_output_location(
-            entry_location,
-            output_location=settings.combine_output_location,
-            output_name=settings.combine_output_name,
-        )
-
-        output_path = output_location_to_path(output_location)
-        if output_path.exists() and not settings.combine_force:
-            logger.info("Skipping combine step (output exists): %s", output_location)
-        else:
-            rdflib_preloaded_graph = await asyncio.to_thread(build_combined_graph, entry_location)
-            logger.info("Finished combining imports; serializing to: %s", output_location)
-            await asyncio.to_thread(serialize_graph_to_ttl, rdflib_preloaded_graph, output_location)
-
-        if settings.graph_backend == "rdflib":
-            settings.ttl_path = str(output_path)
-
-    sparql: SparqlEngine = create_sparql_engine(settings, rdflib_graph=rdflib_preloaded_graph)
+    sparql: SparqlEngine = create_sparql_engine(settings)
     await sparql.startup()
     app.state.sparql = sparql
     app.state.snapshot_service = GraphSnapshotService(sparql=sparql, settings=settings)
 
-    # Only build node/edge tables when running in rdflib mode.
-    if settings.graph_backend == "rdflib":
-        assert isinstance(sparql, RdflibEngine)
-        if sparql.graph is None:
-            raise RuntimeError("rdflib graph failed to load")
-
-        store = RDFStore(
-            ttl_path=settings.ttl_path,
-            include_bnodes=settings.include_bnodes,
-            max_triples=settings.max_triples,
-        )
-        store.load(sparql.graph)
-        app.state.store = store
-
     yield
 
     await sparql.shutdown()
@@ -109,7 +62,7 @@ async def stats() -> StatsResponse:
     meta = snap.meta
     return StatsResponse(
         backend=meta.backend if meta else app.state.sparql.name,
-        ttl_path=meta.ttl_path if meta and meta.ttl_path else settings.ttl_path,
+        ttl_path=meta.ttl_path if meta else None,
         sparql_endpoint=meta.sparql_endpoint if meta else None,
         parsed_triples=len(snap.edges),
         nodes=len(snap.nodes),
@@ -138,28 +91,6 @@ async def neighbors(req: NeighborsRequest) -> NeighborsResponse:
     return NeighborsResponse(selected_ids=req.selected_ids, neighbor_ids=neighbor_ids)
 
 
-@app.get("/api/nodes", response_model=NodesResponse)
-def nodes(
-    limit: int = Query(default=10_000, ge=1, le=200_000),
-    offset: int = Query(default=0, ge=0),
-) -> NodesResponse:
-    if settings.graph_backend != "rdflib":
-        raise HTTPException(status_code=501, detail="GET /api/nodes is only supported in GRAPH_BACKEND=rdflib mode")
-    store: RDFStore = app.state.store
-    return NodesResponse(total=store.node_count, nodes=store.node_slice(offset=offset, limit=limit))
-
-
-@app.get("/api/edges", response_model=EdgesResponse)
-def edges(
-    limit: int = Query(default=50_000, ge=1, le=500_000),
-    offset: int = Query(default=0, ge=0),
-) -> EdgesResponse:
-    if settings.graph_backend != "rdflib":
-        raise HTTPException(status_code=501, detail="GET /api/edges is only supported in GRAPH_BACKEND=rdflib mode")
-    store: RDFStore = app.state.store
-    return EdgesResponse(total=store.edge_count, edges=store.edge_slice(offset=offset, limit=limit))
-
-
 @app.get("/api/graph", response_model=GraphResponse)
 async def graph(
     node_limit: int = Query(default=50_000, ge=1, le=200_000),