def add_from_namespace_query(self, session, ns, primary_keys):
"""
Fetches all map-annotations with the given namespace
This will only work if there are no duplicates, otherwise an
exception will be thrown
WARNING: You should probably only use this in MA_APPEND mode since
the parents of existing annotations aren't fetched (requires a query
for each parent type)
WARNING: This may be resource intensive
TODO: Use omero.utils.populate_metadata._QueryContext for batch queries
:param session: An OMERO session
:param ns: The namespace
:param primary_keys: Primary keys
"""
qs = session.getQueryService()
q = 'FROM MapAnnotation WHERE ns=:ns ORDER BY id DESC'
p = ParametersI()
p.addString('ns', ns)
results = qs.findAllByQuery(q, p)
log.debug('Found %d MapAnnotations in ns:%s', len(results), ns)
for ma in results:
cma = CanonicalMapAnnotation(ma, primary_keys)
r = self.add(cma)
if r:
raise Exception(
'Duplicate MapAnnotation primary key: id:%s %s' % (
unwrap(ma.getId()), str(r)))
def testProjectionPermissions(self, fixture):
writer = self.writer(fixture)
reader = self.reader(fixture)
project = self.make_project(name="testProjectPermissions",
client=writer)
update = writer.sf.getUpdateService()
project = update.saveAndReturnObject(project)
try:
perms1 = unwrap(
reader.projection(("select new ome.util.PermDetails(p) "
"from Project p where p.id = :id"),
ParametersI().addId(project.id.val)))[0][0]
perms2 = unwrap(
reader.projection(
("select new map(p.id as id, p as p_details_permissions) "
"from Project p where p.id = :id"),
ParametersI().addId(project.id.val)))[0][0]
perms2 = perms2["p_details_permissions"]
assert perms1 == perms2
assert fixture.canRead
except IndexError:
# No permissions were returned.
assert not fixture.canRead
else:
self.assertPerms(perms1, fixture)
self.assertPerms(perms2, fixture)
def testOwnerId(self):
p = ParametersI()
self.assertNull(p.theFilter)
p.exp(rlong(1))
self.assertNotNull(p.theFilter)
self.assertNotNull(p.theFilter.ownerId)
assert rlong(1) == p.getExperimenter()
self.assertNull(p.allExps().getExperimenter())
self.assertNotNull(p.theFilter)
def testGroupId(self):
p = ParametersI()
self.assertNull(p.theFilter)
p.grp(rlong(1))
self.assertNotNull(p.theFilter)
self.assertNotNull(p.theFilter.groupId)
assert rlong(1) == p.getGroup()
self.assertNull(p.allGrps().getGroup())
self.assertNotNull(p.theFilter)
def testGroup(self):
p = ParametersI()
p.grp(rlong(1))
assert p.isGroup()
assert p.getGroup().getValue() == 1
p.allGrps()
assert not p.isGroup()
def testExperimenter(self):
p = ParametersI()
p.exp(rlong(1))
assert p.isExperimenter()
assert p.getExperimenter().getValue() == 1
p.allExps()
assert not p.isExperimenter()
def testExperimenter(self):
p = ParametersI()
p.exp(rlong(1))
self.assertTrue(p.isExperimenter())
self.assertEquals(p.getExperimenter().getValue(), 1L)
p.allExps()
self.assertFalse(p.isExperimenter())
def testGroup(self):
p = ParametersI()
p.grp(rlong(1))
self.assert_(p.isGroup())
self.assertEquals(p.getGroup().getValue(), 1L)
p.allGrps()
self.assertFalse(p.isGroup())
def testGroup(self):
p = ParametersI()
p.grp(rlong(1))
self.assert_(p.isGroup())
self.assertEquals(p.getGroup().getValue(), 1L)
p.allGrps()
self.assertFalse(p.isGroup())
def testExperimenter(self):
p = ParametersI()
p.exp(rlong(1))
self.assertTrue(p.isExperimenter())
self.assertEquals(p.getExperimenter().getValue(), 1L)
p.allExps()
self.assertFalse(p.isExperimenter())
def testGroup(self):
p = ParametersI()
p.grp(rlong(1))
assert p.isGroup()
assert p.getGroup().getValue() == 1L
p.allGrps()
assert not p.isGroup()
def testExperimenter(self):
p = ParametersI()
p.exp(rlong(1))
assert p.isExperimenter()
assert p.getExperimenter().getValue() == 1L
p.allExps()
assert not p.isExperimenter()
def getProjects(query_prx, username):
return query_prx.findAllByQuery(
"select p from Project p"
" join fetch p.datasetLinks dil"
" join fetch dil.child"
" where p.details.owner.omeName = :name",
ParametersI().add("name", rstring(username)))
def testDefaults(self):
p = ParametersI()
# Removed: self.assertFalse(p.isLeaves())
self.assertFalse(p.isGroup())
self.assertFalse(p.isExperimenter())
self.assertFalse(p.isEndTime())
self.assertFalse(p.isStartTime())
self.assertFalse(p.isPagination())
self.assertFalse(p.getUnique())
def testTimes(self):
p = ParametersI()
self.assertNull(p.theFilter)
p.startTime(rtime(0))
self.assertNotNull(p.theFilter)
self.assertNotNull(p.theFilter.startTime)
p.endTime(rtime(1))
self.assertNotNull(p.theFilter.endTime)
p.allTimes()
self.assertNotNull(p.theFilter)
self.assertNull(p.theFilter.startTime)
self.assertNull(p.theFilter.endTime)
def well_images(request, conn=None, **kwargs):
# check for mandatory parameter id
well_id = request.GET.get("id", None)
if well_id is None:
return JsonResponse({"error": "No well id provided."})
try:
query_service = conn.getQueryService()
# set well id
params = ParametersI()
params.add("well_id", rlong(long(well_id)))
# get total count first
count = query_service.projection(
"select count(distinct ws.id) from WellSample ws " +
"where ws.well.id = :well_id",
params,
)
results = {"data": [], "meta": {"totalCount": count[0][0].val}}
# set offset and limit
filter = omero.sys.Filter()
filter.offset = rint(request.GET.get("offset", 0))
filter.limit = rint(request.GET.get("limit", 10))
params.theFilter = filter
# fire off query
images = query_service.findAllByQuery(
"select ws.image from WellSample ws " +
"where ws.well.id = :well_id order by well_index", params)
# we need only image id and name for our purposes
for img in images:
img_ret = {"@id": img.getId().getValue()}
if img.getName() is not None:
img_ret["Name"] = img.getName().getValue()
results["data"].append(img_ret)
return JsonResponse(results)
except Exception as get_well_images_exception:
return JsonResponse({"error": repr(get_well_images_exception)})
def testDefaults(self):
p = ParametersI()
# Removed: assert not p.isLeaves()
assert not p.isGroup()
assert not p.isExperimenter()
assert not p.isEndTime()
assert not p.isStartTime()
assert not p.isPagination()
assert not p.getUnique()
def testOptionsAcquisitionData(self):
p = ParametersI()
self.assertNull(p.getAcquisitionData())
self.assertEquals(rbool(True),
p.acquisitionData().getAcquisitionData())
self.assertEquals(rbool(False),
p.noAcquisitionData().getAcquisitionData())
self.assertNotNull(p.getAcquisitionData())
def testTimes(self):
p = ParametersI()
self.assertNull(p.theFilter)
p.startTime(rtime(0))
self.assertNotNull(p.theFilter)
self.assertNotNull(p.theFilter.startTime)
p.endTime(rtime(1))
self.assertNotNull(p.theFilter.endTime)
p.allTimes()
self.assertNotNull(p.theFilter)
self.assertNull(p.theFilter.startTime)
self.assertNull(p.theFilter.endTime)
def testGroupId(self):
p = ParametersI()
self.assertNull(p.theFilter)
p.grp(rlong(1))
self.assertNotNull(p.theFilter)
self.assertNotNull(p.theFilter.groupId)
self.assertEquals(rlong(1), p.getGroup())
self.assertNull(p.allGrps().getGroup())
self.assertNotNull(p.theFilter)
def testOwnerId(self):
p = ParametersI()
self.assertNull(p.theFilter)
p.exp(rlong(1))
self.assertNotNull(p.theFilter)
self.assertNotNull(p.theFilter.ownerId)
self.assertEquals(rlong(1), p.getExperimenter())
self.assertNull(p.allExps().getExperimenter())
self.assertNotNull(p.theFilter)
def testProjectionPermissions(self, fixture):
writer = self.writer(fixture)
reader = self.reader(fixture)
project = ProjectI()
project.name = rstring("testProjectPermissions")
project = writer.saveAndReturnObject(project)
try:
perms = unwrap(
reader.projection(
"select p.details.permissions from Project p where p.id = :id",
ParametersI().addId(project.id.val)))[0][0]
assert fixture.canRead
except IndexError:
# No permissions were returned.
assert not fixture.canRead
else:
self.assertPerms(perms, fixture)
def testProjectionPermissions(self, fixture):
writer = self.writer(fixture)
reader = self.reader(fixture)
project = self.make_project(name="testProjectPermissions",
client=writer)
group = project.details.group.id.val
owner = project.details.owner.id.val
key = (group, owner)
try:
if key in self._cache:
# In pytest, this is never actually reached,
# since each test is a new instance, but this
# would be the performance speed up needed in
# clients. See #12474
assert False
else:
proj = unwrap(
reader.projection(
"select p from Project p where p.id = :id",
ParametersI().addId(project.id.val),
{"omero:group": str(group)}))[0][0]
assert fixture.canRead
perms = proj.details.permissions
value = {
"perms": str(perms),
"canAnnotate": perms.canAnnotate(),
"canDelete": perms.canDelete(),
"canEdit": perms.canEdit(),
"canLink": perms.canLink(),
"canChgrp": perms.canChgrp(),
"canChown": perms.canChown(),
}
self._cache[key] = value
except IndexError:
# No permissions were returned.
assert not fixture.canRead
else:
self.assertPerms(self._cache[key], fixture)
def testUnique(self):
p = ParametersI()
self.assertNull(p.getUnique())
self.assertEquals(rbool(True), p.unique().getUnique())
self.assertEquals(rbool(False), p.noUnique().getUnique())
self.assertNotNull(p.getUnique())
def testFilter(self):
p = ParametersI()
p.noPage()
self.assertEquals(None, p.theFilter)
p.page(2,3)
self.assert_(p.isPagination())
self.assertEquals( rint(2), p.theFilter.offset )
self.assertEquals( rint(3), p.theFilter.limit )
p.noPage()
self.assertFalse(p.isPagination())
self.assertEquals(None, p.theFilter.offset)
self.assertEquals(None, p.theFilter.limit)
self.assertEquals(None, p.getLimit())
self.assertEquals(None, p.getOffset())
def testOptionsOrphan(self):
p = ParametersI()
self.assertNull(p.getOrphan())
assert rbool(True) == p.orphan().getOrphan()
assert rbool(False) == p.noOrphan().getOrphan()
self.assertNotNull(p.getOrphan())
def testAddLongs(self):
p = ParametersI()
p.addLongs("longs", [1, 2])
p.map["longs"].val.index(rlong(1))
p.map["longs"].val.index(rlong(2))
def testAddLongRType(self):
p = ParametersI()
p.addLong("long", rlong(1))
self.assertEquals(rlong(1), p.map["long"])
def testAddBasicInt(self):
p = ParametersI()
p.add("int", rint(1))
self.assertEquals(rint(1), p.map["int"])
def testAddLongRType(self):
p = ParametersI()
p.addLong("long", rlong(1))
assert rlong(1) == p.map["long"]
def testAddLongRType(self):
p = ParametersI()
p.addLong("long", rlong(1))
self.assertEquals(rlong(1), p.map["long"])
filter.limit = rint(10)
filter.offset = rint(0)
plates = q.findAll("Plate", filter)
if len(plates) == 0:
print "No plates"
sys.exit(0)
else:
import random
example_plate = random.choice(plates)
print "Loading wells for Plate %s (%s)" % (
example_plate.getId().getValue(), example_plate.getName().getValue())
# An example of true paging
filter.limit = rint(12)
params = ParametersI()
params.addId(example_plate.getId().getValue())
params.theFilter = filter
offset = 0
while True:
wells = q.findAllByQuery(LOAD_WELLS, params)
if len(wells) == 0:
break
else:
offset += len(wells)
params.theFilter.offset = rint(offset)
for well in wells:
id = well.getId().getValue()
def testAddIdRaw(self):
p = ParametersI()
p.addId(1)
assert rlong(1) == p.map["id"]
def testAddIdRType(self):
p = ParametersI()
p.addId(rlong(1))
assert rlong(1) == p.map["id"]
def testBasics(self):
p = ParametersI()
p.exp(rlong(1))
p.grp(rlong(1))
p.endTime(rtime(1))
def testAddLongs(self):
p = ParametersI()
p.addLongs("longs", [1, 2])
p.map["longs"].val.index(rlong(1))
p.map["longs"].val.index(rlong(2))
def testAddIds(self):
p = ParametersI()
p.addIds([1, 2])
p.map["ids"].val.index(rlong(1))
p.map["ids"].val.index(rlong(2))
def hql(self, args, loop=False):
from omero_sys_ParametersI import ParametersI
ice_map = dict()
if args.admin:
ice_map["omero.group"] = "-1"
c = self.ctx.conn(args)
q = c.sf.getQueryService()
p = ParametersI()
p.page(args.offset, args.limit)
rv = self.project(q, args.query, p, ice_map)
has_details = self.display(rv, style=args.style, idsonly=args.ids_only)
if self.ctx.isquiet or not sys.stdout.isatty():
return
input = """
To see details for object, enter line number.
To move ahead one page, enter 'p'
To re-display list, enter 'r'.
To quit, enter 'q' or just enter.
"""
if loop:
input = input + """To run another query, press enter\n"""
while True:
id = self.ctx.input(input)
id = id.lower()
# Exit loop
if not id:
return True
if id.startswith("q"):
return False
# Stay in loop
if id.startswith("p"):
p.page(p.getOffset().val + p.getLimit().val, p.getLimit())
self.ctx.dbg("\nCurrent page: offset=%s, limit=%s\n" %
(p.theFilter.offset.val, p.theFilter.limit.val))
rv = self.project(q, args.query, p, ice_map)
self.display(rv, style=args.style, idsonly=args.ids_only)
elif id.startswith("r"):
self.display(rv, style=args.style, idsonly=args.ids_only)
else:
try:
id = int(id)
obj = rv[id]
if id not in has_details:
self.ctx.out("No details available: %s" % id)
continue
else:
# Unwrap the object_list from IQuery.projection
obj = obj[0].val
except:
self.ctx.out("Invalid choice: %s" % id)
continue
keys = sorted(obj.__dict__)
keys.remove("_id")
keys.remove("_details")
self.ctx.out("id = %s" % obj.id.val)
for key in keys:
value = self.unwrap(obj.__dict__[key])
if isinstance(value, str):
value = "'%s'" % value
if key.startswith("_"):
key = key[1:]
self.ctx.out("%s = %s" % (key, value))
continue
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import omero
from omero.rtypes import *
from omero_sys_ParametersI import ParametersI
client = omero.client(sys.argv)
try:
sf = client.createSession()
q = sf.getQueryService()
query_string = "select i from Image i where i.id = :id and name like :namedParameter";
p = ParametersI()
p.addId(1L)
p.add("namedParameter", rstring("cell%mit%"));
results = q.findAllByQuery(query_string, p)
finally:
client.closeSession()
def testUnique(self):
p = ParametersI()
self.assertNull(p.getUnique())
assert rbool(True) == p.unique().getUnique()
assert rbool(False) == p.noUnique().getUnique()
self.assertNotNull(p.getUnique())
def testAddBasicString(self):
p = ParametersI()
p.add("string", rstring("a"))
self.assertEquals(rstring("a"), p.map["string"])
filter.limit = rint(10)
filter.offset = rint(0)
plates = q.findAll("Plate", filter)
if len(plates) == 0:
print "No plates"
sys.exit(0)
else:
import random
example_plate = random.choice(plates)
print "Loading wells for Plate %s (%s)" % (example_plate.getId().getValue(), example_plate.getName().getValue())
# An example of true paging
filter.limit = rint(12)
params = ParametersI()
params.addId(example_plate.getId().getValue())
params.theFilter = filter
offset = 0
while True:
wells = q.findAllByQuery(LOAD_WELLS, params)
if len(wells) == 0:
break
else:
offset += len(wells)
params.theFilter.offset = rint( offset )
for well in wells:
id = well.getId().getValue()
def testAddIdRType(self):
p = ParametersI()
p.addId(rlong(1))
self.assertEquals(rlong(1), p.map["id"])
import omero
from omero_sys_ParametersI import ParametersI # Temporary
c = omero.client();
s = c.createSession();
q = s.getQueryService();
QUERY = 'select p from Plate p left outer join fetch p.wells w left outer join fetch w.wellSamples s left outer join fetch s.image where p.id = :id';
filter = omero.sys.Filter();
plates = q.findAll('Plate', filter);
print 'Plate:'
for i in range(len(plates)):
params = ParametersI();
params.addId(plates[i].getId().getValue());
plate = q.findByQuery(QUERY, params);
print ' %d %s ' % ( i, plate.getName().getValue() )
wells = {}
for well in plate.copyWells():
row = well.getRow() and well.getRow().getValue() or -1
col = well.getColumn() and well.getColumn().getValue() or -1
if row in wells:
row_list = wells[row];
else:
row_list = []
wells[row] = row_list;
row_list.append(col);
row_list.sort()
def testAddIds(self):
p = ParametersI()
p.addIds([1, 2])
p.map["ids"].val.index(rlong(1))
p.map["ids"].val.index(rlong(2))
def testAddBasicInt(self):
p = ParametersI()
p.add("int", rint(1))
assert rint(1) == p.map["int"]
def testBasics(self):
p = ParametersI()
p.exp(rlong(1))
p.grp(rlong(1))
p.endTime(rtime(1))
def testAddBasicString(self):
p = ParametersI()
p.add("string", rstring("a"))
assert rstring("a") == p.map["string"]
def testUnique(self):
p = ParametersI()
self.assertNull(p.getUnique())
self.assertEquals(rbool(True), p.unique().getUnique())
self.assertEquals(rbool(False), p.noUnique().getUnique())
self.assertNotNull(p.getUnique())
def testOptionsLeaves(self):
p = ParametersI()
self.assertNull(p.getLeaves())
assert rbool(True) == p.leaves().getLeaves()
assert rbool(False) == p.noLeaves().getLeaves()
self.assertNotNull(p.getLeaves())
def testFilter(self):
p = ParametersI()
p.noPage()
self.assertEquals(None, p.theFilter)
p.page(2, 3)
self.assert_(p.isPagination())
self.assertEquals(rint(2), p.theFilter.offset)
self.assertEquals(rint(3), p.theFilter.limit)
p.noPage()
self.assertFalse(p.isPagination())
self.assertEquals(None, p.theFilter.offset)
self.assertEquals(None, p.theFilter.limit)
self.assertEquals(None, p.getLimit())
self.assertEquals(None, p.getOffset())
def testOptionsLeaves(self):
p = ParametersI()
self.assertNull(p.getLeaves())
self.assertEquals(rbool(True), p.leaves().getLeaves())
self.assertEquals(rbool(False), p.noLeaves().getLeaves())
self.assertNotNull(p.getLeaves())
def testOptionsAcquisitionData(self):
p = ParametersI()
self.assertNull(p.getAcquisitionData())
assert rbool(True) == p.acquisitionData().getAcquisitionData()
assert rbool(False) == p.noAcquisitionData().getAcquisitionData()
self.assertNotNull(p.getAcquisitionData())
def testDistinctMaps(self):
p1 = ParametersI()
p2 = ParametersI()
self.assertFalse(p1.map is p2.map)
def hql(self, args, loop = False):
from omero_sys_ParametersI import ParametersI
ice_map = dict()
if args.admin:
ice_map["omero.group"]="-1"
c = self.ctx.conn(args)
q = c.sf.getQueryService()
p = ParametersI()
p.page(args.offset, args.limit)
rv = self.project(q, args.query, p, ice_map)
has_details = self.display(rv)
if args.quiet:
return
input = """
To see details for object, enter line number.
To move ahead one page, enter 'p'
To re-display list, enter 'r'.
To quit, enter 'q' or just enter.
"""
if loop:
input = input + """To run another query, press enter\n"""
while True:
id = self.ctx.input(input)
id = id.lower()
# Exit loop
if not id:
return True
if id.startswith("q"):
return False
# Stay in loop
if id.startswith("p"):
p.page(p.getOffset().val + p.getLimit().val, p.getLimit())
self.ctx.dbg("\nCurrent page: offset=%s, limit=%s\n" % (p.theFilter.offset.val, p.theFilter.limit.val))
rv = self.project(q, args.query, p, ice_map)
self.display(rv)
elif id.startswith("r"):
self.display(rv)
else:
try:
id = long(id)
obj = rv[id]
if id not in has_details:
self.ctx.out("No details available: %s" % id)
continue
else:
obj = obj[0].val # Unwrap the object_list from IQuery.projection
except:
self.ctx.out("Invalid choice: %s" % id)
continue
keys = sorted(obj.__dict__)
keys.remove("_id")
keys.remove("_details")
self.ctx.out("id = %s" % obj.id.val)
for key in keys:
value = self.unwrap(obj.__dict__[key])
if isinstance(value, (str, unicode)):
value = "'%s'" % value
if key.startswith("_"):
key = key[1:]
self.ctx.out("%s = %s" % (key, value))
continue
def testSameMap(self):
m = {'key': 0}
p1 = ParametersI(parammap=m)
p2 = ParametersI(parammap=m)
self.assertTrue(p1.map is p2.map)
from omero.rtypes import rint
from omero_sys_ParametersI import ParametersI # Temporary
c = omero.client()
s = c.createSession()
q = s.getQueryService()
GET_IMAGES_WITH_PLATES = "select i from Image i join i.wellSamples ws join ws.well w" " join w.plate p" # Inner joins
GET_PLATE_FROM_IMAGE_ID = (
"select p from Plate p join p.wells w join w.wellSamples ws" " join ws.image i where i.id = :id"
)
filter = omero.sys.Filter()
filter.limit = rint(100)
filter.offset = rint(0)
params = ParametersI()
params.theFilter = filter
images = q.findAllByQuery(GET_IMAGES_WITH_PLATES, params)
print "Found %s images" % len(images)
for image in images:
params = ParametersI()
params.addId(image.getId().getValue())
# Multiple plates per image will through an exception
plate = q.findByQuery(GET_PLATE_FROM_IMAGE_ID, params)
print "Image %s belongs to Plate %s (%s)" % (
image.getId().getValue(),
plate.getId().getValue(),
plate.getName().getValue(),
def testAddLongRaw(self):
p = ParametersI()
p.addLong("long", 1)
assert rlong(1) == p.map["long"]
from omero_sys_ParametersI import ParametersI # Temporary
c = omero.client()
s = c.createSession()
q = s.getQueryService()
QUERY = ("select p from Plate p left outer join fetch p.wells w"
" left outer join fetch w.wellSamples s"
" left outer join fetch s.image where p.id = :id")
filter = omero.sys.Filter()
plates = q.findAll('Plate', filter)
print 'Plate:'
for i in range(len(plates)):
params = ParametersI()
params.addId(plates[i].getId().getValue())
plate = q.findByQuery(QUERY, params)
print ' %d %s ' % (i, plate.getName().getValue())
wells = {}
for well in plate.copyWells():
row = well.getRow() and well.getRow().getValue() or -1
col = well.getColumn() and well.getColumn().getValue() or -1
if row in wells:
row_list = wells[row]
else:
row_list = []
wells[row] = row_list
row_list.append(col)
row_list.sort()
def testFilter(self):
p = ParametersI()
p.noPage()
assert None == p.theFilter
p.page(2, 3)
assert p.isPagination()
assert rint(2) == p.theFilter.offset
assert rint(3) == p.theFilter.limit
p.noPage()
assert not p.isPagination()
assert None == p.theFilter.offset
assert None == p.theFilter.limit
assert None == p.getLimit()
assert None == p.getOffset()
