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))