class TestUserAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.User(config) url = config.api_url @patch('maproulette.api.maproulette_server.requests.Session.get') def test_find_user_by_username(self, mock_request, api_instance=api): test_username = '******' api_instance.find_user_by_username(test_username) mock_request.assert_called_once_with( f'{self.url}/users/find/{test_username}', params={ 'limit': '10', 'page': '0' }) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_add_user_to_project(self, mock_request, api_instance=api): test_user_id = '12345' test_project_id = '6789' test_group = '2' api_instance.add_user_to_project(user_id=test_user_id, project_id=test_project_id, group_type=test_group, is_osm_user_id='true') mock_request.assert_called_once_with( f'{self.url}/user/{test_user_id}/project/{test_project_id}/{test_group}', json=None, params={'isOSMUserId': 'true'}) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_add_user_list_to_project(self, mock_request, api_instance=api): test_user_ids = [123, 456, 789] test_project_id = '6789' test_group = '2' api_instance.add_user_list_to_project(user_ids=test_user_ids, project_id=test_project_id, group_type=test_group, is_osm_user_id='true') mock_request.assert_called_once_with( f'{self.url}/user/project/{test_project_id}/{test_group}', params={'isOSMUserId': 'true'}, json=test_user_ids)
class TestUserAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.User(config) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_find_user_by_username(self, mock_request, api_instance=api): test_username = '******' mock_request.return_value.status_code = '200' response = api_instance.find_user_by_username(test_username) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.post') def test_add_user_to_project(self, mock_request, api_instance=api): test_user_id = '12345' test_project_id = '6789' test_group = '2' mock_request.return_value.status_code = '200' response = api_instance.add_user_to_project(user_id=test_user_id, project_id=test_project_id, group_type=test_group, is_osm_user_id='true') self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_add_user_list_to_project(self, mock_request, api_instance=api): test_user_ids = [123, 456, 789] test_project_id = '6789' test_group = '2' mock_request.return_value.status_code = '200' response = api_instance.add_user_list_to_project( user_ids=test_user_ids, project_id=test_project_id, group_type=test_group, is_osm_user_id='true') self.assertEqual(response['status'], '200')
import maproulette import json # Create a configuration object using a url and API key config = maproulette.Configuration(api_key='{YOUR_API_KEY}') # Create an API object using your config object api = maproulette.Project(config) # We can fetch a project using the name 'Health Facilities in India': my_project_name = 'Health Facilities in India' # Print the API response print(json.dumps(api.find_project(my_project_name), indent=4, sort_keys=True)) # We can also fetch a project using the project ID: my_project_id = '4719' # Print the API response print( json.dumps(api.get_project_by_id(my_project_id), indent=4, sort_keys=True)) # We can access the project's challenges as well: print( json.dumps(api.get_project_challenges(my_project_id), indent=4, sort_keys=True)) # If we want to create a new project, we can use the Project Model: my_project = maproulette.ProjectModel(name='my_new_project_name_20200120_abc')
class TestAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") server = maproulette.MapRouletteServer(configuration=config) @patch('maproulette.api.maproulette_server.MapRouletteServer.get') @patch('requests.Session.get') def test_get_not_found_error(self, mock_get, mock_server_get, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() not_found_error = errors.NotFoundError(message='Resource not found', status=404, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_get.return_value = mock_response mock_server_get.side_effect = not_found_error with self.assertRaises(errors.NotFoundError) as context: server_instance.get(endpoint='') assert context.exception.message == 'Resource not found' assert context.exception.status == 404 @patch('maproulette.api.maproulette_server.MapRouletteServer.get') @patch('requests.Session.get') def test_get_generic_http_error(self, mock_get, mock_server_get, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() generic_http_error = errors.HttpError(message='An HTTP error occurred', status=403, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_get.return_value = mock_response mock_server_get.side_effect = generic_http_error with self.assertRaises(errors.HttpError) as context: server_instance.get(endpoint='') assert context.exception.message == 'An HTTP error occurred' assert context.exception.status == 403 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.get') @patch('requests.Session.get') def test_get_connection_error(self, mock_get, mock_server_get, server_instance=server): mock_response = mock.Mock() requests_connection_error = requests.exceptions.ConnectionError() connection_error = errors.ConnectionUnavailableError( message='Connection Unavailable', status=500, payload='error payload') mock_response.raise_for_status.side_effect = requests_connection_error mock_get.return_value = mock_response mock_server_get.side_effect = connection_error with self.assertRaises(errors.ConnectionUnavailableError) as context: server_instance.get(endpoint='') assert context.exception.message == 'Connection Unavailable' assert context.exception.status == 500 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.post') @patch('requests.Session.post') def test_post_invalid_json_error(self, mock_post, mock_server_post, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() invalid_json_error = errors.InvalidJsonError( message='Invalid JSON payload', status=400, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_post.return_value = mock_response mock_server_post.side_effect = invalid_json_error with self.assertRaises(errors.InvalidJsonError) as context: server_instance.post(endpoint='') assert context.exception.message == 'Invalid JSON payload' assert context.exception.status == 400 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.post') @patch('requests.Session.post') def test_post_generic_http_error(self, mock_post, mock_server_post, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() generic_http_error = errors.HttpError(message='An HTTP error occurred', status=403, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_post.return_value = mock_response mock_server_post.side_effect = generic_http_error with self.assertRaises(errors.HttpError) as context: server_instance.post(endpoint='') assert context.exception.message == 'An HTTP error occurred' assert context.exception.status == 403 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.post') @patch('requests.Session.post') def test_post_unauthorized_error(self, mock_post, mock_server_post, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() unauthorized_error = errors.UnauthorizedError( message='The user is not authorized to make this request', status=401, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_post.return_value = mock_response mock_server_post.side_effect = unauthorized_error with self.assertRaises(errors.UnauthorizedError) as context: server_instance.post(endpoint='') assert context.exception.message == 'The user is not authorized to make this request' assert context.exception.status == 401 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.post') @patch('requests.Session.post') def test_post_connection_error(self, mock_post, mock_server_post, server_instance=server): mock_response = mock.Mock() requests_connection_error = requests.exceptions.ConnectionError() connection_error = errors.ConnectionUnavailableError( message='Connection Unavailable', status=500, payload='error payload') mock_response.raise_for_status.side_effect = requests_connection_error mock_post.return_value = mock_response mock_server_post.side_effect = connection_error with self.assertRaises(errors.ConnectionUnavailableError) as context: server_instance.post(endpoint='') assert context.exception.message == 'Connection Unavailable' assert context.exception.status == 500 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.put') @patch('requests.Session.put') def test_put_invalid_json_error(self, mock_put, mock_server_put, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() invalid_json_error = errors.InvalidJsonError( message='Invalid JSON payload', status=400, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_put.return_value = mock_response mock_server_put.side_effect = invalid_json_error with self.assertRaises(errors.InvalidJsonError) as context: server_instance.put(endpoint='') assert context.exception.message == 'Invalid JSON payload' assert context.exception.status == 400 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.put') @patch('requests.Session.put') def test_put_generic_http_error(self, mock_put, mock_server_put, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() generic_http_error = errors.HttpError(message='An HTTP error occurred', status=403, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_put.return_value = mock_response mock_server_put.side_effect = generic_http_error with self.assertRaises(errors.HttpError) as context: server_instance.put(endpoint='') assert context.exception.message == 'An HTTP error occurred' assert context.exception.status == 403 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.put') @patch('requests.Session.put') def test_put_unauthorized_error(self, mock_put, mock_server_put, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() unauthorized_error = errors.UnauthorizedError( message='The user is not authorized to make this request', status=401, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_put.return_value = mock_response mock_server_put.side_effect = unauthorized_error with self.assertRaises(errors.UnauthorizedError) as context: server_instance.put(endpoint='') assert context.exception.message == 'The user is not authorized to make this request' assert context.exception.status == 401 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.put') @patch('requests.Session.put') def test_put_connection_error(self, mock_put, mock_server_put, server_instance=server): mock_response = mock.Mock() requests_connection_error = requests.exceptions.ConnectionError() connection_error = errors.ConnectionUnavailableError( message='Connection Unavailable', status=500, payload='error payload') mock_response.raise_for_status.side_effect = requests_connection_error mock_put.return_value = mock_response mock_server_put.side_effect = connection_error with self.assertRaises(errors.ConnectionUnavailableError) as context: server_instance.put(endpoint='') assert context.exception.message == 'Connection Unavailable' assert context.exception.status == 500 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.delete') @patch('requests.Session.delete') def test_delete_unauthorized_error(self, mock_delete, mock_server_delete, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() unauthorized_error = errors.UnauthorizedError( message='The user is not authorized to make this request', status=401, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_delete.return_value = mock_response mock_server_delete.side_effect = unauthorized_error with self.assertRaises(errors.UnauthorizedError) as context: server_instance.delete(endpoint='') assert context.exception.message == 'The user is not authorized to make this request' assert context.exception.status == 401 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.delete') @patch('requests.Session.delete') def test_delete_not_found_error(self, mock_delete, mock_server_delete, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() not_found_error = errors.NotFoundError(message='Resource not found', status=404, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_delete.return_value = mock_response mock_server_delete.side_effect = not_found_error with self.assertRaises(errors.NotFoundError) as context: server_instance.delete(endpoint='') assert context.exception.message == 'Resource not found' assert context.exception.status == 404 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.delete') @patch('requests.Session.delete') def test_delete_generic_http_error(self, mock_delete, mock_server_delete, server_instance=server): mock_response = mock.Mock() requests_http_error = requests.exceptions.HTTPError() generic_http_error = errors.HttpError(message='An HTTP error occurred', status=403, payload='error payload') mock_response.raise_for_status.side_effect = requests_http_error mock_delete.return_value = mock_response mock_server_delete.side_effect = generic_http_error with self.assertRaises(errors.HttpError) as context: server_instance.delete(endpoint='') assert context.exception.message == 'An HTTP error occurred' assert context.exception.status == 403 assert context.exception.payload == 'error payload' @patch('maproulette.api.maproulette_server.MapRouletteServer.delete') @patch('requests.Session.delete') def test_delete_connection_error(self, mock_delete, mock_server_delete, server_instance=server): mock_response = mock.Mock() requests_connection_error = requests.exceptions.ConnectionError() connection_error = errors.ConnectionUnavailableError( message='Connection Unavailable', status=500, payload='error payload') mock_response.raise_for_status.side_effect = requests_connection_error mock_delete.return_value = mock_response mock_server_delete.side_effect = connection_error with self.assertRaises(errors.ConnectionUnavailableError) as context: server_instance.delete(endpoint='') assert context.exception.message == 'Connection Unavailable' assert context.exception.status == 500 assert context.exception.payload == 'error payload' @patch('json.loads') def test_parse_response_message(self, mock_loads, server_instance=server): mock_loads.return_value = {'message': 'some message'} self.assertTrue(server_instance.parse_response_message(mock_loads)) @patch('json.loads') def test_parse_response_message_value_error(self, mock_loads, server_instance=server): mock_loads.side_effect = ValueError() self.assertIsNone(server_instance.parse_response_message(mock_loads)) @patch('json.loads') def test_parse_response_message_key_error(self, mock_loads, server_instance=server): mock_loads.side_effect = KeyError() self.assertIsNone(server_instance.parse_response_message(mock_loads))
class TestTaskAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.Task(config) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_by_id(self, mock_request, api_instance=api): test_task_id = '42914448' mock_request.return_value.status_code = '200' response = api_instance.get_task_by_id(test_task_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_history(self, mock_request, api_instance=api): test_task_id = '42914448' mock_request.return_value.status_code = '200' response = api_instance.get_task_history(test_task_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_tasks(self, mock_request, api_instance=api): test_tasks = [] geometries = test_geojson['features'][0]['geometry'] test_task_model = maproulette.TaskModel(name='test_task', parent='12345', geometries=geometries) test_tasks.append(test_task_model.to_dict()) mock_request.return_value.status_code = '200' responses = api_instance.create_tasks(test_tasks) for response in responses: self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_tasks(self, mock_request, api_instance=api): geometries = test_geojson['features'][0]['geometry'] test_task_model = maproulette.TaskModel(name='test_task', parent='12345', geometries=geometries) mock_request.return_value.status_code = '200' response = api_instance.update_tasks(test_task_model) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_tags(self, mock_request, api_instance=api): task_id = '42914448' mock_request.return_value.status_code = '200' response = api_instance.get_task_tags(task_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_task_tags(self, mock_request, api_instance=api): task_id = '42914448' tags = 'test' mock_request.return_value.status_code = '200' response = api_instance.delete_task_tags(task_id, tags) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_tasks_by_tags(self, mock_request, api_instance=api): tags = 'test' mock_request.return_value.status_code = '200' response = api_instance.get_tasks_by_tags(tags) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_update_task_tags(self, mock_request, api_instance=api): task_id = '42914448' tags = 'test' mock_request.return_value.status_code = '200' response = api_instance.update_task_tags(task_id, tags) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_task_status(self, mock_request, api_instance=api): task_id = '42914448' status = 3 mock_request.return_value.status_code = '200' response = api_instance.update_task_status(task_id, status) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_comments(self, mock_request, api_instance=api): task_id = '42914448' mock_request.return_value.status_code = '200' response = api_instance.get_task_comments(task_id) self.assertEqual(response['status'], '200') def test_batch_generator(self, api_instance=api): batch_size = 10 test_length = 1234 test_list = [i for i in range(test_length)] running_total = 0 for chunk in api_instance.batch_generator(test_list, batch_size): running_total += len(chunk) self.assertIsInstance(chunk, list) self.assertLessEqual(len(chunk), batch_size) self.assertEqual(test_length, running_total)
import time import maproulette try: MAPROULETTE_API_KEY = os.environ['MAPROULETTE_API_KEY'] except KeyError: raise KeyError( "Please set the MapRoulette API key in environment variable MAPROULETTE_API_KEY. " "Get it from https://maproulette.org/user/profile") PROJECT_ID = 41947 logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO) osmdump = pathlib.Path('data/thueringen-latest.osm.pbf') osmdump_mtime = datetime.datetime.fromtimestamp(osmdump.stat().st_mtime) config = maproulette.Configuration(api_key=MAPROULETTE_API_KEY) challenge_api = maproulette.Challenge(config) challenge = challenge_api.get_challenge_by_id(17667)['data'] if challenge['status'] == 3: logging.info("Rebuilding challenge %d", challenge['id']) result = challenge_api.rebuild_challenge(challenge['id'], remove_unmatched=True) logging.info("Result: %s", result) time.sleep(30) result = challenge_api.update_challenge( challenge['id'], {'dataOriginDate': osmdump_mtime.isoformat()}) logging.info("Result: %s", result)
class TestProjectAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.Project(config) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_by_id(self, mock_request, api_instance=api): test_project_id = '32922' mock_request.return_value.status_code = '200' response = api_instance.get_project_by_id(test_project_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_by_name(self, mock_request, api_instance=api): test_project_name = 'Maptime!' mock_request.return_value.status_code = '200' response = api_instance.get_project_by_name(test_project_name) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_find_project(self, mock_request, api_instance=api): test_search = 'Health Facilities in India' mock_request.return_value.status_code = '200' response = api_instance.find_project(test_search) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_challenges(self, mock_request, api_instance=api): test_project_id = '12974' mock_request.return_value.status_code = '200' response = api_instance.get_project_challenges(test_project_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_project(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel( name='Test_Project_Name', description='This is a test project') mock_request.return_value.status_code = '200' response = api_instance.create_project(test_project_model) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.post') def test_add_challenge_to_project(self, mock_request, api_instance=api): test_virtual_project_model = maproulette.ProjectModel( name='Test Virtual Project Name', id=1234) test_challenge_model = maproulette.ChallengeModel( name='Test Challenge Name', id=246) test_virtual_project_id = test_virtual_project_model.id test_challenge_id = test_challenge_model.id mock_request.return_value.status_code = '200' response = api_instance.add_challenge_to_project( test_virtual_project_id, test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.post') def test_remove_challenge_from_project(self, mock_request, api_instance=api): test_virtual_project_model = maproulette.ProjectModel( name='Test Virtual Project Name', id=1234) test_challenge_model = maproulette.ChallengeModel( name='Test Challenge Name', id=246) test_virtual_project_id = test_virtual_project_model.id test_challenge_id = test_challenge_model.id mock_request.return_value.status_code = '200' response = api_instance.remove_challenge_from_project( test_virtual_project_id, test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_project(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel(name='Test Project Name', id=1234) test_project_id = test_project_model.id mock_request.return_value.status_code = '200' response = api_instance.delete_project(test_project_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_project(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel(name='Test Project Name', id=1234) test_updated_project_model = maproulette.ProjectModel( name='Test Updated Project Name') test_project_model_id = test_project_model.id mock_request.return_value.status_code = '200' response = api_instance.update_project(test_project_model_id, test_updated_project_model) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_by_ids(self, mock_request, api_instance=api): test_project_ids = '1234,2468,1356' mock_request.return_value.status_code = '200' response = api_instance.get_projects_by_ids(test_project_ids) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_random_tasks(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel(name='Test Project Name', id=1234) test_project_id = test_project_model.id mock_request.return_value.status_code = '200' response = api_instance.get_random_tasks(test_project_id) self.assertEqual(response['status'], '200')
class TestChallengeAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.Challenge(config) url = config.api_url @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_by_id(self, mock_request, api_instance=api): test_challenge_id = '12974' api_instance.get_challenge_by_id(test_challenge_id) mock_request.assert_called_once_with(f'{self.url}/challenge/12974', params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_statistics_by_id(self, mock_request, api_instance=api): test_challenge_id = '12974' api_instance.get_challenge_statistics_by_id(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/data/challenge/{test_challenge_id}', params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_tasks(self, mock_request, api_instance=api): test_challenge_id = '12974' api_instance.get_challenge_tasks(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/tasks', params={ 'limit': '10', 'page': '0' }) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_challenge(self, mock_request, api_instance=api): test_challenge_model = maproulette.ChallengeModel( name='Test_Challenge_Name', instruction='Do something', description='This is a test challenge', overpassQL=test_overpassQL_query) api_instance.create_challenge(test_challenge_model) mock_request.assert_called_once_with( f'{self.url}/challenge', json=json.loads(create_challenge_output), params=None) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_add_tasks_to_challenge(self, mock_request, api_instance=api): test_challenge_id = '12978' api_instance.add_tasks_to_challenge(test_geojson, test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/12978/addTasks', json=test_geojson, params=None) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_virtual_challenge(self, mock_request, api_instance=api): # TODO: add model for virtual challenge to aid in posting test_challenge_model = maproulette.ChallengeModel( name='Test_Challenge_Name', instruction='Do something', description='This is a test challenge', overpassQL=test_overpassQL_query) api_instance.create_virtual_challenge(test_challenge_model) mock_request.assert_called_once_with(f'{self.url}/virtualchallenge', json=test_challenge_model, params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_by_name(self, mock_request, api_instance=api): test_project_id = '12345' test_challenge_name = 'Test_Challenge_Name' api_instance.get_challenge_by_name(test_project_id, test_challenge_name) mock_request.assert_called_once_with( f'{self.url}/project/{test_project_id}/challenge/{test_challenge_name}', params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenges_by_tags(self, mock_request, api_instance=api): test_challenge_tag = 'River' mock_request.return_value.status_code = '200' response = api_instance.get_challenges_by_tags(test_challenge_tag) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_virtual_challenge_by_id(self, mock_request, api_instance=api): test_virtual_challenge_id = '12345' api_instance.get_virtual_challenge_by_id(test_virtual_challenge_id) mock_request.assert_called_once_with( f'{self.url}/virtualchallenge/{test_virtual_challenge_id}', params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_listing(self, mock_request, api_instance=api): test_project_ids = '12345,67891,23456' api_instance.get_challenge_listing(test_project_ids) mock_request.assert_called_once_with(f'{self.url}/challenges/listing', params={ 'projectIds': test_project_ids, 'limit': '10', 'page': '0', 'onlyEnabled': 'true' }) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_children(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.get_challenge_children(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/children', params={ 'limit': '10', 'page': '0' }) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_comments(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.get_challenge_comments(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/comments', params={ 'limit': '10', 'page': '0' }) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_extract_challenge_comments(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.extract_challenge_comments(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/comments/extract', params={ 'limit': '10', 'page': '0' }) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_extract_task_summaries(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.extract_task_summaries(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/tasks/extract', params={ 'limit': '10', 'page': '0', 'status': '', 'reviewStatus': '', 'priority': '', 'exportProperties': '', 'taskPropertySearch': '' }) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_geojson(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.get_challenge_geojson(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/view/{test_challenge_id}', params={ 'status': '', 'reviewStatus': '', 'priority': '', 'taskPropertySearch': '' }) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_task_priorities(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.update_task_priorities(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/updateTaskPriorities', json=None, params=None) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_reset_task_instructions(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.reset_task_instructions(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/resetTaskInstructions', json=None, params=None) @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_challenge(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.delete_challenge(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}', params={'immediate': 'false'}) @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_challenge_tasks(self, mock_request, api_instance=api): test_challenge_id = '12345' api_instance.delete_challenge_tasks(test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}/tasks', params={'statusFilters': ''}) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_challenge(self, mock_request, api_instance=api): test_challenge_id = '12345' test_challenge_model = maproulette.ChallengeModel( name='Test_Challenge_Name', instruction='Do something', description='This is a test challenge', overpassQL=test_overpassQL_query) api_instance.update_challenge(test_challenge_id, test_challenge_model) mock_request.assert_called_once_with( f'{self.url}/challenge/{test_challenge_id}', json=json.loads(create_challenge_output), params=None)
def payload(integration_id: int, payload: dict): integration = IntegrationService.get_secrets(integration_id) if integration is None: raise IntegrationNotFound('Integration Not Found') if integration.integration != "maproulette": raise Exception("Only MapRoulette Integrations supported"); for ele in ['prediction', 'project', 'project_desc', 'challenge', 'challenge_instr', 'threshold', 'inferences']: if payload.get(ele) is None: raise Exception('Missing ' + ele + ' key in body') auth = integration.auth if payload.get('auth') is not None: auth = payload.get('auth') parsed = urlparse(integration.url) config = maproulette.Configuration( api_key=auth, hostname=parsed.netloc, protocol=parsed.scheme ) project_api = maproulette.Project(config) challenge_api = maproulette.Challenge(config) try: project = project_api.get_project_by_name( project_name=payload.get('project') ) except: project = project_api.create_project( data={ "name": payload.get('project'), "display_name": payload.get('project'), "description": payload.get('project_desc'), "enabled": True } ) try: challenge = challenge_api.create_challenge( data={ 'name': payload.get('challenge'), 'parent': project['data']['id'], 'instruction': payload.get('challenge_instr') } ) except Exception as e: raise e req_inferences = payload.get('inferences', 'all') req_threshold = float(payload.get('threshold', '0')) stream = PredictionService.export(int(payload.get('prediction'))) inferences = PredictionService.inferences(int(payload.get('prediction'))) pred = PredictionService.get_prediction_by_id(int(payload.get('prediction'))) if req_inferences != 'all': inferences = [ req_inferences ] fc = { 'type': 'FeatureCollection', 'features': [] } for row in stream: if req_inferences != 'all' and row[3].get(req_inferences) is None: continue if req_inferences != 'all' and row[3].get(req_inferences) <= req_threshold: continue properties_dict = {} if row[4]: properties_dict = row[3] valid_dict = {} valid_dict.update({'validity': row[4]}) properties_dict.update(valid_dict) feat = { "id": row[0], "quadkey": row[1], "type": "Feature", "properties": properties_dict, "geometry": json.loads(row[2]) } fc['features'].append(feat) challenge_api.add_tasks_to_challenge( challenge_id=challenge['data']['id'], data=fc ) return { "project": project['data']['id'], "challenge": challenge['data']['id'] }
class TestTaskAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.Task(config) url = config.api_url @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_by_id(self, mock_request, api_instance=api): test_task_id = '42914448' api_instance.get_task_by_id(test_task_id) mock_request.assert_called_once_with(f'{self.url}/task/{test_task_id}', params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_history(self, mock_request, api_instance=api): test_task_id = '42914448' api_instance.get_task_history(test_task_id) mock_request.assert_called_once_with( f'{self.url}/task/{test_task_id}/history', params=None) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_tasks(self, mock_request, api_instance=api): test_tasks = [] geometries = test_geojson['features'][0]['geometry'] test_task_model = maproulette.TaskModel(name='test_task', parent='12345', geometries=geometries) test_tasks.append(test_task_model.to_dict()) api_instance.create_tasks(test_tasks) input_json_list = [] for task in test_tasks: input_json_list.append({ 'name': task['name'], 'parent': task['parent'], 'geometries': task['geometries'] }) mock_request.assert_called_once_with(f'{self.url}/tasks', json=input_json_list, params=None) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_cooperative_task(self, mock_request, api_instance=api): test_child_operation = maproulette.ChildOperationModel( operation="setTags", data={"test_tag_4": "True"}) test_parent_operation = maproulette.ParentOperationModel( operation_type="modifyElement", element_type="way", osm_id="31110737", child_operations=test_child_operation.to_dict()) test_cooperative_work = maproulette.CooperativeWorkModel( version=2, type=1, parent_operations=test_parent_operation) test_task = maproulette.TaskModel( name="Test_Coop_Task", parent=1234, geometries=test_geojson['features'][0]['geometry'], cooperative_work=test_cooperative_work) with self.assertRaises(ValueError): test_child_operation.operation = "invalid" with self.assertRaises(ValueError): test_parent_operation.operation_type = "invalid" with self.assertRaises(ValueError): test_parent_operation.element_type = "invalid" with self.assertRaises(ValueError): test_parent_operation.osm_id = "invalid" with self.assertRaises(ValueError): test_cooperative_work.type = "invalid" api_instance.create_task(test_task) mock_request.assert_called_once_with(f'{self.url}/task', json=test_task, params=None) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_tasks(self, mock_request, api_instance=api): geometries = test_geojson['features'][0]['geometry'] test_task_model = maproulette.TaskModel(name='test_task', parent='12345', geometries=geometries) api_instance.update_tasks(test_task_model) mock_request.assert_called_once_with(f'{self.url}/tasks', json=test_task_model, params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_tags(self, mock_request, api_instance=api): test_task_id = '42914448' api_instance.get_task_tags(test_task_id) mock_request.assert_called_once_with( f'{self.url}/task/{test_task_id}/tags', params=None) @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_task_tags(self, mock_request, api_instance=api): task_id = '42914448' tags = 'test' api_instance.delete_task_tags(task_id, tags) mock_request.assert_called_once_with(f'{self.url}/task/{task_id}/tags', params={'tags': tags}) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_tasks_by_tags(self, mock_request, api_instance=api): tags = 'test' api_instance.get_tasks_by_tags(tags) mock_request.assert_called_once_with(f'{self.url}/tasks/tags', params={ 'tags': tags, 'limit': '10', 'page': '0' }) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_get_tasks_by_bounding_box(self, mock_request, api_instance=api): left = -1.22321018 bottom = 47.690315 right = -122.306191 top = 47.706912 api_instance.get_tasks_by_bounding_box(left=left, bottom=bottom, right=right, top=top) mock_request.assert_called_once_with( f'{self.url}/tasks/box/{left}/{bottom}/{right}/{top}', json=None, params={ "limit": '10000', "page": '0', "excludeLocked": 'false', "order": 'ASC', "includeTotal": 'false', "includeGeometries": 'false', "includeTags": 'false' }) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_update_task_tags(self, mock_request, api_instance=api): task_id = '42914448' tags = 'test' api_instance.update_task_tags(task_id, tags) mock_request.assert_called_once_with( f'{self.url}/task/{task_id}/tags/update', params={'tags': tags}) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_task_status(self, mock_request, api_instance=api): task_id = '42914448' status = 3 api_instance.update_task_status(task_id, status) mock_request.assert_called_once_with( f'{self.url}/task/{task_id}/{status}', params={ 'comment': 'None', 'tags': 'None', 'requestReview': 'None' }, json=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_task_comments(self, mock_request, api_instance=api): task_id = '42914448' api_instance.get_task_comments(task_id) mock_request.assert_called_once_with( f'{self.url}/task/{task_id}/comments', params=None) def test_batch_generator(self, api_instance=api): batch_size = 10 test_length = 1234 test_list = [i for i in range(test_length)] running_total = 0 for chunk in api_instance.batch_generator(test_list, batch_size): running_total += len(chunk) self.assertIsInstance(chunk, list) self.assertLessEqual(len(chunk), batch_size) self.assertEqual(test_length, running_total)
def payload(integration_id: int, payload: dict): integration = IntegrationService.get_secrets(integration_id) if integration is None: raise IntegrationNotFound("Integration Not Found") if integration.integration != "maproulette": raise Exception("Only MapRoulette Integrations supported") for ele in [ "prediction", "project", "project_desc", "challenge", "challenge_instr", "threshold", "inferences", ]: if payload.get(ele) is None: raise Exception("Missing " + ele + " key in body") auth = integration.auth if payload.get("auth") is not None: auth = payload.get("auth") parsed = urlparse(integration.url) config = maproulette.Configuration(api_key=auth, hostname=parsed.netloc, protocol=parsed.scheme) project_api = maproulette.Project(config) challenge_api = maproulette.Challenge(config) try: project = project_api.get_project_by_name( project_name=payload.get("project")) except Exception: project = project_api.create_project( data={ "name": payload.get("project"), "display_name": payload.get("project"), "description": payload.get("project_desc"), "enabled": True, }) try: challenge = challenge_api.create_challenge( data={ "name": payload.get("challenge"), "parent": project["data"]["id"], "instruction": payload.get("challenge_instr"), }) except Exception as e: raise e req_inferences = payload.get("inferences", "all") req_threshold = float(payload.get("threshold", "0")) stream = PredictionService.export(int(payload.get("prediction"))) feats = {"type": "FeatureCollection", "features": []} for row in stream: if req_inferences != "all" and row[3].get(req_inferences) is None: continue if req_inferences != "all" and row[3].get( req_inferences) <= req_threshold: continue properties_dict = row[3] if row[4]: valid_dict = {} valid_dict.update({"validity": row[4]}) properties_dict.update(valid_dict) properties_dict["mle:id"] = row[0] feat = { "quadkey": row[1], "type": "Feature", "properties": properties_dict, "geometry": json.loads(row[2]), } feats["features"].append(feat) challenge_api.add_tasks_to_challenge( challenge_id=challenge["data"]["id"], data=feats) return { "project": project["data"]["id"], "challenge": challenge["data"]["id"] }
class TestChallengeAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.Challenge(config) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_by_id(self, mock_request, api_instance=api): test_challenge_id = '12974' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_by_id(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_statistics_by_id(self, mock_request, api_instance=api): test_challenge_id = '12974' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_statistics_by_id( test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_tasks(self, mock_request, api_instance=api): test_challenge_id = '12974' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_tasks(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_challenge(self, mock_request, api_instance=api): test_challenge_model = maproulette.ChallengeModel( name='Test_Challenge_Name', instruction='Do something', description='This is a test challenge', overpassQL=test_overpassQL_query) mock_request.return_value.status_code = '200' response = api_instance.create_challenge(test_challenge_model) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_add_tasks_to_challenge(self, mock_request, api_instance=api): test_challenge_id = '12978' mock_request.return_value.status_code = '200' response = api_instance.add_tasks_to_challenge(test_geojson, test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_virtual_challenge(self, mock_request, api_instance=api): # TODO: add model for virtual challenge to aid in posting test_challenge_model = maproulette.ChallengeModel( name='Test_Challenge_Name', instruction='Do something', description='This is a test challenge', overpassQL=test_overpassQL_query) mock_request.return_value.status_code = '200' response = api_instance.create_virtual_challenge(test_challenge_model) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_by_name(self, mock_request, api_instance=api): test_project_id = '12345' test_challenge_name = 'Test_Challenge_Name' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_by_name(test_project_id, test_challenge_name) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenges_by_tags(self, mock_request, api_instance=api): test_challenge_tag = 'River' mock_request.return_value.status_code = '200' response = api_instance.get_challenges_by_tags(test_challenge_tag) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_virtual_challenge_by_id(self, mock_request, api_instance=api): test_virtual_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.get_virtual_challenge_by_id( test_virtual_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_listing(self, mock_request, api_instance=api): test_project_ids = '12345,67891,23456' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_listing(test_project_ids) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_children(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_children(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_comments(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_comments(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_extract_challenge_comments(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.extract_challenge_comments(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_extract_task_summaries(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.extract_task_summaries(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_challenge_geojson(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.get_challenge_geojson(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_task_priorities(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.update_task_priorities(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_reset_task_instructions(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.reset_task_instructions(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_challenge(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.delete_challenge(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_challenge_tasks(self, mock_request, api_instance=api): test_challenge_id = '12345' mock_request.return_value.status_code = '200' response = api_instance.delete_challenge_tasks(test_challenge_id) self.assertEqual(response['status'], '200') @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_challenge(self, mock_request, api_instance=api): test_challenge_id = '12345' test_challenge_model = maproulette.ChallengeModel( name='Test_Challenge_Name', instruction='Do something', description='This is a test challenge', overpassQL=test_overpassQL_query) mock_request.return_value.status_code = '200' response = api_instance.update_challenge(test_challenge_id, test_challenge_model) self.assertEqual(response['status'], '200')
class TestProjectAPI(unittest.TestCase): config = maproulette.Configuration(api_key="API_KEY") api = maproulette.Project(config) url = config.api_url @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_by_id(self, mock_request, api_instance=api): test_project_id = '32922' api_instance.get_project_by_id(test_project_id) mock_request.assert_called_once_with( f'{self.url}/project/{test_project_id}', params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_by_name(self, mock_request, api_instance=api): test_project_name = 'Maptime!' api_instance.get_project_by_name(test_project_name) mock_request.assert_called_once_with( f'{self.url}/projectByName/{test_project_name}', params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_find_project(self, mock_request, api_instance=api): test_search = 'Health Facilities in India' api_instance.find_project(test_search) mock_request.assert_called_once_with(f'{self.url}/projects', params={ 'search': test_search, 'limit': '10', 'page': '0', 'onlyEnabled': 'true' }) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_challenges(self, mock_request, api_instance=api): test_project_id = '12974' api_instance.get_project_challenges(test_project_id) mock_request.assert_called_once_with( f'{self.url}/project/{test_project_id}/challenges', params={ 'limit': '10', 'page': '0' }) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_create_project(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel( name='Test_Project_Name', description='This is a test project') api_instance.create_project(test_project_model) mock_request.assert_called_once_with(f'{self.url}/project', json=test_project, params=None) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_add_challenge_to_project(self, mock_request, api_instance=api): test_virtual_project_model = maproulette.ProjectModel( name='Test Virtual Project Name', id=1234) test_challenge_model = maproulette.ChallengeModel( name='Test Challenge Name', id=246) test_virtual_project_id = test_virtual_project_model.id test_challenge_id = test_challenge_model.id api_instance.add_challenge_to_project(test_virtual_project_id, test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/project/{test_virtual_project_id}/challenge/{test_challenge_id}/add', json=None, params=None) @patch('maproulette.api.maproulette_server.requests.Session.post') def test_remove_challenge_from_project(self, mock_request, api_instance=api): test_virtual_project_model = maproulette.ProjectModel( name='Test Virtual Project Name', id=1234) test_challenge_model = maproulette.ChallengeModel( name='Test Challenge Name', id=246) test_virtual_project_id = test_virtual_project_model.id test_challenge_id = test_challenge_model.id api_instance.remove_challenge_from_project(test_virtual_project_id, test_challenge_id) mock_request.assert_called_once_with( f'{self.url}/project/{test_virtual_project_id}/challenge/{test_challenge_id}/remove', json=None, params=None) @patch('maproulette.api.maproulette_server.requests.Session.delete') def test_delete_project(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel(name='Test Project Name', id=1234) test_project_id = test_project_model.id api_instance.delete_project(test_project_id) mock_request.assert_called_once_with( f'{self.url}/project/{test_project_id}', params={'immediate': 'false'}) @patch('maproulette.api.maproulette_server.requests.Session.put') def test_update_project(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel(name='Test Project Name', id=1234) test_updated_project_name = 'Test Updated Project Name' test_updated_project_model = maproulette.ProjectModel( name=test_updated_project_name) test_project_model_id = test_project_model.id api_instance.update_project(test_project_model_id, test_updated_project_model) mock_request.assert_called_once_with( f'{self.url}/project/{test_project_model_id}', json={'name': test_updated_project_name}, params=None) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_project_by_ids(self, mock_request, api_instance=api): test_project_ids = '1234,2468,1356' api_instance.get_projects_by_ids(test_project_ids) mock_request.assert_called_once_with( f'{self.url}/projectsById', params={'projectIds': test_project_ids}) @patch('maproulette.api.maproulette_server.requests.Session.get') def test_get_random_tasks(self, mock_request, api_instance=api): test_project_model = maproulette.ProjectModel(name='Test Project Name', id=1234) test_project_id = test_project_model.id api_instance.get_random_tasks(test_project_id) mock_request.assert_called_once_with( f'{self.url}/project/{test_project_id}/tasks', params={ 'limit': '1', 'proximity': '-1', 'search': '' })
import maproulette import json # Create a configuration object for MapRoulette using your API key: config = maproulette.Configuration(api_key="API_KEY") # Create an API object with the above config object: api = maproulette.Task(config) # To fetch a task, specify the task ID task_id = '42914448' # Printing response print(json.dumps(api.get_task_by_id(task_id), indent=4, sort_keys=True)) # You can access a task's history: print(json.dumps(api.get_task_history(task_id), indent=4, sort_keys=True)) # Or get a task's tags: print(json.dumps(api.get_task_tags(task_id), indent=4, sort_keys=True)) # You can also fetch tasks by specifying a list of tags: tags = 'tag1,tag2' print(json.dumps(api.get_tasks_by_tags(tags), indent=4, sort_keys=True))
with urllib.request.urlopen( "https://hackmd.io/@1ec5/BJ7h-KIPw/download") as doc: for line in doc: line = line.decode() if line.startswith("---"): break for line in doc: line = line.decode() if '|' not in line: continue category, tags, preset = line.split('|') presets[category.strip()] = preset.strip() print("For category", category.strip(), "use preset", preset[:50].strip()) config = maproulette.Configuration(api_key=os.getenv("MR_API_KEY")) proj_api = maproulette.Project(config) proj_name = "Santa Clara County Social distancing protocol import" try: data = proj_api.get_project_by_name(proj_name)["data"] proj = maproulette.ProjectModel(name=data["name"], id=data["id"]) existing = True print("Using existing project ID", proj.id) except maproulette.api.errors.NotFoundError: proj = maproulette.ProjectModel(name=proj_name) existing = False print("Creating new project") if not existing: proj.description = """Importing business facilities based on [social distancing protocols](https://sdp.sccgov.org/) that business owners have filed with the [Santa Clara County Public Health Department](https://en.wikipedia.org/wiki/Santa_Clara_County_Public_Health_Department) under [COVID-19](https://en.wikipedia.org/wiki/COVID-19_pandemic_in_the_San_Francisco_Bay_Area) public health orders. See the [proposal on the OpenStreetMap wiki](https://wiki.openstreetmap.org/wiki/Santa_Clara_County,_California/Social_distancing_protocol_import) for more information."""