def test_new_batches(self):
rest = _RestProxyForTest()
batches = Batches(rest)
# Successful run.
rest.expect_post(
"/batches", self._check_inputs, 200, {
'requests': [{
'calc_state': 'PENDING',
'uuid': '1'
}, {
'calc_state': 'RUNNING',
'uuid': '2'
}]
})
states = batches.new_batches(
[[self.dummy_propagation_params, self.dummy_opm_params],
[self.dummy_propagation_params, self.dummy_opm_params]])
self.assertEqual(2, len(states))
self.assertEqual('1', states[0].get_uuid())
self.assertEqual('PENDING', states[0].get_calc_state())
self.assertEqual('2', states[1].get_uuid())
self.assertEqual('RUNNING', states[1].get_calc_state())
# Unsuccessful run.
rest.expect_post("/batches", self._check_inputs, 400, {})
with self.assertRaises(RuntimeError):
batches.new_batches(
[[self.dummy_propagation_params, self.dummy_opm_params],
[self.dummy_propagation_params, self.dummy_opm_params]])
def test_get_summaries(self):
rest = _RestProxyForTest()
batches = Batches(rest)
# Successful request.
rest.expect_get(
'/batch?project_uuid=' + self.dummy_propagation_params.get_project_uuid(),
200,
{'items': [
{'uuid': 'aaa', 'calc_state': 'RUNNING'},
{'uuid': 'bbb', 'calc_state': 'COMPLETED'},
{'uuid': 'ccc', 'calc_state': 'FAILED'}
]})
summaries = batches.get_summaries(self.dummy_propagation_params.get_project_uuid())
self.assertEqual(3, len(summaries))
self.assertEqual('aaa', summaries['aaa'].get_uuid())
self.assertEqual('RUNNING', summaries['aaa'].get_calc_state())
self.assertEqual('bbb', summaries['bbb'].get_uuid())
self.assertEqual('COMPLETED', summaries['bbb'].get_calc_state())
self.assertEqual('ccc', summaries['ccc'].get_uuid())
self.assertEqual('FAILED', summaries['ccc'].get_calc_state())
# Unsuccessful request.
rest.expect_get(
'/batch?project_uuid=' + self.dummy_propagation_params.get_project_uuid(), 403, {})
with self.assertRaises(RuntimeError):
batches.get_summaries(self.dummy_propagation_params.get_project_uuid())
def test_new_batch(self):
rest = _RestProxyForTest()
batches = Batches(rest)
# A successful run.
rest.expect_post("/batch", self._check_input, 200, {'calc_state': 'PENDING', 'uuid': '1'})
state = batches.new_batch(self.dummy_propagation_params, self.dummy_opm_params)
self.assertEqual('1', state.get_uuid())
self.assertEqual('PENDING', state.get_calc_state())
# Unsuccessful run.
rest.expect_post("/batch", self._check_input, 400, {'calc_state': 'PENDING', 'uuid': '1'})
with self.assertRaises(RuntimeError):
batches.new_batch(self.dummy_propagation_params, self.dummy_opm_params)
def setup(self, url, token, parent_project=None):
timer = Timer()
timer.start("Setup")
self.parent_project = parent_project
rest = RestRequests(url)
self.auth = Auth(rest)
if not self.auth.authorize(token):
# Try one more time, since often the error is a session expired error and
# seems to work fine on the second try.
print("Encountered error, retrying authorization")
if not self.auth.authorize(token):
timer.stop()
return False
self.rest = AuthorizingRestProxy(rest, self.auth.get_token())
self.projects = Projects(self.rest)
self.batches = Batches(self.rest)
self.groups = Groups(self.rest)
self.permissions = Permissions(self.rest)
# Also sets up a project to work in.
self.project = self.projects.new_project(
parent_project, None,
"Test project created at " + str(datetime.datetime.now()))
print("Set up project with uuid " + self.project.get_uuid())
timer.stop()
return True
def test_get_propagation_results(self):
rest = _RestProxyForTest()
batches = Batches(rest)
# Parts count not specified. No result retrieval is attempted.
state = StateSummary({
'uuid': 'aaa',
'calc_state': 'COMPLETED',
})
self.assertIsNone(batches.get_propagation_results(state))
# Parts count is 0. No result retrieval is attempted.
state = StateSummary({
'uuid': 'aaa',
'calc_state': 'COMPLETED',
'parts_count': 0,
})
self.assertIsNone(batches.get_propagation_results(state))
# Normal retrieval.
state = StateSummary({
'uuid': 'aaa',
'calc_state': 'COMPLETED',
'parts_count': 2,
})
rest.expect_get('/batch/aaa/1', 200, {'part_index': 'a', 'calc_state': 'RUNNING'})
rest.expect_get('/batch/aaa/2', 200, {'part_index': 'z', 'calc_state': 'COMPLETED'})
results = batches.get_propagation_results(state)
self.assertEqual(2, len(results.get_parts()))
self.assertEqual('a', results.get_parts()[0].get_part_index())
self.assertEqual('z', results.get_parts()[1].get_part_index())
# Some parts could not be found.
state = StateSummary({
'uuid': 'aaa',
'calc_state': 'FAILED',
'parts_count': 3,
})
rest.expect_get('/batch/aaa/1', 404, 'Not json')
rest.expect_get('/batch/aaa/2', 200, {'part_index': 'z', 'calc_state': 'COMPLETED'})
rest.expect_get('/batch/aaa/3', 404, 'Not json')
results = batches.get_propagation_results(state)
self.assertEqual(3, len(results.get_parts()))
self.assertIsNone(results.get_parts()[0])
self.assertEqual('z', results.get_parts()[1].get_part_index())
self.assertIsNone(results.get_parts()[2])
# Complete failure.
state = StateSummary({
'uuid': 'aaa',
'calc_state': 'COMPLETED',
'parts_count': 2,
})
rest.expect_get('/batch/aaa/1', 403, 'irrelevant')
with self.assertRaises(RuntimeError):
batches.get_propagation_results(state)
def propagate_states(state_vectors, epoch_time, end_time):
"""Propagate states from one time to another
Assume state epoch is the same as integration start time
Args:
sate_vectors (list of lists) - list of lists with 6 elements
[rx, ry, rz, vx, vy, vz] [km, km/s]
epoch_time (datetime.datetime) - epoch of state (UTC datetime)
end_time (datetime.datetime) - time at which to end the simulation
(UTC datetime)
Returns:
end_state_vectors (list of lists) - states at end of integration
[rx, ry, rz, vx, vy, vz] [km, km/s]
"""
# Convert times to strings
epoch_time_str = batch_time_string_from_datetime(epoch_time)
start_time_str = epoch_time_str
end_time_str = batch_time_string_from_datetime(end_time)
print("Propagating %i states to propagate from %s to %s" %
(len(state_vectors), start_time_str, end_time_str))
url = "https://pro-equinox-162418.appspot.com/_ah/api/adam/v1"
rest = RestRequests(url)
batches_module = Batches(rest)
# Create batches from statevectors
batches = []
propagation_params = PropagationParams({
'start_time':
start_time_str,
'end_time':
end_time_str,
'project_uuid':
'ffffffff-ffff-ffff-ffff-ffffffffffff'
})
for state_vector in state_vectors:
opm_params = OpmParams({
'epoch': start_time_str,
'state_vector': state_vector
})
batches.append(Batch(propagation_params, opm_params))
# submit batches and wait till they finish running
BatchRunManager(batches_module, batches).run()
# Get final states
end_state_vectors = []
for batch in batches:
end_state_vectors.append(batch.get_results().get_end_state_vector())
return end_state_vectors
def test_delete_batch(self):
rest = _RestProxyForTest()
batches = Batches(rest)
# Successful request.
rest.expect_delete("/batch/aaa", 204)
batches.delete_batch('aaa')
# 200 isn't a valid return value for delete calls right now
rest.expect_delete("/batch/aaa", 200)
with self.assertRaises(RuntimeError):
batches.delete_batch('aaa')
def setup(self):
timer = Timer()
timer.start("Setup")
rest = RetryingRestProxy(RestRequests(self.config.get_url()))
auth = Auth(rest)
if not auth.authenticate(self.config.get_token()):
print("Could not authenticate.")
return False
self.rest = AuthenticatingRestProxy(rest, self.config.get_token())
self.projects = Projects(self.rest)
self.batches = Batches(self.rest)
self.groups = Groups(self.rest)
self.permissions = Permissions(self.rest)
timer.stop()
return True
def setup(self):
timer = Timer()
timer.start("Setup")
rest = RetryingRestProxy(RestRequests(self.url))
auth = Auth(rest)
if not auth.authenticate(self.token):
print("Could not authenticate.")
return False
self.rest = AuthenticatingRestProxy(rest, self.token)
self.projects = Projects(self.rest)
self.batches = Batches(self.rest)
self.groups = Groups(self.rest)
self.permissions = Permissions(self.rest)
self.processing_service = AdamProcessingService(self.rest)
timer.stop()
return True
def setup(self):
"""Sets up the API client and modules for issuing requests to the ADAM API."""
timer = Timer()
timer.start("Setup")
retrying_rest = RetryingRestProxy(RestRequests())
self.rest = AuthenticatingRestProxy(retrying_rest)
auth = Auth(self.rest)
if not auth.authenticate():
print("Could not authenticate.")
return False
self.projects = ProjectsClient(self.rest)
self.batches = Batches(self.rest)
self.groups = Groups(self.rest)
self.permissions = Permissions(self.rest)
self.processing_service = AdamProcessingService(self.rest)
timer.stop()
return True
def test_get_summary(self):
rest = _RestProxyForTest()
batches = Batches(rest)
# Successful request.
rest.expect_get('/batch/aaa', 200, {'uuid': 'aaa', 'calc_state': 'RUNNING'})
summary = batches.get_summary('aaa')
self.assertEqual('aaa', summary.get_uuid())
self.assertEqual('RUNNING', summary.get_calc_state())
# Successfully found missing.
rest.expect_get('/batch/aaa', 404, 'Not JSON wat')
self.assertIsNone(batches.get_summary('aaa'))
# Unsuccessful request.
rest.expect_get('/batch/aaa', 503, 'Also not JSON wat')
with self.assertRaises(RuntimeError):
batches.get_summary('aaa')
# 'drag_coeff': 2.5, # object drag coefficient
# 'covariance': covariance, # object covariance
# 'perturbation': 3, # sigma perturbation on state vector
# 'hypercube': 'FACES', # hypercube propagation type
# 'originator': 'Robot', # originator of run
# 'object_name': 'TestObj', # object name
# 'object_id': 'test1234', # object ID
})
batch = Batch(propagation_params, opm_params)
print("Submitting OPM:")
print(batch.get_opm_params().generate_opm())
# Submit and wait until batch run is ready
batches_module = Batches(auth_rest)
BatchRunManager(batches_module, [batch]).run()
# Get final parts count
parts_count = batch.get_state_summary().get_parts_count()
print("Final state: %s, part count %s\n" % (batch.get_calc_state(), parts_count))
# Get ephemeris of specified part
part_to_get = 0
eph = batch.get_results().get_parts()[part_to_get].get_ephemeris()
print("Ephemeris:")
print(eph)
# Get the end state vector (uncomment to use)
# end_state_vector = batch.get_results().get_end_state_vector()
# print("State vector at the end of propagation:")