wandelbots-nova 2.8.2__tar.gz → 2.8.4__tar.gz

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wandelbots-nova
-Version: 2.8.2
+Version: 2.8.4
 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>
@@ -42,7 +42,8 @@ Requires-Dist: aiostream<0.7,>=0.6.1; extra == 'wandelscript'
 Requires-Dist: antlr4-python3-runtime==4.13.1; extra == 'wandelscript'
 Requires-Dist: dotenv; extra == 'wandelscript'
 Requires-Dist: geometricalgebra<0.2,>=0.1.3; extra == 'wandelscript'
-Requires-Dist: typer[all]<0.16,>=0.12; extra == 'wandelscript'
+Requires-Dist: numpy>=1.1.19; extra == 'wandelscript'
+Requires-Dist: typer[all]<0.17,>=0.12; extra == 'wandelscript'
 Description-Content-Type: text/markdown
 
 # wandelbots-nova (Python SDK)

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/nova/program/runner.py

@@ -35,13 +35,13 @@ class ExecutionContext:
     # Maps the motion group id to the list of recorded motion lists
     # Each motion list is a path the was planned separately
     motion_group_recordings: list[list[MotionState]]
-    output: dict
+    output_data: dict[str, Any]
 
     def __init__(self, robot_cell: RobotCell, stop_event: anyio.Event):
         self._robot_cell = robot_cell
         self._stop_event = stop_event
         self.motion_group_recordings = []
-        self.output_data: dict[str, Any] = {}
+        self.output_data = {}
 
     @property
     def robot_cell(self) -> RobotCell:
@@ -73,6 +73,7 @@ class ProgramRun(BaseModel):
     start_time: dt.datetime | None = Field(None, description="Start time of the program run")
     end_time: dt.datetime | None = Field(None, description="End time of the program run")
     input_data: dict[str, Any] | None = Field(None, description="Input of the program run")
+    output_data: dict[str, Any] | None = Field(None, description="Output of the program run")
 
 
 class ProgramRunner(ABC):
@@ -83,18 +84,13 @@ class ProgramRunner(ABC):
     """
 
     def __init__(
-        self,
-        program_id: str,
-        args: dict[str, Any],
-        robot_cell_override: RobotCell | None = None,
-        simulate: bool = False,
+        self, program_id: str, args: dict[str, Any], robot_cell_override: RobotCell | None = None
     ):
         """
         Args:
             program_id (str): The unique identifier of the program.
             args (dict[str, Any]): The arguments to pass to the program.
             robot_cell_override (RobotCell | None, optional): The robot cell to use for the program. Defaults to None.
-            simulate (bool, optional): If True, the program will be simulated and not connect to NOVA. Used for testing. Defaults to False.
         """
         self._run_id = str(uuid.uuid4())
         self._program_id = program_id
@@ -111,6 +107,7 @@ class ProgramRunner(ABC):
             start_time=None,
             end_time=None,
             input_data=args,
+            output_data={},
         )
         self._thread: threading.Thread | None = None
         self._stop_event: threading.Event | None = None
@@ -375,9 +372,8 @@ class ProgramRunner(ABC):
                             f"Program {self.program_id} run {self.run_id} completed successfully"
                         )
                 finally:
-                    # write path to output
-                    # self._program_run.execution_results = execution_context.motion_group_recordings
-                    # self._program_run.output_data = execution_context.output_data
+                    # program output data
+                    self._program_run.output_data = execution_context.output_data
 
                     logger.info(
                         f"Program {self.program_id} run {self.run_id} finished. Run teardown routine..."

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "wandelbots-nova"
-version = "2.8.2"
+version = "2.8.4"
 description = "Official Python SDK for the Wandelbots Nova"
 authors = [
     { name = "Wandelbots GmbH" },
@@ -58,7 +58,8 @@ wandelscript = [
     "antlr4-python3-runtime==4.13.1",
     "dotenv",
     "geometricalgebra>=0.1.3,<0.2",
-    "typer[all]>=0.12,<0.16",
+    "typer[all]>=0.12,<0.17",
+    "numpy>=1.1.19",
 ]
 novax = [
     "fastapi>=0.115.6",
@@ -111,6 +112,7 @@ junit_family = "xunit2"
 norecursedirs = "develop .ipynb_checkpoints .venv .tox *.egg"
 testpaths = """
     nova
+    wandelscript
     tests
 """
 markers = """

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/runner.py

@@ -8,7 +8,6 @@ from nova.cell.robot_cell import RobotCell
 from nova.program import Program
 from nova.program import ProgramRunner as NovaProgramRunner
 from nova.program.runner import ExecutionContext as NovaExecutionContext
-from nova.program.runner import ProgramRun
 from wandelscript.datatypes import ElementType
 from wandelscript.ffi import ForeignFunction
 from wandelscript.ffi_loader import load_foreign_functions
@@ -16,11 +15,6 @@ from wandelscript.metamodel import Program as WandelscriptProgram
 from wandelscript.runtime import ExecutionContext
 
 
-# TODO: how to return this in the end?
-class WandelscriptProgramRun(ProgramRun):
-    store: dict
-
-
 class ProgramRunner(NovaProgramRunner):
     """Provides functionalities to manage a single program execution"""
 

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/tests/test_builtins.py

@@ -28,11 +28,11 @@ print(a)
 """
     robot_cell = SimulatedRobotCell()
     if exception is None:
-        runner = wandelscript.run(code, robot_cell_override=robot_cell)
+        runner = wandelscript.run(program_id="test", program=code, robot_cell_override=robot_cell)
         assert runner.state is ProgramRunState.COMPLETED
     else:
         with pytest.raises(exception):
-            wandelscript.run(code, robot_cell_override=robot_cell)
+            wandelscript.run(program_id="test", program=code, robot_cell_override=robot_cell)
 
 
 @pytest.mark.parametrize(
@@ -53,7 +53,7 @@ new_pose = assoc(pose, {index}, 42)
 """
     robot_cell = SimulatedRobotCell()
     with pytest.raises(exception):
-        runner = wandelscript.run(code, robot_cell_override=robot_cell)
+        runner = wandelscript.run(program_id="test", program=code, robot_cell_override=robot_cell)
         assert runner.state is ProgramRunState.FAILED
 
 

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/tests/test_examples.py

@@ -74,9 +74,13 @@ def test_example(example_name):
     logger.info(f"Running example {example_name}...")
     program, data, config = EXAMPLES[example_name]
     robot_cell = _robot_cell_from_configuration(config)
-    runner = wandelscript.run(program, robot_cell_override=robot_cell, default_tcp="Flange")
-    store = runner.program_run.result
-    print(store)
+    runner = wandelscript.run(
+        program_id=example_name,
+        program=program,
+        robot_cell_override=robot_cell,
+        default_tcp="Flange",
+    )
+    store = runner.program_run.output_data
     for key, expected in data.items():
         if isinstance(expected, list):
             expected = tuple(tuple(v) if isinstance(v, list) else v for v in expected)

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/tests/test_motion.py

@@ -29,33 +29,16 @@ move frame("tool") to (2, 2, 0)
     )
     with pytest.raises(ProgramRuntimeError):
         wandelscript.run(
-            code,
+            program_id="test",
+            program=code,
             robot_cell_override=SimulatedRobotCell(controller=controller),
             default_robot="0@controller",
         )
 
 
-def test_simple_motion():
-    code = """
-move via ptp() to (0, 0, 10, 0, 0, 0)
-move via line() to (0, 10, 10, 0, 0, 0)
-sync
-"""
-    cell = get_robot_cell()
-    runner = wandelscript.run(
-        code, robot_cell_override=cell, default_robot="0@controller", default_tcp="Flange"
-    )
-    assert len(runner.program_run.execution_results) == 1
-    first_pose = runner.program_run.execution_results[-1][0].state.pose
-    last_pose = runner.program_run.execution_results[-1][-1].state.pose
-    # The first position will be at the origin because the simulated robot assumes it as the default initial position
-    assert np.allclose(first_pose.to_tuple(), (0, 0, 0, 0, 0, 0))
-    assert np.allclose(last_pose.to_tuple(), (0, 10, 10, 0, 0, 0))
-
-
 def test_no_robot():
     code = """print("hello world")"""
-    wandelscript.run(code, robot_cell_override=RobotCell())
+    wandelscript.run(program_id="test", program=code, robot_cell_override=RobotCell())
 
 
 def test_motion_type_p2p_line():
@@ -77,7 +60,9 @@ move via ptp() to (23, 0, 626, 0, 0, 0)
     ]
 
     cell = get_robot_cell()
-    runner = wandelscript.run(code, robot_cell_override=cell, default_tcp="Flange")
+    runner = wandelscript.run(
+        program_id="test", program=code, robot_cell_override=cell, default_tcp="Flange"
+    )
 
     record_of_commands = runner.execution_context.robot_cell.get_motion_group(
         "0@controller"

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/tests/test_run_twice.py

@@ -21,8 +21,10 @@ print("print something")
 move via line() to (0, 100, 400, 0, pi, 0)
 """
     for i in range(2):
-        runner = run(code, robot_cell_override=robot_cell, default_tcp="Flange")
-        assert runner.program_run.result["a"] == 9
+        runner = run(
+            program_id="test", program=code, robot_cell_override=robot_cell, default_tcp="Flange"
+        )
+        assert runner.program_run.output_data["a"] == 9
         assert runner.program_run.state is ProgramRunState.COMPLETED
         assert "print something" in runner.program_run.logs
         assert not isinstance(sys.stdout, Tee)

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/tests/test_runner.py

@@ -1,7 +1,6 @@
 import asyncio
 import sys
 import time
-import uuid
 from datetime import datetime
 from typing import Any
 
@@ -80,14 +79,15 @@ move via line() to home :: (0, 100, 0, 0, 0, 0)
     }
 
     runner = run(
-        code,
+        program_id="test",
+        program=code,
         args={},
         robot_cell_override=SimulatedRobotCell(),
         default_robot="0@controller",
         default_tcp="Flange",
         foreign_functions=foreign_functions,
     )
-    store = runner.program_run.result
+    store = runner.program_run.output_data
     assert "home" in store
     assert store["a"] == 9
     assert runner.program_run.state is ProgramRunState.COMPLETED
@@ -114,7 +114,8 @@ print(a)
 """
 
     runner = run(
-        code,
+        program_id="test",
+        program=code,
         args={},
         robot_cell_override=SimulatedRobotCell(),
         default_robot="0@controller",
@@ -126,8 +127,11 @@ print(a)
 
 
 def test_program_runner():
-    program_runner = ProgramRunner(program="move via p2p() to [100, 0, 300, 0, pi, 0]", args={})
-    assert uuid.UUID(str(program_runner.id)) is not None
+    program_runner = ProgramRunner(
+        program_id="test", program="move via p2p() to [100, 0, 300, 0, pi, 0]", args={}
+    )
+    assert program_runner.program_run.run is not None
+    assert program_runner.program_run.program is not None
     assert program_runner.state is ProgramRunState.PREPARING
 
 
@@ -152,6 +156,7 @@ print(read(controller[0], "pose"))
 move via line() to (0, 100, 300, 0, pi, 0)
 """
     program_runner = ProgramRunner(
+        program_id="test",
         program=code,
         args={},
         robot_cell_override=SimulatedRobotCell(),
@@ -175,12 +180,8 @@ move via line() to (0, 100, 300, 0, pi, 0)
     # It should not be possible to start the runner after the runner was completed
     with pytest.raises(RuntimeError):
         program_runner.start(sync=True)
-    # Check path
-    assert len(program_runner.program_run.execution_results) > 0
-    last_state = program_runner.program_run.execution_results[-1][-1]
-    assert np.allclose(last_state.state.pose.to_tuple(), (0, 100, 300, 0, np.pi, 0))
     # Check store
-    store = program_runner.program_run.result
+    store = program_runner.program_run.output_data
     assert np.allclose(
         tuple(store["home"]["position"]) + tuple(store["home"]["orientation"]),
         (0, 0, 400, 0, np.pi, 0),
@@ -210,6 +211,7 @@ move via p2p() to home
 )
 def test_program_runner_stop(code):
     program_runner = ProgramRunner(
+        program_id="test",
         program=code,
         args={},
         robot_cell_override=SimulatedRobotCell(),
@@ -247,7 +249,9 @@ move via p2p() to mispelled_var
 )
 def test_program_runner_failed(code, exception):
     with pytest.raises(exception):
-        runner = run(code, args={}, robot_cell_override=SimulatedRobotCell())
+        runner = run(
+            program_id="test", program=code, args={}, robot_cell_override=SimulatedRobotCell()
+        )
         assert runner.program_run.state is ProgramRunState.FAILED
         assert runner.program_run.error is not None
         assert runner.program_run.traceback is not None
@@ -263,5 +267,7 @@ wait 4000
 move via p2p() to home :: (0, 0, 100)
 """
     with pytest.raises(Exception):
-        runner = run(code, args={}, robot_cell_override=raising_robot_cell)
+        runner = run(
+            program_id="test", program=code, args={}, robot_cell_override=raising_robot_cell
+        )
         assert runner.program_run.state is ProgramRunState.FAILED

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/tests/test_runtime.py

@@ -47,7 +47,13 @@ debug()
 """
 
     robot_cell = SimulatedRobotCell()
-    run(code, robot_cell_override=robot_cell, default_robot="0@controller", default_tcp="Flange")
+    run(
+        program_id="test",
+        program=code,
+        robot_cell_override=robot_cell,
+        default_robot="0@controller",
+        default_tcp="Flange",
+    )
     assert test_a == 1
 
 
@@ -104,9 +110,16 @@ def test_robot_code_execution(code, num_robots, expected_exception):
     )
     if expected_exception:
         with pytest.raises(expected_exception):
-            run(code, robot_cell_override=robot_cell, default_tcp="Flange")
+            run(
+                program_id="test",
+                program=code,
+                robot_cell_override=robot_cell,
+                default_tcp="Flange",
+            )
     else:
-        result = run(code, robot_cell_override=robot_cell, default_tcp="Flange")
+        result = run(
+            program_id="test", program=code, robot_cell_override=robot_cell, default_tcp="Flange"
+        )
         assert result is not None
 
 

{wandelbots_nova-2.8.2 → wandelbots_nova-2.8.4}/wandelscript/utils/pose.py

@@ -13,6 +13,7 @@ def pose_to_versor(pose: Pose) -> cga3d.Vector:
         The versor
 
     Examples:
+    >>> import numpy as np
     >>> p = Pose((0, 0, 5, 0, 0, 1))
     >>> assert np.allclose(pose_to_versor(p).to_pos_and_rot_vector(), [0, 0, 5, 0, 0, 1])
     """