wandelbots-nova 2.2.2__tar.gz → 2.3.0__tar.gz

{wandelbots_nova-2.2.2 → wandelbots_nova-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wandelbots-nova
-Version: 2.2.2
+Version: 2.3.0
 Summary: Official Python SDK for the Wandelbots Nova
 Author: Wandelbots GmbH
 Author-email: Christoph Biering <christoph.biering@wandelbots.com>, Mahsum Demir <mahsum.demir@wandelbots.com>, Dirk Sonnemann <dirk.sonnemann@wandelbots.com>, Andreas Langenhagen <andreas.langenhagen@wandelbots.com>, Stefan Wagner <stefan.wagner@wandelbots.com>, André Kühnert <andre.kuhnert@wandelbots.com>

wandelbots_nova-2.3.0/novax/api/programs.py

@@ -0,0 +1,78 @@
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException, Path
+
+from novax.api.dependencies import get_program_manager
+from novax.program_manager import ProgramDetails, ProgramManager, ProgramRun, RunProgramRequest
+
+router = APIRouter(prefix="/programs", tags=["programs"])
+
+
+class ProgramResponse(ProgramDetails):
+    input_schema: dict[str, Any]
+
+
+@router.get("", operation_id="getPrograms", response_model=list[ProgramResponse])
+async def get_programs(program_manager: ProgramManager = Depends(get_program_manager)):
+    """List all programs"""
+    programs = await program_manager.get_programs()
+    return [
+        ProgramResponse(
+            **program_details.model_dump(),
+            input_schema=program_manager._program_functions[program].json_schema,
+        )
+        for program, program_details in programs.items()
+    ]
+
+
+@router.get("/{program}", operation_id="getProgram", response_model=ProgramResponse)
+async def get_program(
+    program: str = Path(..., description="The ID of the program"),
+    program_manager: ProgramManager = Depends(get_program_manager),
+):
+    """Get program details"""
+    program_details = await program_manager.get_program(program)
+    if not program_details:
+        raise HTTPException(status_code=404, detail="Program not found")
+
+    program_fn = program_manager._program_functions[program]
+
+    return ProgramResponse(**program_details.model_dump(), input_schema=program_fn.json_schema)
+
+
+@router.post("/{program}/start", operation_id="startProgram", response_model=ProgramRun)
+async def start_program(
+    program: str = Path(..., description="The ID of the program"),
+    request: RunProgramRequest = Body(...),
+    program_manager: ProgramManager = Depends(get_program_manager),
+):
+    """Run a program"""
+    if not await program_manager.get_program(program):
+        raise HTTPException(status_code=404, detail="Program not found")
+
+    if program_manager.running_program:
+        raise HTTPException(status_code=400, detail="A program is already running")
+
+    return await program_manager.run_program(program, request.parameters)
+
+
+@router.post("/{program}/stop", operation_id="stopProgram")
+async def stop_program(
+    program: str = Path(..., description="The ID of the program"),
+    program_manager: ProgramManager = Depends(get_program_manager),
+):
+    """Stop the run"""
+    if not await program_manager.get_program(program):
+        raise HTTPException(status_code=404, detail="Program not found")
+
+    if not program_manager.running_program:
+        raise HTTPException(status_code=400, detail="No program is running")
+
+    if program_manager.running_program != program:
+        raise HTTPException(
+            status_code=400,
+            detail="Program is not running. Currently running: {program_manager.running_program}",
+        )
+
+    await program_manager.stop_program(program)
+    return None

{wandelbots_nova-2.2.2 → wandelbots_nova-2.3.0}/novax/program_manager.py

@@ -84,12 +84,20 @@ class ProgramManager:
     def __init__(self):
         self._programs: dict[str, ProgramDetails] = {}
         self._program_functions: dict[str, Program] = {}
-        self._runners: dict[str, dict[str, NovaxProgramRunner]] = {}
+        self._runner: NovaxProgramRunner | None = None
         self._program_sources: list[ProgramSource] = []
 
     def has_program(self, program_id: str) -> bool:
         return program_id in self._programs
 
+    @property
+    def is_any_program_running(self) -> bool:
+        return self._runner is not None and self._runner.is_running()
+
+    @property
+    def running_program(self) -> Optional[str]:
+        return self._runner.program_id if self.is_any_program_running and self._runner else None
+
     def register_program_source(self, program_source: ProgramSource) -> None:
         """
         Register a program source with the program manager.
@@ -145,32 +153,29 @@ class ProgramManager:
         """Get a specific program by ID"""
         return self._programs.get(program_id)
 
-    async def get_program_runs(self, program_id: str) -> list[ProgramRun]:
-        """Get all runs for a specific program"""
-        return [runner.program_run for runner in self._runners.get(program_id, {}).values()]
-
-    async def get_program_run(self, program_id: str, run_id: str) -> ProgramRun:
-        """Get a specific run for a program"""
-        return self._runners[program_id][run_id].program_run
-
     async def run_program(
-        self, program_id: str, parameters: Optional[dict[str, Any]] = None
+        self, program_id: str, parameters: dict[str, Any] | None = None
     ) -> ProgramRun:
         """Run a registered program with given parameters"""
-        runner = NovaxProgramRunner(program_id, self._program_functions, parameters)
-        if program_id not in self._runners:
-            self._runners[program_id] = {}
-        self._runners[program_id][runner.run_id] = runner
+        if self.is_any_program_running:
+            raise RuntimeError("A program is already running")
+
+        runner = self._runner = NovaxProgramRunner(program_id, self._program_functions, parameters)
         runner.start(sync=False)
         return runner.program_run
 
-    async def stop_program(self, program_id: str, run_id: str):
+    async def stop_program(self, program_id: str):
         """Stop a running program"""
-        runner = self._runners[program_id][run_id]
-        if not runner:
-            raise ValueError(f"Runner {run_id} not found")
-        runner.stop(sync=True)
-        del self._runners[program_id][run_id]
+        if not self.is_any_program_running or self._runner is None:
+            raise RuntimeError("No program is running")
+
+        if self.running_program != program_id:
+            raise RuntimeError(
+                f"Program {program_id} is not running. Currently running: {self.running_program}"
+            )
+
+        self._runner.stop(sync=True)
+        self._runner = None
 
 
 # Example implementations of ProgramSource

{wandelbots_nova-2.2.2 → wandelbots_nova-2.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wandelbots-nova"
-version = "2.2.2"
+version = "2.3.0"
 description = "Official Python SDK for the Wandelbots Nova"
 authors = [
     { name = "Wandelbots GmbH" },

wandelbots_nova-2.3.0/tests/novax/api/test_programs.py

@@ -0,0 +1,136 @@
+import asyncio
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+def test_get_programs(novax_app):
+    client = TestClient(novax_app)
+    response = client.get("/programs")
+
+    assert response.status_code == 200
+    programs = response.json()
+    assert isinstance(programs, list)
+    assert len(programs) >= 1
+
+    # Check that simple_program is in the list
+    program_ids = [p["program_id"] for p in programs]
+    assert "simple_program" in program_ids
+
+    # Check program structure
+    simple_program = next(p for p in programs if p["program_id"] == "simple_program")
+    assert "program_id" in simple_program
+    assert "created_at" in simple_program
+    assert "updated_at" in simple_program
+
+
+def test_get_program_success(novax_app):
+    client = TestClient(novax_app)
+    response = client.get("/programs/simple_program")
+
+    assert response.status_code == 200
+    program = response.json()
+
+    assert program["program_id"] == "simple_program"
+    assert "created_at" in program
+    assert "updated_at" in program
+    assert "input_schema" in program
+
+
+def test_get_program_not_found(novax_app):
+    client = TestClient(novax_app)
+    response = client.get("/programs/nonexistent_program")
+
+    assert response.status_code == 404
+    assert response.json()["detail"] == "Program not found"
+
+
+def test_start_program_success(novax_app):
+    client = TestClient(novax_app)
+    response = client.post(
+        "/programs/simple_program/start", json={"parameters": {"number_of_steps": 5}}
+    )
+
+    assert response.status_code == 200
+    run = response.json()
+
+    assert "run_id" in run
+    assert "program_id" in run
+    assert "state" in run
+
+
+def test_start_program_without_parameters(novax_app):
+    client = TestClient(novax_app)
+    response = client.post("/programs/simple_program/start", json={})
+
+    assert response.status_code == 200
+    run = response.json()
+
+    assert "run_id" in run
+    assert "program_id" in run
+    assert "state" in run
+
+
+def test_start_program_not_found(novax_app):
+    client = TestClient(novax_app)
+    response = client.post("/programs/nonexistent_program/start", json={"parameters": {}})
+
+    assert response.status_code == 404
+    assert response.json()["detail"] == "Program not found"
+
+
+def test_start_program(novax_app):
+    client = TestClient(novax_app)
+
+    # Start first program
+    response1 = client.post(
+        "/programs/simple_program/start", json={"parameters": {"number_of_steps": 10}}
+    )
+    assert response1.status_code == 200
+
+
+@pytest.mark.integration
+@pytest.mark.asyncio
+async def test_stop_program_success(novax_app):
+    client = TestClient(novax_app)
+
+    # First start a program
+    start_response = client.post(
+        "/programs/simple_program/start", json={"parameters": {"number_of_steps": 30}}
+    )
+    assert start_response.status_code == 200
+    await asyncio.sleep(3)
+
+    # Then stop the program
+    response = client.post("/programs/simple_program/stop")
+    assert response.status_code == 200, response.json()
+
+
+def test_stop_program_not_found(novax_app):
+    client = TestClient(novax_app)
+    response = client.post("/programs/nonexistent_program/stop")
+
+    assert response.status_code == 404
+    assert response.json()["detail"] == "Program not found"
+
+
+def test_stop_program_not_running(novax_app):
+    client = TestClient(novax_app)
+    response = client.post("/programs/simple_program/stop")
+
+    assert response.status_code == 400
+    assert response.json()["detail"] == "No program is running"
+
+
+def test_stop_program_wrong_program(novax_app):
+    client = TestClient(novax_app)
+
+    # Start a program
+    start_response = client.post(
+        "/programs/simple_program/start", json={"parameters": {"number_of_steps": 10}}
+    )
+    assert start_response.status_code == 200
+
+    # Try to stop a non existing program
+    response = client.post("/programs/different_program/stop")
+    assert response.status_code == 404

wandelbots_nova-2.3.0/tests/novax/serve.py

@@ -0,0 +1,46 @@
+import asyncio
+
+import dotenv
+
+import nova
+
+dotenv.load_dotenv()
+
+
+@nova.program(name="test")
+async def test():
+    print("Hello, world!")
+
+
+@nova.program(name="simple_program")
+async def simple_program(number_of_steps: int = 30):
+    print("Hello World!")
+
+    for i in range(number_of_steps):
+        print(f"Step: {i}")
+        await asyncio.sleep(1)
+
+    print("Finished Hello World!")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    from novax import Novax
+
+    novax = Novax()
+    app = novax.create_app()
+    novax.include_programs_router(app)
+
+    novax.register_program(test)
+    novax.register_program(simple_program)
+
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=8000,
+        reload=False,
+        log_level="info",
+        proxy_headers=True,
+        forwarded_allow_ips="*",
+    )

wandelbots_nova-2.2.2/novax/api/programs.py

@@ -1,94 +0,0 @@
-from fastapi import APIRouter, Body, Depends, HTTPException, Path
-
-from novax.api.dependencies import get_program_manager
-from novax.program_manager import ProgramDetails, ProgramManager, ProgramRun, RunProgramRequest
-
-router = APIRouter(prefix="/programs", tags=["programs"])
-
-
-@router.get("", operation_id="getPrograms", response_model=list[ProgramDetails])
-async def get_programs(program_manager: ProgramManager = Depends(get_program_manager)):
-    """List all programs"""
-    programs = await program_manager.get_programs()
-    return list(programs.values())
-
-
-@router.get("/{program}", operation_id="getProgram")
-async def get_program(
-    program: str = Path(..., description="The ID of the program"),
-    program_manager: ProgramManager = Depends(get_program_manager),
-):
-    """Get program details"""
-    program_details = await program_manager.get_program(program)
-    if not program_details:
-        raise HTTPException(status_code=404, detail="Program not found")
-
-    program_fn = program_manager._program_functions[program]
-
-    return {
-        **program_details.model_dump(),
-        "input_schema": program_fn.json_schema,
-        "_links": {
-            "self": {"href": f"/programs/{program}", "method": "GET"},
-            "runs": {"href": f"/programs/{program}/runs", "method": "POST"},
-        },
-    }
-
-
-@router.get("/{program}/runs", operation_id="getProgramRuns", response_model=list[ProgramRun])
-async def get_program_runs(
-    program: str = Path(..., description="The ID of the program"),
-    program_manager: ProgramManager = Depends(get_program_manager),
-):
-    """List all program runs"""
-    if not await program_manager.get_program(program):
-        raise HTTPException(status_code=404, detail="Program not found")
-
-    return await program_manager.get_program_runs(program)
-
-
-@router.post("/{program}/runs", operation_id="runProgram", response_model=ProgramRun)
-async def run_program(
-    program: str = Path(..., description="The ID of the program"),
-    request: RunProgramRequest = Body(...),
-    program_manager: ProgramManager = Depends(get_program_manager),
-):
-    """Run a program"""
-    if not await program_manager.get_program(program):
-        raise HTTPException(status_code=404, detail="Program not found")
-
-    return await program_manager.run_program(program, request.parameters)
-
-
-@router.get("/{program}/runs/{run}", operation_id="getProgramRun")
-async def get_program_run(
-    program: str = Path(..., description="The ID of the program"),
-    run: str = Path(..., description="The ID of the run"),
-    program_manager: ProgramManager = Depends(get_program_manager),
-):
-    """Get state of the run"""
-    if not await program_manager.get_program(program):
-        raise HTTPException(status_code=404, detail="Program not found")
-
-    program_run = await program_manager.get_program_run(program, run)
-    return {
-        **program_run.model_dump(),
-        "_links": {
-            "self": {"href": f"/programs/{program}/runs/{run}", "method": "GET"},
-            "stop": {"href": f"/programs/{program}/runs/{run}/stop", "method": "POST"},
-        },
-    }
-
-
-@router.post("/{program}/runs/{run}/stop", operation_id="stopProgramRun", status_code=204)
-async def stop_program_run(
-    program: str = Path(..., description="The ID of the program"),
-    run: str = Path(..., description="The ID of the run"),
-    program_manager: ProgramManager = Depends(get_program_manager),
-):
-    """Stop the run"""
-    if not await program_manager.get_program(program):
-        raise HTTPException(status_code=404, detail="Program not found")
-
-    await program_manager.stop_program(program, run)
-    return None

wandelbots_nova-2.2.2/tests/novax/api/test_programs.py

@@ -1,177 +0,0 @@
-import asyncio
-
-import pytest
-from fastapi.testclient import TestClient
-
-
-def test_get_programs(novax_app):
-    """Test GET /programs - list all programs"""
-    client = TestClient(novax_app)
-    response = client.get("/programs")
-
-    assert response.status_code == 200
-    programs = response.json()
-    assert isinstance(programs, list)
-    assert len(programs) >= 1
-
-    # Check that simple_program is in the list
-    program_ids = [p["program_id"] for p in programs]
-    assert "simple_program" in program_ids
-
-    # Check program structure
-    simple_program = next(p for p in programs if p["program_id"] == "simple_program")
-    assert "program_id" in simple_program
-    assert "created_at" in simple_program
-    assert "updated_at" in simple_program
-
-
-def test_get_program_success(novax_app):
-    """Test GET /programs/{program} - get program details"""
-    client = TestClient(novax_app)
-    response = client.get("/programs/simple_program")
-
-    assert response.status_code == 200
-    program = response.json()
-
-    assert program["program_id"] == "simple_program"
-    assert "created_at" in program
-    assert "updated_at" in program
-    assert "input_schema" in program
-    assert "_links" in program
-    assert "self" in program["_links"]
-    assert "runs" in program["_links"]
-
-
-def test_get_program_not_found(novax_app):
-    """Test GET /programs/{program} - program not found"""
-    client = TestClient(novax_app)
-    response = client.get("/programs/nonexistent_program")
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Program not found"
-
-
-def test_list_program_runs_empty(novax_app):
-    """Test GET /programs/{program}/runs - list runs (empty)"""
-    client = TestClient(novax_app)
-    response = client.get("/programs/simple_program/runs")
-
-    assert response.status_code == 200
-    runs = response.json()
-    assert isinstance(runs, list)
-    assert len(runs) == 0
-
-
-def test_list_program_runs_program_not_found(novax_app):
-    """Test GET /programs/{program}/runs - program not found"""
-    client = TestClient(novax_app)
-    response = client.get("/programs/nonexistent_program/runs")
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Program not found"
-
-
-def test_run_program_success(novax_app):
-    """Test POST /programs/{program}/runs - run program"""
-    client = TestClient(novax_app)
-    response = client.post(
-        "/programs/simple_program/runs", json={"parameters": {"number_of_steps": 5}}
-    )
-
-    assert response.status_code == 200
-    run = response.json()
-
-    assert "run_id" in run
-    assert "program_id" in run
-    assert "state" in run
-
-
-def test_run_program_without_parameters(novax_app):
-    """Test POST /programs/{program}/runs - run program without parameters"""
-    client = TestClient(novax_app)
-    response = client.post("/programs/simple_program/runs", json={})
-
-    assert response.status_code == 200
-    run = response.json()
-
-    assert "run_id" in run
-    assert "program_id" in run
-    assert "state" in run
-
-
-def test_run_program_not_found(novax_app):
-    """Test POST /programs/{program}/runs - program not found"""
-    client = TestClient(novax_app)
-    response = client.post("/programs/nonexistent_program/runs", json={"parameters": {}})
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Program not found"
-
-
-def test_get_program_run_success(novax_app):
-    """Test GET /programs/{program}/runs/{run} - get run details"""
-    client = TestClient(novax_app)
-
-    # First create a run
-    run_response = client.post(
-        "/programs/simple_program/runs", json={"parameters": {"number_of_steps": 1}}
-    )
-    assert run_response.status_code == 200
-    run_id = run_response.json()["run_id"]
-
-    # Then get the run details
-    response = client.get(f"/programs/simple_program/runs/{run_id}")
-
-    assert response.status_code == 200
-    run = response.json()
-
-    assert run["run_id"] == run_id
-    assert run["program_id"] == "simple_program"
-    assert "state" in run
-    assert "_links" in run
-    assert "self" in run["_links"]
-    assert "stop" in run["_links"]
-
-
-def test_get_program_run_program_not_found(novax_app):
-    """Test GET /programs/{program}/runs/{run} - program not found"""
-    client = TestClient(novax_app)
-    response = client.get("/programs/nonexistent_program/runs/some_run_id")
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Program not found"
-
-
-@pytest.mark.integration
-@pytest.mark.asyncio
-async def test_stop_program_run_success(novax_app):
-    """Test POST /programs/{program}/runs/{run}/stop - stop run"""
-    client = TestClient(novax_app)
-
-    # First create a run
-    run_response = client.post(
-        "/programs/simple_program/runs", json={"parameters": {"number_of_steps": 10}}
-    )
-    assert run_response.status_code == 200
-    print(run_response.json())
-    run_id = run_response.json()["run_id"]
-    print(run_id)
-
-    await asyncio.sleep(4)
-
-    r = client.get(f"/programs/simple_program/runs/{run_id}")
-    print(r.json())
-
-    # Then stop the run
-    response = client.post(f"/programs/simple_program/runs/{run_id}/stop")
-
-    assert response.status_code == 204
-
-
-def test_stop_program_run_program_not_found(novax_app):
-    """Test POST /programs/{program}/runs/{run}/stop - program not found"""
-    client = TestClient(novax_app)
-    response = client.post("/programs/nonexistent_program/runs/some_run_id/stop")
-
-    assert response.status_code == 404
-    assert response.json()["detail"] == "Program not found"