def test__convert_to_annotation_cls_annotations():
"""Test that if an Annotation cls is passed in that nothing
is done"""
expected = Annotations(id="5", etag="12", values={'foo': 'bar'})
annotation_cls = evaluation._convert_to_annotation_cls(id='5',
etag='12',
values=expected)
assert expected == annotation_cls
def test_entity_version(syn, project, schedule_for_cleanup):
# Make an Entity and make sure the version is one
entity = File(parent=project['id'])
entity['path'] = utils.make_bogus_data_file()
schedule_for_cleanup(entity['path'])
entity = syn.store(entity)
syn.set_annotations(Annotations(entity, entity.etag, {'fizzbuzz': 111222}))
entity = syn.get(entity)
assert entity.versionNumber == 1
# Update the Entity and make sure the version is incremented
entity.foo = 998877
entity['name'] = 'foobarbat'
entity['description'] = 'This is a test entity...'
entity = syn.store(entity, forceVersion=True, versionLabel="Prada remix")
assert entity.versionNumber == 2
# Get the older data and verify the random stuff is still there
annotations = syn.get_annotations(entity, version=1)
assert annotations['fizzbuzz'][0] == 111222
returnEntity = syn.get(entity, version=1)
assert returnEntity.versionNumber == 1
assert returnEntity['fizzbuzz'][0] == 111222
assert 'foo' not in returnEntity
# Try the newer Entity
returnEntity = syn.get(entity)
assert returnEntity.versionNumber == 2
assert returnEntity['foo'][0] == 998877
assert returnEntity['name'] == 'foobarbat'
assert returnEntity['description'] == 'This is a test entity...'
assert returnEntity['versionLabel'] == 'Prada remix'
# Try the older Entity again
returnEntity = syn.get(entity, version=1)
assert returnEntity.versionNumber == 1
assert returnEntity['fizzbuzz'][0] == 111222
assert 'foo' not in returnEntity
# Delete version 2
syn.delete(entity, version=2)
returnEntity = syn.get(entity)
assert returnEntity.versionNumber == 1
def test_annotations(syn, project, schedule_for_cleanup):
# Get the annotations of an Entity
entity = syn.store(Folder(parent=project['id']))
anno = syn.get_annotations(entity)
assert hasattr(anno, 'id')
assert hasattr(anno, 'etag')
assert anno.id == entity.id
assert anno.etag == entity.etag
# Set the annotations, with keywords too
anno['bogosity'] = 'total'
syn.set_annotations(
Annotations(entity,
entity.etag,
anno,
wazoo='Frank',
label='Barking Pumpkin',
shark=16776960))
# Check the update
annote = syn.get_annotations(entity)
assert annote['bogosity'] == ['total']
assert annote['wazoo'] == ['Frank']
assert annote['label'] == ['Barking Pumpkin']
assert annote['shark'] == [16776960]
# More annotation setting
annote['primes'] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
annote['phat_numbers'] = [1234.5678, 8888.3333, 1212.3434, 6677.8899]
annote['goobers'] = ['chris', 'jen', 'jane']
annote['present_time'] = datetime.now()
annote['maybe'] = [True, False]
syn.set_annotations(annote)
# Check it again
annotation = syn.get_annotations(entity)
assert annotation['primes'] == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
assert annotation['phat_numbers'] == [
1234.5678, 8888.3333, 1212.3434, 6677.8899
]
assert annotation['goobers'] == ['chris', 'jen', 'jane']
assert (annotation['present_time'][0].strftime('%Y-%m-%d %H:%M:%S') ==
annote['present_time'].strftime('%Y-%m-%d %H:%M:%S'))
assert annotation['maybe'] == [True, False]
def _convert_to_annotation_cls(
sub_status: SubmissionStatus,
values: typing.Union[Annotations, dict]) -> Annotations:
"""Convert synapse style annotation or dict to synapseclient.Annotation
Args:
sub_status: A synapseclient.SubmissionStatus
values: A synapseclient.Annotations or dict
Returns:
A synapseclient.Annotations
"""
if isinstance(values, Annotations):
return values
if is_synapse_annotations(values):
values = from_synapse_annotations(values)
else:
values = Annotations(id=sub_status.id,
etag=sub_status.etag,
values=values)
return values
def test_command_copy(test_state):
"""Tests the 'synapse cp' function"""
# Create a Project
project_entity = test_state.syn.store(Project(name=str(uuid.uuid4())))
test_state.schedule_for_cleanup(project_entity.id)
# Create a Folder in Project
folder_entity = test_state.syn.store(Folder(name=str(uuid.uuid4()),
parent=project_entity))
test_state.schedule_for_cleanup(folder_entity.id)
# Create and upload a file in Folder
repo_url = 'https://github.com/Sage-Bionetworks/synapsePythonClient'
annots = {'test': ['hello_world']}
# Create, upload, and set annotations on a file in Folder
filename = utils.make_bogus_data_file()
test_state.schedule_for_cleanup(filename)
file_entity = test_state.syn.store(File(filename, parent=folder_entity))
externalURL_entity = test_state.syn.store(File(repo_url, name='rand', parent=folder_entity, synapseStore=False))
test_state.syn.set_annotations(Annotations(file_entity, file_entity.etag, annots))
test_state.syn.set_annotations(Annotations(externalURL_entity, externalURL_entity.etag, annots))
test_state.schedule_for_cleanup(file_entity.id)
test_state.schedule_for_cleanup(externalURL_entity.id)
# Test cp function
output = run(test_state,
'synapse'
'--skip-checks', 'cp', file_entity.id, '--destinationId', project_entity.id)
output_URL = run(test_state,
'synapse'
'--skip-checks', 'cp', externalURL_entity.id, '--destinationId', project_entity.id)
copied_id = parse(r'Copied syn\d+ to (syn\d+)', output)
copied_URL_id = parse(r'Copied syn\d+ to (syn\d+)', output_URL)
# Verify that our copied files are identical
copied_ent = test_state.syn.get(copied_id)
copied_URL_ent = test_state.syn.get(copied_URL_id, downloadFile=False)
test_state.schedule_for_cleanup(copied_id)
test_state.schedule_for_cleanup(copied_URL_id)
copied_ent_annot = test_state.syn.get_annotations(copied_id)
copied_url_annot = test_state.syn.get_annotations(copied_URL_id)
copied_prov = test_state.syn.getProvenance(copied_id)['used'][0]['reference']['targetId']
copied_url_prov = test_state.syn.getProvenance(copied_URL_id)['used'][0]['reference']['targetId']
# Make sure copied files are the same
assert copied_prov == file_entity.id
assert copied_ent_annot == annots
assert copied_ent.properties.dataFileHandleId == file_entity.properties.dataFileHandleId
# Make sure copied URLs are the same
assert copied_url_prov == externalURL_entity.id
assert copied_url_annot == annots
assert copied_URL_ent.externalURL == repo_url
assert copied_URL_ent.name == 'rand'
assert copied_URL_ent.properties.dataFileHandleId == externalURL_entity.properties.dataFileHandleId
# Verify that errors are being thrown when a
# file is copied to a folder/project that has a file with the same filename
pytest.raises(ValueError, run, test_state, 'synapse', '--debug', '--skip-checks', 'cp', file_entity.id,
'--destinationId', project_entity.id)
def test_copy(syn, schedule_for_cleanup):
"""Tests the copy function"""
# Create a Project
project_entity = syn.store(Project(name=str(uuid.uuid4())))
schedule_for_cleanup(project_entity.id)
# Create two Folders in Project
folder_entity = syn.store(Folder(name=str(uuid.uuid4()), parent=project_entity))
second_folder = syn.store(Folder(name=str(uuid.uuid4()), parent=project_entity))
third_folder = syn.store(Folder(name=str(uuid.uuid4()), parent=project_entity))
schedule_for_cleanup(folder_entity.id)
schedule_for_cleanup(second_folder.id)
schedule_for_cleanup(third_folder.id)
# Annotations and provenance
repo_url = 'https://github.com/Sage-Bionetworks/synapsePythonClient'
annos = {'test': ['hello_world']}
prov = Activity(name="test", used=repo_url)
# Create, upload, and set annotations/provenance on a file in Folder
filename = utils.make_bogus_data_file()
schedule_for_cleanup(filename)
file_entity = syn.store(File(filename, parent=folder_entity))
externalURL_entity = syn.store(File(repo_url, name='rand', parent=folder_entity, synapseStore=False))
syn.set_annotations(Annotations(file_entity, file_entity.etag, annos))
syn.set_annotations(Annotations(externalURL_entity, externalURL_entity.etag, annos))
syn.setProvenance(externalURL_entity.id, prov)
schedule_for_cleanup(file_entity.id)
schedule_for_cleanup(externalURL_entity.id)
# ------------------------------------
# TEST COPY FILE
# ------------------------------------
output = synapseutils.copy(syn, file_entity.id, destinationId=project_entity.id)
output_URL = synapseutils.copy(syn, externalURL_entity.id, destinationId=project_entity.id,
skipCopyAnnotations=True)
# Verify that our copied files are identical
copied_ent = syn.get(output[file_entity.id])
copied_URL_ent = syn.get(output_URL[externalURL_entity.id], downloadFile=False)
copied_ent_annot = syn.get_annotations(copied_ent)
copied_url_annot = syn.get_annotations(copied_URL_ent)
copied_prov = syn.getProvenance(copied_ent)
copied_url_prov = syn.getProvenance(copied_URL_ent)
schedule_for_cleanup(copied_ent.id)
schedule_for_cleanup(copied_URL_ent.id)
# TEST: set_Provenance = Traceback
assert copied_prov['used'][0]['reference']['targetId'] == file_entity.id
assert copied_url_prov['used'][0]['reference']['targetId'] == externalURL_entity.id
# TEST: Make sure copied files are the same
assert copied_ent_annot == annos
assert copied_ent.dataFileHandleId == file_entity.dataFileHandleId
# TEST: Make sure copied URLs are the same
assert copied_url_annot == {}
assert copied_URL_ent.externalURL == repo_url
assert copied_URL_ent.name == 'rand'
assert copied_URL_ent.dataFileHandleId == externalURL_entity.dataFileHandleId
# TEST: Throw error if file is copied to a folder/project that has a file with the same filename
pytest.raises(ValueError, synapseutils.copy, syn, project_entity.id, destinationId=project_entity.id)
pytest.raises(ValueError, synapseutils.copy, syn, file_entity.id, destinationId=project_entity.id)
pytest.raises(ValueError, synapseutils.copy, syn, file_entity.id, destinationId=third_folder.id,
setProvenance="gib")
pytest.raises(ValueError, synapseutils.copy, syn, file_entity.id, destinationId=file_entity.id)
# Test: setProvenance = None
output = synapseutils.copy(syn, file_entity.id, destinationId=second_folder.id, setProvenance=None)
pytest.raises(SynapseHTTPError, syn.getProvenance, output[file_entity.id])
schedule_for_cleanup(output[file_entity.id])
# Test: setProvenance = Existing
output_URL = synapseutils.copy(syn, externalURL_entity.id, destinationId=second_folder.id, setProvenance="existing")
output_prov = syn.getProvenance(output_URL[externalURL_entity.id])
schedule_for_cleanup(output_URL[externalURL_entity.id])
assert output_prov['name'] == prov['name']
assert output_prov['used'] == prov['used']
# ------------------------------------
# TEST COPY LINKS
# ------------------------------------
second_file = utils.make_bogus_data_file()
# schedule_for_cleanup(filename)
second_file_entity = syn.store(File(second_file, parent=project_entity))
link_entity = Link(second_file_entity.id, parent=folder_entity.id)
link_entity = syn.store(link_entity)
copied_link = synapseutils.copy(syn, link_entity.id, destinationId=second_folder.id)
old = syn.get(link_entity.id, followLink=False)
new = syn.get(copied_link[link_entity.id], followLink=False)
assert old.linksTo['targetId'] == new.linksTo['targetId']
schedule_for_cleanup(second_file_entity.id)
schedule_for_cleanup(link_entity.id)
schedule_for_cleanup(copied_link[link_entity.id])
time.sleep(3)
pytest.raises(ValueError, synapseutils.copy, syn, link_entity.id, destinationId=second_folder.id)
# ------------------------------------
# TEST COPY TABLE
# ------------------------------------
second_project = syn.store(Project(name=str(uuid.uuid4())))
schedule_for_cleanup(second_project.id)
cols = [Column(name='n', columnType='DOUBLE', maximumSize=50),
Column(name='c', columnType='STRING', maximumSize=50),
Column(name='i', columnType='INTEGER')]
data = [[2.1, 'foo', 10],
[2.2, 'bar', 20],
[2.3, 'baz', 30]]
schema = syn.store(Schema(name='Testing', columns=cols, parent=project_entity.id))
syn.store(RowSet(schema=schema, rows=[Row(r) for r in data]))
table_map = synapseutils.copy(syn, schema.id, destinationId=second_project.id)
copied_table = syn.tableQuery('select * from %s' % table_map[schema.id])
rows = copied_table.asRowSet()['rows']
# TEST: Check if all values are the same
for i, row in enumerate(rows):
assert row['values'] == data[i]
pytest.raises(ValueError, synapseutils.copy, syn, schema.id, destinationId=second_project.id)
schedule_for_cleanup(schema.id)
schedule_for_cleanup(table_map[schema.id])
# ------------------------------------
# TEST COPY FOLDER
# ------------------------------------
mapping = synapseutils.copy(syn, folder_entity.id, destinationId=second_project.id)
for i in mapping:
old = syn.get(i, downloadFile=False)
new = syn.get(mapping[i], downloadFile=False)
assert old.name == new.name
assert old.annotations == new.annotations
assert old.concreteType == new.concreteType
pytest.raises(ValueError, synapseutils.copy, syn, folder_entity.id, destinationId=second_project.id)
# TEST: Throw error if excludeTypes isn't in file, link and table or isn't a list
pytest.raises(ValueError, synapseutils.copy, syn, second_folder.id, destinationId=second_project.id,
excludeTypes=["foo"])
pytest.raises(ValueError, synapseutils.copy, syn, second_folder.id, destinationId=second_project.id,
excludeTypes="file")
# TEST: excludeType = ["file"], only the folder is created
second = synapseutils.copy(syn, second_folder.id, destinationId=second_project.id,
excludeTypes=["file", "table", "link"])
copied_folder = syn.get(second[second_folder.id])
assert copied_folder.name == second_folder.name
assert len(second) == 1
# TEST: Make sure error is thrown if foldername already exists
pytest.raises(ValueError, synapseutils.copy, syn, second_folder.id, destinationId=second_project.id)
# ------------------------------------
# TEST COPY PROJECT
# ------------------------------------
third_project = syn.store(Project(name=str(uuid.uuid4())))
schedule_for_cleanup(third_project.id)
mapping = synapseutils.copy(syn, project_entity.id, destinationId=third_project.id)
for i in mapping:
old = syn.get(i, downloadFile=False)
new = syn.get(mapping[i], downloadFile=False)
if not isinstance(old, Project):
assert old.name == new.name
assert old.annotations == new.annotations
assert old.concreteType == new.concreteType
# TEST: Can't copy project to a folder
pytest.raises(ValueError, synapseutils.copy, syn, project_entity.id, destinationId=second_folder.id)