def prep_directory(client, mrepo):
"""
Create an empty FS directory by performing an import and
then deleting the created fileset.
"""
from omero.cmd import Delete2, DoAll
from omero.grid import ImportSettings
from omero.model import ChecksumAlgorithmI
from omero.model import FilesetI
from omero.model import FilesetEntryI
from omero.model import UploadJobI
fs = FilesetI()
fs.linkJob(UploadJobI())
entry = FilesetEntryI()
entry.clientPath = rstring("README.txt")
fs.addFilesetEntry(entry)
settings = ImportSettings()
settings.checksumAlgorithm = ChecksumAlgorithmI()
settings.checksumAlgorithm.value = rstring("SHA1-160")
proc = mrepo.importFileset(fs, settings)
try:
tmp = create_path()
prx = proc.getUploader(0)
try:
tmp.write_text("THIS IS A PLACEHOLDER")
hash = client.sha1(tmp)
with open(tmp, "r") as source:
client.write_stream(source, prx)
finally:
prx.close()
tmp.remove()
handle = proc.verifyUpload([hash])
try:
req = handle.getRequest()
fs = req.activity.parent
finally:
handle.close()
dir = unwrap(mrepo.treeList(fs.templatePrefix.val))
oid = dir.items()[0][1].get("id")
ofile = client.sf.getQueryService().get("OriginalFile", oid)
delete1 = Delete2(targetObjects={'Fileset': [fs.id.val]})
delete2 = Delete2(targetObjects={'OriginalFile': [ofile.id.val]})
doall = DoAll()
doall.requests = [delete1, delete2]
cb = client.submit(doall)
cb.close(True)
finally:
proc.close()
return fs.templatePrefix.val
def testDeleteComment(self):
comment = omero.model.CommentAnnotationI()
comment = self.update.saveAndReturnObject(comment)
images = list()
# Single Comment linked to 3 Images and 3 Datasets
for i in range(0, 3):
img = self.new_image(name="testDeleteComment")
img.linkAnnotation(comment)
images.append(self.update.saveAndReturnObject(img))
ds = self.make_dataset("testDeleteComment")
ds.linkAnnotation(comment)
self.update.saveAndReturnObject(ds)
cid = comment.id.val
assert self.query.find("CommentAnnotation", cid)
# Remove comment from first image
linkIds = []
for l in images[0].copyAnnotationLinks():
linkIds.append(l.id.val)
command = Delete2(targetObjects={"ImageAnnotationLink": linkIds})
handle = self.client.sf.submit(command)
self.waitOnCmd(self.client, handle)
handle.close()
# Delete Dry Run...
command = Delete2(targetObjects={"CommentAnnotation": [cid]},
dryRun=True)
handle = self.client.sf.submit(command)
self.waitOnCmd(self.client, handle)
# ...Should tell us that remaining links will be deleted
rsp = handle.getResponse()
handle.close()
assert ('ome.model.annotations.ImageAnnotationLink'
in rsp.deletedObjects)
links = rsp.deletedObjects['ome.model.annotations.ImageAnnotationLink']
assert len(links) == 2
dlnks = rsp.deletedObjects[
'ome.model.annotations.DatasetAnnotationLink']
assert len(dlnks) == 3
# Comment should not yet be deleted
assert self.query.find("CommentAnnotation", cid)
# Finally, delete Comment
command = Delete2(targetObjects={"CommentAnnotation": [cid]})
handle = self.client.sf.submit(command)
self.waitOnCmd(self.client, handle)
handle.close()
assert not self.query.find("CommentAnnotation", cid)
def testStepsDuringDelete(self):
img = self.make_image(name="delete test")
command = Delete2(targetObjects={"Image": [img.id.val]})
handle = self.client.sf.submit(command)
end_by = time() + 5
latest_step = 0
try:
while time() < end_by:
# still within five seconds of request submission
status = handle.getStatus()
# current step increases monotonically
assert latest_step <= status.currentStep
latest_step = status.currentStep
if status.stopTime > 0:
# request stops after last step commenced
assert status.currentStep == status.steps - 1
return
except:
handle.close()
raise Exception('delete did not complete within five seconds')
def RemoveMapAnnotations(conn, dtype, Id):
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
obj = conn.getObject(dtype, int(Id))
name = obj.getName()
anns = list(obj.listAnnotations())
mapann_ids = [
ann.id for ann in anns
if isinstance(ann, omero.gateway.MapAnnotationWrapper)
]
print(mapann_ids)
try:
delete = Delete2(targetObjects={'MapAnnotation': mapann_ids})
handle = conn.c.sf.submit(delete)
conn.c.waitOnCmd(handle,
loops=10,
ms=500,
failonerror=True,
failontimeout=False,
closehandle=False)
return 0
except Exception as ex:
print("Failed to delete links: {} ".format(ex.message))
return 1
return
def testOddMessage(self):
store = self.client.sf.createRawFileStore()
images = list()
for i in range(0, 10):
img = self.make_image()
iid = img.getId().getValue()
oFile = omero.model.OriginalFileI()
oFile.setName(rstring('companion_file.txt'))
oFile.setPath(rstring('/my/path/to/the/file/'))
oFile.setSize(rlong(7471))
oFile.setHash(rstring("pending"))
oFile.setMimetype(rstring('Companion/Deltavision'))
ofid = self.update.saveAndReturnObject(oFile).id.val
store.setFileId(ofid)
binary = 'aaa\naaaa\naaaaa'
store.write(binary, 0, 0)
of = store.save()
fa = omero.model.FileAnnotationI()
fa.setNs(rstring(omero.constants.namespaces.NSCOMPANIONFILE))
fa.setFile(of)
self.link(img, fa)
images.append(iid)
command = Delete2(targetObjects={"Image": images})
handle = self.client.sf.submit(command)
callback = self.waitOnCmd(self.client, handle)
callback.close(True)
def test5793(self):
uuid = self.ctx.sessionUuid
img = self.new_image(name="delete tagset test")
tag = omero.model.TagAnnotationI()
tag.textValue = rstring("tag %s" % uuid)
tag = self.update.saveAndReturnObject(tag)
img.linkAnnotation(tag)
img = self.update.saveAndReturnObject(img)
tagset = omero.model.TagAnnotationI()
tagset.textValue = rstring("tagset %s" % uuid)
tagset.linkAnnotation(tag)
tagset = self.update.saveAndReturnObject(tagset)
tag = tagset.linkedAnnotationList()[0]
command = Delete2(targetObjects={"Annotation": [tagset.id.val]})
handle = self.client.sf.submit(command)
self.waitOnCmd(self.client, handle)
assert not self.query.find("TagAnnotation", tagset.id.val)
assert tag.id.val == self.query.find("TagAnnotation",
tag.id.val).id.val
def remove_MapAnnotations(conn, dtype, Id):
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
image = conn.getObject(dtype, int(Id))
namespace = omero.constants.metadata.NSCLIENTMAPANNOTATION
filename = image.getName()
anns = list(image.listAnnotations())
mapann_ids = [
ann.id for ann in anns
if isinstance(ann, omero.gateway.MapAnnotationWrapper)
]
try:
delete = Delete2(targetObjects={'MapAnnotation': mapann_ids})
handle = conn.c.sf.submit(delete)
conn.c.waitOnCmd(handle,
loops=10,
ms=500,
failonerror=True,
failontimeout=False,
closehandle=False)
except Exception, ex:
print("Failed to delete links: {}".format(ex.message))
def testBasicUsage(self):
img = self.new_image(name="delete test")
tag = omero.model.TagAnnotationI()
img.linkAnnotation(tag)
img = self.update.saveAndReturnObject(img)
command = Delete2(targetObjects={"Image": [img.id.val]})
handle = self.client.sf.submit(command)
self.waitOnCmd(self.client, handle)
def testDeleteImagesTwoFilesetsErr(self):
"""
If we try to partially delete 2 Filesets, both should be returned
by the delete error
"""
# 2 filesets, each with 2 images
imagesFsOne = self.importMIF(2)
imagesFsTwo = self.importMIF(2)
# delete should fail...
iids = [imagesFsOne[0].id.val, imagesFsTwo[0].id.val]
delete = Delete2(targetObjects={"Image": iids})
self.doSubmit(delete, self.client, test_should_pass=False)
def testDeleteProjectWithoutContent(self):
uuid = self.ctx.sessionUuid
images = list()
for i in range(0, 5):
img = self.new_image(name="test-delete-image-%i" % i)
tag = omero.model.TagAnnotationI()
img.linkAnnotation(tag)
images.append(self.update.saveAndReturnObject(img))
# create dataset
dataset = self.make_dataset('DS-test-2936-%s' % uuid)
# create project
project = self.make_project('PR-test-2936-%s' % uuid)
# put dataset in project
self.link(project, dataset)
# put image in dataset
for image in images:
self.link(dataset, image)
keep = ChildOption(excludeType=[
"TagAnnotation", "TermAnnotation", "FileAnnotation", "Dataset",
"Image"
])
dc = Delete2(targetObjects={'Project': [project.id.val]},
childOptions=[keep])
handle = self.client.sf.submit(dc)
self.waitOnCmd(self.client, handle)
assert not self.query.find('Project', project.id.val)
assert dataset.id.val == self.query.find('Dataset',
dataset.id.val).id.val
p = omero.sys.Parameters()
p.map = {}
p.map["oid"] = dataset.id
sql = "select im from Image im "\
"left outer join fetch im.datasetLinks dil "\
"left outer join fetch dil.parent d " \
"where d.id = :oid " \
"order by im.id asc"
res = self.query.findAllByQuery(sql, p)
assert 5 == len(res)
for e in res:
if e.id.val not in [i.id.val for i in images]:
self.assertRaises('Image %i is not in the [%s]' %
(e.id.val, ",".join(images)))
def testDeleteMany(self):
images = list()
for i in range(0, 5):
img = self.new_image(name="delete test")
tag = omero.model.TagAnnotationI()
img.linkAnnotation(tag)
images.append(self.update.saveAndReturnObject(img))
ids = [image.id.val for image in images]
command = Delete2(targetObjects={"Image": ids})
handle = self.client.sf.submit(command)
self.waitOnCmd(self.client, handle)
def test7314(self):
"""
Test the delete of an original file when a file annotation is present
"""
o = self.client.upload(__file__)
fa = omero.model.FileAnnotationI()
fa.file = o.proxy()
fa = self.update.saveAndReturnObject(fa)
command = Delete2(targetObjects={"OriginalFile": [o.id.val]})
handle = self.client.sf.submit(command)
self.waitOnCmd(self.client, handle)
with pytest.raises(omero.ServerError):
self.query.get("FileAnnotation", fa.id.val)
def testDeleteFilesetOK(self):
"""
Simple example of the MIF delete good case:
a single fileset containing 2 images.
Delete the fileset, the delete should succeed.
"""
images = self.importMIF(2)
fsId = self.query.get("Image", images[0].id.val).fileset.id.val
# Now delete the fileset, should succeed
delete = Delete2(targetObjects={"Fileset": [fsId]})
self.doSubmit(delete, self.client)
# The dataset, fileset and both images should be deleted.
assert not self.query.find("Fileset", fsId)
assert not self.query.find("Image", images[0].id.val)
assert not self.query.find("Image", images[1].id.val)
def testDeleteOneImageFilesetErr(self):
"""
Simple example of the MIF delete good case:
two images in a MIF.
Delete one image, the delete should fail.
"""
images = self.importMIF(2)
# Now delete one image
delete = Delete2(targetObjects={"Image": [images[0].id.val]})
self.doSubmit(delete, self.client, test_should_pass=False)
# Neither image should be deleted.
assert images[0].id.val == self.query.find("Image",
images[0].id.val).id.val
assert images[1].id.val == self.query.find("Image",
images[1].id.val).id.val
def testDeleteAllImagesFilesetOK(self):
"""
Simple example of the MIF delete good case:
two images in a MIF.
Delete all images, the delete should succeed.
"""
images = self.importMIF(2)
fsId = self.query.get("Image", images[0].id.val).fileset.id.val
# Now delete all images, should succeed
iids = [images[0].id.val, images[1].id.val]
delete = Delete2(targetObjects={"Image": iids})
self.doSubmit(delete, self.client)
# The fileset and both images should be deleted.
assert not self.query.find("Fileset", fsId)
assert not self.query.find("Image", images[0].id.val)
assert not self.query.find("Image", images[1].id.val)
def remove_map_annotations(conn, object):
"""Remove ALL Map Annotations on the object"""
anns = list(object.listAnnotations())
mapann_ids = [
ann.id for ann in anns
if isinstance(ann, omero.gateway.MapAnnotationWrapper)
]
try:
delete = Delete2(targetObjects={'MapAnnotation': mapann_ids})
handle = conn.c.sf.submit(delete)
conn.c.waitOnCmd(handle,
loops=10,
ms=500,
failonerror=True,
failontimeout=False,
closehandle=False)
except Exception as ex:
print("Failed to delete links: {}".format(ex.message))
return
def delete(self, obj):
"""
Deletes a list of model entities (ProjectI, DatasetI or ImageI)
by creating Delete2 commands and calling
:func:`~test.ITest.doSubmit`.
:param obj: a list of objects to be deleted
"""
if isinstance(obj[0], ProjectI):
t = "Project"
elif isinstance(obj[0], DatasetI):
t = "Dataset"
elif isinstance(obj[0], ImageI):
t = "Image"
else:
assert False, "Object type not supported."
ids = [i.id.val for i in obj]
command = Delete2(targetObjects={t: ids})
self.doSubmit(command, self.client)
def testDeleteOneDatasetFilesetErr(self):
"""
Simple example of the MIF delete bad case:
a single fileset containing 2 images is split among 2 datasets.
Delete one dataset, delete fails.
"""
datasets = self.createDatasets(2, "testDeleteOneDatasetFilesetErr")
images = self.importMIF(2)
for i in range(2):
self.link(datasets[i], images[i])
# Now delete one dataset
delete = Delete2(targetObjects={"Dataset": [datasets[0].id.val]})
self.doSubmit(delete, self.client)
# The dataset should be deleted, but not any images.
assert not self.query.find("Dataset", datasets[0].id.val)
assert images[0].id.val == self.query.find("Image",
images[0].id.val).id.val
assert images[1].id.val == self.query.find("Image",
images[1].id.val).id.val
def testDeleteDatasetFilesetOK(self):
"""
Simple example of the MIF delete good case:
a single fileset containing 2 images in one dataset.
Delete the dataset, the delete should succeed.
"""
ds = self.make_dataset("testDeleteDatasetFilesetOK")
images = self.importMIF(2)
fsId = self.query.get("Image", images[0].id.val).fileset.id.val
for i in range(2):
self.link(ds, images[i])
# Now delete the dataset, should succeed
delete = Delete2(targetObjects={"Dataset": [ds.id.val]})
self.doSubmit(delete, self.client)
# The dataset, fileset and both images should be deleted.
assert not self.query.find("Dataset", ds.id.val)
assert not self.query.find("Fileset", fsId)
assert not self.query.find("Image", images[0].id.val)
assert not self.query.find("Image", images[1].id.val)
def testDeleteProjectWithEmptyDatasetLinkedToAnotherProjectHard(self):
"""
P1->D
P2->D
Delete P1
See https://trac.openmicroscopy.org.uk/ome/ticket/12452
"""
p1 = self.make_project()
p2 = self.make_project()
d = self.make_dataset()
self.link(p1, d)
self.link(p2, d)
hard = ChildOption(includeType=["Dataset"])
delete = Delete2(targetObjects={"Project": [p1.id.val]},
childOptions=[hard])
self.doSubmit(delete, self.client)
assert self.query.find("Project", p2.id.val)
assert not self.query.find("Project", p1.id.val)
assert not self.query.find("Dataset", d.id.val)
def testCheckIfDeleted(self):
uuid = self.ctx.sessionUuid
userName = self.ctx.userName
img = self.new_image(name="to delete - test")
tag = omero.model.TagAnnotationI()
img.linkAnnotation(tag)
iid = self.update.saveAndReturnObject(img).id.val
cmd = Delete2(targetObjects={"Image": [iid]})
handle = self.client.sf.submit(cmd)
callback = self.waitOnCmd(self.client, handle)
cbString = str(handle)
callback.close(True) # Don't close handle
assert not self.query.find("Image", iid)
# create new session and double check
import os
import Ice
c = omero.client(
pmap=['--Ice.Config=' + (os.environ.get("ICE_CONFIG"))])
host = c.ic.getProperties().getProperty('omero.host')
port = int(c.ic.getProperties().getProperty('omero.port'))
cl1 = omero.client(host=host, port=port)
cl1.createSession(userName, userName)
with pytest.raises(Ice.ObjectNotExistException):
omero.cmd.HandlePrx.checkedCast(cl1.ic.stringToProxy(cbString))
# join session and double check
cl2 = omero.client(host=host, port=port)
cl2.joinSession(uuid)
with pytest.raises(Ice.ObjectNotExistException):
omero.cmd.HandlePrx.checkedCast(cl2.ic.stringToProxy(cbString))
def testDeleteDatasetWithImageLinkedToAnotherDatasetHard(self):
"""
D1->I
D2->I
Delete D1
See https://trac.openmicroscopy.org.uk/ome/ticket/12452
"""
d1 = self.make_dataset()
d2 = self.make_dataset()
i = self.make_image()
self.link(d1, i)
self.link(d2, i)
hard = ChildOption(includeType=["Image"])
delete = Delete2(targetObjects={"Dataset": [d1.id.val]},
childOptions=[hard])
self.doSubmit(delete, self.client)
assert not self.query.find("Dataset", d1.id.val)
assert self.query.find("Dataset", d2.id.val)
assert not self.query.find("Image", i.id.val)
def testDeleteDatasetTwoFilesetsErr(self):
"""
If we try to partially delete 2 Filesets, both should be returned
by the delete error
"""
# 2 filesets, each with 2 images
imagesFsOne = self.importMIF(2)
imagesFsTwo = self.importMIF(2)
ds = self.make_dataset("testDeleteDatasetTwoFilesetsErr")
self.importMIF(2)
for i in (imagesFsOne, imagesFsTwo):
self.link(ds, i[0])
# delete should remove only the Dataset
delete = Delete2(targetObjects={"Dataset": [ds.id.val]})
self.doSubmit(delete, self.client)
# The dataset should be deleted.
assert not self.query.find("Dataset", ds.id.val)
# Neither image should be deleted.
for i in (imagesFsOne[0], imagesFsTwo[0]):
assert i.id.val == self.query.find("Image", i.id.val).id.val
def testCheckIfDeleted2(self):
uuid = self.ctx.sessionUuid
# dataset with many images
images = list()
for i in range(0, 50):
img = self.new_image(name="test-delete-image-%i" % i)
tag = omero.model.TagAnnotationI()
img.linkAnnotation(tag)
images.append(self.update.saveAndReturnObject(img))
# create dataset
dataset = self.make_dataset('DS-test-%s' % uuid)
# put image in dataset
for img in images:
self.link(dataset, img)
ids = [image.id.val for image in images]
command = Delete2(targetObjects={"Image": ids})
handle = self.client.sf.submit(command)
callback = self.waitOnCmd(self.client, handle, ms=1000, loops=50)
callback.close(True)
p = omero.sys.Parameters()
p.map = {}
p.map["oid"] = dataset.id
sql = "select im from Image im "\
"left outer join fetch im.datasetLinks dil "\
"left outer join fetch dil.parent d " \
"where d.id = :oid " \
"order by im.id asc"
assert 0 == len(self.query.findAllByQuery(sql, p))
def testDeleteAllDatasetsFilesetOK(self):
"""
Simple example of the MIF delete bad case:
a single fileset containing 2 images is split among 2 datasets.
Delete all datasets, delete succeeds.
"""
datasets = self.createDatasets(2, "testDeleteAllDatasetsFilesetOK")
images = self.importMIF(2)
fsId = self.query.get("Image", images[0].id.val).fileset.id.val
for i in range(2):
self.link(datasets[i], images[i])
# Now delete all datasets, should succeed
dids = [datasets[0].id.val, datasets[1].id.val]
delete = Delete2(targetObjects={"Dataset": dids})
self.doSubmit(delete, self.client)
# Both datasets, the fileset and both images should be deleted.
assert not self.query.find("Dataset", datasets[0].id.val)
assert not self.query.find("Dataset", datasets[1].id.val)
assert not self.query.find("Fileset", fsId)
assert not self.query.find("Image", images[0].id.val)
assert not self.query.find("Image", images[1].id.val)
def testCleanseNonsenseName(self, capsys):
"""
Test cleanse removes file on disk after OriginalFile
name was changed to nonsense and its Image was deleted
"""
# import image and retrieve the OriginalFile
# (orig_file), its name and path
image = self.import_fake_file()[0]
fileset = self.get_fileset([image])
params = omero.sys.ParametersI()
params.addId(fileset.getId())
q = ("select originalFile.path, originalFile.id "
"from FilesetEntry where fileset.id = :id")
queryService = self.root.sf.getQueryService()
result = queryService.projection(q, params, self.group_ctx)
path_in_mrepo = result[0][0].getValue()
orig_file_path = self.make_path(path_in_mrepo)
assert os.path.exists(orig_file_path)
orig_file_id = result[0][1].getValue()
orig_file = self.query.get("OriginalFile", orig_file_id)
orig_file_name = orig_file.getName().getValue()
orig_file_path_and_name = self.make_path(path_in_mrepo, orig_file_name)
assert os.path.isfile(orig_file_path_and_name)
# retrieve the logfile, its name and path
q = ("select o from FilesetJobLink l "
"join l.parent as fs join l.child as j "
"join j.originalFileLinks l2 join l2.child as o "
"where fs.id = :id and "
"o.mimetype = 'application/omero-log-file'")
logfile = queryService.findByQuery(q, params, self.group_ctx)
logfile_name = logfile.getName().getValue()
path_in_mrepo = logfile.getPath().getValue()
logfile_path = self.make_path(path_in_mrepo)
assert os.path.exists(logfile_path)
logfile_path_and_name = self.make_path(path_in_mrepo, logfile_name)
assert os.path.isfile(logfile_path_and_name)
# change the names of original_file and logfile to nonsense
name = "nonsensical"
update_service = self.root.sf.getUpdateService()
orig_file.setName(omero.rtypes.rstring(name))
update_service.saveAndReturnObject(orig_file, self.group_ctx)
logfile.setName(omero.rtypes.rstring(name))
update_service.saveAndReturnObject(logfile, self.group_ctx)
# run the cleanse command, which will not delete
# the files on disk
self.args += [self.data_dir]
self.cli.invoke(self.args, strict=True)
assert os.path.exists(orig_file_path)
assert os.path.isfile(orig_file_path_and_name)
assert os.path.exists(logfile_path)
assert os.path.isfile(logfile_path_and_name)
# delete the image, which will not delete
# the files on disk because of the nonsensical name
# of orig_file and logfile
command = Delete2(targetObjects={"Image": [image.id.val]})
handle = self.client.sf.submit(command)
self.wait_on_cmd(self.client, handle)
assert os.path.exists(orig_file_path)
assert os.path.isfile(orig_file_path_and_name)
assert os.path.exists(logfile_path)
assert os.path.isfile(logfile_path_and_name)
# run cleanse command again, which will now delete the
# files on disk, the original file, the logfile
# and their directories
self.cli.invoke(self.args, strict=True)
out, err = capsys.readouterr()
assert not os.path.exists(orig_file_path)
assert not os.path.isfile(orig_file_path_and_name)
assert not os.path.exists(logfile_path)
assert not os.path.isfile(logfile_path_and_name)
def test_move_annotations(self, remove, script_runner):
script_id = super(TestUtilScripts, self).get_script(move_annotations)
assert script_id > 0
# create new Admin and user in same group
admin_client, admin = self.new_client_and_user(system=True)
group = admin_client.sf.getAdminService().getEventContext().groupId
client, user = self.new_client_and_user(group=group)
user_id = user.id.val
field_count = 2
# User creates Plate and Adds annotations...
plate = self.import_plates(client=client, fields=field_count)[0]
well_ids = []
for well in plate.copyWells():
well_ids.append(well.id)
for well_sample in well.copyWellSamples():
image = well_sample.getImage()
# Add annotations
tag = omero.model.TagAnnotationI()
tag.textValue = omero.rtypes.rstring("testTag")
self.link(image, tag, client=client)
comment = omero.model.CommentAnnotationI()
comment.textValue = omero.rtypes.rstring("test Comment")
self.link(image, comment, client=client)
rating = omero.model.LongAnnotationI()
rating.longValue = omero.rtypes.rlong(5)
rating.ns = omero.rtypes.rstring(
omero.constants.metadata.NSINSIGHTRATING)
self.link(image, rating, client=client)
# Either the 'user' or 'root' will run the script
if script_runner == 'user':
script_runner_client = client
else:
script_runner_client = admin_client
# Run script on each type, with/without removing Annotations
for anntype in ('Tag', 'Comment', 'Rating'):
args = {
"Data_Type": omero.rtypes.rstring("Well"),
"IDs": omero.rtypes.rlist(well_ids),
"Annotation_Type": omero.rtypes.rstring(anntype),
"Remove_Annotations_From_Images": omero.rtypes.rbool(remove)
}
message = run_script(script_runner_client, script_id,
args, "Message")
assert message.val == "Moved %s Annotations" % field_count
# Check new links are owned by user
# and remove annotations from Wells...
query_service = client.getSession().getQueryService()
query = ("select l from WellAnnotationLink as l"
" join fetch l.child as ann"
" join fetch l.details.owner as owner"
" where l.parent.id in (:ids)")
params = omero.sys.ParametersI().addIds(well_ids)
links = query_service.findAllByQuery(query, params)
link_ids = [l.id.val for l in links]
assert len(link_ids) == field_count * 3
for l in links:
assert l.getDetails().owner.id.val == user_id
delete = Delete2(targetObjects={'WellAnnotationLink': link_ids})
handle = client.sf.submit(delete)
client.waitOnCmd(handle, loops=10, ms=500, failonerror=True,
failontimeout=False, closehandle=False)
# Run again with 'All' annotations.
args = {
"Data_Type": omero.rtypes.rstring("Plate"),
"IDs": omero.rtypes.rlist([plate.id]),
"Annotation_Type": omero.rtypes.rstring("All"),
"Remove_Annotations_From_Images": omero.rtypes.rbool(remove)
}
message = run_script(script_runner_client, script_id, args, "Message")
# If we've been removing annotations above,
# there will be None left to move
if remove:
expected = "No annotations moved. See info."
else:
expected = "Moved %s Annotations" % (field_count * 3)
assert message.val == expected
# Run again - None moved since Annotations are already on Well
message = run_script(script_runner_client, script_id, args, "Message")
assert message.val == "No annotations moved. See info."
def delete(self, obj_type, obj):
delete = Delete2(targetObjects={obj_type: [obj.id.val]})
return self.submit(delete)
def test3639(self):
uuid = self.ctx.sessionUuid
images = list()
for i in range(0, 5):
images.append(self.make_image())
p = omero.sys.Parameters()
p.map = {}
p.map["oids"] = rlist([rlong(s.id.val) for s in images])
# create dataset
dataset = self.make_dataset('DS-test-2936-%s' % uuid)
# put image in dataset
for image in images:
self.link(dataset, image)
# log in as group owner:
client_o, owner = self.new_client_and_user(group=self.group,
owner=True)
query_o = client_o.sf.getQueryService()
handlers = list()
keep = ChildOption(excludeType=["Image"])
dc = Delete2(targetObjects={'Dataset': [dataset.id.val]},
childOptions=[keep])
handlers.append(str(client_o.sf.submit(dc)))
imageToDelete = images[2].id.val
dc2 = Delete2(targetObjects={'Image': [imageToDelete]})
handlers.append(str(client_o.sf.submit(dc2)))
def _formatReport(delete_handle):
"""
Added as workaround to the changes made in #3006.
"""
delete_report = delete_handle.getResponse()
rv = []
if isinstance(delete_report, omero.cmd.ERR):
rv.append(str(delete_report))
if len(rv) > 0:
return "; ".join(rv)
return None
failure = list()
in_progress = 0
r = None
while (len(handlers) > 0):
for cbString in handlers:
try:
with pytest.raises(Ice.ObjectNotExistException):
handle = omero.cmd.HandlePrx.checkedCast(
client_o.ic.stringToProxy(cbString))
cb = omero.callbacks.CmdCallbackI(client_o, handle)
if not cb.block(500): # ms.
# No errors possible if in progress(
# (since no response)
print "in progress", _formatReport(handle)
in_progress += 1
else:
rsp = cb.getResponse()
if isinstance(rsp, omero.cmd.ERR):
r = _formatReport(handle)
if r is not None:
failure.append(r)
else:
failure.append("No report!!!")
else:
r = _formatReport(handle)
if r is not None:
failure.append(r)
cb.close(True) # Close handle
handlers.remove(cbString)
except Exception:
if r is not None:
failure.append(traceback.format_exc())
if len(failure) > 0:
assert False, ";".join(failure)
assert not query_o.find('Dataset', dataset.id.val)
def run_script():
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
data_types = [rstring('Dataset')]
client = scripts.client(
'Export_kvpairs_to_csv',
"""
This script reads the key values pairs of the images "children" of the dataset and creates a csv file which is then attached to the dataset
""",
scripts.String(
"Data_Type", optional=False, grouping="1",
description="Choose source of images",
values=data_types, default="Dataset"),
scripts.List(
"IDs", optional=False, grouping="2",
description="dataset ID.").ofType(rlong(0)),
authors=["Christian Evenhuis"],
institutions=["MIF UTS"],
contact="*****@*****.**"
)
try:
# process the list of args above.
script_params = {}
for key in client.getInputKeys():
if client.getInput(key):
script_params[key] = client.getInput(key, unwrap=True)
# wrap client to use the Blitz Gateway
conn = BlitzGateway(client_obj=client)
print("connection made")
dataType = script_params["Data_Type"]
print(dataType)
ids = script_params["IDs"]
datasets = list(conn.getObjects(dataType, ids)) # generator of images or datasets
print(ids)
print("datasets:")
print( datasets )
for ds in datasets:
# name of the file
csv_name = "{}_metadata_out.csv".format(ds.getName())
print(csv_name)
# remove the csv if it exists
for ann in ds.listAnnotations():
if( isinstance(ann, omero.gateway.FileAnnotationWrapper) ):
if( ann.getFileName() == csv_name ):
# if the name matches delete it
try:
delete = Delete2(targetObjects={'FileAnnotation': [int(ann.getId())]})
handle = conn.c.sf.submit(delete)
conn.c.waitOnCmd(handle, loops=10, ms=500, failonerror=True,
failontimeout=False, closehandle=False)
print("Deleted existing csv")
except Exception, ex:
print("Failed to delete existing csv: {}".format(ex.message))
else:
print("No exisiting file")
# filename key multiple vals
# assemble the metadata into an OrderedDict of ( OrderedDict of Sets )
file_names = [ img.getName() for img in list(ds.listChildren()) ]
kv_dict = OrderedDict()
for img in ds.listChildren():
fn = img.getName()
kv_dict[fn] = GetExistingMapAnnotions(img)
# attach the data
mess = attach_csv_file( conn, ds, kv_dict )
print(mess)
mess="done"
client.setOutput("Message", rstring(mess))