def test_analysis_files(self):
fw = self.fw
# Upload to session
poem = 'A gaze blank and pitiless as the sun,'
fw.upload_file_to_session(self.session_id,
flywheel.FileSpec('yeats.txt', poem))
file_ref = flywheel.FileReference(id=self.session_id,
type='session',
name='yeats.txt')
analysis = flywheel.AnalysisInput(label=self.rand_string(),
description=self.rand_string(),
inputs=[file_ref])
# Add
analysis_id = fw.add_session_analysis(self.session_id, analysis)
# Download the input file and check content
self.assertDownloadFileTextEquals(
fw.download_input_from_analysis_as_data, analysis_id, 'yeats.txt',
poem)
self.assertDownloadFileTextEqualsWithTicket(
fw.get_analysis_input_download_url, analysis_id, 'yeats.txt', poem)
poem_out = 'Surely the Second Coming is at hand.'
r_analysis = fw.get(analysis_id)
r_analysis.upload_output(flywheel.FileSpec('yeats-out.txt', poem_out))
r_analysis = r_analysis.reload()
self.assertEqual(len(r_analysis.files), 1)
self.assertEqual(r_analysis.files[0].name, 'yeats-out.txt')
self.assertEqual(r_analysis.files[0].size, 36)
self.assertEqual(r_analysis.files[0].mimetype, 'text/plain')
# Download and check content
self.assertDownloadFileTextEquals(
fw.download_output_from_analysis_as_data, analysis_id,
'yeats-out.txt', poem_out)
self.assertDownloadFileTextEqualsWithTicket(
fw.get_analysis_output_download_url, analysis_id, 'yeats-out.txt',
poem_out)
def test_container_analysis(self):
fw = self.fw
acquisition = flywheel.Acquisition(session=self.session_id,
label=self.rand_string())
# Add
acquisition_id = fw.add_acquisition(acquisition)
self.assertNotEmpty(acquisition_id)
poem = 'Troubles my sight: a waste of desert sand;'
fw.upload_file_to_container(acquisition_id,
flywheel.FileSpec('yeats.txt', poem))
file_ref = flywheel.FileReference(id=acquisition_id,
type='acquisition',
name='yeats.txt')
analysis = flywheel.AnalysisInput(label=self.rand_string(),
description=self.rand_string(),
inputs=[file_ref])
# Add
analysis_id = fw.add_container_analysis(acquisition_id, analysis)
self.assertNotEmpty(analysis_id)
# Get the list of analyses in the acquisition
analyses = fw.get_container_analyses(acquisition_id)
self.assertEqual(len(analyses), 1)
r_analysis = analyses[0]
self.assertEqual(r_analysis.id, analysis_id)
self.assertEmpty(r_analysis.job)
self.assertTimestampBeforeNow(r_analysis.created)
self.assertGreaterEqual(r_analysis.modified, r_analysis.created)
self.assertEqual(len(r_analysis.inputs), 1)
self.assertEqual(r_analysis.inputs[0].name, 'yeats.txt')
def test_project_analysis(self):
fw = self.fw
project = flywheel.Project(group=self.group_id,
label=self.rand_string())
# Add
self.project_id = project_id = fw.add_project(project)
self.assertNotEmpty(project_id)
poem = 'The Second Coming! Hardly are those words out'
fw.upload_file_to_project(project_id,
flywheel.FileSpec('yeats.txt', poem))
file_ref = flywheel.FileReference(id=project_id,
type='project',
name='yeats.txt')
analysis = flywheel.AnalysisInput(label=self.rand_string(),
description=self.rand_string(),
inputs=[file_ref])
# Add
analysis_id = fw.add_project_analysis(project_id, analysis)
self.assertNotEmpty(analysis_id)
# Get the list of analyses in the project
analyses = fw.get_project_analyses(project_id)
self.assertEqual(len(analyses), 1)
r_analysis = analyses[0]
self.assertEqual(r_analysis.id, analysis_id)
self.assertEmpty(r_analysis.job)
self.assertTimestampBeforeNow(r_analysis.created)
self.assertGreaterEqual(r_analysis.modified, r_analysis.created)
self.assertEqual(len(r_analysis.inputs), 1)
self.assertEqual(r_analysis.inputs[0].name, 'yeats.txt')
def test_session_analysis(self):
fw = self.fw
session = flywheel.Session(project=self.project_id,
label=self.rand_string())
# Add
session_id = fw.add_session(session)
self.assertNotEmpty(session_id)
poem = 'When a vast image out of Spiritus Mundi'
fw.upload_file_to_session(session_id,
flywheel.FileSpec('yeats.txt', poem))
file_ref = flywheel.FileReference(id=session_id,
type='session',
name='yeats.txt')
analysis = flywheel.AnalysisInput(label=self.rand_string(),
description=self.rand_string(),
inputs=[file_ref])
# Add
analysis_id = fw.add_session_analysis(session_id, analysis)
self.assertNotEmpty(analysis_id)
# Get the list of analyses in the session
analyses = fw.get_session_analyses(session_id)
self.assertEqual(len(analyses), 1)
r_analysis = analyses[0]
self.assertEqual(r_analysis.id, analysis_id)
self.assertEmpty(r_analysis.job)
self.assertTimestampBeforeNow(r_analysis.created)
self.assertGreaterEqual(r_analysis.modified, r_analysis.created)
self.assertEqual(len(r_analysis.inputs), 1)
self.assertEqual(r_analysis.inputs[0].name, 'yeats.txt')
def test_collection_analysis(self):
fw = self.fw
collection = flywheel.Collection(label=self.rand_string())
# Add
self.collection_id = collection_id = fw.add_collection(collection)
self.assertNotEmpty(collection_id)
poem = 'A shape with lion body and the head of a man,'
fw.upload_file_to_collection(collection_id,
flywheel.FileSpec('yeats.txt', poem))
file_ref = flywheel.FileReference(id=collection_id,
type='collection',
name='yeats.txt')
analysis = flywheel.AnalysisInput(label=self.rand_string(),
description=self.rand_string(),
inputs=[file_ref])
# Add
analysis_id = fw.add_collection_analysis(collection_id, analysis)
self.assertNotEmpty(analysis_id)
# Get the list of analyses in the collection
r_collection = fw.get_collection(collection_id)
self.assertEqual(len(r_collection.analyses), 1)
r_analysis = r_collection.analyses[0]
self.assertEqual(r_analysis.id, analysis_id)
self.assertEmpty(r_analysis.job)
self.assertTimestampBeforeNow(r_analysis.created)
self.assertGreaterEqual(r_analysis.modified, r_analysis.created)
self.assertEqual(len(r_analysis.inputs), 1)
self.assertEqual(r_analysis.inputs[0].name, 'yeats.txt')
def test_job_queue(self):
fw = self.fw
poem = 'The blood-dimmed tide is loosed, and everywhere'
fw.upload_file_to_acquisition(self.acquisition_id,
flywheel.FileSpec('yeats.txt', poem))
tag = self.rand_string()
job = flywheel.Job(gear_id=self.gear_id,
destination=flywheel.JobDestination(
id=self.acquisition_id, type='acquisition'),
inputs={
'any-file':
flywheel.FileReference(id=self.acquisition_id,
type='acquisition',
name='yeats.txt')
},
tags=[tag])
# Add
job_id = fw.add_job(job)
self.assertNotEmpty(job_id)
# Check
r_job = fw.get_job(job_id)
self.assertEqual(r_job.state, 'pending')
# Run
r_job = fw.get_next_job(tags=[tag])
self.assertIsNotNone(r_job)
self.assertEqual(r_job.id, job_id)
self.assertIsNotNone(r_job.request)
self.assertIn('dir', r_job.request.target)
self.assertEqual(r_job.request.target['dir'], '/flywheel/v0')
# Next fetch should not find any jobs
try:
fw.get_next_job(tags=[tag])
self.fail('Expected an error retrieving next job')
except flywheel.ApiException as e:
self.assertEqual(e.status, 400)
# Heartbeat
fw.modify_job(job_id, {})
r_job2 = fw.get_job(job_id)
self.assertTimestampAfter(r_job2.modified, r_job.modified)
# Add logs
log1 = [flywheel.JobLogStatement(fd=-1, msg='System message')]
log2 = [
flywheel.JobLogStatement(fd=1, msg='Standard out'),
flywheel.JobLogStatement(fd=2, msg='Standard err')
]
fw.add_job_logs(job_id, log1)
fw.add_job_logs(job_id, log2)
# Finish
r_job.change_state('complete')
r_job3 = fw.get_job(job_id)
self.assertEqual(r_job3.state, 'complete')
self.assertTimestampAfter(r_job3.modified, r_job2.modified)
logs = fw.get_job_logs(job_id)
self.assertEqual(len(logs.logs), 4)
self.assertEqual(logs.logs[1], log1[0])
self.assertEqual(logs.logs[2], log2[0])
self.assertEqual(logs.logs[3], log2[1])
def test_ad_hoc_analysis(self):
fw = self.fw
# Upload to session
poem = 'A gaze blank and pitiless as the sun,'
fw.upload_file_to_session(self.session_id,
flywheel.FileSpec('yeats.txt', poem))
file_ref = flywheel.FileReference(id=self.session_id,
type='session',
name='yeats.txt')
analysis = flywheel.AnalysisInput(label=self.rand_string(),
description=self.rand_string(),
inputs=[file_ref])
# Add
analysis_id = fw.add_session_analysis(self.session_id, analysis)
self.assertNotEmpty(analysis_id)
session = fw.get_session(self.session_id)
self.assertEqual(len(session.analyses), 1)
r_analysis = session.analyses[0]
self.assertEqual(r_analysis.id, analysis_id)
self.assertIsNone(r_analysis.job)
self.assertTimestampBeforeNow(r_analysis.created)
self.assertGreaterEqual(r_analysis.modified, r_analysis.created)
self.assertEqual(len(r_analysis.inputs), 1)
self.assertEqual(r_analysis.inputs[0].name, 'yeats.txt')
# Access analysis directly
r_analysis2 = fw.get_analysis(analysis_id)
self.assertEqual(r_analysis, r_analysis2)
# Generic Get is equivalent
self.assertEqual(fw.get(analysis_id).to_dict(), r_analysis2.to_dict())
# Analysis Notes
text = self.rand_string()
fw.add_session_analysis_note(self.session_id, analysis_id, text)
# Check
session = fw.get_session(self.session_id)
self.assertEqual(len(session.analyses), 1)
r_analysis = session.analyses[0]
self.assertEqual(len(r_analysis.notes), 1)
self.assertNotEmpty(r_analysis.notes[0].user)
self.assertEqual(r_analysis.notes[0].text, text)
self.assertTimestampBeforeNow(r_analysis.notes[0].created)
self.assertTimestampBeforeNow(r_analysis.notes[0].modified)
self.assertTimestampAfter(r_analysis.notes[0].modified,
r_analysis.created)
self.assertGreaterEqual(r_analysis.notes[0].modified,
r_analysis.notes[0].created)
self.assertEqual(r_analysis.parent.id, session.id)
# Access multiple analyses
analysis2 = session.add_analysis(label=analysis.label,
description=analysis.description,
inputs=analysis.inputs)
self.assertIsNotNone(analysis2)
analysis_id2 = analysis2.id
# Try getting analysis incorrectly
self.assertRaises(flywheel.ApiException, fw.get_analyses, 'session',
self.session_id, 'projects')
# Get all Session level analyses in group
analyses = fw.get_analyses('groups', self.group_id, 'sessions')
self.assertEqual(len(analyses), 2)
self.assertEqual(
1, len(list(filter(lambda x: x.id == r_analysis.id, analyses))))
self.assertEqual(
1, len(list(filter(lambda x: x.id == analysis_id2, analyses))))
# Get project level analyses in group (will be zero)
analyses = fw.get_analyses('groups', self.group_id, 'projects')
self.assertEmpty(analyses)
# Info, tags
tag = 'example-tag'
fw.add_analysis_tag(analysis_id, tag)
# Replace info
fw.replace_analysis_info(analysis_id, {'foo': 3, 'bar': 'qaz'})
# Set info
fw.set_analysis_info(analysis_id, {'foo': 42, 'hello': 'world'})
# Check
r_analysis = fw.get_analysis(analysis_id)
self.assertEqual(r_analysis.tags, [tag])
self.assertEqual(r_analysis.info, {
'foo': 42,
'bar': 'qaz',
'hello': 'world'
})
# Delete info fields
fw.delete_analysis_info_fields(analysis_id, ['foo', 'bar'])
r_analysis = fw.get_analysis(analysis_id)
self.assertEqual(r_analysis.info, {'hello': 'world'})
def test_batch_with_jobs(self):
fw = self.fw_device
gear = fw.get_gear(self.gear_id)
self.assertIsNotNone(gear)
# Make a couple jobs
poem = 'Mere anarchy is loosed upon the world,'
fw.upload_file_to_acquisition(self.acquisition_id,
flywheel.FileSpec('yeats.txt', poem))
inputs = {
'any-file':
flywheel.FileReference(id=self.acquisition_id,
type='acquisition',
name='yeats.txt')
}
destination = flywheel.JobDestination(id=self.acquisition_id,
type='acquisition')
tag = self.rand_string()
jobs = [
flywheel.Job(gear_id=self.gear_id,
destination=destination,
inputs=inputs,
tags=[tag]),
flywheel.Job(gear_id=self.gear_id,
destination=destination,
inputs=inputs,
tags=[tag])
]
# Propose batch jobs
proposal = fw.create_batch_job_from_jobs(
flywheel.BatchJobsProposalInput(jobs=jobs))
self.assertIsNotNone(proposal)
self.assertNotEmpty(proposal.id)
# Gear Id should be none, each job already knows its gear
self.assertIsNone(proposal.gear_id)
self.assertIsNotNone(proposal.origin)
self.assertEqual(proposal.origin.type, 'device')
self.assertNotEmpty(proposal.origin.id)
self.assertTimestampBeforeNow(proposal.created)
self.assertGreaterEqual(proposal.modified, proposal.created)
# Get
r_batch = fw.get_batch(proposal.id)
self.assertIsNotNone(r_batch)
# Gear Id should be none, each job already knows its gear
self.assertIsNone(proposal.gear_id)
self.assertEqual(r_batch.state, 'pending')
# Get all
batches = fw.get_all_batches()
self.assertIn(r_batch, batches)
# Start
jobs = fw.start_batch(proposal.id)
self.assertEqual(len(jobs), 2)
# Get again
r_batch2 = fw.get_batch(proposal.id)
self.assertEqual(r_batch2.state, 'running')
self.assertTimestampAfter(r_batch2.modified, r_batch.modified)
# Cancel
cancelled = fw.cancel_batch(proposal.id)
self.assertEqual(cancelled, 2)
