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."""
