Use cwd instead of LYNXKITE_DATA.

Dockerfile

@@ -11,6 +11,6 @@ RUN uv venv && uv pip install \
   -e lynxkite-graph-analytics \
   -e lynxkite-bio \
   -e lynxkite-pillow-example
-ENV LYNXKITE_DATA=examples
+WORKDIR $HOME/app/examples
 ENV PORT=7860
 CMD ["uv", "run", "lynxkite"]

README.md

@@ -41,7 +41,7 @@ uv pip install -e lynxkite-core/[dev] -e lynxkite-app/[dev] -e lynxkite-graph-an
 This also builds the frontend, hopefully very quickly. To run it:
 
 ```bash
-LYNXKITE_DATA=examples LYNXKITE_RELOAD=1 lynxkite
+cd examples && LYNXKITE_RELOAD=1 lynxkite
 ```
 
 If you also want to make changes to the frontend with hot reloading:

examples/AIMO

@@ -786,7 +786,7 @@
       "data": {
         "title": "Input CSV",
         "params": {
-          "filename": "data/aimo-examples.csv",
+          "filename": "uploads/aimo-examples.csv",
           "key": "problem"
         },
         "display": null,

examples/Bio demo

@@ -7,7 +7,7 @@
       "data": {
         "title": "Import CSV",
         "params": {
-          "filename": "examples/drug_target_data_sample.csv",
+          "filename": "uploads/drug_target_data_sample.csv",
           "separator": "<auto>",
           "columns": "<from file>"
         },

examples/Graph RAG

@@ -7,7 +7,7 @@
       "data": {
         "title": "Input document",
         "params": {
-          "filename": "examples/example-pizza.md"
+          "filename": "uploads/example-pizza.md"
         },
         "display": null,
         "error": null,

examples/LynxScribe demo

@@ -138,7 +138,7 @@
       "data": {
         "title": "Scenario selector",
         "params": {
-          "scenario_file": "/home/darabos/nvme/lynxscribe/examples/chat_api/scenarios.yaml",
+          "scenario_file": "uploads/chat_api/scenarios.yaml",
           "node_types": "intent_cluster"
         },
         "display": null,
@@ -252,9 +252,9 @@
       "data": {
         "title": "Knowledge base",
         "params": {
-          "template_cluster_path": "/home/darabos/nvme/lynxscribe/examples/chat_api/data/lynx/tempclusters.pickle",
-          "edges_path": "/home/darabos/nvme/lynxscribe/examples/chat_api/data/lynx/edges.pickle",
-          "nodes_path": "/home/darabos/nvme/lynxscribe/examples/chat_api/data/lynx/nodes.pickle"
+          "template_cluster_path": "uploads/chat_api/data/lynx/tempclusters.pickle",
+          "edges_path": "uploads/chat_api/data/lynx/edges.pickle",
+          "nodes_path": "uploads/chat_api/data/lynx/nodes.pickle"
         },
         "display": null,
         "error": null,

lynxkite-app/README.md

@@ -13,7 +13,7 @@ To run the backend:
 
 ```bash
 uv pip install -e .
-LYNXKITE_DATA=../examples LYNXKITE_RELOAD=1 lynxkite
+cd ../examples && LYNXKITE_RELOAD=1 lynxkite
 ```
 
 To run the frontend:

lynxkite-app/src/lynxkite_app/config.py

@@ -1,8 +0,0 @@
-"""Some common configuration."""
-
-import os
-import pathlib
-
-
-DATA_PATH = pathlib.Path(os.environ.get("LYNXKITE_DATA", "lynxkite_data"))
-CRDT_PATH = pathlib.Path(os.environ.get("LYNXKITE_CRDT_DATA", "lynxkite_crdt_data"))

lynxkite-app/src/lynxkite_app/crdt.py

@@ -3,6 +3,7 @@
 import asyncio
 import contextlib
 import enum
+import pathlib
 import fastapi
 import os.path
 import pycrdt
@@ -11,7 +12,6 @@ import pycrdt_websocket.ystore
 import uvicorn
 import builtins
 from lynxkite.core import workspace, ops
-from . import config
 
 router = fastapi.APIRouter()
 
@@ -32,8 +32,9 @@ class WebsocketServer(pycrdt_websocket.WebsocketServer):
 
         The workspace is loaded from "crdt_data" if it exists there, or from "data", or a new workspace is created.
         """
-        path = config.CRDT_PATH / f"{name}.crdt"
-        assert path.is_relative_to(config.CRDT_PATH)
+        crdt_path = pathlib.Path(".crdt")
+        path = crdt_path / f"{name}.crdt"
+        assert path.is_relative_to(crdt_path)
         ystore = pycrdt_websocket.ystore.FileYStore(path)
         ydoc = pycrdt.Doc()
         ydoc["workspace"] = ws = pycrdt.Map()
@@ -165,9 +166,8 @@ def try_to_load_workspace(ws: pycrdt.Map, name: str):
         ws: CRDT object to udpate with the workspace contents.
         name: Name of the workspace to load.
     """
-    json_path = f"{config.DATA_PATH}/{name}"
-    if os.path.exists(json_path):
-        ws_pyd = workspace.load(json_path)
+    if os.path.exists(name):
+        ws_pyd = workspace.load(name)
         # We treat the display field as a black box, since it is a large
         # dictionary that is meant to change as a whole.
         crdt_update(ws, ws_pyd.model_dump(), non_collaborative_fields={"display"})
@@ -225,8 +225,9 @@ async def execute(
         except asyncio.CancelledError:
             return
     print(f"Running {name} in {ws_pyd.env}...")
-    path = config.DATA_PATH / name
-    assert path.is_relative_to(config.DATA_PATH), "Provided workspace path is invalid"
+    cwd = pathlib.Path()
+    path = cwd / name
+    assert path.is_relative_to(cwd), "Provided workspace path is invalid"
     # Save user changes before executing, in case the execution fails.
     workspace.save(ws_pyd, path)
     ws_pyd._crdt = ws_crdt

lynxkite-app/src/lynxkite_app/main.py

@@ -11,7 +11,7 @@ from fastapi.middleware.gzip import GZipMiddleware
 import starlette
 from lynxkite.core import ops
 from lynxkite.core import workspace
-from . import crdt, config
+from . import crdt
 
 
 def detect_plugins():
@@ -45,9 +45,12 @@ class SaveRequest(workspace.BaseConfig):
     ws: workspace.Workspace
 
 
+data_path = pathlib.Path()
+
+
 def save(req: SaveRequest):
-    path = config.DATA_PATH / req.path
-    assert path.is_relative_to(config.DATA_PATH)
+    path = data_path / req.path
+    assert path.is_relative_to(data_path)
     workspace.save(req.ws, path)
 
 
@@ -61,18 +64,17 @@ async def save_and_execute(req: SaveRequest):
 
 @app.post("/api/delete")
 async def delete_workspace(req: dict):
-    json_path: pathlib.Path = config.DATA_PATH / req["path"]
-    crdt_path: pathlib.Path = config.CRDT_PATH / f"{req['path']}.crdt"
-    assert json_path.is_relative_to(config.DATA_PATH)
-    assert crdt_path.is_relative_to(config.CRDT_PATH)
+    json_path: pathlib.Path = data_path / req["path"]
+    crdt_path: pathlib.Path = data_path / ".crdt" / f"{req['path']}.crdt"
+    assert json_path.is_relative_to(data_path)
     json_path.unlink()
     crdt_path.unlink()
 
 
 @app.get("/api/load")
 def load(path: str):
-    path = config.DATA_PATH / path
-    assert path.is_relative_to(config.DATA_PATH)
+    path = data_path / path
+    assert path.is_relative_to(data_path)
     if not path.exists():
         return workspace.Workspace()
     return workspace.load(path)
@@ -85,15 +87,16 @@ class DirectoryEntry(pydantic.BaseModel):
 
 @app.get("/api/dir/list")
 def list_dir(path: str):
-    path = config.DATA_PATH / path
-    assert path.is_relative_to(config.DATA_PATH)
+    path = data_path / path
+    assert path.is_relative_to(data_path)
     return sorted(
         [
             DirectoryEntry(
-                name=str(p.relative_to(config.DATA_PATH)),
+                name=str(p.relative_to(data_path)),
                 type="directory" if p.is_dir() else "workspace",
             )
             for p in path.iterdir()
+            if not p.name.startswith(".")
         ],
         key=lambda x: x.name,
     )
@@ -101,16 +104,16 @@ def list_dir(path: str):
 
 @app.post("/api/dir/mkdir")
 def make_dir(req: dict):
-    path = config.DATA_PATH / req["path"]
-    assert path.is_relative_to(config.DATA_PATH)
+    path = data_path / req["path"]
+    assert path.is_relative_to(data_path)
     assert not path.exists(), f"{path} already exists"
     path.mkdir()
 
 
 @app.post("/api/dir/delete")
 def delete_dir(req: dict):
-    path: pathlib.Path = config.DATA_PATH / req["path"]
-    assert all([path.is_relative_to(config.DATA_PATH), path.exists(), path.is_dir()])
+    path: pathlib.Path = data_path / req["path"]
+    assert all([path.is_relative_to(data_path), path.exists(), path.is_dir()])
     shutil.rmtree(path)
 
 
@@ -133,8 +136,8 @@ async def upload(req: fastapi.Request):
     """Receives file uploads and stores them in DATA_PATH."""
     form = await req.form()
     for file in form.values():
-        file_path = config.DATA_PATH / file.filename
-        assert file_path.is_relative_to(config.DATA_PATH), "Invalid file path"
+        file_path = data_path / "uploads" / file.filename
+        assert file_path.is_relative_to(data_path), "Invalid file path"
         with file_path.open("wb") as buffer:
             shutil.copyfileobj(file.file, buffer)
     return {"status": "ok"}

lynxkite-app/tests/test_main.py

@@ -1,7 +1,7 @@
+import pathlib
 import uuid
 from fastapi.testclient import TestClient
 from lynxkite_app.main import app, detect_plugins
-from lynxkite_app.config import DATA_PATH
 import os
 
 
@@ -56,10 +56,9 @@ def test_save_and_load():
 
 
 def test_list_dir():
-    test_dir = str(uuid.uuid4())
-    test_dir_full_path = DATA_PATH / test_dir
-    test_dir_full_path.mkdir(parents=True, exist_ok=True)
-    test_file = test_dir_full_path / "test_file.txt"
+    test_dir = pathlib.Path() / str(uuid.uuid4())
+    test_dir.mkdir(parents=True, exist_ok=True)
+    test_file = test_dir / "test_file.txt"
     test_file.touch()
     response = client.get(f"/api/dir/list?path={str(test_dir)}")
     assert response.status_code == 200
@@ -67,12 +66,12 @@ def test_list_dir():
     assert response.json()[0]["name"] == f"{test_dir}/test_file.txt"
     assert response.json()[0]["type"] == "workspace"
     test_file.unlink()
-    test_dir_full_path.rmdir()
+    test_dir.rmdir()
 
 
 def test_make_dir():
     dir_name = str(uuid.uuid4())
     response = client.post("/api/dir/mkdir", json={"path": dir_name})
     assert response.status_code == 200
-    assert os.path.exists(DATA_PATH / dir_name)
-    os.rmdir(DATA_PATH / dir_name)
+    assert os.path.exists(dir_name)
+    os.rmdir(dir_name)

lynxkite-app/web/playwright.config.ts

@@ -23,7 +23,7 @@ export default defineConfig({
     },
   ],
   webServer: {
-    command: "cd ../.. && LYNXKITE_DATA=examples lynxkite",
+    command: "cd ../../examples && lynxkite",
     url: "http://127.0.0.1:8000",
     reuseExistingServer: false,
   },

lynxkite-app/web/src/workspace/Workspace.tsx

@@ -324,7 +324,7 @@ function LynxKiteFlow() {
         x: e.clientX,
         y: e.clientY,
       });
-      node.data!.params.file_path = file.name;
+      node.data!.params.file_path = `uploads/${file.name}`;
       if (file.name.includes(".csv")) {
         node.data!.params.file_format = "csv";
       } else if (file.name.includes(".parquet")) {

lynxkite-core/src/lynxkite/core/workspace.py

@@ -105,7 +105,8 @@ def save(ws: Workspace, path: str):
     j = ws.model_dump()
     j = json.dumps(j, indent=2, sort_keys=True) + "\n"
     dirname, basename = os.path.split(path)
-    os.makedirs(dirname, exist_ok=True)
+    if dirname:
+        os.makedirs(dirname, exist_ok=True)
     # Create temp file in the same directory to make sure it's on the same filesystem.
     with tempfile.NamedTemporaryFile(
         "w", prefix=f".{basename}.", dir=dirname, delete=False

lynxkite-lynxscribe/src/lynxkite_lynxscribe/lynxscribe_ops.py

@@ -2,7 +2,6 @@
 LynxScribe configuration and testing in LynxKite.
 """
 
-import os
 import pathlib
 from lynxscribe.core.llm.base import get_llm_engine
 from lynxscribe.core.vector_store.base import get_vector_store
@@ -222,11 +221,12 @@ def view(input):
     return v
 
 
-async def get_chat_api(ws):
+async def get_chat_api(ws: str):
     from lynxkite.core import workspace
 
-    path = DATA_PATH / ws
-    assert path.is_relative_to(DATA_PATH)
+    cwd = pathlib.Path()
+    path = cwd / ws
+    assert path.is_relative_to(cwd)
     assert path.exists(), f"Workspace {path} does not exist"
     ws = workspace.load(path)
     contexts = await ops.EXECUTORS[ENV](ws)
@@ -285,19 +285,16 @@ async def api_service_get(request):
     return {"error": "Not found"}
 
 
-DATA_PATH = pathlib.Path(os.environ.get("LYNXKITE_DATA", "lynxkite_data"))
-
-
 def get_lynxscribe_workspaces():
     from lynxkite.core import workspace
 
     workspaces = []
-    for p in DATA_PATH.glob("**/*"):
+    for p in pathlib.Path().glob("**/*"):
         if p.is_file():
             try:
                 ws = workspace.load(p)
                 if ws.env == ENV:
-                    workspaces.append(p.relative_to(DATA_PATH))
+                    workspaces.append(p)
             except Exception:
                 pass  # Ignore files that are not valid workspaces.
     workspaces.sort()