def main() -> None:
upload_def(Box, BoxModel("Box", 0.1, 0.1, 0.1))
upload_def(Box2, BoxModel("Box2", 0.2, 0.2, 0.2))
upload_def(Tester, BoxModel("Tester", 0.3, 0.3, 0.3))
upload_def(ParamToReturn)
upload_def(DummyMultiArmRobot)
def main() -> None:
upload_def(AbstractDobot)
upload_def(DobotMagician,
urdf=Urdf(get_data("dobot-magician"),
DobotMagician.urdf_package_name))
upload_def(DobotM1,
urdf=Urdf(get_data("dobot-m1"), DobotM1.urdf_package_name))
upload_def(KinectAzure) # TODO add its mesh
upload_whatever(FitCommonMixin)
def main() -> None:
upload_def(AbstractDobot)
upload_def(DobotMagician,
urdf=Urdf(get_data("dobot-magician"),
DobotMagician.urdf_package_name))
upload_def(DobotM1,
urdf=Urdf(get_data("dobot-m1"), DobotM1.urdf_package_name))
upload_def(
KinectAzure,
Mesh(KinectAzure.__name__, KinectAzure.mesh_filename),
file_to_upload=get_data(KinectAzure.mesh_filename),
)
upload_def(
ConveyorBelt,
Mesh(ConveyorBelt.__name__, ConveyorBelt.mesh_filename),
file_to_upload=get_data(ConveyorBelt.mesh_filename),
)
upload_whatever(FitCommonMixin)
def main() -> None:
upload_def(FlowActions)
upload_def(LogicActions)
upload_def(TimeActions)
upload_def(RandomActions)
def test_list_problems(start_processes: None, ars: ARServer) -> None:
"""This is a test for a bug in get_scene_problems and get_project_problems
functions.
Because of the bug, the RPC returned result=False when there was non-existing ObjectType.
:param start_processes:
:param ars:
:return:
"""
upload_def(DummyMultiArmRobot
) # OT has to exist first, otherwise scene can't be stored
invalid_scene_1 = Scene("invalidScene",
objects=[
SceneObject("invalidObject",
DummyMultiArmRobot.__name__,
Pose())
])
invalid_project_1 = Project("invalidProject", invalid_scene_1.id)
project_service.update_scene(invalid_scene_1)
project_service.update_project(invalid_project_1)
project_service.delete_object_type(
DummyMultiArmRobot.__name__) # now the OT can be deleted
# initial event
show_main_screen_event = event(ars, events.c.ShowMainScreen)
assert show_main_screen_event.data
assert show_main_screen_event.data.what == events.c.ShowMainScreen.Data.WhatEnum.ScenesList
scenes = ars.call_rpc(rpc.s.ListScenes.Request(get_id()),
rpc.s.ListScenes.Response)
assert scenes.result
assert scenes.data
assert len(scenes.data) == 1
assert scenes.data[0].id == invalid_scene_1.id
assert scenes.data[0].name == invalid_scene_1.name
assert scenes.data[0].problems
assert len(scenes.data[0].problems) == 1
projects = ars.call_rpc(rpc.p.ListProjects.Request(get_id()),
rpc.p.ListProjects.Response)
assert projects.result
assert projects.data
assert len(projects.data) == 1
assert projects.data[0].id == invalid_project_1.id
assert projects.data[0].name == invalid_project_1.name
assert projects.data[0].problems
assert len(projects.data[0].problems) == 1
upload_def(DummyMultiArmRobot)
# now the ObjectType exists, so the scene/project should be ok
scenes2 = ars.call_rpc(rpc.s.ListScenes.Request(get_id()),
rpc.s.ListScenes.Response)
assert scenes2.result
assert scenes2.data
assert len(scenes2.data) == 1
assert scenes2.data[0].id == invalid_scene_1.id
assert scenes2.data[0].name == invalid_scene_1.name
assert scenes2.data[0].problems is None
projects2 = ars.call_rpc(rpc.p.ListProjects.Request(get_id()),
rpc.p.ListProjects.Response)
assert projects2.result
assert projects2.data
assert len(projects2.data) == 1
assert projects2.data[0].id == invalid_project_1.id
assert projects2.data[0].name == invalid_project_1.name
assert projects2.data[0].problems is None
def test_update_object_pose(start_processes: None, ars: ARServer) -> None:
upload_def(Box, BoxModel("Box", 0.1, 0.1, 0.1))
upload_def(DummyMultiArmRobot)
test = "test"
event(ars, events.c.ShowMainScreen)
assert ars.call_rpc(
rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args(test)),
rpc.s.NewScene.Response).result
assert len(event(ars, events.o.ChangedObjectTypes).data) == 2
event(ars, events.s.OpenScene)
event(ars, events.s.SceneState)
assert ars.call_rpc(
rpc.s.AddObjectToScene.Request(
get_id(),
rpc.s.AddObjectToScene.Request.Args("obj", Box.__name__, Pose())),
rpc.s.AddObjectToScene.Response,
).result
scene_obj = event(ars, events.s.SceneObjectChanged).data
assert ars.call_rpc(
rpc.s.AddObjectToScene.Request(
get_id(),
rpc.s.AddObjectToScene.Request.Args("robot",
DummyMultiArmRobot.__name__,
Pose())),
rpc.s.AddObjectToScene.Response,
).result
scene_robot = event(ars, events.s.SceneObjectChanged).data
new_pose = Pose(Position(1))
lock_object(ars, scene_obj.id)
assert ars.call_rpc(
rpc.s.UpdateObjectPose.Request(
get_id(),
rpc.s.UpdateObjectPose.Request.Args(scene_obj.id, new_pose)),
rpc.s.UpdateObjectPose.Response,
).result
assert event(ars, events.s.SceneObjectChanged).data.pose == new_pose
unlock_object(ars, scene_obj.id)
lock_object(ars, scene_robot.id)
assert ars.call_rpc(
rpc.s.UpdateObjectPose.Request(
get_id(),
rpc.s.UpdateObjectPose.Request.Args(scene_robot.id, new_pose)),
rpc.s.UpdateObjectPose.Response,
).result
assert event(ars, events.s.SceneObjectChanged).data.pose == new_pose
unlock_object(ars, scene_robot.id)
assert ars.call_rpc(
rpc.s.StartScene.Request(get_id()),
rpc.s.StartScene.Response,
).result
assert event(ars, events.s.SceneState
).data.state == events.s.SceneState.Data.StateEnum.Starting
assert event(ars, events.s.SceneState
).data.state == events.s.SceneState.Data.StateEnum.Started
lock_object(ars, scene_obj.id)
# with started scene, it should still be possible to manipulate the object
assert ars.call_rpc(
rpc.s.UpdateObjectPose.Request(
get_id(),
rpc.s.UpdateObjectPose.Request.Args(scene_obj.id, Pose())),
rpc.s.UpdateObjectPose.Response,
).result
assert event(ars, events.s.SceneObjectChanged).data.pose == Pose()
unlock_object(ars, scene_obj.id)
lock_object(ars, scene_robot.id)
# ...but it should not be possible to manipulate the robot
assert not ars.call_rpc(
rpc.s.UpdateObjectPose.Request(
get_id(),
rpc.s.UpdateObjectPose.Request.Args(scene_robot.id, Pose())),
rpc.s.UpdateObjectPose.Response,
).result
unlock_object(ars, scene_robot.id)
def start_processes() -> Iterator[None]:
global _arserver_port
_arserver_port = find_free_port()
with tempfile.TemporaryDirectory() as tmp_dir:
my_env = os.environ.copy()
project_port = find_free_port()
project_url = f"http://0.0.0.0:{project_port}"
my_env["ARCOR2_PROJECT_SERVICE_URL"] = project_url
my_env["ARCOR2_PROJECT_SERVICE_MOCK_PORT"] = str(project_port)
project_service.URL = project_url
scene_port = find_free_port()
scene_url = f"http://0.0.0.0:{scene_port}"
my_env["ARCOR2_SCENE_SERVICE_URL"] = scene_url
my_env["ARCOR2_SCENE_SERVICE_MOCK_PORT"] = str(scene_port)
scene_service.URL = scene_url
my_env["ARCOR2_EXECUTION_URL"] = f"ws://0.0.0.0:{find_free_port()}"
my_env["ARCOR2_PROJECT_PATH"] = os.path.join(tmp_dir, "packages")
my_env["ARCOR2_SERVER_PORT"] = str(_arserver_port)
my_env["ARCOR2_DATA_PATH"] = os.path.join(tmp_dir, "data")
my_env["ARCOR2_BUILD_URL"] = f"http://0.0.0.0:{find_free_port()}"
processes = []
for cmd in (
"./src.python.arcor2_mocks.scripts/mock_project.pex",
"./src.python.arcor2_mocks.scripts/mock_scene.pex",
"./src.python.arcor2_execution.scripts/execution.pex",
"./src.python.arcor2_build.scripts/build.pex",
):
processes.append(
sp.Popen(cmd, env=my_env, stdout=sp.PIPE, stderr=sp.STDOUT))
scene_service.wait_for(60)
# it may take some time for project service to come up so give it some time
for _ in range(3):
upload_proc = sp.Popen(
"./src.python.arcor2.scripts/upload_builtin_objects.pex",
env=my_env,
stdout=sp.PIPE,
stderr=sp.STDOUT)
ret = upload_proc.communicate()
if upload_proc.returncode == 0:
log_proc_output(ret)
break
else:
raise Exception("Failed to upload objects.")
upload_def(ObjectWithActions)
upload_def(ObjectWithSettings)
LOGGER.info(f"Starting ARServer listening on port {_arserver_port}.")
arserver_proc = sp.Popen(
"./src.python.arcor2_arserver.scripts/arserver.pex",
env=my_env,
stdout=sp.PIPE,
stderr=sp.STDOUT)
processes.append(arserver_proc)
assert arserver_proc.stdout is not None
while True:
line = arserver_proc.stdout.readline().decode().strip()
if not line or "Server initialized." in line: # TODO this is not ideal
break
if arserver_proc.poll():
finish_processes(processes)
raise Exception("ARServer died.")
yield None
finish_processes(processes)
def test_object_aiming(start_processes: None, ars: ARServer) -> None:
mesh = Mesh(Box.__name__, "mesh.dae", [Pose(), Pose(), Pose()])
assert mesh.focus_points
Box.mesh_filename = mesh.data_id
with tempfile.NamedTemporaryFile("wb") as file:
upload_def(Box, model=mesh, file_to_upload=file.name)
upload_def(DummyMultiArmRobot)
test = "test"
event(ars, events.c.ShowMainScreen)
assert ars.call_rpc(
rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args(test)), rpc.s.NewScene.Response
).result
assert len(event(ars, events.o.ChangedObjectTypes).data) == 2
event(ars, events.s.OpenScene)
event(ars, events.s.SceneState)
assert ars.call_rpc(
rpc.s.AddObjectToScene.Request(get_id(), rpc.s.AddObjectToScene.Request.Args("obj", Box.__name__, Pose())),
rpc.s.AddObjectToScene.Response,
).result
scene_obj = event(ars, events.s.SceneObjectChanged).data
assert ars.call_rpc(
rpc.s.AddObjectToScene.Request(
get_id(), rpc.s.AddObjectToScene.Request.Args("robot", DummyMultiArmRobot.__name__, Pose())
),
rpc.s.AddObjectToScene.Response,
).result
scene_robot = event(ars, events.s.SceneObjectChanged).data
assert ars.call_rpc(
rpc.s.StartScene.Request(get_id()),
rpc.s.StartScene.Response,
).result
assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Starting
assert event(ars, events.s.SceneState).data.state == events.s.SceneState.Data.StateEnum.Started
arm = DummyMultiArmRobot.Arms.left
robot_arg = RobotArg(scene_robot.id, list(DummyMultiArmRobot.EEF[arm])[0], arm)
# ------------------------------------------------------------------------------------------------------------------
lock_object(ars, scene_obj.id)
lock_object(ars, scene_robot.id)
assert ars.call_rpc(
rpc.o.ObjectAimingStart.Request(get_id(), rpc.o.ObjectAimingStart.Request.Args(scene_obj.id, robot_arg)),
rpc.o.ObjectAimingStart.Response,
).result
assert not ars.call_rpc(
rpc.o.ObjectAimingStart.Request(get_id(), rpc.o.ObjectAimingStart.Request.Args(scene_obj.id, robot_arg)),
rpc.o.ObjectAimingStart.Response,
).result
assert ars.call_rpc(
rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(0)),
rpc.o.ObjectAimingAddPoint.Response,
).result
assert ars.call_rpc(
rpc.o.ObjectAimingCancel.Request(get_id()),
rpc.o.ObjectAimingCancel.Response,
).result
unlock_object(ars, scene_obj.id)
unlock_object(ars, scene_robot.id)
# ------------------------------------------------------------------------------------------------------------------
lock_object(ars, scene_obj.id)
lock_object(ars, scene_robot.id)
assert ars.call_rpc(
rpc.o.ObjectAimingStart.Request(get_id(), rpc.o.ObjectAimingStart.Request.Args(scene_obj.id, robot_arg)),
rpc.o.ObjectAimingStart.Response,
).result
assert not ars.call_rpc(
rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(-1)),
rpc.o.ObjectAimingAddPoint.Response,
).result
assert not ars.call_rpc(
rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(len(mesh.focus_points))),
rpc.o.ObjectAimingAddPoint.Response,
).result
assert not ars.call_rpc(
rpc.o.ObjectAimingDone.Request(get_id()),
rpc.o.ObjectAimingDone.Response,
).result
for idx in range(len(mesh.focus_points)):
assert ars.call_rpc(
rpc.o.ObjectAimingAddPoint.Request(get_id(), rpc.o.ObjectAimingAddPoint.Request.Args(idx)),
rpc.o.ObjectAimingAddPoint.Response,
).result
assert ars.call_rpc(
rpc.o.ObjectAimingDone.Request(get_id()),
rpc.o.ObjectAimingDone.Response,
).result
assert event(ars, events.s.SceneObjectChanged).data.id == scene_obj.id
unlock_object(ars, scene_obj.id)
unlock_object(ars, scene_robot.id)
def main() -> None:
# abstract classes
upload_def(AbstractRobot)
upload_def(AbstractSimple)
upload_def(AbstractWithPose)
# concrete classes
upload_def(Barcode)
upload_def(Interaction)
upload_def(Aubo, urdf=Urdf(get_data("aubo"), Aubo.urdf_package_name))
upload_def(Simatic)
upload_def(Search)
upload_def(Statistic)
upload_def(Ict)
def test_update_object_model(start_processes: None, ars: ARServer) -> None:
upload_def(BoxType, Box(BoxType.__name__, 0.1, 0.1, 0.1))
upload_def(DummyMultiArmRobot)
event(ars, events.c.ShowMainScreen)
assert ars.call_rpc(
rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args("TestScene")), rpc.s.NewScene.Response
).result
assert len(event(ars, events.o.ChangedObjectTypes).data) == 2
event(ars, events.s.OpenScene)
event(ars, events.s.SceneState)
lock_object(ars, BoxType.__name__)
om = ObjectModel(Model3dType.SPHERE, sphere=Sphere(BoxType.__name__, 0.1))
assert ars.call_rpc(
rpc.o.UpdateObjectModel.Request(get_id(), rpc.o.UpdateObjectModel.Request.Args(BoxType.__name__, om)),
rpc.o.UpdateObjectModel.Response,
).result
ot_evt = event(ars, events.o.ChangedObjectTypes)
assert ot_evt.change_type == ot_evt.Type.UPDATE
assert len(ot_evt.data) == 1
assert ot_evt.data[0].object_model == om
assert ot_evt.data[0].type == BoxType.__name__
assert ot_evt.data[0].has_pose
assert not ot_evt.data[0].disabled
assert BoxType.__name__ in {obj.id for obj in project_service.get_object_type_ids()}
assert BoxType.__name__ in {mod.id for mod in project_service.get_models()}
unlock_object(ars, BoxType.__name__)
lock_object(ars, DummyMultiArmRobot.__name__)
assert not ars.call_rpc(
rpc.o.UpdateObjectModel.Request(
get_id(),
rpc.o.UpdateObjectModel.Request.Args(
DummyMultiArmRobot.__name__,
ObjectModel(Model3dType.SPHERE, sphere=Sphere(DummyMultiArmRobot.__name__, 0.1)),
),
),
rpc.o.UpdateObjectModel.Response,
).result
unlock_object(ars, DummyMultiArmRobot.__name__)
delete_res_1 = ars.call_rpc(
rpc.o.DeleteObjectTypes.Request(get_id(), {BoxType.__name__}, dry_run=True),
rpc.o.DeleteObjectTypes.Response,
)
assert delete_res_1.result
assert delete_res_1.data is None
delete_res_2 = ars.call_rpc(
rpc.o.DeleteObjectTypes.Request(get_id(), {BoxType.__name__}),
rpc.o.DeleteObjectTypes.Response,
)
assert delete_res_2.result
assert delete_res_2.data is None
ot_evt2 = event(ars, events.o.ChangedObjectTypes)
assert ot_evt2.change_type == ot_evt.Type.REMOVE
assert len(ot_evt2.data) == 1
assert ot_evt2.data[0].object_model == om
assert ot_evt2.data[0].type == BoxType.__name__
assert BoxType.__name__ not in {obj.id for obj in project_service.get_object_type_ids()}
assert BoxType.__name__ not in {mod.id for mod in project_service.get_models()}
def main() -> None:
upload_def(AbstractDobot)
upload_def(DobotMagician)
upload_def(DobotM1)
def main() -> None:
upload_def(LoggingTestObject)
upload_def(LoggingTestRobot)
upload_whatever(LoggingMixin)
def test_project_ap_rpcs(start_processes: None, ars: ARServer) -> None:
upload_def(Box, BoxModel(Box.__name__, 1, 2, 3))
event(ars, events.c.ShowMainScreen)
assert ars.call_rpc(
rpc.s.NewScene.Request(get_id(), rpc.s.NewScene.Request.Args("Test scene")), rpc.s.NewScene.Response
).result
assert len(event(ars, events.o.ChangedObjectTypes).data) == 1
scene_data = event(ars, events.s.OpenScene).data
assert scene_data
scene = scene_data.scene
event(ars, events.s.SceneState)
assert ars.call_rpc(
rpc.s.AddObjectToScene.Request(get_id(), rpc.s.AddObjectToScene.Request.Args("box", Box.__name__, Pose())),
rpc.s.AddObjectToScene.Response,
).result
obj = event(ars, events.s.SceneObjectChanged).data
assert obj
# ------------------------------------------------------------------------------------------------------------------
assert ars.call_rpc(
rpc.p.NewProject.Request(get_id(), rpc.p.NewProject.Request.Args(scene.id, "Project name")),
rpc.p.NewProject.Response,
).result
event(ars, events.s.SceneSaved)
event(ars, events.p.OpenProject)
event(ars, events.s.SceneState)
assert ars.call_rpc(
rpc.p.AddActionPoint.Request(get_id(), rpc.p.AddActionPoint.Request.Args("parent_ap", Position())),
rpc.p.AddActionPoint.Response,
).result
parent_ap_evt = event(ars, events.p.ActionPointChanged)
assert ars.call_rpc(
rpc.p.AddActionPoint.Request(
get_id(), rpc.p.AddActionPoint.Request.Args("child_ap", Position(-1), parent_ap_evt.data.id)
),
rpc.p.AddActionPoint.Response,
).result
child_ap_evt = event(ars, events.p.ActionPointChanged)
assert child_ap_evt.data.parent == parent_ap_evt.data.id
lock_object(ars, child_ap_evt.data.id)
assert ars.call_rpc(
rpc.p.AddActionPointOrientation.Request(
get_id(), rpc.p.AddActionPointOrientation.Request.Args(child_ap_evt.data.id, Orientation())
),
rpc.p.AddActionPointOrientation.Response,
).result
ori = event(ars, events.p.OrientationChanged)
assert ars.call_rpc(
rpc.p.AddAction.Request(
get_id(),
rpc.p.AddAction.Request.Args(
child_ap_evt.data.id,
"act_name",
f"{obj.id}/{Box.update_pose.__name__}",
[ActionParameter("new_pose", PosePlugin.type_name(), json.dumps(ori.data.id))],
[Flow()],
),
),
rpc.p.AddAction.Response,
).result
event(ars, events.p.ActionChanged)
unlock_object(ars, child_ap_evt.data.id)
ars.event_mapping[ActionChanged.__name__] = ActionChanged
assert ars.call_rpc(
rpc.p.CopyActionPoint.Request(get_id(), rpc.p.CopyActionPoint.Request.Args(parent_ap_evt.data.id)),
rpc.p.CopyActionPoint.Response,
).result
new_parent_ap = event(ars, events.p.ActionPointChanged)
assert not new_parent_ap.data.parent
new_child_ap = event(ars, events.p.ActionPointChanged)
assert new_child_ap.data.parent == new_parent_ap.data.id
new_ori = event(ars, events.p.OrientationChanged)
assert new_ori.parent_id == new_child_ap.data.id
# with events.p.ActionChanged it would return only BareAction (without parameters)
new_action = event(ars, ActionChanged)
ars.event_mapping[ActionChanged.__name__] = events.p.ActionChanged
assert new_action.parent_id == new_child_ap.data.id
# Pose parameter (orientation id) should be updated now
assert len(new_action.data.parameters) == 1
assert json.loads(new_action.data.parameters[0].value) == new_ori.data.id
def main() -> None:
upload_def(YuMi, urdf=Urdf(get_data("yumi"), YuMi.urdf_package_name))
