Table Of Contents

Previous topic

omero package

Next topic

omero.cmd package

This Page

omero.api package

Module contents

The omero::api module defines all the central verbs for working with OMERO.blitz.

Arguments and return values consist of those

types defined in the other ice files available here. With no further custom code, it is possible to interoperate with OMERO.blitz simply via the definitions here. Start with the ServiceFactory definition at the end of this file.

Note: Using these types is significantly easier in combination with

the JavaDocs of the OMERO.server, specifically the ome.api package. Where not further noted below, the follow mappings between ome.api argument types and omero::api argument types hold:

ome.api omero::api
java.lang.Class string
java.util.Set java.util.List/vector
IPojo options (Map) omero::sys::ParamMap
If null needed omero::RType subclass
... ...
class omero.api.ClientCallback

Bases: Ice.Object

Primary callback interface for interaction between client and server session (“”ServiceFactory””). Where possible these methods will be called one-way to prevent clients from hanging the server.

_ice_type = <IcePy.TypeInfo object at 0x11de6c90>
_op_requestHeartbeat = <IcePy.Operation object at 0x11de6ca8>
_op_sessionClosed = <IcePy.Operation object at 0x11de6cc0>
_op_shutdownIn = <IcePy.Operation object at 0x11de6cd8>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
requestHeartbeat(current=None)

Heartbeat-request made by the server to guarantee that the client is alive. If the client is still active, then some method should be made on the server to update the last idle time.

sessionClosed(current=None)

The session to which this ServiceFactory is connected has been closed. Almost no further method calls (if any) are possible. Create a new session via omero.client.createSession()

shutdownIn(milliseconds, current=None)

Message that the server will be shutting down in the given number of milliseconds, after which all new and running method invocations will receive a CancelledException.

class omero.api.ClientCallbackPrx

Bases: IcePy.ObjectPrx

Heartbeat-request made by the server to guarantee that the client is alive. If the client is still active, then some method should be made on the server to update the last idle time.

begin_requestHeartbeat(_response=None, _ex=None, _sent=None, _ctx=None)
begin_sessionClosed(_response=None, _ex=None, _sent=None, _ctx=None)
begin_shutdownIn(milliseconds, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_requestHeartbeat(_r)
end_sessionClosed(_r)
end_shutdownIn(_r)
requestHeartbeat(_ctx=None)
requestHeartbeat_async(_cb, _ctx=None)
sessionClosed(_ctx=None)
sessionClosed_async(_cb, _ctx=None)
shutdownIn(milliseconds, _ctx=None)
shutdownIn_async(_cb, milliseconds, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.Exporter

Bases: omero.api.StatefulServiceInterface

Stateful service for generating OME-XML or OME-TIFF from data stored in OMERO. Intended usage:

ExporterPrx e = sf.createExporter();

// Exporter is currently in the configuration state // Objects can be added by id which should be present // in the output.

e.addImage(1);

// As soon as a generate method is called, the objects // added to the Exporter are converted to the specified // format. The length of the file produced is returned. // No more objects can be added to the Exporter, nor can // another generate method be called.

long length = e.generateTiff();

// As soon as the server-side file is generated, read() // can be called to get file segments. To create another // file, create a second Exporter. Be sure to close all // Exporter instances.

long read = 0 byte[] buf; while (true) { buf = e.read(read, 1000000); // Store to file locally here if (buf.length

_ice_type = <IcePy.TypeInfo object at 0x3dbbe58>
_op_addImage = <IcePy.Operation object at 0x11febc00>
_op_generateTiff = <IcePy.Operation object at 0x11febc30>
_op_generateXml = <IcePy.Operation object at 0x11febc18>
_op_read = <IcePy.Operation object at 0x11febc48>
addImage_async(_cb, id, current=None)

Adds a single image with basic metadata to the Exporter for inclusion on the next call to getBytes().

generateTiff_async(_cb, current=None)

Generates an OME-TIFF file. The return value is the length of the file produced. This method ends configuration.

generateXml_async(_cb, current=None)

Generates an OME-XML file. The return value is the length of the file produced.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
read_async(_cb, position, length, current=None)

Returns length bytes from the output file. The file can be safely read until reset() is called.

class omero.api.ExporterPrx

Bases: omero.api.StatefulServiceInterfacePrx

Adds a single image with basic metadata to the Exporter for inclusion on the next call to getBytes().

addImage(id, _ctx=None)
addImage_async(_cb, id, _ctx=None)
begin_addImage(id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_generateTiff(_response=None, _ex=None, _sent=None, _ctx=None)
begin_generateXml(_response=None, _ex=None, _sent=None, _ctx=None)
begin_read(position, length, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_addImage(_r)
end_generateTiff(_r)
end_generateXml(_r)
end_read(_r)
generateTiff(_ctx=None)
generateTiff_async(_cb, _ctx=None)
generateXml(_ctx=None)
generateXml_async(_cb, _ctx=None)
read(position, length, _ctx=None)
read_async(_cb, position, length, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IAdmin

Bases: omero.api.ServiceInterface

Administration interface providing access to admin-only functionality as well as JMX-based server access and selected user functions. Most methods require membership in privileged omero.model.ExperimenterGroup groups.

Methods which return omero.model.Experimenter or omero.model.ExperimenterGroup instances fetch and load all related instances of omero.model.ExperimenterGroup or omero.model.Experimenter, respectively.

_ice_type = <IcePy.TypeInfo object at 0x3dbbb28>
_op_addGroupOwners = <IcePy.Operation object at 0x1247d480>
_op_addGroups = <IcePy.Operation object at 0x1247d408>
_op_canUpdate = <IcePy.Operation object at 0x1247d1b0>
_op_changeExpiredCredentials = <IcePy.Operation object at 0x1247d5a0>
_op_changeGroup = <IcePy.Operation object at 0x1247d4f8>
_op_changeOwner = <IcePy.Operation object at 0x1247d4e0>
_op_changePassword = <IcePy.Operation object at 0x1247d540>
_op_changePasswordWithOldPassword = <IcePy.Operation object at 0x1247d558>
_op_changePermissions = <IcePy.Operation object at 0x1247d510>
_op_changeUserPassword = <IcePy.Operation object at 0x1247d570>
_op_containedExperimenters = <IcePy.Operation object at 0x1247d258>
_op_containedGroups = <IcePy.Operation object at 0x1247d270>
_op_createExperimenter = <IcePy.Operation object at 0x1247d3c0>
_op_createExperimenterWithPassword = <IcePy.Operation object at 0x1247d3d8>
_op_createGroup = <IcePy.Operation object at 0x1247d3f0>
_op_createSystemUser = <IcePy.Operation object at 0x1247d3a8>
_op_createUser = <IcePy.Operation object at 0x1247d390>
_op_deleteExperimenter = <IcePy.Operation object at 0x1247d4b0>
_op_deleteGroup = <IcePy.Operation object at 0x1247d4c8>
_op_getDefaultGroup = <IcePy.Operation object at 0x1247d288>
_op_getEventContext = <IcePy.Operation object at 0x1247d5e8>
_op_getExperimenter = <IcePy.Operation object at 0x1247d1c8>
_op_getGroup = <IcePy.Operation object at 0x1247d210>
_op_getLeaderOfGroupIds = <IcePy.Operation object at 0x1247d2e8>
_op_getMemberOfGroupIds = <IcePy.Operation object at 0x1247d2d0>
_op_getMyUserPhotos = <IcePy.Operation object at 0x1247d330>
_op_getSecurityRoles = <IcePy.Operation object at 0x1247d5d0>
_op_lookupExperimenter = <IcePy.Operation object at 0x1247d1e0>
_op_lookupExperimenters = <IcePy.Operation object at 0x1247d1f8>
_op_lookupGroup = <IcePy.Operation object at 0x1247d228>
_op_lookupGroups = <IcePy.Operation object at 0x1247d240>
_op_lookupLdapAuthExperimenter = <IcePy.Operation object at 0x1247d2a0>
_op_lookupLdapAuthExperimenters = <IcePy.Operation object at 0x1247d2b8>
_op_moveToCommonSpace = <IcePy.Operation object at 0x1247d528>
_op_removeGroupOwners = <IcePy.Operation object at 0x1247d498>
_op_removeGroups = <IcePy.Operation object at 0x1247d420>
_op_reportForgottenPassword = <IcePy.Operation object at 0x1247d5b8>
_op_setDefaultGroup = <IcePy.Operation object at 0x1247d438>
_op_setGroupOwner = <IcePy.Operation object at 0x1247d450>
_op_synchronizeLoginCache = <IcePy.Operation object at 0x1247d588>
_op_unsetGroupOwner = <IcePy.Operation object at 0x1247d468>
_op_updateExperimenter = <IcePy.Operation object at 0x1247d348>
_op_updateExperimenterWithPassword = <IcePy.Operation object at 0x1247d360>
_op_updateGroup = <IcePy.Operation object at 0x1247d378>
_op_updateSelf = <IcePy.Operation object at 0x1247d300>
_op_uploadMyUserPhoto = <IcePy.Operation object at 0x1247d318>
addGroupOwners_async(_cb, group, owners, current=None)

Adds the given users to the owner list for this group.

Arguments:
group A currently managed
omero.model.ExperimenterGroup. Not null.
owners A set of currently managed

omero.model.Experimenters. Not null.

addGroups_async(_cb, user, groups, current=None)

Adds a user to the given groups.

Arguments:
user A currently managed entity. Not null. groups Groups to which the user will be added. Not

null.

canUpdate_async(_cb, obj, current=None)

Returns true if the currently logged in user can modify the given omero.model.IObject. This uses the same logic that would be applied during a Hibernate flush to the database.

changeExpiredCredentials_async(_cb, name, oldCred, newCred, current=None)

Used after an omero.ExpiredCredentialException instance is thrown.

changeGroup_async(_cb, obj, omeName, current=None)
changeOwner_async(_cb, obj, omeName, current=None)
changePasswordWithOldPassword_async(_cb, oldPassword, newPassword, current=None)

Changes the password for the current user by passing the old password.

Arguments:
oldPassword Not-null. Must pass validation in the
security sub-system.
newPassword Possibly null to allow logging in with

no password. Exceptions:

SecurityViolation if the oldPassword is incorrect.
changePassword_async(_cb, newPassword, current=None)

Changes the password for the current user.

Warning:This method requires the user to be authenticated with a password and not with a one-time session id. To avoid this problem, use changePasswordWithOldPassword.

See also ticket 911 and ticket 3201

Arguments:
newPassword Possibly null to allow logging in with

no password. Exceptions:

SecurityViolation if the user is not authenticated

with a password.

changePermissions_async(_cb, obj, perms, current=None)
changeUserPassword_async(_cb, omeName, newPassword, current=None)

Changes the password for the a given user.

Arguments:
newPassword Not-null. Might must pass validation in

the security sub-system. Exceptions:

SecurityViolation if the new password is too weak.
containedExperimenters_async(_cb, groupId, current=None)

Fetches all omero.model.Experimenter users contained in this group. The returned users will have all fields filled in and all collections unloaded.

Arguments:
groupId id of the ExperimenterGroup
Returns:
non-null array of all

omero.model.Experimenter users in this group.

containedGroups_async(_cb, experimenterId, current=None)

Fetches all omero.model.ExperimenterGroup groups of which the given user is a member. The returned groups will have all fields filled in and all collections unloaded.

Arguments:
experimenterId id of the Experimenter. Not null.
Returns:
non-null array of all

omero.model.ExperimenterGroup groups for this user.

createExperimenterWithPassword_async(_cb, user, password, defaultGroup, groups, current=None)

Creates and returns a new user in the given groups with password.

Arguments:
user A new omero.model.Experimenter
instance. Not null.
password Not-null. Must pass validation in the
security sub-system.
defaultGroup Instance of
omero.model.ExperimenterGroup. Not null.
groups Array of

omero.model.ExperimenterGroup instances. Can be null. Returns:

id of the newly created

omero.model.Experimenter Not null. Exceptions:

SecurityViolation if the new password is too weak.
createExperimenter_async(_cb, user, defaultGroup, groups, current=None)

Creates and returns a new user in the given groups.

Arguments:
user A new omero.model.Experimenter
instance. Not null.
defaultGroup Instance of
omero.model.ExperimenterGroup. Not null.
groups Array of

omero.model.ExperimenterGroup instances. Can be null. Returns:

id of the newly created

omero.model.Experimenter Not null.

createGroup_async(_cb, group, current=None)

Creates and returns a new group. The omero.model.Details#setPermissions method should be called on the instance which is passed. The given omero.model.Permissions will become the default for all objects created while logged into this group, possibly modified by the user’s umask settings. If no permissions is set, the default will be omero.model.Permissions#USER_PRIVATE, i.e. a group in which no user can see the other group member’s data.

See also ticket 1434

Arguments:
group a new

omero.model.ExperimenterGroup instance. Not null. Returns:

id of the newly created ExperimenterGroup
createSystemUser_async(_cb, experimenter, current=None)

Creates and returns a new system user. This user will be created with the System (administration) group as default and will also be in the user group.

Arguments:
experimenter a new omero.model.Experimenter

instance Returns:

id of the newly created

omero.model.Experimenter

createUser_async(_cb, experimenter, group, current=None)

Creates and returns a new user. This user will be created with the default group specified.

Arguments:
experimenter a new omero.model.Experimenter
instance
group group name of the default group for this user
Returns:
id of the newly created

omero.model.Experimenter

deleteExperimenter_async(_cb, user, current=None)

Removes a user by removing the password information for that user as well as all omero.model.GroupExperimenterMap instances.

Arguments:
user Experimenter to be deleted. Not null.
deleteGroup_async(_cb, group, current=None)

Removes a group by first removing all users in the group, and then deleting the actual omero.model.ExperimenterGroup instance.

Arguments:
group omero.model.ExperimenterGroup to be

deleted. Not null.

getDefaultGroup_async(_cb, experimenterId, current=None)

Retrieves the default omero.model.ExperimenterGroup group for the given user id.

Arguments:
experimenterId of the Experimenter. Not null.
Returns:
non-null omero.model.ExperimenterGroup. If

no default group is found, an exception will be thrown.

getEventContext_async(_cb, current=None)

Returns an implementation of omero.sys.EventContext loaded with the security for the current user and thread. If called remotely, not all values of omero.sys.EventContext will be sensible.

Returns:
Non-null, immutable omero.sys.EventContext

instance

getExperimenter_async(_cb, id, current=None)

Fetches an omero.model.Experimenter and all related omero.model.ExperimenterGroup.

Arguments:
id id of the Experimenter
Returns:
an Experimenter. Never null.
Exceptions:
ApiUsageException if id does not exist.
getGroup_async(_cb, id, current=None)

Fetches an omero.model.ExperimenterGroup and all contained omero.model.Experimenter users.

Arguments:
id id of the ExperimenterGroup
Returns:
an ExperimenterGroup. Never null.
Exceptions:
ApiUsageException if id does not exist.
getLeaderOfGroupIds_async(_cb, exp, current=None)

Finds the ids for all groups for which the given omero.model.Experimenter is owner/leader.

Arguments:
exp Non-null, managed (i.e. with id)
getMemberOfGroupIds_async(_cb, exp, current=None)

Finds the ids for all groups for which the given omero.model.Experimenter is a member.

Arguments:
exp Non-null, managed (i.e. with id)
getMyUserPhotos_async(_cb, current=None)

Retrieves the omero.model.OriginalFile object attached to this user as specified by uploadMyUserPhoto. The return value is order by the most recently modified file first.

Returns:
file objects. Possibly empty.
getSecurityRoles_async(_cb, current=None)

Returns the active omero.sys.Roles in use by the server.

Returns:
Non-null, immutable omero.sys.Roles

instance.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
lookupExperimenter_async(_cb, name, current=None)

Looks up an omero.model.Experimenter and all related omero.model.ExperimenterGroup by name.

Arguments:
name Name of the Experimenter
Returns:
an Experimenter. Never null.
Exceptions:
ApiUsageException if omeName does not exist.
lookupExperimenters_async(_cb, current=None)

Looks up all omero.model.Experimenter experimenters present and all related omero.model.ExperimenterGroup groups.

Returns:
all Experimenters. Never null.
lookupGroup_async(_cb, name, current=None)

Looks up an omero.model.ExperimenterGroup and all contained omero.model.Experimenter users by name.

Arguments:
name Name of the ExperimenterGroup
Returns:
an ExperimenterGroup. Never null.
Exceptions:
ApiUsageException if groupName does not exist.
lookupGroups_async(_cb, current=None)

Looks up all omero.model.ExperimenterGroup groups present and all related omero.model.Experimenter experimenters. The experimenter’s groups are also loaded.

Returns:
all Groups. Never null.
lookupLdapAuthExperimenter_async(_cb, id, current=None)

Looks up omero.model.Experimenter experimenters who use LDAP authentication (has set dn on password table).

Returns:
Experimenter. Never null.
lookupLdapAuthExperimenters_async(_cb, current=None)

Looks up all ids of omero.model.Experimenter experimenters who use LDAP authentication (has set dn on password table).

Returns:
list of experimenters. Never null.
moveToCommonSpace_async(_cb, objects, current=None)

Moves the given objects into the user group to make them visible and linkable from all security contexts.

See also ticket 1794

Arguments:
objects
removeGroupOwners_async(_cb, group, owners, current=None)

removes the given users from the owner list for this group.

Arguments:
group A currently managed
omero.model.ExperimenterGroup. Not
owners A set of currently managed

omero.model.Experimenters. Not null.

removeGroups_async(_cb, user, groups, current=None)

Removes an experimenter from the given groups.

The root experimenter is required to be in both the user and system groups. An experimenter may not remove themself from the user or system group. An experimenter may not be a member of only the user group, some other group is also required as the default group. An experimenter must remain a member of some group.

Arguments:
user A currently managed entity. Not null. groups Groups from which the user will be removed.

Not null.

reportForgottenPassword_async(_cb, name, email, current=None)
setDefaultGroup_async(_cb, user, group, current=None)

Sets the default group for a given user.

Arguments:
user A currently managed
omero.model.Experimenter. Not null.
group The group which should be set as default group

for this user. Not null.

setGroupOwner_async(_cb, group, owner, current=None)

Adds the user to the owner list for this group.

Since Beta 4.2 multiple users can be the owner of a group.

Arguments:
group A currently managed
omero.model.ExperimenterGroup. Not null.
owner A currently managed

omero.model.Experimenter. Not null.

synchronizeLoginCache_async(_cb, current=None)

Uses JMX to refresh the login cache if supported. Some backends may not provide refreshing. This may be called internally during some other administrative tasks. The exact implementation of this depends on the application server and the authentication/authorization backend.

unsetGroupOwner_async(_cb, group, owner, current=None)

Removes the user from the owner list for this group.

Since Beta 4.2 multiple users can be the owner of a group.

Arguments:
group A currently managed
omero.model.ExperimenterGroup. Not null.
owner A currently managed

omero.model.Experimenter. Not null.

updateExperimenterWithPassword_async(_cb, experimenter, password, current=None)

Updates an experimenter if admin or owner of group. Only string fields on the object are taken into account. The root and guest experimenters may not be renamed.

Arguments:
experimenter the Experimenter to update. password Not-null. Must pass validation in the

security sub-system.

updateExperimenter_async(_cb, experimenter, current=None)

Updates an experimenter if admin or owner of group. Only string fields on the object are taken into account. The root and guest experimenters may not be renamed.

Before a SecurityViolation would be thrown, however, this method will pass to updateSelf if the current user matches the given experimenter.

Arguments:
experimenter the Experimenter to update.
updateGroup_async(_cb, group, current=None)

Updates an experimenter group if admin or owner of group. Only string fields on the object are taken into account. The root, system and guest groups may not be renamed, nor may the user’s current group.

Arguments:
group the ExperimenterGroup to update.
updateSelf_async(_cb, experimenter, current=None)

Allows a user to update his/her own information. This is limited to the fields on Experimenter, all other fields (groups, etc.) are ignored. The experimenter argument need not have the proper id nor the proper omeName (which is immutable). To change the users default group (which is the only other customizable option), use setDefaultGroup

Arguments:
experimenter A data transfer object. Only the fields:

firstName, middleName, lastName, email, and institution are checked. Not null.

uploadMyUserPhoto_async(_cb, filename, format, data, current=None)

Uploads a photo for the user which will be displayed on his/her profile. This photo will be saved as an omero.model.OriginalFile object with the given format, and attached to the user’s omero.model.Experimenter object via an omero.model.FileAnnotation with the namespace: openmicroscopy.org/omero/experimenter/photo (NSEXPERIMENTERPHOTO). If such an omero.model.OriginalFile instance already exists, it will be overwritten. If more than one photo is present, the oldest version will be modified (i.e. the highest updateEvent id).

Note: as outlined in ticket 1794 this photo will be placed in the user group and therefore will be visible to everyone on the system.

Arguments:
filename Not null. String name which will be used. format Not null. Format.value string. ‘image/jpeg’
and ‘image/png’ are common values.
data Not null. Data from the image. This will be

written to disk. Returns:

the id of the overwritten or newly created user

photo OriginalFile object.

class omero.api.IAdminPrx

Bases: omero.api.ServiceInterfacePrx

Returns true if the currently logged in user can modify the given omero.model.IObject. This uses the same logic that would be applied during a Hibernate flush to the database.

addGroupOwners(group, owners, _ctx=None)
addGroupOwners_async(_cb, group, owners, _ctx=None)
addGroups(user, groups, _ctx=None)
addGroups_async(_cb, user, groups, _ctx=None)
begin_addGroupOwners(group, owners, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addGroups(user, groups, _response=None, _ex=None, _sent=None, _ctx=None)
begin_canUpdate(obj, _response=None, _ex=None, _sent=None, _ctx=None)
begin_changeExpiredCredentials(name, oldCred, newCred, _response=None, _ex=None, _sent=None, _ctx=None)
begin_changeGroup(obj, omeName, _response=None, _ex=None, _sent=None, _ctx=None)
begin_changeOwner(obj, omeName, _response=None, _ex=None, _sent=None, _ctx=None)
begin_changePassword(newPassword, _response=None, _ex=None, _sent=None, _ctx=None)
begin_changePasswordWithOldPassword(oldPassword, newPassword, _response=None, _ex=None, _sent=None, _ctx=None)
begin_changePermissions(obj, perms, _response=None, _ex=None, _sent=None, _ctx=None)
begin_changeUserPassword(omeName, newPassword, _response=None, _ex=None, _sent=None, _ctx=None)
begin_containedExperimenters(groupId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_containedGroups(experimenterId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createExperimenter(user, defaultGroup, groups, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createExperimenterWithPassword(user, password, defaultGroup, groups, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createGroup(group, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createSystemUser(experimenter, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createUser(experimenter, group, _response=None, _ex=None, _sent=None, _ctx=None)
begin_deleteExperimenter(user, _response=None, _ex=None, _sent=None, _ctx=None)
begin_deleteGroup(group, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getDefaultGroup(experimenterId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getEventContext(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getExperimenter(id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getGroup(id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getLeaderOfGroupIds(exp, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMemberOfGroupIds(exp, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMyUserPhotos(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getSecurityRoles(_response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupExperimenter(name, _response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupExperimenters(_response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupGroup(name, _response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupGroups(_response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupLdapAuthExperimenter(id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupLdapAuthExperimenters(_response=None, _ex=None, _sent=None, _ctx=None)
begin_moveToCommonSpace(objects, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeGroupOwners(group, owners, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeGroups(user, groups, _response=None, _ex=None, _sent=None, _ctx=None)
begin_reportForgottenPassword(name, email, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setDefaultGroup(user, group, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setGroupOwner(group, owner, _response=None, _ex=None, _sent=None, _ctx=None)
begin_synchronizeLoginCache(_response=None, _ex=None, _sent=None, _ctx=None)
begin_unsetGroupOwner(group, owner, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateExperimenter(experimenter, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateExperimenterWithPassword(experimenter, password, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateGroup(group, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateSelf(experimenter, _response=None, _ex=None, _sent=None, _ctx=None)
begin_uploadMyUserPhoto(filename, format, data, _response=None, _ex=None, _sent=None, _ctx=None)
canUpdate(obj, _ctx=None)
canUpdate_async(_cb, obj, _ctx=None)
changeExpiredCredentials(name, oldCred, newCred, _ctx=None)
changeExpiredCredentials_async(_cb, name, oldCred, newCred, _ctx=None)
changeGroup(obj, omeName, _ctx=None)
changeGroup_async(_cb, obj, omeName, _ctx=None)
changeOwner(obj, omeName, _ctx=None)
changeOwner_async(_cb, obj, omeName, _ctx=None)
changePassword(newPassword, _ctx=None)
changePasswordWithOldPassword(oldPassword, newPassword, _ctx=None)
changePasswordWithOldPassword_async(_cb, oldPassword, newPassword, _ctx=None)
changePassword_async(_cb, newPassword, _ctx=None)
changePermissions(obj, perms, _ctx=None)
changePermissions_async(_cb, obj, perms, _ctx=None)
changeUserPassword(omeName, newPassword, _ctx=None)
changeUserPassword_async(_cb, omeName, newPassword, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
containedExperimenters(groupId, _ctx=None)
containedExperimenters_async(_cb, groupId, _ctx=None)
containedGroups(experimenterId, _ctx=None)
containedGroups_async(_cb, experimenterId, _ctx=None)
createExperimenter(user, defaultGroup, groups, _ctx=None)
createExperimenterWithPassword(user, password, defaultGroup, groups, _ctx=None)
createExperimenterWithPassword_async(_cb, user, password, defaultGroup, groups, _ctx=None)
createExperimenter_async(_cb, user, defaultGroup, groups, _ctx=None)
createGroup(group, _ctx=None)
createGroup_async(_cb, group, _ctx=None)
createSystemUser(experimenter, _ctx=None)
createSystemUser_async(_cb, experimenter, _ctx=None)
createUser(experimenter, group, _ctx=None)
createUser_async(_cb, experimenter, group, _ctx=None)
deleteExperimenter(user, _ctx=None)
deleteExperimenter_async(_cb, user, _ctx=None)
deleteGroup(group, _ctx=None)
deleteGroup_async(_cb, group, _ctx=None)
end_addGroupOwners(_r)
end_addGroups(_r)
end_canUpdate(_r)
end_changeExpiredCredentials(_r)
end_changeGroup(_r)
end_changeOwner(_r)
end_changePassword(_r)
end_changePasswordWithOldPassword(_r)
end_changePermissions(_r)
end_changeUserPassword(_r)
end_containedExperimenters(_r)
end_containedGroups(_r)
end_createExperimenter(_r)
end_createExperimenterWithPassword(_r)
end_createGroup(_r)
end_createSystemUser(_r)
end_createUser(_r)
end_deleteExperimenter(_r)
end_deleteGroup(_r)
end_getDefaultGroup(_r)
end_getEventContext(_r)
end_getExperimenter(_r)
end_getGroup(_r)
end_getLeaderOfGroupIds(_r)
end_getMemberOfGroupIds(_r)
end_getMyUserPhotos(_r)
end_getSecurityRoles(_r)
end_lookupExperimenter(_r)
end_lookupExperimenters(_r)
end_lookupGroup(_r)
end_lookupGroups(_r)
end_lookupLdapAuthExperimenter(_r)
end_lookupLdapAuthExperimenters(_r)
end_moveToCommonSpace(_r)
end_removeGroupOwners(_r)
end_removeGroups(_r)
end_reportForgottenPassword(_r)
end_setDefaultGroup(_r)
end_setGroupOwner(_r)
end_synchronizeLoginCache(_r)
end_unsetGroupOwner(_r)
end_updateExperimenter(_r)
end_updateExperimenterWithPassword(_r)
end_updateGroup(_r)
end_updateSelf(_r)
end_uploadMyUserPhoto(_r)
getDefaultGroup(experimenterId, _ctx=None)
getDefaultGroup_async(_cb, experimenterId, _ctx=None)
getEventContext(_ctx=None)
getEventContext_async(_cb, _ctx=None)
getExperimenter(id, _ctx=None)
getExperimenter_async(_cb, id, _ctx=None)
getGroup(id, _ctx=None)
getGroup_async(_cb, id, _ctx=None)
getLeaderOfGroupIds(exp, _ctx=None)
getLeaderOfGroupIds_async(_cb, exp, _ctx=None)
getMemberOfGroupIds(exp, _ctx=None)
getMemberOfGroupIds_async(_cb, exp, _ctx=None)
getMyUserPhotos(_ctx=None)
getMyUserPhotos_async(_cb, _ctx=None)
getSecurityRoles(_ctx=None)
getSecurityRoles_async(_cb, _ctx=None)
lookupExperimenter(name, _ctx=None)
lookupExperimenter_async(_cb, name, _ctx=None)
lookupExperimenters(_ctx=None)
lookupExperimenters_async(_cb, _ctx=None)
lookupGroup(name, _ctx=None)
lookupGroup_async(_cb, name, _ctx=None)
lookupGroups(_ctx=None)
lookupGroups_async(_cb, _ctx=None)
lookupLdapAuthExperimenter(id, _ctx=None)
lookupLdapAuthExperimenter_async(_cb, id, _ctx=None)
lookupLdapAuthExperimenters(_ctx=None)
lookupLdapAuthExperimenters_async(_cb, _ctx=None)
moveToCommonSpace(objects, _ctx=None)
moveToCommonSpace_async(_cb, objects, _ctx=None)
removeGroupOwners(group, owners, _ctx=None)
removeGroupOwners_async(_cb, group, owners, _ctx=None)
removeGroups(user, groups, _ctx=None)
removeGroups_async(_cb, user, groups, _ctx=None)
reportForgottenPassword(name, email, _ctx=None)
reportForgottenPassword_async(_cb, name, email, _ctx=None)
setDefaultGroup(user, group, _ctx=None)
setDefaultGroup_async(_cb, user, group, _ctx=None)
setGroupOwner(group, owner, _ctx=None)
setGroupOwner_async(_cb, group, owner, _ctx=None)
synchronizeLoginCache(_ctx=None)
synchronizeLoginCache_async(_cb, _ctx=None)
static uncheckedCast(proxy, facet=None)
unsetGroupOwner(group, owner, _ctx=None)
unsetGroupOwner_async(_cb, group, owner, _ctx=None)
updateExperimenter(experimenter, _ctx=None)
updateExperimenterWithPassword(experimenter, password, _ctx=None)
updateExperimenterWithPassword_async(_cb, experimenter, password, _ctx=None)
updateExperimenter_async(_cb, experimenter, _ctx=None)
updateGroup(group, _ctx=None)
updateGroup_async(_cb, group, _ctx=None)
updateSelf(experimenter, _ctx=None)
updateSelf_async(_cb, experimenter, _ctx=None)
uploadMyUserPhoto(filename, format, data, _ctx=None)
uploadMyUserPhoto_async(_cb, filename, format, data, _ctx=None)
class omero.api.IConfig

Bases: omero.api.ServiceInterface

Access to server configuration. These methods provide access to the state and configuration of the server and its components (e.g. the database). However, it should not be assumed that two subsequent calls to a proxy for this service will go to the same server due to clustering.

Not all possible server configuration is available through this API. Some values (such as DB connection info, ports, etc.) must naturally be set before this service is accessible.

Manages synchronization of the various configuration sources internally. It is therefore important that as far as possible all configuration changes take place via this interface and not, for example, directly via java.util.prefs.Preferences.

Also used as the main developer example for developing (stateless) ome.api interfaces. See source code documentation for more.

_ice_type = <IcePy.TypeInfo object at 0x3dbbb58>
_op_getClientConfigDefaults = <IcePy.Operation object at 0x1247d678>
_op_getClientConfigValues = <IcePy.Operation object at 0x1247d660>
_op_getConfigDefaults = <IcePy.Operation object at 0x1247d648>
_op_getConfigValue = <IcePy.Operation object at 0x1247d618>
_op_getConfigValues = <IcePy.Operation object at 0x1247d630>
_op_getDatabaseTime = <IcePy.Operation object at 0x1247d6d8>
_op_getDatabaseUuid = <IcePy.Operation object at 0x1247d6c0>
_op_getServerTime = <IcePy.Operation object at 0x1247d6f0>
_op_getVersion = <IcePy.Operation object at 0x1247d600>
_op_setConfigValue = <IcePy.Operation object at 0x1247d690>
_op_setConfigValueIfEquals = <IcePy.Operation object at 0x1247d6a8>
getClientConfigDefaults_async(_cb, current=None)

Reads the etc/omero.properties file and returns all the key/value pairs that are found there which match the prefix omero.client.

Returns:
a map from the found keys to the linked values.
getClientConfigValues_async(_cb, current=None)

Retrieves configuration values like getConfigValues but only those with the prefix omero.client.

Returns:
a map from the found keys to the linked values.
getConfigDefaults_async(_cb, current=None)

Reads the etc/omero.properties file and returns all the key/value pairs that are found there. Since this file is not to be edited its assumed that these values are in the public domain and so there’s no need to protect them.

Returns:
a map from the found keys to the linked values.
getConfigValue_async(_cb, key, current=None)

Retrieves a configuration value from the backend store. Permissions applied to the configuration value may cause a SecurityViolation to be thrown.

Arguments:
key The non-null name of the desired configuration

value Returns:

The string value linked to this key, possibly null

if not set. Exceptions:

ApiUsageException if the key is null or invalid. SecurityViolation if the value for the key is not

readable.

getConfigValues_async(_cb, keyRegex, current=None)

Retrieves configuration values from the backend store which match the given regex. Any configuration value which would throw an exception on being loaded is omitted.

Arguments:
keyRegex The non-null regex of the desired

configuration values Returns:

a map from the found keys to the linked values.
getDatabaseTime_async(_cb, current=None)

Checks the database for its time using a SELECT statement.

Returns:
Non-null RTime representation of the

database time. Exceptions:

InternalException though any call can throw an

InternalException it is more likely that this can occur while contacting the DB. An exception here most likely means (A) a temporary issue with the DB or (B) a SQL dialect issue which must be corrected by the Omero team.

getDatabaseUuid_async(_cb, current=None)

Provides the UUID for this OMERO (database) instance. To make imports and exports function properly, only one physical database should be active with a given instance UUID. All other copies of the database with that UUID are invalid as soon as one modification is made.

This value is stored in the configuration table under the key omero.db.uuid.

Returns:
String not null.
getServerTime_async(_cb, current=None)

Checks the current server for its time. This value may be variant depending on whether the service is clustered or not.

Returns:
Non-null RTime representation of the

server’s own time.

getVersion_async(_cb, current=None)

Provides the release version. OMERO-internal values will be in the form Major.minor.patch, starting with the value 4.0.0 for the 4.0 release, Spring 2009.

Customized values should begin with a alphabetic sequence followed by a hyphen: ACME-0.0.1 and any build information should follow the patch number also with a hyphen: 4.0.0-RC1. These values will be removed by getVersion

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
setConfigValueIfEquals_async(_cb, key, value, test, current=None)

Calls setConfigValue if and only if the configuration property is currently equal to the test argument. If the test is null or empty, then the configuration property will be set only if missing.

Arguments:
key value
Exceptions:
ApiUsageException SecurityViolation
setConfigValue_async(_cb, key, value, current=None)

Sets a configuration value in the backend store. Permissions applied to the configuration value may cause a SecurityViolation to be thrown. If the value is null or empty, then the configuration will be removed in all writable configuration sources. If the configuration is set in a non-modifiable source (e.g. in a property file on the classpath), then a subsequent call to getConfigValue will return that value.

Arguments:
key The non-null name of the desired configuration
value
value The string value to assign to the given key.
Exceptions:
ApiUsageException if the key is null or invalid. SecurityViolation if the value is not writable.
class omero.api.IConfigPrx

Bases: omero.api.ServiceInterfacePrx

Provides the release version. OMERO-internal values will be in the form Major.minor.patch, starting with the value 4.0.0 for the 4.0 release, Spring 2009.

Customized values should begin with a alphabetic sequence followed by a hyphen: ACME-0.0.1 and any build information should follow the patch number also with a hyphen: 4.0.0-RC1. These values will be removed by getVersion

begin_getClientConfigDefaults(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getClientConfigValues(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getConfigDefaults(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getConfigValue(key, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getConfigValues(keyRegex, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getDatabaseTime(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getDatabaseUuid(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getServerTime(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getVersion(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setConfigValue(key, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setConfigValueIfEquals(key, value, test, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_getClientConfigDefaults(_r)
end_getClientConfigValues(_r)
end_getConfigDefaults(_r)
end_getConfigValue(_r)
end_getConfigValues(_r)
end_getDatabaseTime(_r)
end_getDatabaseUuid(_r)
end_getServerTime(_r)
end_getVersion(_r)
end_setConfigValue(_r)
end_setConfigValueIfEquals(_r)
getClientConfigDefaults(_ctx=None)
getClientConfigDefaults_async(_cb, _ctx=None)
getClientConfigValues(_ctx=None)
getClientConfigValues_async(_cb, _ctx=None)
getConfigDefaults(_ctx=None)
getConfigDefaults_async(_cb, _ctx=None)
getConfigValue(key, _ctx=None)
getConfigValue_async(_cb, key, _ctx=None)
getConfigValues(keyRegex, _ctx=None)
getConfigValues_async(_cb, keyRegex, _ctx=None)
getDatabaseTime(_ctx=None)
getDatabaseTime_async(_cb, _ctx=None)
getDatabaseUuid(_ctx=None)
getDatabaseUuid_async(_cb, _ctx=None)
getServerTime(_ctx=None)
getServerTime_async(_cb, _ctx=None)
getVersion(_ctx=None)
getVersion_async(_cb, _ctx=None)
setConfigValue(key, value, _ctx=None)
setConfigValueIfEquals(key, value, test, _ctx=None)
setConfigValueIfEquals_async(_cb, key, value, test, _ctx=None)
setConfigValue_async(_cb, key, value, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IContainer

Bases: omero.api.ServiceInterface

Provides methods for dealing with the core Pojos of OME. Included are: Projects, Datasets, Images.

Read API

The names of the methods correlate to how the function operates:

load: start at container objects and work down toward the leaves, returning hierarchy (Project-&gt;Dataset-&gt;Image find: start at leaf objects and work up to containers, returning hierarchy get: retrieves only leaves in the hierarchy (currently only Images)

Options Mechanism

The options are used to add some constraints to the generic method e.g. load hierarchy trees images for a given user. This mechanism should give us enough flexibility to extend the API if necessary, e.g. in some cases we might want to retrieve the images with or without annotations

Most methods take such an options map which is built on the client-side using the Parameters class. The currently supported options are:

annotator(Integer): If key exists but value null, annotations are retrieved for all objects in the hierarchy where they exist; if a valid experimenterID, annotations are only retrieved for that user. May not be used be all methods. Default: all annotations leaves(Boolean): if FALSE omits images from the returned hierarchy. May not be used by all methods. Default: true experimenter(Integer): enables filtering on a per-experimenter basis. This option has a method-specific (and possibly context-specific) meaning. Please see the individual methods. group(Integer): enables filtering on a per-group basis. The experimenter value is ignored if present and instead a similar filtering is done using all experimenters in the given group.

Write API

As outlined in TODO, the semantics of the Omero write API are based on three rules:

IObject-valued fields for which isLoaded() returns false are assumed filtered Collection-valued fields that are null are assumed filtered Collection-valued fields for which getDetails().isFiltered(String collectionName) returns true are assumed filtered. TODO: should we accept isFiltered for all fields?

In each of these cases, the server will reload that given field before attempting to save the graph.

For all write calls, the options map (see below) must contain the userId and the userGroupId for the newly created objects. TODO umask.

_ice_type = <IcePy.TypeInfo object at 0x3dbbb88>
_op_createDataObject = <IcePy.Operation object at 0x1247d7c8>
_op_createDataObjects = <IcePy.Operation object at 0x1247d7e0>
_op_findContainerHierarchies = <IcePy.Operation object at 0x1247d720>
_op_getCollectionCount = <IcePy.Operation object at 0x1247d798>
_op_getImages = <IcePy.Operation object at 0x1247d738>
_op_getImagesByOptions = <IcePy.Operation object at 0x1247d768>
_op_getImagesBySplitFilesets = <IcePy.Operation object at 0x1247d780>
_op_getUserImages = <IcePy.Operation object at 0x1247d750>
_op_loadContainerHierarchy = <IcePy.Operation object at 0x1247d708>
_op_retrieveCollection = <IcePy.Operation object at 0x1247d7b0>
_op_updateDataObject = <IcePy.Operation object at 0x1247d828>
_op_updateDataObjects = <IcePy.Operation object at 0x1247d840>
createDataObject_async(_cb, obj, options, current=None)

Creates the specified data object.

A placeholder parent object is created if the data object is to be put in a collection.

For example, if the object is a Dataset, we first create a Project as parent then we set the Dataset parent as follows: //pseudo-code TODO Project p = new Project(id,false); dataset.addProject(p);

then for each parent relationship a DataObject omero.model.ILink is created.

Arguments:
obj

IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null.

options Parameters as above.
Returns:
the created object
createDataObjects_async(_cb, dataObjects, options, current=None)

Convenience method to save network calls. Loops over the array of IObjects calling createDataObject.

Arguments:
dataObjects
Array of Omero IObjects
options

Parameters as above.

findContainerHierarchies_async(_cb, rootType, imageIds, options, current=None)

Retrieves hierarchy trees in various hierarchies that contain the specified Images.

This method will look for all the containers containing the specified Images and then for all containers containing those containers and on up the container hierarchy.

This method returns a Set with all root nodes that were found. Every root node is linked to the found objects and so on until the leaf nodes, which are omero.model.Image objects. Note that the type of any root node in the returned set can be the given rootNodeType, any of its containees or an omero.model.Image.

For example, say that you pass in the ids of six Images: i1, i2, i3, i4, i5, i6. If the P/D/I hierarchy in the DB looks like this:

__p1__
/
_d1_ _d2_ d3
/ / |
i1 i2 i3 i4 i5 i6

Then the returned set will contain p1, d3, i5, i6. All objects will be properly linked up.

Finally, this method will only retrieve the nodes that are connected in a tree to the specified leaf image nodes. Back to the previous example, if d1 contained image img500, then the returned object would not contain img500. In a similar way, if p1 contained ds300 and this dataset weren’t linked to any of the i1, i2, i3, i4, i5, i6 images, then ds300 would not be part of the returned tree rooted by p1.

Arguments:
rootType

top-most type which will be searched for Can be omero.model.Project. Not null.

imageIds

Contains the ids of the Images that sit at the bottom of the trees. Not null.

options

Parameters as above. annotator used. experimenter|group may be applied at the top-level only or at each level in the hierarchy, but will not apply to the leaf (Image) level. Returns:

A Set with all root nodes that were

found.

getCollectionCount_async(_cb, type, property, ids, options, current=None)

Counts the number of members in a collection for a given object. For example, if you wanted to retrieve the number of Images contained in a Dataset you would pass TODO.

Arguments:
type

The fully-qualified classname of the object to be tested

property

Name of the property on that class, omitting getters and setters.

ids
Set of Longs, the ids of the objects to test
options

Parameters. Unused. Returns:

A map from id integer to count integer
getImagesByOptions_async(_cb, options, current=None)

Retrieves images by options.

Arguments:
options

Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf(“YYYY-MM-DD hh:mm:ss.ms”). acquisition data is only relevant for images. Returns:

A set of images.
getImagesBySplitFilesets_async(_cb, included, options, current=None)

Given a list of IDs of certain entity types, calculates which filesets are split such that a non-empty proper subset of their images are referenced, directly or indirectly, as being included. The return value lists both the fileset IDs and the image IDs in ascending order, the image ID lists separated by if they were included. Warning: following discussion in trac ticket 11019 the return type may be changed. Arguments:

included the entities included options parameters, presently ignored
Returns:
the partially included filesets
getImages_async(_cb, rootType, rootIds, options, current=None)

Retrieve a user’s (or all users’) images within any given container. For example, all images in project, applying temporal filtering or pagination.

Arguments:
rootType

A Class which will have its hierarchy searched for Images. Not null.

rootIds

A set of ids of type rootNodeType Not null.

options

Parameters as above. No notion of leaves. experimenter|group apply at the Image level. OPTIONS: - startTime and/or endTime should be Timestamp.valueOf(“YYYY-MM-DD hh:mm:ss.ms”);

limit and offset are applied at the Image-level. That is, calling with Dataset.class, limit == 10 and offset == 0 will first perform one query to get an effective set of rootNodeIds, then getImages will be called with an effective rootNodeType of Image.class and the new ids.

acquisition data is only relevant for images. Returns:

A set of images.
getUserImages_async(_cb, options, current=None)

Retrieves a user’s images.

Arguments:
options

Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. Returns:

A set of images.
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()

Convenience method for creating links. Functionality also available from createDataObject

Arguments:
links Array of links to be created. options Parameters as above.
Returns:
the created links
loadContainerHierarchy_async(_cb, rootType, rootIds, options, current=None)

Retrieves hierarchy trees rooted by a given node (unless orphan is specified – See below)

This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of omero.model.Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing omero.model.Dataset objects will point to the same omero.model.Image object. And so on.

Arguments:
rootType

The type of the root node. Can be omero.model.Project, omero.model.Dataset, omero.model.Screen or omero.model.Plate. Cannot be null.

rootIds

The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.

options

Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user’s Projects, or user’s Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a omero.model.Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned. Returns:

a set of hierarchy trees. The requested node as

root and all of its descendants. The type of the returned value will be rootNodeType, unless orphan is specified in which case objects of type rootNodeType and below may be returned.

retrieveCollection_async(_cb, obj, collectionName, options, current=None)

Retrieves a collection with all members initialized (loaded). This is useful when a collection has been nulled in a previous query.

Arguments:
obj Can be unloaded. collectionName

public final static String from the IObject.class

options

Parameters. Unused. Returns:

An initialized collection.

Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren’t deleted, only the Link objects.

Arguments:
links Not null. options Parameters as above.
updateDataObject_async(_cb, obj, options, current=None)

Updates a data object.

To link or unlink objects to the specified object, we should call the methods link or unlink. TODO Or do we use for example dataset.setProjects(set of projects) to add. Tink has to be set as follows dataset->project and project->dataset.

Alternatively, you can make sure that the collection is exactly how it should be in the database. If you can’t guarantee this, it’s best to send all your collections back as null

Arguments:
obj Pojos-based IObject. Supported: Project,
Dataset, Annotation, Group, Experimenter.
options Parameters as above.
Returns:
created data object
updateDataObjects_async(_cb, objs, options, current=None)

Convenience method to save network calls. Loops over the array of IObjects calling updateDataObject.

Arguments:
objs options

Parameters as above. Returns:

created data objects.
class omero.api.IContainerPrx

Bases: omero.api.ServiceInterfacePrx

Retrieves hierarchy trees rooted by a given node (unless orphan is specified – See below)

This method also retrieves the Experimenters linked to the objects in the tree. Similarly, all Images will be linked to their Pixel objects if included.

Note that objects are never duplicated. For example, if an Experimenter owns all the objects in the retrieved tree, then those objects will be linked to the same instance of omero.model.Experimenter. Or if an Image is contained in more than one Dataset in the retrieved tree, then all enclosing omero.model.Dataset objects will point to the same omero.model.Image object. And so on.

Arguments:
rootType

The type of the root node. Can be omero.model.Project, omero.model.Dataset, omero.model.Screen or omero.model.Plate. Cannot be null.

rootIds

The ids of the root nodes. Can be null if an Experimenter is specified in options, otherwise an Exception is thrown to prevent all images in the entire database from being downloaded.

options

Parameters as above. annotator, leaves, orphan, acquisition data used. acquisition data is only relevant for images and taken into account if the images are loaded. If rootNodeIds==null, experimenter|group must be set and filtering will be applied at the Class-level; e.g. to retrieve a user’s Projects, or user’s Datasets. If rootNodeIds!=null, the result will be filtered by the experimenter|group at the Image and intermediate levels if available. Due to the amount of data potentially linked a Screen/Plate, the leaves option is not taken into account when the root node is a omero.model.Screen. orphan implies that objects which are not contained in an object of rootNodeType should also be returned. Returns:

a set of hierarchy trees. The requested node as

root and all of its descendants. The type of the returned value will be rootNodeType, unless orphan is specified in which case objects of type rootNodeType and below may be returned.

begin_createDataObject(obj, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createDataObjects(dataObjects, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findContainerHierarchies(rootType, imageIds, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getCollectionCount(type, property, ids, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getImages(rootType, rootIds, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getImagesByOptions(options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getImagesBySplitFilesets(included, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getUserImages(options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadContainerHierarchy(rootType, rootIds, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_retrieveCollection(obj, collectionName, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateDataObject(obj, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateDataObjects(objs, options, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
createDataObject(obj, options, _ctx=None)
createDataObject_async(_cb, obj, options, _ctx=None)
createDataObjects(dataObjects, options, _ctx=None)
createDataObjects_async(_cb, dataObjects, options, _ctx=None)
end_createDataObject(_r)
end_createDataObjects(_r)
end_findContainerHierarchies(_r)
end_getCollectionCount(_r)
end_getImages(_r)
end_getImagesByOptions(_r)
end_getImagesBySplitFilesets(_r)
end_getUserImages(_r)
end_loadContainerHierarchy(_r)
end_retrieveCollection(_r)
end_updateDataObject(_r)
end_updateDataObjects(_r)
findContainerHierarchies(rootType, imageIds, options, _ctx=None)
findContainerHierarchies_async(_cb, rootType, imageIds, options, _ctx=None)
getCollectionCount(type, property, ids, options, _ctx=None)
getCollectionCount_async(_cb, type, property, ids, options, _ctx=None)
getImages(rootType, rootIds, options, _ctx=None)
getImagesByOptions(options, _ctx=None)
getImagesByOptions_async(_cb, options, _ctx=None)
getImagesBySplitFilesets(included, options, _ctx=None)
getImagesBySplitFilesets_async(_cb, included, options, _ctx=None)
getImages_async(_cb, rootType, rootIds, options, _ctx=None)
getUserImages(options, _ctx=None)
getUserImages_async(_cb, options, _ctx=None)
loadContainerHierarchy(rootType, rootIds, options, _ctx=None)
loadContainerHierarchy_async(_cb, rootType, rootIds, options, _ctx=None)
retrieveCollection(obj, collectionName, options, _ctx=None)
retrieveCollection_async(_cb, obj, collectionName, options, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateDataObject(obj, options, _ctx=None)
updateDataObject_async(_cb, obj, options, _ctx=None)
updateDataObjects(objs, options, _ctx=None)
updateDataObjects_async(_cb, objs, options, _ctx=None)
class omero.api.ILdap

Bases: omero.api.ServiceInterface

Administration interface providing access to admin-only functionality as well as JMX-based server access and selected user functions. Most methods require membership in privileged omero.model.ExperimenterGroup groups.

Methods which return omero.model.Experimenter or omero.model.ExperimenterGroup instances fetch and load all related instances of omero.model.ExperimenterGroup or omero.model.Experimenter, respectively.

_ice_type = <IcePy.TypeInfo object at 0x3dbbbb8>
_op_createUser = <IcePy.Operation object at 0x1247d990>
_op_discover = <IcePy.Operation object at 0x1247d960>
_op_discoverGroups = <IcePy.Operation object at 0x1247d978>
_op_findDN = <IcePy.Operation object at 0x1247d8d0>
_op_findExperimenter = <IcePy.Operation object at 0x1247d900>
_op_findGroup = <IcePy.Operation object at 0x1247d918>
_op_findGroupDN = <IcePy.Operation object at 0x1247d8e8>
_op_getSetting = <IcePy.Operation object at 0x1247d948>
_op_searchAll = <IcePy.Operation object at 0x1247d858>
_op_searchByAttribute = <IcePy.Operation object at 0x1247d888>
_op_searchByAttributes = <IcePy.Operation object at 0x1247d8a0>
_op_searchByDN = <IcePy.Operation object at 0x1247d8b8>
_op_searchDnInGroups = <IcePy.Operation object at 0x1247d870>
_op_setDN = <IcePy.Operation object at 0x1247d930>
createUser_async(_cb, username, current=None)

Creates an omero.model.Experimenter entry in the OMERO DB based on the supplied LDAP username. Arguments:

username
Returns:
created Experimenter or null
discoverGroups_async(_cb, current=None)

Discovers and lists omero.model.ExperimenterGroups which are present in the remote LDAP server and in the local DB but have the ldap property set to false.

Returns:
list of ExperimenterGroups.
discover_async(_cb, current=None)

Discovers and lists omero.model.Experimenters who are present in the remote LDAP server and in the local DB but have the ldap property set to false.

Returns:
list of Experimenters.
findDN_async(_cb, username, current=None)

Searches unique Distinguished Name - string in LDAP for Common Name equals username. Common Name should be unique under the specified base. If list of cn’s contains more then one DN will return exception.

Arguments:
username

Name of the Experimenter equals CommonName. Returns:

a Distinguished Name. Never null.
Exceptions:
ApiUsageException

if more then one ‘cn’ under the specified base.

findExperimenter_async(_cb, username, current=None)

Searches Experimenter by unique Distinguished Name - string in LDAP for Common Name equals username. Common Name should be unique under the specified base. If list of cn’s contains more then one DN will return exception.

Arguments:
username

Name of the Experimenter equals CommonName. Returns:

an Experimenter. Never null.
Exceptions:
ApiUsageException

if more then one ‘cn’ under the specified base.

findGroupDN_async(_cb, groupname, current=None)

Looks up the DN for a group.

Returns:
a Distinguished Name. Never null.
Exceptions:
ApiUsageException

if more then one ‘cn’ under the specified base.

findGroup_async(_cb, groupname, current=None)

Looks up a specific omero.model.ExperimenterGroup in LDAP using the provided group name. It is expected that the group name will be unique in the searched LDAP base tree. If more than one group with the specified name has been found, an exception will be thrown.

Arguments:
groupname
Returns:
an ExperimenterGroup. Never null.
Exceptions:
ApiUsageException

if more then one group name matches under the specified base.

getSetting_async(_cb, current=None)

Gets config value from properties.

Returns:
boolean
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
searchAll_async(_cb, current=None)

Searches all omero.model.Experimenter list on LDAP for attribute objectClass = person.

Returns:
all Experimenter list.
searchByAttribute_async(_cb, dn, attribute, value, current=None)

Searches all omero.model.Experimenter in LDAP for specified attribute.

Arguments:
dn Distinguished Name base for search. Never
null.
attribute Name of attribute. Never null or empty. value Expected value of attribute. Never null or

empty. Returns:

List of Experimenters.
searchByAttributes_async(_cb, dn, attributes, values, current=None)

Searches all omero.model.Experimenter in LDAP for specified attributes. Attributes should be specified in StringSet and their values should be set in equivalent StringSet.

Arguments:
dn Distinguished Name base for search. Never
null.
attributes Name of attribute. Never null or empty. values Expected value of attribute. Never null

or empty. Returns:

List of Experimenters.
searchByDN_async(_cb, userdn, current=None)

Searches one omero.model.Experimenter in LDAP for specified Distinguished Name.

Arguments:
userdn

unique Distinguished Name - string of user, Never null or empty. Returns:

an Experimenter.
searchDnInGroups_async(_cb, attr, value, current=None)

Searches Distinguished Name in groups.

Arguments:
attr Name of member attribute. Never null or empty. value User’s DN which should be set on value for

attribute. Never null or empty. Returns:

List of groups which contains DN.
setDN_async(_cb, experimenterID, dn, current=None)
class omero.api.ILdapPrx

Bases: omero.api.ServiceInterfacePrx

Searches all omero.model.Experimenter list on LDAP for attribute objectClass = person.

Returns:
all Experimenter list.
begin_createUser(username, _response=None, _ex=None, _sent=None, _ctx=None)
begin_discover(_response=None, _ex=None, _sent=None, _ctx=None)
begin_discoverGroups(_response=None, _ex=None, _sent=None, _ctx=None)
begin_findDN(username, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findExperimenter(username, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findGroup(groupname, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findGroupDN(groupname, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getSetting(_response=None, _ex=None, _sent=None, _ctx=None)
begin_searchAll(_response=None, _ex=None, _sent=None, _ctx=None)
begin_searchByAttribute(dn, attribute, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_searchByAttributes(dn, attributes, values, _response=None, _ex=None, _sent=None, _ctx=None)
begin_searchByDN(userdn, _response=None, _ex=None, _sent=None, _ctx=None)
begin_searchDnInGroups(attr, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setDN(experimenterID, dn, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
createUser(username, _ctx=None)
createUser_async(_cb, username, _ctx=None)
discover(_ctx=None)
discoverGroups(_ctx=None)
discoverGroups_async(_cb, _ctx=None)
discover_async(_cb, _ctx=None)
end_createUser(_r)
end_discover(_r)
end_discoverGroups(_r)
end_findDN(_r)
end_findExperimenter(_r)
end_findGroup(_r)
end_findGroupDN(_r)
end_getSetting(_r)
end_searchAll(_r)
end_searchByAttribute(_r)
end_searchByAttributes(_r)
end_searchByDN(_r)
end_searchDnInGroups(_r)
end_setDN(_r)
findDN(username, _ctx=None)
findDN_async(_cb, username, _ctx=None)
findExperimenter(username, _ctx=None)
findExperimenter_async(_cb, username, _ctx=None)
findGroup(groupname, _ctx=None)
findGroupDN(groupname, _ctx=None)
findGroupDN_async(_cb, groupname, _ctx=None)
findGroup_async(_cb, groupname, _ctx=None)
getSetting(_ctx=None)
getSetting_async(_cb, _ctx=None)
searchAll(_ctx=None)
searchAll_async(_cb, _ctx=None)
searchByAttribute(dn, attribute, value, _ctx=None)
searchByAttribute_async(_cb, dn, attribute, value, _ctx=None)
searchByAttributes(dn, attributes, values, _ctx=None)
searchByAttributes_async(_cb, dn, attributes, values, _ctx=None)
searchByDN(userdn, _ctx=None)
searchByDN_async(_cb, userdn, _ctx=None)
searchDnInGroups(attr, value, _ctx=None)
searchDnInGroups_async(_cb, attr, value, _ctx=None)
setDN(experimenterID, dn, _ctx=None)
setDN_async(_cb, experimenterID, dn, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IMetadata

Bases: omero.api.ServiceInterface

Provides method to interact with acquisition metadata and annotations.

_ice_type = <IcePy.TypeInfo object at 0x3dbbbe8>
_op_countAnnotationsUsedNotOwned = <IcePy.Operation object at 0x1247da98>
_op_countSpecifiedAnnotations = <IcePy.Operation object at 0x1247da38>
_op_getTaggedObjectsCount = <IcePy.Operation object at 0x1247da20>
_op_loadAnnotation = <IcePy.Operation object at 0x1247da50>
_op_loadAnnotations = <IcePy.Operation object at 0x1247d9c0>
_op_loadAnnotationsUsedNotOwned = <IcePy.Operation object at 0x1247da80>
_op_loadChannelAcquisitionData = <IcePy.Operation object at 0x1247d9a8>
_op_loadInstrument = <IcePy.Operation object at 0x1247da68>
_op_loadLogFiles = <IcePy.Operation object at 0x1247dac8>
_op_loadSpecifiedAnnotations = <IcePy.Operation object at 0x1247d9d8>
_op_loadSpecifiedAnnotationsLinkedTo = <IcePy.Operation object at 0x1247dab0>
_op_loadTagContent = <IcePy.Operation object at 0x1247d9f0>
_op_loadTagSets = <IcePy.Operation object at 0x1247da08>
countAnnotationsUsedNotOwned_async(_cb, annotationType, userID, current=None)

Counts the number of annotation of a given type used by the specified user but not owned by the user.

Arguments:
annotationType The type of annotations to load. userID The identifier of the user.
Returns:
See above.
countSpecifiedAnnotations_async(_cb, annotationType, include, exclude, options, current=None)

Counts the number of annotation of a given type.

Arguments:
annotationType The type of annotations to load. include The collection of name space, one of the
constants defined by this class.
exclude The collection of name space, one of the
constants defined by this class.
options The POJO options.
Returns:
See above.
getTaggedObjectsCount_async(_cb, ids, options, current=None)

Returns a map whose key is a tag id and the value the number of Projects, Datasets, and Images linked to that tag.

Arguments:
ids The collection of ids. options The POJO options.
Returns:
See above.
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
loadAnnotation_async(_cb, annotationIds, current=None)

Loads the specified annotations.

Arguments:
annotationIds The collection of annotation ids.
Returns:
See above.
loadAnnotationsUsedNotOwned_async(_cb, annotationType, userID, current=None)

Loads the annotations of a given type used by the specified user but not owned by the user.

Arguments:
annotationType The type of annotations to load. userID The identifier of the user.
Returns:
See above.
loadAnnotations_async(_cb, rootType, rootIds, annotationTypes, annotatorIds, options, current=None)

Loads all the annotations of given types, that have been attached to the specified rootNodes for the specified annotatorIds. If no types specified, all annotations will be loaded. This method looks for the annotations that have been attached to each of the specified objects. It then maps each rootId onto the set of annotations that were found for that node. If no annotations were found for that node, then the entry will be null. Otherwise it will be a Map containing omero.model.Annotation objects.

Arguments:
rootType

The type of the nodes the annotations are linked to. Mustn’t be null.

rootIds

Ids of the objects of type rootType. Mustn’t be null.

annotationType

The types of annotation to retrieve. If null all annotations will be loaded. String of the type omero.model.annotations.*.

annotatorIds

Ids of the users for whom annotations should be retrieved. If null, all annotations returned.

options
Returns:
A map whose key is rootId and value the

Map of all annotations for that node or null.

loadChannelAcquisitionData_async(_cb, ids, current=None)

Loads the logical channels and the acquisition metadata related to them.

Arguments:
ids The collection of logical channel’s ids.

Mustn’t be null. Returns:

The collection of loaded logical channels.
loadInstrument_async(_cb, id, current=None)

Loads the instrument and its components i.e. detectors, objectives, etc.

Arguments:
id The id of the instrument to load.
Returns:
See above
loadLogFiles_async(_cb, rootType, ids, current=None)

Finds the original file IDs for the import logs corresponding to the given Image or Fileset IDs.

Arguments:
rootNodeType

the root node type, may be omero.model.Image or omero.model.Fileset

ids

the IDs of the entities for which the import log original file IDs are required Returns:

the original file IDs of the import logs
loadSpecifiedAnnotationsLinkedTo_async(_cb, annotationType, include, exclude, rootNodeType, rootNodeIds, options, current=None)

Loads the annotations of a given type linked to the specified objects. It is possible to filter the annotations by including or excluding name spaces set on the annotations.

This method looks for the annotations that have been attached to each of the specified objects. It then maps each rootNodeId onto the set of annotations that were found for that node. If no annotations were found for that node, the map will not contain an entry for that node. Otherwise it will be a Set containing omero.model.Annotation objects. The rootNodeType supported are: Project, Dataset, Image, Pixels, Screen, Plate, PlateAcquisition, Well, Fileset.

Arguments:
annotationType The type of annotations to load. include
Include the annotations with the specified name spaces.
exclude
Exclude the annotations with the specified name spaces.
rootNodeType
The type of objects the annotations are linked to.
rootNodeIds The identifiers of the objects. options The POJO options.
Returns:
A collection of found annotations.
loadSpecifiedAnnotations_async(_cb, annotationType, include, exclude, options, current=None)

Loads all the annotations of a given type. It is possible to filter the annotations by including or excluding name spaces set on the annotations.

Arguments:
annotationType The type of annotations to load. include
Include the annotations with the specified name spaces.
exclude
Exclude the annotations with the specified name spaces.
options The POJO options.
Returns:
A collection of found annotations.
loadTagContent_async(_cb, ids, options, current=None)

Loads the TagSet if the id is specified otherwise loads all the TagSet.

Arguments:
ids The id of the tag to load or -1.
Returns:
Map whose key is a Tag/TagSet and the

value either a Map or a list of related DataObject.

loadTagSets_async(_cb, options, current=None)

Loads all the TagSets. Returns a collection of AnnotationAnnotatioLink objects and, if the orphan parameters is true, the TagAnnotation object. Note that the difference between a TagSet and a Tag is made using the NS_INSIGHT_TAG_SET namespace.

Arguments:
options The POJO options.
Returns:
See above.
class omero.api.IMetadataPrx

Bases: omero.api.ServiceInterfacePrx

Loads the logical channels and the acquisition metadata related to them.

Arguments:
ids The collection of logical channel’s ids.

Mustn’t be null. Returns:

The collection of loaded logical channels.
begin_countAnnotationsUsedNotOwned(annotationType, userID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_countSpecifiedAnnotations(annotationType, include, exclude, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTaggedObjectsCount(ids, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadAnnotation(annotationIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadAnnotations(rootType, rootIds, annotationTypes, annotatorIds, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadAnnotationsUsedNotOwned(annotationType, userID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadChannelAcquisitionData(ids, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadInstrument(id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadLogFiles(rootType, ids, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadSpecifiedAnnotations(annotationType, include, exclude, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadSpecifiedAnnotationsLinkedTo(annotationType, include, exclude, rootNodeType, rootNodeIds, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadTagContent(ids, options, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadTagSets(options, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
countAnnotationsUsedNotOwned(annotationType, userID, _ctx=None)
countAnnotationsUsedNotOwned_async(_cb, annotationType, userID, _ctx=None)
countSpecifiedAnnotations(annotationType, include, exclude, options, _ctx=None)
countSpecifiedAnnotations_async(_cb, annotationType, include, exclude, options, _ctx=None)
end_countAnnotationsUsedNotOwned(_r)
end_countSpecifiedAnnotations(_r)
end_getTaggedObjectsCount(_r)
end_loadAnnotation(_r)
end_loadAnnotations(_r)
end_loadAnnotationsUsedNotOwned(_r)
end_loadChannelAcquisitionData(_r)
end_loadInstrument(_r)
end_loadLogFiles(_r)
end_loadSpecifiedAnnotations(_r)
end_loadSpecifiedAnnotationsLinkedTo(_r)
end_loadTagContent(_r)
end_loadTagSets(_r)
getTaggedObjectsCount(ids, options, _ctx=None)
getTaggedObjectsCount_async(_cb, ids, options, _ctx=None)
loadAnnotation(annotationIds, _ctx=None)
loadAnnotation_async(_cb, annotationIds, _ctx=None)
loadAnnotations(rootType, rootIds, annotationTypes, annotatorIds, options, _ctx=None)
loadAnnotationsUsedNotOwned(annotationType, userID, _ctx=None)
loadAnnotationsUsedNotOwned_async(_cb, annotationType, userID, _ctx=None)
loadAnnotations_async(_cb, rootType, rootIds, annotationTypes, annotatorIds, options, _ctx=None)
loadChannelAcquisitionData(ids, _ctx=None)
loadChannelAcquisitionData_async(_cb, ids, _ctx=None)
loadInstrument(id, _ctx=None)
loadInstrument_async(_cb, id, _ctx=None)
loadLogFiles(rootType, ids, _ctx=None)
loadLogFiles_async(_cb, rootType, ids, _ctx=None)
loadSpecifiedAnnotations(annotationType, include, exclude, options, _ctx=None)
loadSpecifiedAnnotationsLinkedTo(annotationType, include, exclude, rootNodeType, rootNodeIds, options, _ctx=None)
loadSpecifiedAnnotationsLinkedTo_async(_cb, annotationType, include, exclude, rootNodeType, rootNodeIds, options, _ctx=None)
loadSpecifiedAnnotations_async(_cb, annotationType, include, exclude, options, _ctx=None)
loadTagContent(ids, options, _ctx=None)
loadTagContent_async(_cb, ids, options, _ctx=None)
loadTagSets(options, _ctx=None)
loadTagSets_async(_cb, options, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IPixels

Bases: omero.api.ServiceInterface

Metadata gateway for the omero.api.RenderingEngine and clients. This service provides all DB access that the rendering engine needs as well as Pixels services to a client. It also allows the rendering engine to also be run external to the server (e.g. client-side).

_ice_type = <IcePy.TypeInfo object at 0x3dbbc18>
_op_copyAndResizeImage = <IcePy.Operation object at 0x1247dbd0>
_op_copyAndResizePixels = <IcePy.Operation object at 0x1247dbb8>
_op_createImage = <IcePy.Operation object at 0x1247dbe8>
_op_getAllEnumerations = <IcePy.Operation object at 0x1247dba0>
_op_getBitDepth = <IcePy.Operation object at 0x1247db70>
_op_getEnumeration = <IcePy.Operation object at 0x1247db88>
_op_loadRndSettings = <IcePy.Operation object at 0x1247db40>
_op_retrieveAllRndSettings = <IcePy.Operation object at 0x1247db28>
_op_retrievePixDescription = <IcePy.Operation object at 0x1247dae0>
_op_retrieveRndSettings = <IcePy.Operation object at 0x1247daf8>
_op_retrieveRndSettingsFor = <IcePy.Operation object at 0x1247db10>
_op_saveRndSettings = <IcePy.Operation object at 0x1247db58>
_op_setChannelGlobalMinMax = <IcePy.Operation object at 0x1247dc00>
copyAndResizeImage_async(_cb, imageId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, current=None)

Copies the metadata, and only the metadata linked to a Image object into a new Image object of equal or differing size across one or many of its three physical dimensions or temporal dimension. It is beyond the scope of this method to handle updates or changes to the raw pixel data available through omero.api.RawPixelsStore or to add and link omero.model.PlaneInfo and/or other Pixels set specific metadata. It is also assumed that the caller wishes the pixels dimensions and omero.model.PixelsType to remain the same; changing these is outside the scope of this method. NOTE: As omero.model.Channel objects are only able to apply to a single set of Pixels any annotations or linkage to these objects will be lost.

Arguments:
imageId The source Image id. sizeX The new size across the X-axis.

null if the copy should maintain the same size.

sizeY The new size across the Y-axis.

null if the copy should maintain the same size.

sizeZ The new size across the Z-axis.

null if the copy should maintain the same size.

sizeT The new number of timepoints.

null if the copy should maintain the same number.

channelList The channels that should be copied into
the new Pixels set.
methodology The name of the new Image. copyStats Whether or not to copy the

omero.model.StatsInfo for each channel. Returns:

Id of the new Pixels object on success or

null on failure. Exceptions:

ValidationException If the X, Y, Z, T or

channelList dimensions are out of bounds or the Pixels object corresponding to pixelsId is unlocatable.

copyAndResizePixels_async(_cb, pixelsId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, current=None)

Copies the metadata, and only the metadata linked to a Pixels object into a new Pixels object of equal or differing size across one or many of its three physical dimensions or temporal dimension. It is beyond the scope of this method to handle updates or changes to the raw pixel data available through omero.api.RawPixelsStore or to add and link omero.model.PlaneInfo and/or other Pixels set specific metadata. It is also assumed that the caller wishes the pixels dimensions and omero.model.PixelsType to remain the same; changing these is outside the scope of this method. NOTE: As omero.model.Channel objects are only able to apply to a single set of Pixels any annotations or linkage to these objects will be lost.

Arguments:
pixelsId The source Pixels set id. sizeX The new size across the X-axis.

null if the copy should maintain the same size.

sizeY The new size across the Y-axis.

null if the copy should maintain the same size.

sizeZ The new size across the Z-axis.

null if the copy should maintain the same size.

sizeT The new number of timepoints.

null if the copy should maintain the same number.

channelList The channels that should be copied into
the new Pixels set.
methodology An optional string signifying the

methodology that will be used to produce this new Pixels set.

copyStats Whether or not to copy the

omero.model.StatsInfo for each channel. Returns:

Id of the new Pixels object on success or

null on failure. Exceptions:

ValidationException If the X, Y, Z, T or

channelList dimensions are out of bounds or the Pixels object corresponding to pixelsId is unlocatable.

createImage_async(_cb, sizeX, sizeY, sizeZ, sizeT, channelList, pixelsType, name, description, current=None)

Creates the metadata, and only the metadata linked to an Image object. It is beyond the scope of this method to handle updates or changes to the raw pixel data available through omero.api.RawPixelsStore or to add and link omero.model.PlaneInfo or omero.model.StatsInfo objects and/or other Pixels set specific metadata. It is also up to the caller to update the pixels dimensions.

Arguments:
sizeX The new size across the X-axis. sizeY The new size across the Y-axis. sizeZ The new size across the Z-axis. sizeT The new number of timepoints. pixelsType The pixelsType name The name of the new Image. description The description of the new Image.
Returns:
Id of the new Image object on success or

null on failure. Exceptions:

ValidationException If the channel list is

null or of size == 0.

getAllEnumerations_async(_cb, enumClass, current=None)

Retrieves the exhaustive list of enumerations for a given enumeration class.

Arguments:
enumClass Enumeration class.
Returns:
List of all enumeration objects for the

enumClass.

getBitDepth_async(_cb, type, current=None)

Bit depth for a given pixel type.

Arguments:
type Pixels type.
Returns:
Bit depth in bits.
getEnumeration_async(_cb, enumClass, value, current=None)

Retrieves a particular enumeration for a given enumeration class.

Arguments:
enumClass Enumeration class. value Enumeration string value.
Returns:
Enumeration object.
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
loadRndSettings_async(_cb, renderingSettingsId, current=None)

Loads a specific set of rendering settings. The following objects are pre-linked:

renderingDef.quantization renderingDef.model renderingDef.waveRendering renderingDef.waveRendering.color renderingDef.waveRendering.family renderingDef.spatialDomainEnhancement

Arguments:
renderingSettingsId Rendering definition id.
Exceptions:
ValidationException If no RenderingDef

matches the ID renderingDefId. Returns:

Rendering definition.
retrieveAllRndSettings_async(_cb, pixId, userId, current=None)

Retrieves all the rendering settings for a given pixels set and the passed user. The following objects are pre-linked:

renderingDef.quantization renderingDef.model renderingDef.waveRendering renderingDef.waveRendering.color renderingDef.waveRendering.family renderingDef.spatialDomainEnhancement

Arguments:
pixId Pixels id. userId The id of the user.
Returns:
Rendering definition.
retrievePixDescription_async(_cb, pixId, current=None)

Retrieves the pixels metadata. The following objects are pre-linked:

pixels.pixelsType pixels.pixelsDimensions pixels.channels pixels.channnels.statsInfo pixels.channnels.colorComponent pixels.channnels.logicalChannel pixels.channnels.logicalChannel.photometricInterpretation

Arguments:
pixId Pixels id.
Returns:
Pixels object which matches id.
retrieveRndSettingsFor_async(_cb, pixId, userId, current=None)

Retrieves the rendering settings for a given pixels set and the passed user. The following objects are pre-linked:

renderingDef.quantization renderingDef.model renderingDef.waveRendering renderingDef.waveRendering.color renderingDef.waveRendering.family renderingDef.spatialDomainEnhancement

Arguments:
pixId Pixels id. userID The id of the user.
Returns:
Rendering definition.
retrieveRndSettings_async(_cb, pixId, current=None)

Retrieves the rendering settings for a given pixels set and the currently logged in user. If the current user has no omero.model.RenderingDef, and the user is an administrator, then a omero.model.RenderingDef may be returned for the owner of the omero.model.Pixels. This matches the behavior of the Rendering service.

The following objects will be pre-linked:

renderingDef.quantization renderingDef.model renderingDef.waveRendering renderingDef.waveRendering.color renderingDef.waveRendering.family renderingDef.spatialDomainEnhancement

Arguments:
pixId Pixels id.
Returns:
Rendering definition.
saveRndSettings_async(_cb, rndSettings, current=None)

Saves the specified rendering settings.

Arguments:
rndSettings Rendering settings.
setChannelGlobalMinMax_async(_cb, pixelsId, channelIndex, min, max, current=None)

Sets the channel global (all 2D optical sections corresponding to a particular channel) minimum and maximum for a Pixels set.

Arguments:
pixelsId The source Pixels set id. channelIndex The channel index within the Pixels set. min The channel global minimum. max The channel global maximum.
class omero.api.IPixelsPrx

Bases: omero.api.ServiceInterfacePrx

Retrieves the pixels metadata. The following objects are pre-linked:

pixels.pixelsType pixels.pixelsDimensions pixels.channels pixels.channnels.statsInfo pixels.channnels.colorComponent pixels.channnels.logicalChannel pixels.channnels.logicalChannel.photometricInterpretation

Arguments:
pixId Pixels id.
Returns:
Pixels object which matches id.
begin_copyAndResizeImage(imageId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, _response=None, _ex=None, _sent=None, _ctx=None)
begin_copyAndResizePixels(pixelsId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createImage(sizeX, sizeY, sizeZ, sizeT, channelList, pixelsType, name, description, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAllEnumerations(enumClass, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getBitDepth(type, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getEnumeration(enumClass, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_loadRndSettings(renderingSettingsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_retrieveAllRndSettings(pixId, userId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_retrievePixDescription(pixId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_retrieveRndSettings(pixId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_retrieveRndSettingsFor(pixId, userId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveRndSettings(rndSettings, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setChannelGlobalMinMax(pixelsId, channelIndex, min, max, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
copyAndResizeImage(imageId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, _ctx=None)
copyAndResizeImage_async(_cb, imageId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, _ctx=None)
copyAndResizePixels(pixelsId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, _ctx=None)
copyAndResizePixels_async(_cb, pixelsId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, _ctx=None)
createImage(sizeX, sizeY, sizeZ, sizeT, channelList, pixelsType, name, description, _ctx=None)
createImage_async(_cb, sizeX, sizeY, sizeZ, sizeT, channelList, pixelsType, name, description, _ctx=None)
end_copyAndResizeImage(_r)
end_copyAndResizePixels(_r)
end_createImage(_r)
end_getAllEnumerations(_r)
end_getBitDepth(_r)
end_getEnumeration(_r)
end_loadRndSettings(_r)
end_retrieveAllRndSettings(_r)
end_retrievePixDescription(_r)
end_retrieveRndSettings(_r)
end_retrieveRndSettingsFor(_r)
end_saveRndSettings(_r)
end_setChannelGlobalMinMax(_r)
getAllEnumerations(enumClass, _ctx=None)
getAllEnumerations_async(_cb, enumClass, _ctx=None)
getBitDepth(type, _ctx=None)
getBitDepth_async(_cb, type, _ctx=None)
getEnumeration(enumClass, value, _ctx=None)
getEnumeration_async(_cb, enumClass, value, _ctx=None)
loadRndSettings(renderingSettingsId, _ctx=None)
loadRndSettings_async(_cb, renderingSettingsId, _ctx=None)
retrieveAllRndSettings(pixId, userId, _ctx=None)
retrieveAllRndSettings_async(_cb, pixId, userId, _ctx=None)
retrievePixDescription(pixId, _ctx=None)
retrievePixDescription_async(_cb, pixId, _ctx=None)
retrieveRndSettings(pixId, _ctx=None)
retrieveRndSettingsFor(pixId, userId, _ctx=None)
retrieveRndSettingsFor_async(_cb, pixId, userId, _ctx=None)
retrieveRndSettings_async(_cb, pixId, _ctx=None)
saveRndSettings(rndSettings, _ctx=None)
saveRndSettings_async(_cb, rndSettings, _ctx=None)
setChannelGlobalMinMax(pixelsId, channelIndex, min, max, _ctx=None)
setChannelGlobalMinMax_async(_cb, pixelsId, channelIndex, min, max, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IProjection

Bases: omero.api.ServiceInterface

Provides methods for performing projections of Pixels sets.

_ice_type = <IcePy.TypeInfo object at 0x3dbbc48>
_op_projectPixels = <IcePy.Operation object at 0x1247dc30>
_op_projectStack = <IcePy.Operation object at 0x1247dc18>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
projectPixels_async(_cb, pixelsId, pixelsType, algorithm, tStart, tEnd, channelList, stepping, zStart, zEnd, name, current=None)

Performs a projection through selected optical sections and optical sections for a given set of time points of a Pixels set. The Image which is linked to the Pixels set will be copied using omero.api.IPixels#copyAndResizeImage.

Arguments:
pixelsId The source Pixels set Id. pixelsType The destination Pixels type. If

null, the source Pixels set pixels type will be used.

algorithm MAXIMUM_INTENSITY,

MEAN_INTENSITY or SUM_INTENSITY. NOTE: When performing a SUM_INTENSITY projection, pixel values will be pinned to the maximum pixel value of the destination Pixels type.

tStart Timepoint to start projecting from. tEnd Timepoint to finish projecting. channels List of the channel indexes to use while
calculating the projection.
stepping Stepping value to use while calculating the

projection. For example, stepping=1 will use every optical section from start to end where stepping=2 will use every other section from start to end to perform the projection.

zStart Optical section to start projecting from. zEnd Optical section to finish projecting. name Name for the newly created image. If

null the name of the Image linked to the Pixels qualified by pixelsId will be used with a Projection suffix. For example, GFP-H2B Image of HeLa Cells will have an Image name of GFP-H2B Image of HeLa Cells Projection used for the projection. Returns:

The Id of the newly created Image which has been

projected. Exceptions:

ValidationException Where:

algorithm is unknown tStart is out of range tEnd is out of range tStart > tEnd channels is null or has indexes out of range zStart is out of range zEnd is out of range zStart > zEnd the Pixels set qualified by pixelsId is unlocatable.

projectStack_async(_cb, pixelsId, pixelsType, algorithm, timepoint, channelIndex, stepping, start, end, current=None)

Performs a projection through the optical sections of a particular wavelength at a given time point of a Pixels set. Arguments:

pixelsId The source Pixels set Id. pixelsType The destination Pixels type. If

null, the source Pixels set pixels type will be used.

algorithm MAXIMUM_INTENSITY,

MEAN_INTENSITY or SUM_INTENSITY. NOTE: When performing a SUM_INTENSITY projection, pixel values will be pinned to the maximum pixel value of the destination Pixels type.

timepoint Timepoint to perform the projection. channelIndex Index of the channel to perform the
projection.
stepping Stepping value to use while calculating the

projection. For example, stepping=1 will use every optical section from start to end where stepping=2 will use every other section from start to end to perform the projection.

start Optical section to start projecting from. end Optical section to finish projecting.
Returns:
A byte array of projected pixel values whose length

is equal to the Pixels set 8 sizeX * sizeY * bytesPerPixel in big-endian format. Exceptions:

ValidationException Where:

algorithm is unknown timepoint is out of range channelIndex is out of range start is out of range end is out of range start > end the Pixels set qualified by pixelsId is unlocatable.

class omero.api.IProjectionPrx

Bases: omero.api.ServiceInterfacePrx

Performs a projection through the optical sections of a particular wavelength at a given time point of a Pixels set. Arguments:

pixelsId The source Pixels set Id. pixelsType The destination Pixels type. If

null, the source Pixels set pixels type will be used.

algorithm MAXIMUM_INTENSITY,

MEAN_INTENSITY or SUM_INTENSITY. NOTE: When performing a SUM_INTENSITY projection, pixel values will be pinned to the maximum pixel value of the destination Pixels type.

timepoint Timepoint to perform the projection. channelIndex Index of the channel to perform the
projection.
stepping Stepping value to use while calculating the

projection. For example, stepping=1 will use every optical section from start to end where stepping=2 will use every other section from start to end to perform the projection.

start Optical section to start projecting from. end Optical section to finish projecting.
Returns:
A byte array of projected pixel values whose length

is equal to the Pixels set 8 sizeX * sizeY * bytesPerPixel in big-endian format. Exceptions:

ValidationException Where:

algorithm is unknown timepoint is out of range channelIndex is out of range start is out of range end is out of range start > end the Pixels set qualified by pixelsId is unlocatable.

begin_projectPixels(pixelsId, pixelsType, algorithm, tStart, tEnd, channelList, stepping, zStart, zEnd, name, _response=None, _ex=None, _sent=None, _ctx=None)
begin_projectStack(pixelsId, pixelsType, algorithm, timepoint, channelIndex, stepping, start, end, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_projectPixels(_r)
end_projectStack(_r)
projectPixels(pixelsId, pixelsType, algorithm, tStart, tEnd, channelList, stepping, zStart, zEnd, name, _ctx=None)
projectPixels_async(_cb, pixelsId, pixelsType, algorithm, tStart, tEnd, channelList, stepping, zStart, zEnd, name, _ctx=None)
projectStack(pixelsId, pixelsType, algorithm, timepoint, channelIndex, stepping, start, end, _ctx=None)
projectStack_async(_cb, pixelsId, pixelsType, algorithm, timepoint, channelIndex, stepping, start, end, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IQuery

Bases: omero.api.ServiceInterface

Provides methods for directly querying object graphs. As far as is possible, IQuery should be considered the lowest level DB-access (SELECT) interface. Unlike the omero.api.IUpdate interface, using other methods will most likely not leave the database in an inconsistent state, but may provide stale data in some situations.

By convention, all methods that begin with get will never return a null or empty java.util.Collection, but instead will throw a omero.ValidationException.

_ice_type = <IcePy.TypeInfo object at 0x3dbbc78>
_op_find = <IcePy.Operation object at 0x1247dc60>
_op_findAll = <IcePy.Operation object at 0x1247dc78>
_op_findAllByExample = <IcePy.Operation object at 0x1247dca8>
_op_findAllByFullText = <IcePy.Operation object at 0x1247dd20>
_op_findAllByQuery = <IcePy.Operation object at 0x1247dd08>
_op_findAllByString = <IcePy.Operation object at 0x1247dcd8>
_op_findByExample = <IcePy.Operation object at 0x1247dc90>
_op_findByQuery = <IcePy.Operation object at 0x1247dcf0>
_op_findByString = <IcePy.Operation object at 0x1247dcc0>
_op_get = <IcePy.Operation object at 0x1247dc48>
_op_projection = <IcePy.Operation object at 0x1247dd38>
_op_refresh = <IcePy.Operation object at 0x1247dd50>
findAllByExample_async(_cb, example, filter, current=None)

Searches based on provided example entity. The returned entities will be limited by the omero.sys.Filter object.

Note: findAllbyExample does not operate on the id field. For that, use find, get, findByQuery, or findAllByQuery

Arguments:
example Non-null example object. filter filters the result set. Can be null.
Returns:
Possibly empty List of IObject results.
findAllByFullText_async(_cb, klass, query, params, current=None)

Executes a full text search based on Lucene. Each term in the query can also be prefixed by the name of the field to which is should be restricted.

Examples:

owner:root AND annotation:someTag file:xml AND name:hoechst

For more information, see Query Parser Syntax

The return values are first filtered by the security system.

Arguments:
klass A non-null class specification of which type
should be searched.
query A non-null query string. An empty string will
return no results.
params

Currently the parameters themselves are unused. But the omero.sys.Parameters#theFilter can be used to limit the number of results returned (omero.sys.Filter#limit) or the user for who the results will be found (omero.sys.Filter#ownerId). Returns:

A list of loaded omero.model.IObject

instances. Never null.

findAllByQuery_async(_cb, query, params, current=None)

Executes the stored query with the given name. If a query with the name cannot be found, an exception will be thrown.

The queryName parameter can be an actual query String if the StringQuerySource is configured on the server and the user running the query has proper permissions.

Queries can only return lists of omero.model.IObject instances. This means all must be of the form:

select this from SomeModelClass this ...

though the alias this is unimportant. Do not try to return multiple classes in one call like:

select this, that from SomeClass this, SomeOtherClass that ...

nor to project values out of an object:

select this.name from SomeClass this ...

If a page is desired, add it to the query parameters.

Arguments:
query Query to execute. Not null. params
Returns:
Possibly empty List of IObject results.
findAllByString_async(_cb, klass, field, value, caseSensitive, filter, current=None)

Searches a given field matching against a String. Method allows for case sensitive or insensitive searching using the (I)LIKE comparators. Result set will be reduced by the omero.sys.Filter instance.

Arguments:
klass type of entity to be searched. Not null. field the name of the field, either as simple string

or as public final static from the entity class, e.g. omero.model.Project#NAME. Not null.

value String used for search. Not null. caseSensitive whether to use LIKE or ILIKE filter filters the result set. Can be null.
Returns:
A list (possibly empty) with the results.
findAll_async(_cb, klass, filter, current=None)

Looks up all entities that belong to this class and match filter.

Arguments:
klass entity type to be searched. Not null. filter filters the result set. Can be null.
Returns:
a collection if initialized entities or an empty

List if none exist.

findByExample_async(_cb, example, current=None)

Searches based on provided example entity. The example entity should uniquely specify the entity or an exception will be thrown.

Note: findByExample does not operate on the id field. For that, use find, get, findByQuery, or findAllByQuery.

Arguments:
example Non-null example object.
Returns:
Possibly null IObject result.
Exceptions:
ApiUsageException if more than one result is return.
findByQuery_async(_cb, query, params, current=None)

Executes the stored query with the given name. If a query with the name cannot be found, an exception will be thrown.

The queryName parameter can be an actual query String if the StringQuerySource is configured on the server and the user running the query has proper permissions.

Arguments:
query Query to execute params
Returns:
Possibly null IObject result.
Exceptions:
ValidationException
findByString_async(_cb, klass, field, value, current=None)

Searches a given field matching against a String. Method does not allow for case sensitive or insensitive searching since this is essentially a lookup. The existence of more than one result will result in an exception.

Arguments:
klass type of entity to be searched field the name of the field, either as simple string

or as public final static from the entity class, e.g. omero.model.Project#NAME

value String used for search.
Returns:
found entity or possibly null.
Exceptions:
ome.conditions.ApiUsageException

if more than one result.

find_async(_cb, klass, id, current=None)

Looks up an entity by class and id. If no such objects exists, return a null.

Arguments:
klass klass the type of the entity. Not null. id the entity’s id
Returns:
an initialized entity or null if id doesn’t exist.
get_async(_cb, klass, id, current=None)

Looks up an entity by class and id. If no such object exists, an exception will be thrown.

Arguments:
klass the type of the entity. Not null. id the entity’s id
Returns:
an initialized entity
Exceptions:
ValidationException if the id doesn’t exist.
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
projection_async(_cb, query, params, current=None)

Return a sequence of omero.RType sequences.

Each element of the outer sequence is one row in the return value. Each element of the inner sequence is one column specified in the HQL.

omero.model.IObject instances are returned wrapped in an omero.RObject instance. Primitives are mapped to the expected omero.RType subclass. Types without an omero.RType mapper if returned will throw an exception if present in the select except where a manual conversion is present on the server. This includes:

omero.model.Permissions instances are serialized to an omero.RMap containing the keys: perms, canAnnotate, canEdit, canLink, canDelete

The quantity types like omero.model.Length are serialized to an omero.RMap containing the keys: value, unit, symbol

As with SQL, if an aggregation statement is used, a group by clause must be added.

Examples:

select i.name, i.description from Image i where i.name like ‘%.dv’

select tag.textValue, tagset.textValue from TagAnnotation tag join tag.annotationLinks l join l.child tagset

select p.pixelsType.value, count(p.id) from Pixel p group by p.pixelsType.value

refresh_async(_cb, iObject, current=None)

Refreshes an entire omero.model.IObject graph, recursive loading all data for the managed instances in the graph from the database. If any non-managed entities are detected (e.g. without ids), an omero.ApiUsageException will be thrown.

Arguments:
iObject Non-null managed omero.model.IObject

graph which should have all values re-assigned from the database Returns:

a similar omero.model.IObject graph (with

possible additions and deletions) which is in-sync with the database. Exceptions:

ApiUsageException if any non-managed entities are

found.

class omero.api.IQueryPrx

Bases: omero.api.ServiceInterfacePrx

Looks up an entity by class and id. If no such object exists, an exception will be thrown.

Arguments:
klass the type of the entity. Not null. id the entity’s id
Returns:
an initialized entity
Exceptions:
ValidationException if the id doesn’t exist.
begin_find(klass, id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findAll(klass, filter, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findAllByExample(example, filter, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findAllByFullText(klass, query, params, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findAllByQuery(query, params, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findAllByString(klass, field, value, caseSensitive, filter, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findByExample(example, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findByQuery(query, params, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findByString(klass, field, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_get(klass, id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_projection(query, params, _response=None, _ex=None, _sent=None, _ctx=None)
begin_refresh(iObject, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_find(_r)
end_findAll(_r)
end_findAllByExample(_r)
end_findAllByFullText(_r)
end_findAllByQuery(_r)
end_findAllByString(_r)
end_findByExample(_r)
end_findByQuery(_r)
end_findByString(_r)
end_get(_r)
end_projection(_r)
end_refresh(_r)
find(klass, id, _ctx=None)
findAll(klass, filter, _ctx=None)
findAllByExample(example, filter, _ctx=None)
findAllByExample_async(_cb, example, filter, _ctx=None)
findAllByFullText(klass, query, params, _ctx=None)
findAllByFullText_async(_cb, klass, query, params, _ctx=None)
findAllByQuery(query, params, _ctx=None)
findAllByQuery_async(_cb, query, params, _ctx=None)
findAllByString(klass, field, value, caseSensitive, filter, _ctx=None)
findAllByString_async(_cb, klass, field, value, caseSensitive, filter, _ctx=None)
findAll_async(_cb, klass, filter, _ctx=None)
findByExample(example, _ctx=None)
findByExample_async(_cb, example, _ctx=None)
findByQuery(query, params, _ctx=None)
findByQuery_async(_cb, query, params, _ctx=None)
findByString(klass, field, value, _ctx=None)
findByString_async(_cb, klass, field, value, _ctx=None)
find_async(_cb, klass, id, _ctx=None)
get(klass, id, _ctx=None)
get_async(_cb, klass, id, _ctx=None)
projection(query, params, _ctx=None)
projection_async(_cb, query, params, _ctx=None)
refresh(iObject, _ctx=None)
refresh_async(_cb, iObject, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IRenderingSettings

Bases: omero.api.ServiceInterface

Provides method to apply rendering settings to a collection of images. All methods will receive the id of the pixels set to copy the rendering settings from.

_ice_type = <IcePy.TypeInfo object at 0x3dbbdc8>
_op_applySettingsToDataset = <IcePy.Operation object at 0x1247dea0>
_op_applySettingsToImage = <IcePy.Operation object at 0x1247ded0>
_op_applySettingsToImages = <IcePy.Operation object at 0x1247deb8>
_op_applySettingsToPixels = <IcePy.Operation object at 0x1247dee8>
_op_applySettingsToProject = <IcePy.Operation object at 0x1247de88>
_op_applySettingsToSet = <IcePy.Operation object at 0x1247de70>
_op_createNewRenderingDef = <IcePy.Operation object at 0x1247dd98>
_op_getRenderingSettings = <IcePy.Operation object at 0x1247dd80>
_op_resetDefaults = <IcePy.Operation object at 0x1247ddb0>
_op_resetDefaultsByOwnerInSet = <IcePy.Operation object at 0x1247de40>
_op_resetDefaultsForPixels = <IcePy.Operation object at 0x1247ddf8>
_op_resetDefaultsInDataset = <IcePy.Operation object at 0x1247de10>
_op_resetDefaultsInImage = <IcePy.Operation object at 0x1247dde0>
_op_resetDefaultsInSet = <IcePy.Operation object at 0x1247de28>
_op_resetDefaultsNoSave = <IcePy.Operation object at 0x1247ddc8>
_op_resetMinMaxInSet = <IcePy.Operation object at 0x1247de58>
_op_sanityCheckPixels = <IcePy.Operation object at 0x1247dd68>
_op_setOriginalSettingsForPixels = <IcePy.Operation object at 0x1247df18>
_op_setOriginalSettingsInDataset = <IcePy.Operation object at 0x1247df30>
_op_setOriginalSettingsInImage = <IcePy.Operation object at 0x1247df00>
_op_setOriginalSettingsInSet = <IcePy.Operation object at 0x1247df48>
applySettingsToDataset_async(_cb, _from, to, current=None)

Applies rendering settings to all images in a given Dataset.

Arguments:
from The Id of the pixels set to copy the rendering
settings from.
to The Id of the dataset container to apply settings

to. Returns:

A map with two boolean keys. The value of the

TRUE is a collection of images ID, the settings were successfully applied to. The value of the FALSE is a collection of images ID, the settings could not be applied to. Exceptions:

ValidationException if the rendering settings

from is unlocatable or the dataset to is unlocatable.

applySettingsToImage_async(_cb, _from, to, current=None)

Applies rendering settings to a given Image.

Arguments:
from The Id of the pixels set to copy the rendering
settings from.
to The Id of the image container to apply settings

to. Returns:

true if the settings were successfully

applied, false otherwise. Exceptions:

ValidationException if the rendering settings

from is unlocatable or the image to is unlocatable.

applySettingsToImages_async(_cb, _from, to, current=None)

Applies rendering settings to a given Image.

Arguments:
from The Id of the pixels set to copy the rendering
settings from.
to The Id of the image container to apply settings

to. Returns:

true if the settings were successfully

applied, false otherwise. Exceptions:

ValidationException if the rendering settings

from is unlocatable or the image to is unlocatable.

applySettingsToPixels_async(_cb, _from, to, current=None)

Applies rendering settings to a given Pixels.

Arguments:
from The Id of the pixels set to copy the rendering
settings from.
to The Id of the pixels container to apply settings

to. Returns:

See above.
Exceptions:
ValidationException if the rendering settings

from is unlocatable or the pixelsto is unlocatable.

applySettingsToProject_async(_cb, _from, to, current=None)

Applies rendering settings to all images in all Datasets of a given Project.

Arguments:
from The Id of the pixels set to copy the rendering
settings from.
to The Id of the project container to apply settings

to. Returns:

A map with two boolean keys. The value of the

TRUE is a collection of images ID, the settings were successfully applied to. The value of the FALSE is a collection of images ID, the settings could not be applied to. Exceptions:

ValidationException if the rendering settings

from is unlocatable or the project to is unlocatable.

applySettingsToSet_async(_cb, _from, toType, nodeIds, current=None)

Applies rendering settings to one or many containers. If a container such as Dataset is to be copied to, all images within that Dataset will have the rendering settings applied. Supported container types are:

omero.model.Project omero.model.Dataset omero.model.Image omero.model.Plate omero.model.Screen omero.model.Pixels

Arguments:
from The Id of the pixels set to copy the rendering
settings from.
toType The type of nodes to handle. nodeIds Ids of the node type.
Returns:
A map with two boolean keys. The value of the

TRUE is a collection of images ID, the settings were successfully applied to. The value of the FALSE is a collection of images ID, the settings could not be applied to. Exceptions:

ValidationException if an illegal type

is used.

createNewRenderingDef_async(_cb, pixels, current=None)

Creates a new rendering definition object along with its sub-objects.

Arguments:
pixels The Pixels set to link to the rendering

definition. Returns:

A new, blank rendering definition and sub-objects.

NOTE: the linked Pixels has been unloaded.

getRenderingSettings_async(_cb, pixelsId, current=None)

Returns the default rendering settings for a given pixels for the current user.

Arguments:
pixelsId The Id of the Pixels
Returns:
See above.
Exceptions:
ValidationException if the image qualified by

imageId is unlocatable.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
resetDefaultsByOwnerInSet_async(_cb, type, nodeIds, current=None)

Resets the rendering settings of a given group of containers based on the owner’s (essentially a copy). Supported container types are:

omero.model.Project omero.model.Dataset omero.model.Image omero.model.Plate omero.model.Pixels

Arguments:
type The type of nodes to handle. nodeIds Ids of the node type.
Returns:
A omero.sys.LongList of image IDs that have

had their rendering settings reset. Exceptions:

ValidationException if an illegal type

is used.

resetDefaultsForPixels_async(_cb, pixelsId, current=None)

Resets a Pixels’ default rendering settings back to those that are specified by the rendering engine intelligent pretty good image (PG) logic.

Arguments:
pixelsId The Id of the Pixels.
Exceptions:
ValidationException if the Pixels qualified by

pixelsId is unlocatable.

resetDefaultsInDataset_async(_cb, dataSetId, current=None)

Resets a dataset’s rendering settings back to those that are specified by the rendering engine intelligent pretty good image (PG) logic.

Arguments:
dataSetId The Id of the Dataset.
Returns:
A java.util.Set of image IDs that have had

their rendering settings reset. Exceptions:

ValidationException if the image qualified by

dataSetId is unlocatable.

resetDefaultsInImage_async(_cb, imageId, current=None)

Resets an image’s default rendering settings back to those that are specified by the rendering engine intelligent pretty good image (PG) logic.

Arguments:
imageId The Id of the Image.
Exceptions:
ValidationException if the image qualified by

imageId is unlocatable.

resetDefaultsInSet_async(_cb, type, nodeIds, current=None)

Resets a rendering settings back to one or many containers that are specified by the rendering engine intelligent pretty good image (PG) logic. Supported container types are:

omero.model.Project omero.model.Dataset omero.model.Image omero.model.Plate omero.model.Pixels

Arguments:
type The type of nodes to handle. nodeIds Ids of the node type.
Returns:
A java.util.Set of image IDs that have had

their rendering settings reset. Exceptions:

ValidationException if an illegal type

is used.

resetDefaultsNoSave_async(_cb, _def, pixels, current=None)

Resets the given rendering settings to those that are specified by the rendering engine intelligent pretty good image (PG) logic for the pixels set linked to that set of rendering settings. NOTE: This method should only be used to reset a rendering definition that has been retrieved via getRenderingSettings(long) as it relies on certain objects being loaded. The rendering settings are not saved.

Arguments:
def A RenderingDef to reset. It is expected that

def.pixels will be unloaded and that the actual linked Pixels set will be provided in the pixels argument.

pixels The Pixels set for def.
Returns:
def with the rendering settings reset.
resetDefaults_async(_cb, _def, pixels, current=None)

Resets the given rendering settings to those that are specified by the rendering engine intelligent pretty good image (PG) logic for the pixels set linked to that set of rendering settings. NOTE: This method should only be used to reset a rendering definition that has been retrieved via getRenderingSettings as it relies on certain objects being loaded. The rendering settings are saved upon completion.

Arguments:
def A RenderingDef to reset. It is expected that

def.pixels will be unloaded and that the actual linked Pixels set will be provided in the pixels argument.

pixels The Pixels set for def.
resetMinMaxInSet_async(_cb, type, nodeIds, current=None)

Resets a the channel windows for one or many containers back to their global minimum and global maximum for the channel. Supported container types are:

omero.model.Project omero.model.Dataset omero.model.Image omero.model.Plate omero.model.Pixels

Arguments:
type The type of nodes to handle. nodeIds Ids of the node type.
Returns:
A omero.sys.LongList of image IDs that have

had their rendering settings reset. Exceptions:

ValidationException if an illegal type

is used.

sanityCheckPixels_async(_cb, pFrom, pTo, current=None)

Checks if the specified sets of pixels are compatible. Returns true if the pixels set is valid, false otherwise.

Arguments:
pFrom The pixels set to copy the settings from. pTo The pixels set to copy the settings to.
Returns:
See above.
setOriginalSettingsForPixels_async(_cb, pixelsId, current=None)

Resets an Pixels’ default rendering settings back to channel global minimum and maximum.

Arguments:
pixelsId The Id of the Pixels set.
Exceptions:
ValidationException if the image qualified by

pixelsId is unlocatable.

setOriginalSettingsInDataset_async(_cb, dataSetId, current=None)

Resets a dataset’s rendering settings back to channel global minimum and maximum.

Arguments:
datasetId The id of the dataset to handle.
Returns:
A omero.sys.LongList of image IDs that have

had their rendering settings reset. Exceptions:

ValidationException if the image qualified by

datasetId is unlocatable.

setOriginalSettingsInImage_async(_cb, imageId, current=None)

Resets an image’s default rendering settings back to channel global minimum and maximum.

Arguments:
imageId The Id of the Image.
Exceptions:
ValidationException if the image qualified by

imageId is unlocatable.

setOriginalSettingsInSet_async(_cb, type, nodeIds, current=None)

Resets a rendering settings back to channel global minimum and maximum for the specified containers. Supported container types are:

omero.model.Project omero.model.Dataset omero.model.Image omero.model.Plate omero.model.Pixels

Arguments:
type The type of nodes to handle. nodeIds Ids of the node type.
Returns:
A omero.sys.LongList of image IDs that have

had their rendering settings reset. Exceptions:

ValidationException if an illegal type

is used.

class omero.api.IRenderingSettingsPrx

Bases: omero.api.ServiceInterfacePrx

Checks if the specified sets of pixels are compatible. Returns true if the pixels set is valid, false otherwise.

Arguments:
pFrom The pixels set to copy the settings from. pTo The pixels set to copy the settings to.
Returns:
See above.
applySettingsToDataset(_from, to, _ctx=None)
applySettingsToDataset_async(_cb, _from, to, _ctx=None)
applySettingsToImage(_from, to, _ctx=None)
applySettingsToImage_async(_cb, _from, to, _ctx=None)
applySettingsToImages(_from, to, _ctx=None)
applySettingsToImages_async(_cb, _from, to, _ctx=None)
applySettingsToPixels(_from, to, _ctx=None)
applySettingsToPixels_async(_cb, _from, to, _ctx=None)
applySettingsToProject(_from, to, _ctx=None)
applySettingsToProject_async(_cb, _from, to, _ctx=None)
applySettingsToSet(_from, toType, nodeIds, _ctx=None)
applySettingsToSet_async(_cb, _from, toType, nodeIds, _ctx=None)
begin_applySettingsToDataset(_from, to, _response=None, _ex=None, _sent=None, _ctx=None)
begin_applySettingsToImage(_from, to, _response=None, _ex=None, _sent=None, _ctx=None)
begin_applySettingsToImages(_from, to, _response=None, _ex=None, _sent=None, _ctx=None)
begin_applySettingsToPixels(_from, to, _response=None, _ex=None, _sent=None, _ctx=None)
begin_applySettingsToProject(_from, to, _response=None, _ex=None, _sent=None, _ctx=None)
begin_applySettingsToSet(_from, toType, nodeIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createNewRenderingDef(pixels, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRenderingSettings(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaults(_def, pixels, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultsByOwnerInSet(type, nodeIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultsForPixels(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultsInDataset(dataSetId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultsInImage(imageId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultsInSet(type, nodeIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultsNoSave(_def, pixels, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetMinMaxInSet(type, nodeIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_sanityCheckPixels(pFrom, pTo, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setOriginalSettingsForPixels(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setOriginalSettingsInDataset(dataSetId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setOriginalSettingsInImage(imageId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setOriginalSettingsInSet(type, nodeIds, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
createNewRenderingDef(pixels, _ctx=None)
createNewRenderingDef_async(_cb, pixels, _ctx=None)
end_applySettingsToDataset(_r)
end_applySettingsToImage(_r)
end_applySettingsToImages(_r)
end_applySettingsToPixels(_r)
end_applySettingsToProject(_r)
end_applySettingsToSet(_r)
end_createNewRenderingDef(_r)
end_getRenderingSettings(_r)
end_resetDefaults(_r)
end_resetDefaultsByOwnerInSet(_r)
end_resetDefaultsForPixels(_r)
end_resetDefaultsInDataset(_r)
end_resetDefaultsInImage(_r)
end_resetDefaultsInSet(_r)
end_resetDefaultsNoSave(_r)
end_resetMinMaxInSet(_r)
end_sanityCheckPixels(_r)
end_setOriginalSettingsForPixels(_r)
end_setOriginalSettingsInDataset(_r)
end_setOriginalSettingsInImage(_r)
end_setOriginalSettingsInSet(_r)
getRenderingSettings(pixelsId, _ctx=None)
getRenderingSettings_async(_cb, pixelsId, _ctx=None)
resetDefaults(_def, pixels, _ctx=None)
resetDefaultsByOwnerInSet(type, nodeIds, _ctx=None)
resetDefaultsByOwnerInSet_async(_cb, type, nodeIds, _ctx=None)
resetDefaultsForPixels(pixelsId, _ctx=None)
resetDefaultsForPixels_async(_cb, pixelsId, _ctx=None)
resetDefaultsInDataset(dataSetId, _ctx=None)
resetDefaultsInDataset_async(_cb, dataSetId, _ctx=None)
resetDefaultsInImage(imageId, _ctx=None)
resetDefaultsInImage_async(_cb, imageId, _ctx=None)
resetDefaultsInSet(type, nodeIds, _ctx=None)
resetDefaultsInSet_async(_cb, type, nodeIds, _ctx=None)
resetDefaultsNoSave(_def, pixels, _ctx=None)
resetDefaultsNoSave_async(_cb, _def, pixels, _ctx=None)
resetDefaults_async(_cb, _def, pixels, _ctx=None)
resetMinMaxInSet(type, nodeIds, _ctx=None)
resetMinMaxInSet_async(_cb, type, nodeIds, _ctx=None)
sanityCheckPixels(pFrom, pTo, _ctx=None)
sanityCheckPixels_async(_cb, pFrom, pTo, _ctx=None)
setOriginalSettingsForPixels(pixelsId, _ctx=None)
setOriginalSettingsForPixels_async(_cb, pixelsId, _ctx=None)
setOriginalSettingsInDataset(dataSetId, _ctx=None)
setOriginalSettingsInDataset_async(_cb, dataSetId, _ctx=None)
setOriginalSettingsInImage(imageId, _ctx=None)
setOriginalSettingsInImage_async(_cb, imageId, _ctx=None)
setOriginalSettingsInSet(type, nodeIds, _ctx=None)
setOriginalSettingsInSet_async(_cb, type, nodeIds, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IRepositoryInfo

Bases: omero.api.ServiceInterface

Provides methods for obtaining information for server repository disk space allocation. Could be used generically to obtain usage information for any mount point, however, this interface is prepared for the API to provide methods to obtain usage info for the server filesystem containing the image uploads. For the OMERO server base this is /OMERO. For this implementation it could be anything e.g. /Data1.

Methods that fail or cannot execute on the server will throw an InternalException. This would not be normal and would indicate some server or disk failure.

_ice_type = <IcePy.TypeInfo object at 0x3dbbdf8>
_op_getFreeSpaceInKilobytes = <IcePy.Operation object at 0x1247df78>
_op_getUsageFraction = <IcePy.Operation object at 0x1247df90>
_op_getUsedSpaceInKilobytes = <IcePy.Operation object at 0x1247df60>
_op_removeUnusedFiles = <IcePy.Operation object at 0x1247dfc0>
_op_sanityCheckRepository = <IcePy.Operation object at 0x1247dfa8>
getFreeSpaceInKilobytes_async(_cb, current=None)

Returns the free or available space on this file system including nested subdirectories.

Returns:
Free space on this file system in KB.
Exceptions:
ResourceError If there is a problem retrieving disk

space free.

getUsageFraction_async(_cb, current=None)

Returns a double of the used space divided by the free space. This method will be called by a client to watch the repository filesystem so that it doesn’t exceed 95% full.

Returns:
Fraction of used/free.
Exceptions:
ResourceError If there is a problem calculating the

usage fraction.

getUsedSpaceInKilobytes_async(_cb, current=None)

Returns the total space in bytes for this file system including nested subdirectories.

Returns:
Total space used on this file system.
Exceptions:
ResourceError If there is a problem retrieving disk

space used.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
removeUnusedFiles_async(_cb, current=None)

Removes all files from the server that do not have an OriginalFile complement in the database, all the Pixels that do not have a complement in the database and all the Thumbnail’s that do not have a complement in the database.

Exceptions:
ResourceError If deletion fails.
sanityCheckRepository_async(_cb, current=None)

Checks that image data repository has not exceeded 95% disk space use level. Exceptions:

ResourceError If the repository usage has exceeded
95%.
InternalException If there is a critical failure

while sanity checking the repository.

class omero.api.IRepositoryInfoPrx

Bases: omero.api.ServiceInterfacePrx

Returns the total space in bytes for this file system including nested subdirectories.

Returns:
Total space used on this file system.
Exceptions:
ResourceError If there is a problem retrieving disk

space used.

begin_getFreeSpaceInKilobytes(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getUsageFraction(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getUsedSpaceInKilobytes(_response=None, _ex=None, _sent=None, _ctx=None)
begin_removeUnusedFiles(_response=None, _ex=None, _sent=None, _ctx=None)
begin_sanityCheckRepository(_response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_getFreeSpaceInKilobytes(_r)
end_getUsageFraction(_r)
end_getUsedSpaceInKilobytes(_r)
end_removeUnusedFiles(_r)
end_sanityCheckRepository(_r)
getFreeSpaceInKilobytes(_ctx=None)
getFreeSpaceInKilobytes_async(_cb, _ctx=None)
getUsageFraction(_ctx=None)
getUsageFraction_async(_cb, _ctx=None)
getUsedSpaceInKilobytes(_ctx=None)
getUsedSpaceInKilobytes_async(_cb, _ctx=None)
removeUnusedFiles(_ctx=None)
removeUnusedFiles_async(_cb, _ctx=None)
sanityCheckRepository(_ctx=None)
sanityCheckRepository_async(_cb, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IRoi

Bases: omero.api.ServiceInterface

Interface for working with regions of interest.

_ice_type = <IcePy.TypeInfo object at 0x3dbbca8>
_op_findByImage = <IcePy.Operation object at 0x11feb150>
_op_findByPlane = <IcePy.Operation object at 0x11feb168>
_op_findByRoi = <IcePy.Operation object at 0x11feb138>
_op_getMeasuredRois = <IcePy.Operation object at 0x11feb1f8>
_op_getMeasuredRoisMap = <IcePy.Operation object at 0x11feb210>
_op_getPoints = <IcePy.Operation object at 0x11feb180>
_op_getRoiMeasurements = <IcePy.Operation object at 0x11feb1e0>
_op_getRoiStats = <IcePy.Operation object at 0x11feb198>
_op_getShapeStats = <IcePy.Operation object at 0x11feb1b0>
_op_getShapeStatsList = <IcePy.Operation object at 0x11feb1c8>
_op_getTable = <IcePy.Operation object at 0x11feb228>
_op_uploadMask = <IcePy.Operation object at 0x11feb240>
findByImage_async(_cb, imageId, opts, current=None)

Returns all the Rois in an Image, indexed via Shape.

Loads Rois as findByRoi.

findByPlane_async(_cb, imageId, z, t, opts, current=None)

Returns all the Rois on the given plane, indexed via Shape.

Loads Rois as findByRoi.

findByRoi_async(_cb, roiId, opts, current=None)

Returns a RoiResult with a single Roi member. Shape linkages are properly created. All Shapes are loaded, as is the Pixels and Image object. TODO: Annotations?

getMeasuredRoisMap_async(_cb, imageId, annotationIds, opts, current=None)

Returns a map from omero.model.FileAnnotation ids to RoiResult instances. Logic is identical to getMeasuredRois, but Roi data will not be duplicated. (i.e. the objects are referentially identical)

getMeasuredRois_async(_cb, imageId, annotationId, opts, current=None)

Loads the ROIs which are linked to by the given omero.model.FileAnnotation id for the given image.

Arguments:
annotationId if -1, logic is identical to findByImage(imageId, opts)
getPoints_async(_cb, shapeId, current=None)

Calculate the points contained within a given shape

getRoiMeasurements_async(_cb, imageId, opts, current=None)

Returns a list of omero.model.FileAnnotation instances with the namespace openmicroscopy.org/measurements which are attached to the omero.model.Plate containing the given image AND which are attached to at least one omero.model.Roi

Arguments:
opts, userId and groupId are respected based on the

ownership of the annotation.

getRoiStats_async(_cb, roiId, current=None)

Calculate stats for all the shapes within the given Roi.

getShapeStatsList_async(_cb, shapeIdList, current=None)

Calculate the stats for the points within the given Shapes.

getShapeStats_async(_cb, shapeId, current=None)

Calculate the stats for the points within the given Shape.

getTable_async(_cb, annotationId, current=None)

Returns the OMERO.tables service via the omero.model.FileAnnotation id returned by getImageMeasurements.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
uploadMask_async(_cb, roiId, z, t, bytes, current=None)
class omero.api.IRoiPrx

Bases: omero.api.ServiceInterfacePrx

Returns a RoiResult with a single Roi member. Shape linkages are properly created. All Shapes are loaded, as is the Pixels and Image object. TODO: Annotations?

begin_findByImage(imageId, opts, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findByPlane(imageId, z, t, opts, _response=None, _ex=None, _sent=None, _ctx=None)
begin_findByRoi(roiId, opts, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMeasuredRois(imageId, annotationId, opts, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMeasuredRoisMap(imageId, annotationIds, opts, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPoints(shapeId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRoiMeasurements(imageId, opts, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRoiStats(roiId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getShapeStats(shapeId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getShapeStatsList(shapeIdList, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTable(annotationId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_uploadMask(roiId, z, t, bytes, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_findByImage(_r)
end_findByPlane(_r)
end_findByRoi(_r)
end_getMeasuredRois(_r)
end_getMeasuredRoisMap(_r)
end_getPoints(_r)
end_getRoiMeasurements(_r)
end_getRoiStats(_r)
end_getShapeStats(_r)
end_getShapeStatsList(_r)
end_getTable(_r)
end_uploadMask(_r)
findByImage(imageId, opts, _ctx=None)
findByImage_async(_cb, imageId, opts, _ctx=None)
findByPlane(imageId, z, t, opts, _ctx=None)
findByPlane_async(_cb, imageId, z, t, opts, _ctx=None)
findByRoi(roiId, opts, _ctx=None)
findByRoi_async(_cb, roiId, opts, _ctx=None)
getMeasuredRois(imageId, annotationId, opts, _ctx=None)
getMeasuredRoisMap(imageId, annotationIds, opts, _ctx=None)
getMeasuredRoisMap_async(_cb, imageId, annotationIds, opts, _ctx=None)
getMeasuredRois_async(_cb, imageId, annotationId, opts, _ctx=None)
getPoints(shapeId, _ctx=None)
getPoints_async(_cb, shapeId, _ctx=None)
getRoiMeasurements(imageId, opts, _ctx=None)
getRoiMeasurements_async(_cb, imageId, opts, _ctx=None)
getRoiStats(roiId, _ctx=None)
getRoiStats_async(_cb, roiId, _ctx=None)
getShapeStats(shapeId, _ctx=None)
getShapeStatsList(shapeIdList, _ctx=None)
getShapeStatsList_async(_cb, shapeIdList, _ctx=None)
getShapeStats_async(_cb, shapeId, _ctx=None)
getTable(annotationId, _ctx=None)
getTable_async(_cb, annotationId, _ctx=None)
static uncheckedCast(proxy, facet=None)
uploadMask(roiId, z, t, bytes, _ctx=None)
uploadMask_async(_cb, roiId, z, t, bytes, _ctx=None)
class omero.api.IScript

Bases: omero.api.ServiceInterface

Utility service for managing and launching scripts for execution by the Processor API.

Typical usage might include (PYTHON):

sf = client.createSession() svc = sf.getScriptService() scripts = svc.getScripts()

if len(scripts) >= 1: script_id = svc.keys()[-1] else: script_id = svc.uploadScript(‘/test/my_script.py’, SCRIPT_TEXT)

params = svc.getParams(script_id)

# You will need to parse the params to create the proper input inputs = {}

# The last parameter is how long to wait as an RInt proc = svc.runScript(script_id, inputs, None) try: cb = omero.scripts.ProcessCallbackI(client, proc) while not cb.block(1000): # ms. pass cb.close() rv = proc.getResults(0) finally: proc.close(False)

See OMERO.scripts for more information.

_ice_type = <IcePy.TypeInfo object at 0x3dbbcd8>
_op_canRunScript = <IcePy.Operation object at 0x11feb378>
_op_deleteScript = <IcePy.Operation object at 0x11feb348>
_op_editScript = <IcePy.Operation object at 0x11feb300>
_op_getParams = <IcePy.Operation object at 0x11feb330>
_op_getScriptID = <IcePy.Operation object at 0x11feb2a0>
_op_getScriptText = <IcePy.Operation object at 0x11feb2b8>
_op_getScriptWithDetails = <IcePy.Operation object at 0x11feb318>
_op_getScripts = <IcePy.Operation object at 0x11feb258>
_op_getScriptsByMimetype = <IcePy.Operation object at 0x11feb270>
_op_getUserScripts = <IcePy.Operation object at 0x11feb288>
_op_runScript = <IcePy.Operation object at 0x11feb360>
_op_uploadOfficialScript = <IcePy.Operation object at 0x11feb2e8>
_op_uploadScript = <IcePy.Operation object at 0x11feb2d0>
_op_validateScript = <IcePy.Operation object at 0x11feb390>
canRunScript_async(_cb, scriptID, current=None)

Returns true if there is a processor which will run the given script.

Either the script is an official script and this method will return true (though an individual invocation may fail with an omero.ResourceError for some reason) or this is a user script, and a usermode processor must be active which takes the scripts user or group.

deleteScript_async(_cb, scriptID, current=None)

Delete the script on the server with id. The file will also be removed from disk.

Arguments:
scriptID Id of the script to delete.
Exceptions:
ApiUsageException SecurityViolation
editScript_async(_cb, fileObject, scriptText, current=None)

Modify the text for the given script object.

Arguments:
script see above.
Exceptions:
ApiUsageException SecurityViolation
getParams_async(_cb, scriptID, current=None)

Get the parameters that the script takes and returns, along with other metadata available from the script.

Arguments:
scriptID see above.
Returns:
see above.
Exceptions:
ApiUsageException
getScriptID_async(_cb, path, current=None)

Get the id of an official script by the script path. The script service ensures that all script paths are unique.

Note: there is no similar method for user scripts (e.g. getUserScriptID) since the path is not guaranteed to be unique.

Arguments:
scriptName The name of the script.
Returns:
see above.
Exceptions:
ApiUsageException SecurityViolation
getScriptText_async(_cb, scriptID, current=None)

Get the text from the server for the script with given id.

Arguments:
scriptID see above.
Returns:
see above.
Exceptions:
ApiUsageException
getScriptWithDetails_async(_cb, scriptID, current=None)

Get the script from the server with details from OriginalFile Arguments:

scriptID see above
Returns:
see above
Exceptions:
ApiUsageException
getScriptsByMimetype_async(_cb, mimetype, current=None)

This method returns official server scripts identified with the specified extension as a list of omero.model.OriginalFile objects. These scripts will be executed by the server if submitted via runScript. The input parameters necessary for proper functioning can be retrieved via getParams.

The omero.model.OriginalFile#path value can be used in other official scripts via the language specific import command, since the script directory will be placed on the appropriate environment path variable.

scripts = scriptService.getScripts(“py”) for script in scripts: text = scriptService.getScriptText(script.id.val) path = script.path.val[1:] # First symbol is a “/” path = path.replace(“/”,”.”) print “Possible import: %s” % path

Arguments:
mimetype the mimetype identifying the scripts.
Returns:
see above.
Exceptions:
ApiUsageException SecurityViolation
getScripts_async(_cb, current=None)

This method returns official server scripts as a list of omero.model.OriginalFile objects. These scripts will be executed by the server if submitted via runScript. The input parameters necessary for proper functioning can be retrieved via getParams.

The omero.model.OriginalFile#path value can be used in other official scripts via the language specific import command, since the script directory will be placed on the appropriate environment path variable.

scripts = scriptService.getScripts() for script in scripts: text = scriptService.getScriptText(script.id.val) # First character is a “/” symbol path = script.path.val[1:] path = path.replace(“/”,”.”) print “Possible import: %s” % path

Returns:
see above.
Exceptions:
ApiUsageException SecurityViolation
getUserScripts_async(_cb, acceptsList, current=None)

Returns non-official scripts which have been uploaded by individual users. These scripts will not be run by the server, though a user can start a personal usermode processor which will allow the scripts to be executed. This is particularly useful for testing new scripts.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
runScript_async(_cb, scriptID, inputs, waitSecs, current=None)

If ResourceError is thrown, then no Processor is available. Use scheduleJob to create a omero.model.ScriptJob in the Waiting state. A Processor may become available.

try: proc = scriptService.runScript(1, {}, None) except ResourceError: job = scriptService.scheduleScript(1, {}, None)

The ScriptProcess proxy MUST be closed before exiting. If you would like the script execution to continue in the background, pass True as the argument.

try: proc.poll() # See if process is finished finally: proc.close(True) # Detach and execution can continue # proc.close(False) # OR script is immediately stopped.

uploadOfficialScript_async(_cb, path, scriptText, current=None)

Like uploadScript but is only callable by administrators. The parameters for the script are also checked.

uploadScript_async(_cb, path, scriptText, current=None)

Upload a user script to the server and return the id. This method checks that a script with that names does not exist and that the script has parameters if possible, i.e. a usermode processor is running which for the current user.

Arguments:
script see above.
Returns:
The new id of the script.
Exceptions:
ApiUsageException SecurityViolation
validateScript_async(_cb, j, acceptsList, current=None)

Used internally by processor.py to check if the script attached to the omero.model.Job has a valid script attached, based on the acceptsList and the current security context.

An example of an acceptsList might be Experimenter(myUserId, False), meaning that only scripts belonging to me should be trusted. An empty list implies that the server should return what it would by default trust.

A valid script will be returned if it exists; otherwise null.

class omero.api.IScriptPrx

Bases: omero.api.ServiceInterfacePrx

This method returns official server scripts as a list of omero.model.OriginalFile objects. These scripts will be executed by the server if submitted via runScript. The input parameters necessary for proper functioning can be retrieved via getParams.

The omero.model.OriginalFile#path value can be used in other official scripts via the language specific import command, since the script directory will be placed on the appropriate environment path variable.

scripts = scriptService.getScripts() for script in scripts: text = scriptService.getScriptText(script.id.val) # First character is a “/” symbol path = script.path.val[1:] path = path.replace(“/”,”.”) print “Possible import: %s” % path

Returns:
see above.
Exceptions:
ApiUsageException SecurityViolation
begin_canRunScript(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_deleteScript(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_editScript(fileObject, scriptText, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getParams(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptID(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptText(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptWithDetails(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScripts(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptsByMimetype(mimetype, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getUserScripts(acceptsList, _response=None, _ex=None, _sent=None, _ctx=None)
begin_runScript(scriptID, inputs, waitSecs, _response=None, _ex=None, _sent=None, _ctx=None)
begin_uploadOfficialScript(path, scriptText, _response=None, _ex=None, _sent=None, _ctx=None)
begin_uploadScript(path, scriptText, _response=None, _ex=None, _sent=None, _ctx=None)
begin_validateScript(j, acceptsList, _response=None, _ex=None, _sent=None, _ctx=None)
canRunScript(scriptID, _ctx=None)
canRunScript_async(_cb, scriptID, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
deleteScript(scriptID, _ctx=None)
deleteScript_async(_cb, scriptID, _ctx=None)
editScript(fileObject, scriptText, _ctx=None)
editScript_async(_cb, fileObject, scriptText, _ctx=None)
end_canRunScript(_r)
end_deleteScript(_r)
end_editScript(_r)
end_getParams(_r)
end_getScriptID(_r)
end_getScriptText(_r)
end_getScriptWithDetails(_r)
end_getScripts(_r)
end_getScriptsByMimetype(_r)
end_getUserScripts(_r)
end_runScript(_r)
end_uploadOfficialScript(_r)
end_uploadScript(_r)
end_validateScript(_r)
getParams(scriptID, _ctx=None)
getParams_async(_cb, scriptID, _ctx=None)
getScriptID(path, _ctx=None)
getScriptID_async(_cb, path, _ctx=None)
getScriptText(scriptID, _ctx=None)
getScriptText_async(_cb, scriptID, _ctx=None)
getScriptWithDetails(scriptID, _ctx=None)
getScriptWithDetails_async(_cb, scriptID, _ctx=None)
getScripts(_ctx=None)
getScriptsByMimetype(mimetype, _ctx=None)
getScriptsByMimetype_async(_cb, mimetype, _ctx=None)
getScripts_async(_cb, _ctx=None)
getUserScripts(acceptsList, _ctx=None)
getUserScripts_async(_cb, acceptsList, _ctx=None)
runScript(scriptID, inputs, waitSecs, _ctx=None)
runScript_async(_cb, scriptID, inputs, waitSecs, _ctx=None)
static uncheckedCast(proxy, facet=None)
uploadOfficialScript(path, scriptText, _ctx=None)
uploadOfficialScript_async(_cb, path, scriptText, _ctx=None)
uploadScript(path, scriptText, _ctx=None)
uploadScript_async(_cb, path, scriptText, _ctx=None)
validateScript(j, acceptsList, _ctx=None)
validateScript_async(_cb, j, acceptsList, _ctx=None)
class omero.api.ISession

Bases: omero.api.ServiceInterface

omero.model.Session creation service for OMERO. Access to all other services is dependent upon a properly created and still active omero.model.Session.

The session uuid (omero.model.Session#getUuid) can be considered a capability token, or temporary single use password. Simply by possessing it the client has access to all information available to the omero.model.Session.

Note: Both the RMI ome.system.ServiceFactory as well as the Ice omero.api.ServiceFactory use omero.api.ISession to acquire a omero.model.Session. In the Ice case, Glacier2 contacts omero.api.ISession itself and returns a ServiceFactory remote proxy. From both ServiceFactory instances, it is possible but not necessary to access omero.api.ISession.

_ice_type = <IcePy.TypeInfo object at 0x3dbbd08>
_op_closeSession = <IcePy.Operation object at 0x11feb438>
_op_createSession = <IcePy.Operation object at 0x11feb3a8>
_op_createSessionWithTimeout = <IcePy.Operation object at 0x11feb3d8>
_op_createSessionWithTimeouts = <IcePy.Operation object at 0x11feb3f0>
_op_createUserSession = <IcePy.Operation object at 0x11feb3c0>
_op_getInput = <IcePy.Operation object at 0x11feb498>
_op_getInputKeys = <IcePy.Operation object at 0x11feb4f8>
_op_getInputs = <IcePy.Operation object at 0x11feb528>
_op_getMyOpenAgentSessions = <IcePy.Operation object at 0x11feb468>
_op_getMyOpenClientSessions = <IcePy.Operation object at 0x11feb480>
_op_getMyOpenSessions = <IcePy.Operation object at 0x11feb450>
_op_getOutput = <IcePy.Operation object at 0x11feb4b0>
_op_getOutputKeys = <IcePy.Operation object at 0x11feb510>
_op_getOutputs = <IcePy.Operation object at 0x11feb540>
_op_getReferenceCount = <IcePy.Operation object at 0x11feb420>
_op_getSession = <IcePy.Operation object at 0x11feb408>
_op_setInput = <IcePy.Operation object at 0x11feb4c8>
_op_setOutput = <IcePy.Operation object at 0x11feb4e0>
closeSession_async(_cb, sess, current=None)

Closes session and releases all resources. It is preferred that all clients call this method as soon as possible to free memory, but it is possible to not call close, and rejoin a session later.

The current reference count for the session is returned. If the session does not exist, -1. If this call caused the death of the session, then -2.

createSessionWithTimeout_async(_cb, p, timeToLiveMilliseconds, current=None)

Allows an admin to create a Session for the give omero.sys.Principal.

Arguments:
principal

Non-null omero.sys.Principal with the target user’s name

timeToLiveMilliseconds

The time that this omero.model.Session has until destruction. This is useful to override the server default so that an initial delay before the user is given the token will not be construed as idle time. A value less than 1 will cause the default max timeToLive to be used; but timeToIdle will be disabled.

createSessionWithTimeouts_async(_cb, p, timeToLiveMilliseconds, timeToIdleMilliseconds, current=None)

Allows an admin to create a omero.model.Session for the given omero.sys.Principal.

Arguments:
principal

Non-null omero.sys.Principal with the target user’s name

timeToLiveMilliseconds

The time that this omero.model.Session has until destruction. Setting the value to 0 will prevent destruction unless the session remains idle.

timeToIdleMilliseconds

The time that this omero.model.Session can remain idle before being destroyed. Setting the value to 0 will prevent idleness based destruction.

createSession_async(_cb, p, credentials, current=None)

Creates a new session and returns it to the user.

Exceptions:
ApiUsageException if principal is null SecurityViolation if the password check fails
createUserSession_async(_cb, timeToLiveMilliseconds, timeToIdleMilliseconds, defaultGroup, current=None)

Allows a user to open up another session for him/herself with the given defaults without needing to re-enter password.

getInputKeys_async(_cb, sess, current=None)

Retrieves all keys in the omero.model.Session input environment.

Returns:
a StringSet of keys
getInput_async(_cb, sess, key, current=None)

Retrieves an entry from the given omero.model.Session input environment.

getInputs_async(_cb, sess, current=None)

Retrieves all inputs from the given omero.model.Session input environment.

getMyOpenAgentSessions_async(_cb, agent, current=None)

Like getMyOpenSessions but returns only those sessions with the given agent string.

getMyOpenClientSessions_async(_cb, current=None)

Like getMyOpenSessions but returns only those sessions started by official OMERO clients.

getMyOpenSessions_async(_cb, current=None)

Returns a list of open sessions for the current user. The list is ordered by session creation time, so that the last item was created last.

getOutputKeys_async(_cb, sess, current=None)

Retrieves all keys in the omero.model.Session output environment.

getOutput_async(_cb, sess, key, current=None)

Retrieves an entry from the omero.model.Session output environment.

getOutputs_async(_cb, sess, current=None)

Retrieves all outputs from the given omero.model.Session input environment.

getReferenceCount_async(_cb, sessionUuid, current=None)

Retrieves the current reference count for the given uuid. Has the same semantics as getSession.

getSession_async(_cb, sessionUuid, current=None)

Retrieves the session associated with this uuid, updating the last access time as well. Throws a RemovedSessionException if not present, or a SessionTimeoutException if expired.

This method can be used as a Session ping.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
setInput_async(_cb, sess, key, value, current=None)

Places an entry in the given omero.model.Session input environment. If the value is null, the key will be removed.

setOutput_async(_cb, sess, key, value, current=None)

Places an entry in the given omero.model.Session output environment. If the value is null, the key will be removed.

class omero.api.ISessionPrx

Bases: omero.api.ServiceInterfacePrx

Creates a new session and returns it to the user.

Exceptions:
ApiUsageException if principal is null SecurityViolation if the password check fails
begin_closeSession(sess, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createSession(p, credentials, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createSessionWithTimeout(p, timeToLiveMilliseconds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createSessionWithTimeouts(p, timeToLiveMilliseconds, timeToIdleMilliseconds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createUserSession(timeToLiveMilliseconds, timeToIdleMilliseconds, defaultGroup, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getInput(sess, key, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getInputKeys(sess, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getInputs(sess, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMyOpenAgentSessions(agent, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMyOpenClientSessions(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getMyOpenSessions(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getOutput(sess, key, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getOutputKeys(sess, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getOutputs(sess, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getReferenceCount(sessionUuid, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getSession(sessionUuid, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setInput(sess, key, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setOutput(sess, key, value, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
closeSession(sess, _ctx=None)
closeSession_async(_cb, sess, _ctx=None)
createSession(p, credentials, _ctx=None)
createSessionWithTimeout(p, timeToLiveMilliseconds, _ctx=None)
createSessionWithTimeout_async(_cb, p, timeToLiveMilliseconds, _ctx=None)
createSessionWithTimeouts(p, timeToLiveMilliseconds, timeToIdleMilliseconds, _ctx=None)
createSessionWithTimeouts_async(_cb, p, timeToLiveMilliseconds, timeToIdleMilliseconds, _ctx=None)
createSession_async(_cb, p, credentials, _ctx=None)
createUserSession(timeToLiveMilliseconds, timeToIdleMilliseconds, defaultGroup, _ctx=None)
createUserSession_async(_cb, timeToLiveMilliseconds, timeToIdleMilliseconds, defaultGroup, _ctx=None)
end_closeSession(_r)
end_createSession(_r)
end_createSessionWithTimeout(_r)
end_createSessionWithTimeouts(_r)
end_createUserSession(_r)
end_getInput(_r)
end_getInputKeys(_r)
end_getInputs(_r)
end_getMyOpenAgentSessions(_r)
end_getMyOpenClientSessions(_r)
end_getMyOpenSessions(_r)
end_getOutput(_r)
end_getOutputKeys(_r)
end_getOutputs(_r)
end_getReferenceCount(_r)
end_getSession(_r)
end_setInput(_r)
end_setOutput(_r)
getInput(sess, key, _ctx=None)
getInputKeys(sess, _ctx=None)
getInputKeys_async(_cb, sess, _ctx=None)
getInput_async(_cb, sess, key, _ctx=None)
getInputs(sess, _ctx=None)
getInputs_async(_cb, sess, _ctx=None)
getMyOpenAgentSessions(agent, _ctx=None)
getMyOpenAgentSessions_async(_cb, agent, _ctx=None)
getMyOpenClientSessions(_ctx=None)
getMyOpenClientSessions_async(_cb, _ctx=None)
getMyOpenSessions(_ctx=None)
getMyOpenSessions_async(_cb, _ctx=None)
getOutput(sess, key, _ctx=None)
getOutputKeys(sess, _ctx=None)
getOutputKeys_async(_cb, sess, _ctx=None)
getOutput_async(_cb, sess, key, _ctx=None)
getOutputs(sess, _ctx=None)
getOutputs_async(_cb, sess, _ctx=None)
getReferenceCount(sessionUuid, _ctx=None)
getReferenceCount_async(_cb, sessionUuid, _ctx=None)
getSession(sessionUuid, _ctx=None)
getSession_async(_cb, sessionUuid, _ctx=None)
setInput(sess, key, value, _ctx=None)
setInput_async(_cb, sess, key, value, _ctx=None)
setOutput(sess, key, value, _ctx=None)
setOutput_async(_cb, sess, key, value, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.IShare

Bases: omero.api.ServiceInterface

Provides method for sharing - collaboration process for images, datasets, projects.

_ice_type = <IcePy.TypeInfo object at 0x3dbbd38>
_op_activate = <IcePy.Operation object at 0x11feb558>
_op_addComment = <IcePy.Operation object at 0x11feb780>
_op_addGuest = <IcePy.Operation object at 0x11feb888>
_op_addGuests = <IcePy.Operation object at 0x11feb828>
_op_addObject = <IcePy.Operation object at 0x11feb708>
_op_addObjects = <IcePy.Operation object at 0x11feb6f0>
_op_addReply = <IcePy.Operation object at 0x11feb798>
_op_addUser = <IcePy.Operation object at 0x11feb870>
_op_addUsers = <IcePy.Operation object at 0x11feb810>
_op_closeShare = <IcePy.Operation object at 0x11feb6d8>
_op_createShare = <IcePy.Operation object at 0x11feb678>
_op_deactivate = <IcePy.Operation object at 0x11feb570>
_op_deleteComment = <IcePy.Operation object at 0x11feb7b0>
_op_getActiveConnections = <IcePy.Operation object at 0x11feb8d0>
_op_getAllGuests = <IcePy.Operation object at 0x11feb7e0>
_op_getAllMembers = <IcePy.Operation object at 0x11feb7c8>
_op_getAllUsers = <IcePy.Operation object at 0x11feb7f8>
_op_getCommentCount = <IcePy.Operation object at 0x11feb750>
_op_getComments = <IcePy.Operation object at 0x11feb768>
_op_getContentMap = <IcePy.Operation object at 0x11feb660>
_op_getContentSize = <IcePy.Operation object at 0x11feb648>
_op_getContentSubList = <IcePy.Operation object at 0x11feb630>
_op_getContents = <IcePy.Operation object at 0x11feb618>
_op_getEvents = <IcePy.Operation object at 0x11feb918>
_op_getMemberCount = <IcePy.Operation object at 0x11feb5a0>
_op_getMemberShares = <IcePy.Operation object at 0x11feb5d0>
_op_getMemberSharesFor = <IcePy.Operation object at 0x11feb600>
_op_getOwnShares = <IcePy.Operation object at 0x11feb5b8>
_op_getPastConnections = <IcePy.Operation object at 0x11feb8e8>
_op_getShare = <IcePy.Operation object at 0x11feb588>
_op_getSharesOwnedBy = <IcePy.Operation object at 0x11feb5e8>
_op_invalidateConnection = <IcePy.Operation object at 0x11feb900>
_op_notifyMembersOfShare = <IcePy.Operation object at 0x11feb930>
_op_removeGuest = <IcePy.Operation object at 0x11feb8b8>
_op_removeGuests = <IcePy.Operation object at 0x11feb858>
_op_removeObject = <IcePy.Operation object at 0x11feb738>
_op_removeObjects = <IcePy.Operation object at 0x11feb720>
_op_removeUser = <IcePy.Operation object at 0x11feb8a0>
_op_removeUsers = <IcePy.Operation object at 0x11feb840>
_op_setActive = <IcePy.Operation object at 0x11feb6c0>
_op_setDescription = <IcePy.Operation object at 0x11feb690>
_op_setExpiration = <IcePy.Operation object at 0x11feb6a8>
activate_async(_cb, shareId, current=None)

Turns on the access control lists attached to the given share for the current session. Warning: this will slow down the execution of the current session for all database reads. Writing to the database will not be allowed. If share does not exist or is not accessible (non-members) or is disabled, then an ValidationException is thrown.

addComment_async(_cb, shareId, comment, current=None)

Creates omero.model.TextAnnotation comment for omero.model.Session share.

addGuest_async(_cb, shareId, emailAddress, current=None)

Adds guest email address to the share.

addGuests_async(_cb, shareId, emailAddresses, current=None)

Adds guest email addresses to the share.

addObject_async(_cb, shareId, iobject, current=None)

Adds new omero.model.IObject item to omero.model.Session share. The entire object graph with the exception of all Details will be loaded into the share. If you would like to load a single object, then pass an unloaded reference.

addObjects_async(_cb, shareId, iobjects, current=None)

Adds new omero.model.IObject items to omero.model.Session share. Conceptually calls addObjects for every argument passed, but the graphs will be merged.

addReply_async(_cb, shareId, comment, replyTo, current=None)

Creates omero.model.TextAnnotation comment which replies to an existing comment.

Returns:
the new omero.model.TextAnnotation
addUser_async(_cb, shareId, exp, current=None)

Adds omero.model.Experimenter experimenter to omero.model.Session share.

addUsers_async(_cb, shareId, exps, current=None)

Adds omero.model.Experimenter experimenters to omero.model.Session share.

closeShare_async(_cb, shareId, current=None)

Closes omero.model.Session share. No further logins will be possible and all getters (e.g. getMemberShares, getOwnShares, ...) will filter these results if {@code onlyActive} is true.

createShare_async(_cb, description, expiration, items, exps, guests, enabled, current=None)

Creates omero.model.Session share with all related: omero.model.IObject itmes, omero.model.Experimenter members, and guests.

Arguments:
enabled

if true, then the share is immediately available for use. If false, then the share is in draft state. All methods on this interface will work for shares except activate. Similarly, the share password cannot be used by guests to login.

deactivate_async(_cb, current=None)

Turns off the access control lists with the current share.

deleteComment_async(_cb, comment, current=None)

Deletes omero.model.Annotation comment from the database.

getActiveConnections_async(_cb, shareId, current=None)

Gets actual active connections to omero.model.Session share.

Returns:
map of experimenter and IP address
getAllGuests_async(_cb, shareId, current=None)

Get the email addresses for all share guests.

getAllMembers_async(_cb, shareId, current=None)

Get all omero.model.Experimenter users who are a member of the share.

getAllUsers_async(_cb, shareId, current=None)

Get a single set containing the omero.model.Experimenter#getOmeName login names of the users as well email addresses for guests.

Arguments:
shareId
Returns:
a StringSet containing the login of all

users Exceptions:

ValidationException

if there is a conflict between email addresses and user names.

getCommentCount_async(_cb, shareIds, current=None)

Returns a map from share id to comment count.

Arguments:
shareIds Not null.
Returns:
Map with all ids present and 0 if no count exists.
Exceptions:
ValidationException if a given share does not exist
getComments_async(_cb, shareId, current=None)

Looks up all omero.model.Annotation comments which belong to the omero.model.Session share.

Returns:
list of Annotation
getContentMap_async(_cb, shareId, current=None)

Returns the contents of the share keyed by type.

getContentSize_async(_cb, shareId, current=None)

Returns the number of items in the share.

getContentSubList_async(_cb, shareId, start, finish, current=None)

Returns a range of items from the share.

getContents_async(_cb, shareId, current=None)

Looks up all omero.model.IObject items belong to the omero.model.Session share.

Returns:
list of objects. Not null. Probably not empty.
getEvents_async(_cb, shareId, exp, _from, to, current=None)

Gets events for omero.model.Session share per omero.model.Experimenter experimenter for period of time. Returns:

List of events
getMemberCount_async(_cb, shareIds, current=None)

Returns a map from share id to the count of total members (including the owner). This is represented by omero.model.ShareMember links.

Arguments:
shareIds Not null.
Returns:
Map with all ids present.
Exceptions:
ValidationException if a given share does not exist
getMemberSharesFor_async(_cb, user, active, current=None)

Gets all shares where given omero.model.Experimenter is a member.

Arguments:
onlyActive

if true, then only shares which can be used for login will be returned. All draft shares (see createShare) and closed shares (see closeShare) will be filtered. Returns:

set of shares. Never null. May be empty.
getMemberShares_async(_cb, active, current=None)

Gets all shares where current omero.model.Experimenter is a member.

Arguments:
onlyActive

if true, then only shares which can be used for login will be returned. All draft shares (see createShare) and closed shares (see closeShare) will be filtered. Returns:

set of shares. Never null. May be empty.
getOwnShares_async(_cb, active, current=None)

Gets all owned shares for the current omero.model.Experimenter.

Arguments:
onlyActive

if true, then only shares which can be used for login will be returned. All draft shares (see createShare) and closed shares (see closeShare) will be filtered. Returns:

set of shares. Never null. May be empty.
getPastConnections_async(_cb, shareId, current=None)

Gets previous connections to omero.model.Session share.

Returns:
map of experimenter and IP address
getShare_async(_cb, shareId, current=None)

Gets a share as a omero.model.Session with all related: omero.model.Annotation comments, omero.model.Experimenter members, fully loaded. Unlike the other methods on this interface, if the sessionId is unknown, does not throw a omero.ValidationException.

Returns:
a omero.model.Session with id and

omero.model.Details set or null. The owner in the Details object is the true owner, and the group in the Details has all member users linked. omero.model.Annotation instances of the share are linked to the omero.model.Session. Missing is a list of share guests.

getSharesOwnedBy_async(_cb, user, active, current=None)

Gets all shares owned by the given omero.model.Experimenter.

Arguments:
onlyActive

if true, then only shares which can be used for login will be returned. All draft shares (see createShare) and closed shares (see closeShare) will be filtered. Returns:

set of shares. Never null. May be empty.
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
invalidateConnection_async(_cb, shareId, exp, current=None)

Makes the connection invalid for omero.model.Session share for specified user.

notifyMembersOfShare_async(_cb, shareId, subject, message, html, current=None)

Notifies via email selected members of share.

removeGuest_async(_cb, shareId, emailAddress, current=None)

Removes guest email address from share.

removeGuests_async(_cb, shareId, emailAddresses, current=None)

Removes guest email addresses from the share.

removeObject_async(_cb, shareId, iobject, current=None)

Removes existing omero.model.IObject object from the omero.model.Session share.

removeObjects_async(_cb, shareId, iobjects, current=None)

Remove existing items from the share.

removeUser_async(_cb, shareId, exp, current=None)

Removes omero.model.Experimenter experimenter from omero.model.Session share.

removeUsers_async(_cb, shareId, exps, current=None)

Removes omero.model.Experimenter experimenters from omero.model.Session share.

setActive_async(_cb, shareId, active, current=None)
setDescription_async(_cb, shareId, description, current=None)
setExpiration_async(_cb, shareId, expiration, current=None)
class omero.api.ISharePrx

Bases: omero.api.ServiceInterfacePrx

Turns on the access control lists attached to the given share for the current session. Warning: this will slow down the execution of the current session for all database reads. Writing to the database will not be allowed. If share does not exist or is not accessible (non-members) or is disabled, then an ValidationException is thrown.

activate(shareId, _ctx=None)
activate_async(_cb, shareId, _ctx=None)
addComment(shareId, comment, _ctx=None)
addComment_async(_cb, shareId, comment, _ctx=None)
addGuest(shareId, emailAddress, _ctx=None)
addGuest_async(_cb, shareId, emailAddress, _ctx=None)
addGuests(shareId, emailAddresses, _ctx=None)
addGuests_async(_cb, shareId, emailAddresses, _ctx=None)
addObject(shareId, iobject, _ctx=None)
addObject_async(_cb, shareId, iobject, _ctx=None)
addObjects(shareId, iobjects, _ctx=None)
addObjects_async(_cb, shareId, iobjects, _ctx=None)
addReply(shareId, comment, replyTo, _ctx=None)
addReply_async(_cb, shareId, comment, replyTo, _ctx=None)
addUser(shareId, exp, _ctx=None)
addUser_async(_cb, shareId, exp, _ctx=None)
addUsers(shareId, exps, _ctx=None)
addUsers_async(_cb, shareId, exps, _ctx=None)
begin_activate(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addComment(shareId, comment, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addGuest(shareId, emailAddress, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addGuests(shareId, emailAddresses, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addObject(shareId, iobject, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addObjects(shareId, iobjects, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addReply(shareId, comment, replyTo, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addUser(shareId, exp, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addUsers(shareId, exps, _response=None, _ex=None, _sent=None, _ctx=None)
begin_closeShare(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createShare(description, expiration, items, exps, guests, enabled, _response=None, _ex=None, _sent=None, _ctx=None)
begin_deactivate(_response=None, _ex=None, _sent=None, _ctx=None)
begin_deleteComment(comment, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getActiveConnections(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAllGuests(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAllMembers(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAllUsers(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getCommentCount(shareIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getComments(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getContentMap(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getContentSize(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getContentSubList(shareId, start, finish, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getContents(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getEvents(shareId, exp, _from, to, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMemberCount(shareIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMemberShares(active, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMemberSharesFor(user, active, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getOwnShares(active, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPastConnections(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getShare(shareId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getSharesOwnedBy(user, active, _response=None, _ex=None, _sent=None, _ctx=None)
begin_invalidateConnection(shareId, exp, _response=None, _ex=None, _sent=None, _ctx=None)
begin_notifyMembersOfShare(shareId, subject, message, html, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeGuest(shareId, emailAddress, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeGuests(shareId, emailAddresses, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeObject(shareId, iobject, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeObjects(shareId, iobjects, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeUser(shareId, exp, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeUsers(shareId, exps, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setActive(shareId, active, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setDescription(shareId, description, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setExpiration(shareId, expiration, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
closeShare(shareId, _ctx=None)
closeShare_async(_cb, shareId, _ctx=None)
createShare(description, expiration, items, exps, guests, enabled, _ctx=None)
createShare_async(_cb, description, expiration, items, exps, guests, enabled, _ctx=None)
deactivate(_ctx=None)
deactivate_async(_cb, _ctx=None)
deleteComment(comment, _ctx=None)
deleteComment_async(_cb, comment, _ctx=None)
end_activate(_r)
end_addComment(_r)
end_addGuest(_r)
end_addGuests(_r)
end_addObject(_r)
end_addObjects(_r)
end_addReply(_r)
end_addUser(_r)
end_addUsers(_r)
end_closeShare(_r)
end_createShare(_r)
end_deactivate(_r)
end_deleteComment(_r)
end_getActiveConnections(_r)
end_getAllGuests(_r)
end_getAllMembers(_r)
end_getAllUsers(_r)
end_getCommentCount(_r)
end_getComments(_r)
end_getContentMap(_r)
end_getContentSize(_r)
end_getContentSubList(_r)
end_getContents(_r)
end_getEvents(_r)
end_getMemberCount(_r)
end_getMemberShares(_r)
end_getMemberSharesFor(_r)
end_getOwnShares(_r)
end_getPastConnections(_r)
end_getShare(_r)
end_getSharesOwnedBy(_r)
end_invalidateConnection(_r)
end_notifyMembersOfShare(_r)
end_removeGuest(_r)
end_removeGuests(_r)
end_removeObject(_r)
end_removeObjects(_r)
end_removeUser(_r)
end_removeUsers(_r)
end_setActive(_r)
end_setDescription(_r)
end_setExpiration(_r)
getActiveConnections(shareId, _ctx=None)
getActiveConnections_async(_cb, shareId, _ctx=None)
getAllGuests(shareId, _ctx=None)
getAllGuests_async(_cb, shareId, _ctx=None)
getAllMembers(shareId, _ctx=None)
getAllMembers_async(_cb, shareId, _ctx=None)
getAllUsers(shareId, _ctx=None)
getAllUsers_async(_cb, shareId, _ctx=None)
getCommentCount(shareIds, _ctx=None)
getCommentCount_async(_cb, shareIds, _ctx=None)
getComments(shareId, _ctx=None)
getComments_async(_cb, shareId, _ctx=None)
getContentMap(shareId, _ctx=None)
getContentMap_async(_cb, shareId, _ctx=None)
getContentSize(shareId, _ctx=None)
getContentSize_async(_cb, shareId, _ctx=None)
getContentSubList(shareId, start, finish, _ctx=None)
getContentSubList_async(_cb, shareId, start, finish, _ctx=None)
getContents(shareId, _ctx=None)
getContents_async(_cb, shareId, _ctx=None)
getEvents(shareId, exp, _from, to, _ctx=None)
getEvents_async(_cb, shareId, exp, _from, to, _ctx=None)
getMemberCount(shareIds, _ctx=None)
getMemberCount_async(_cb, shareIds, _ctx=None)
getMemberShares(active, _ctx=None)
getMemberSharesFor(user, active, _ctx=None)
getMemberSharesFor_async(_cb, user, active, _ctx=None)
getMemberShares_async(_cb, active, _ctx=None)
getOwnShares(active, _ctx=None)
getOwnShares_async(_cb, active, _ctx=None)
getPastConnections(shareId, _ctx=None)
getPastConnections_async(_cb, shareId, _ctx=None)
getShare(shareId, _ctx=None)
getShare_async(_cb, shareId, _ctx=None)
getSharesOwnedBy(user, active, _ctx=None)
getSharesOwnedBy_async(_cb, user, active, _ctx=None)
invalidateConnection(shareId, exp, _ctx=None)
invalidateConnection_async(_cb, shareId, exp, _ctx=None)
notifyMembersOfShare(shareId, subject, message, html, _ctx=None)
notifyMembersOfShare_async(_cb, shareId, subject, message, html, _ctx=None)
removeGuest(shareId, emailAddress, _ctx=None)
removeGuest_async(_cb, shareId, emailAddress, _ctx=None)
removeGuests(shareId, emailAddresses, _ctx=None)
removeGuests_async(_cb, shareId, emailAddresses, _ctx=None)
removeObject(shareId, iobject, _ctx=None)
removeObject_async(_cb, shareId, iobject, _ctx=None)
removeObjects(shareId, iobjects, _ctx=None)
removeObjects_async(_cb, shareId, iobjects, _ctx=None)
removeUser(shareId, exp, _ctx=None)
removeUser_async(_cb, shareId, exp, _ctx=None)
removeUsers(shareId, exps, _ctx=None)
removeUsers_async(_cb, shareId, exps, _ctx=None)
setActive(shareId, active, _ctx=None)
setActive_async(_cb, shareId, active, _ctx=None)
setDescription(shareId, description, _ctx=None)
setDescription_async(_cb, shareId, description, _ctx=None)
setExpiration(shareId, expiration, _ctx=None)
setExpiration_async(_cb, shareId, expiration, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.ITimeline

Bases: omero.api.ServiceInterface

Service for the querying of OMERO metadata based on creation and modification time. Currently supported types for querying include:

omero.model.Annotation omero.model.Dataset omero.model.Image omero.model.Project omero.model.RenderingDef

Return maps

The map return values will be indexed by the short type name above: Project, Image, ... All keys which are passed in the StringSet argument will be included in the returned map, even if they have no values. A default value of 0 or the empty list [] will be used. The only exception to this rule is that the null or empty StringSet implies all valid keys.

Parameters

All methods take a omero::sys::Parameters object and will apply the filter object for paging through the data in order to prevent loading too many objects. If the parameters argument is null or no paging is activated, then the default will be: OFFSET=0, LIMIT=50. Filter.ownerId and Filter.groupId will also be AND’ed to the query if either value is present. If both are null, then the current user id will be used. To retrieve for all users, use ownerId == rlong(-1) and groupId == null.

Merging

The methods which take a StringSet and a Parameters object, also have a bool merge argument. This argument defines whether or not the LIMIT applies to each object independently ([“a”,”b”] @ 100 == 200) or merges the lists together chronologically ([“a”,”b”] @ 100 merged == 100).

Time used

Except for Image, IObject.details.updateEvent is used in all cases for determining most recent events. Images are compared via Image.acquisitionDate which is unlike the other properties is modifiable by the user.

A typical invocation might look like (in Python):

timeline = sf.getTimelineService() params = ParametersI().page(0,100) types = [“Project”,”Dataset”]) map = timeline.getByPeriod(types, params, False)

At this point, map will not contain more than 200 objects.

This service is defined only in Blitz and so no javadoc is available in the ome.api package.

TODOS: binning, stateful caching, ...

_ice_type = <IcePy.TypeInfo object at 0x3dbbe28>
_op_countByPeriod = <IcePy.Operation object at 0x11feb9a8>
_op_getByPeriod = <IcePy.Operation object at 0x11feb990>
_op_getEventLogsByPeriod = <IcePy.Operation object at 0x11feb9c0>
_op_getMostRecentObjects = <IcePy.Operation object at 0x11feb978>
countByPeriod_async(_cb, types, start, end, p, current=None)

Queries the same information as getByPeriod, but only returns the counts for the given objects.

getByPeriod_async(_cb, types, start, end, p, merge, current=None)

Returns the given LIMIT objects of TYPES as ordered by creation/modification times in the Event table, but within the given time window.

getEventLogsByPeriod_async(_cb, start, end, p, current=None)

Returns the EventLog table objects which are queried to produce the counts above. Note the concept of period inclusion mentioned above.

WORKAROUND WARNING: this method returns non-managed EventLogs (i.e. eventLog.getId() == null) for Image acquisitions.

Return the last LIMIT annotation __Links__ whose parent (IAnnotated) matches one of the parentTypes, whose child (Annotation) matches one of the childTypes (limit of one for the moment), and who namespace matches via ILIKE.

The parents and children will be unloaded. The link will have its creation/update events loaded.

If Parameters.theFilter.ownerId or groupId are set, they will be AND’ed to the query to filter results.

Merges by default based on parentType.

getMostRecentObjects_async(_cb, types, p, merge, current=None)

Returns the last LIMIT objects of TYPES as ordered by creation/modification times in the Event table.

Return the last LIMIT comment annotation links attached to a share by __others__.

Note: Currently the storage of these objects is not optimal and so this method may change.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.ITimelinePrx

Bases: omero.api.ServiceInterfacePrx

Return the last LIMIT annotation __Links__ whose parent (IAnnotated) matches one of the parentTypes, whose child (Annotation) matches one of the childTypes (limit of one for the moment), and who namespace matches via ILIKE.

The parents and children will be unloaded. The link will have its creation/update events loaded.

If Parameters.theFilter.ownerId or groupId are set, they will be AND’ed to the query to filter results.

Merges by default based on parentType.

begin_countByPeriod(types, start, end, p, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getByPeriod(types, start, end, p, merge, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getEventLogsByPeriod(start, end, p, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getMostRecentObjects(types, p, merge, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
countByPeriod(types, start, end, p, _ctx=None)
countByPeriod_async(_cb, types, start, end, p, _ctx=None)
end_countByPeriod(_r)
end_getByPeriod(_r)
end_getEventLogsByPeriod(_r)
end_getMostRecentObjects(_r)
getByPeriod(types, start, end, p, merge, _ctx=None)
getByPeriod_async(_cb, types, start, end, p, merge, _ctx=None)
getEventLogsByPeriod(start, end, p, _ctx=None)
getEventLogsByPeriod_async(_cb, start, end, p, _ctx=None)
getMostRecentObjects(types, p, merge, _ctx=None)
getMostRecentObjects_async(_cb, types, p, merge, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.ITypes

Bases: omero.api.ServiceInterface

Access to reflective type information. Also provides simplified access to special types like enumerations.

_ice_type = <IcePy.TypeInfo object at 0x3dbbd68>
_op_allEnumerations = <IcePy.Operation object at 0x11feba08>
_op_createEnumeration = <IcePy.Operation object at 0x11feb9d8>
_op_deleteEnumeration = <IcePy.Operation object at 0x11feba50>
_op_getAnnotationTypes = <IcePy.Operation object at 0x11feba80>
_op_getEnumeration = <IcePy.Operation object at 0x11feb9f0>
_op_getEnumerationTypes = <IcePy.Operation object at 0x11feba68>
_op_getEnumerationsWithEntries = <IcePy.Operation object at 0x11feba98>
_op_getOriginalEnumerations = <IcePy.Operation object at 0x11febab0>
_op_resetEnumerations = <IcePy.Operation object at 0x11febac8>
_op_updateEnumeration = <IcePy.Operation object at 0x11feba20>
_op_updateEnumerations = <IcePy.Operation object at 0x11feba38>
allEnumerations_async(_cb, type, current=None)
createEnumeration_async(_cb, newEnum, current=None)
deleteEnumeration_async(_cb, oldEnum, current=None)

Deletes enumeration value specified by object.

Arguments:
oldEnum An enumeration object which should be

searched.

getAnnotationTypes_async(_cb, current=None)

Returns a list of classes which implement omero.model.IAnnotated. These can be used in combination with omero.api.Search.

Returns:
a StringSet of

omero.model.IAnnotated implementations

getEnumerationTypes_async(_cb, current=None)

Gets all metadata classes which are IEnum type.

Returns:
set of classes that extend IEnum
Exceptions:
RuntimeException if Class not found.
getEnumeration_async(_cb, type, value, current=None)

Lookup an enumeration value. As with the get-methods of omero.api.IQuery queries returning no results will through an exception.

Arguments:
type An enumeration class which should be searched. value The value for which an enumeration should be

found. Returns:

A managed enumeration. Never null.
Exceptions:
ApiUsageException

if omero.model.IEnum is not found.

getEnumerationsWithEntries_async(_cb, current=None)

Gets all metadata classes which are IEnum type with contained objects.

Returns:
map of classes that extend IEnum
Exceptions:
RuntimeExceptionif xml parsing failure.
getOriginalEnumerations_async(_cb, current=None)

Gets all original values.

Returns:
A list of managed enumerations.
Exceptions:
RuntimeException if xml parsing failure.
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
resetEnumerations_async(_cb, enumClass, current=None)
updateEnumeration_async(_cb, oldEnum, current=None)

Updates enumeration value specified by object.

Arguments:
oldEnum An enumeration object which should be

searched. Returns:

A managed enumeration. Never null.
updateEnumerations_async(_cb, oldEnums, current=None)

Updates enumeration value specified by object.

Arguments:
oldEnums An enumeration collection of objects which

should be searched.

class omero.api.ITypesPrx

Bases: omero.api.ServiceInterfacePrx

allEnumerations(type, _ctx=None)
allEnumerations_async(_cb, type, _ctx=None)
begin_allEnumerations(type, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createEnumeration(newEnum, _response=None, _ex=None, _sent=None, _ctx=None)
begin_deleteEnumeration(oldEnum, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAnnotationTypes(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getEnumeration(type, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getEnumerationTypes(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getEnumerationsWithEntries(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getOriginalEnumerations(_response=None, _ex=None, _sent=None, _ctx=None)
begin_resetEnumerations(enumClass, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateEnumeration(oldEnum, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateEnumerations(oldEnums, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
createEnumeration(newEnum, _ctx=None)
createEnumeration_async(_cb, newEnum, _ctx=None)
deleteEnumeration(oldEnum, _ctx=None)
deleteEnumeration_async(_cb, oldEnum, _ctx=None)
end_allEnumerations(_r)
end_createEnumeration(_r)
end_deleteEnumeration(_r)
end_getAnnotationTypes(_r)
end_getEnumeration(_r)
end_getEnumerationTypes(_r)
end_getEnumerationsWithEntries(_r)
end_getOriginalEnumerations(_r)
end_resetEnumerations(_r)
end_updateEnumeration(_r)
end_updateEnumerations(_r)
getAnnotationTypes(_ctx=None)
getAnnotationTypes_async(_cb, _ctx=None)
getEnumeration(type, value, _ctx=None)
getEnumerationTypes(_ctx=None)
getEnumerationTypes_async(_cb, _ctx=None)
getEnumeration_async(_cb, type, value, _ctx=None)
getEnumerationsWithEntries(_ctx=None)
getEnumerationsWithEntries_async(_cb, _ctx=None)
getOriginalEnumerations(_ctx=None)
getOriginalEnumerations_async(_cb, _ctx=None)
resetEnumerations(enumClass, _ctx=None)
resetEnumerations_async(_cb, enumClass, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateEnumeration(oldEnum, _ctx=None)
updateEnumeration_async(_cb, oldEnum, _ctx=None)
updateEnumerations(oldEnums, _ctx=None)
updateEnumerations_async(_cb, oldEnums, _ctx=None)
class omero.api.IUpdate

Bases: omero.api.ServiceInterface

Provides methods for directly updating object graphs. IUpdate is the lowest level (level-1) interface which may make changes (INSERT, UPDATE, DELETE) to the database. All other methods of changing the database may leave it in an inconsistent state.

All the save* methods act recursively on the entire object graph, replacing placeholders and details where necessary, and then merging the final graph. This means that the objects that are passed into IUpdate.save* methods are copied over to new instances which are then returned. The original objects should be discarded.

saveAndReturnIds behaves slightly differently in that it does not handle object modifications. The graph of objects passed in can consist ONLY if either newly created objects without ids or of unloaded objects with ids. Note: The ids of the saved values may not be in order. This is caused by persistence-by-transitivity. Hibernate may detect an item later in the array if they are interconnected and therefore choose to save it first.

All methods throw omero.ValidationException if the input objects do not pass validation, and omero.OptimisticLockException if the version of a given has already been incremented.

_ice_type = <IcePy.TypeInfo object at 0x3dbbd98>
_op_deleteObject = <IcePy.Operation object at 0x11febb70>
_op_indexObject = <IcePy.Operation object at 0x11febb88>
_op_saveAndReturnArray = <IcePy.Operation object at 0x11febb40>
_op_saveAndReturnIds = <IcePy.Operation object at 0x11febb58>
_op_saveAndReturnObject = <IcePy.Operation object at 0x11febb10>
_op_saveArray = <IcePy.Operation object at 0x11febb28>
_op_saveCollection = <IcePy.Operation object at 0x11febaf8>
_op_saveObject = <IcePy.Operation object at 0x11febae0>
deleteObject_async(_cb, row, current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
indexObject_async(_cb, row, current=None)

Initiates full-text indexing for the given object. This may have to wait for the current {@code FullTextThread} to finish. Can only be executed by an admin. Other users must wait for the background Thread to complete.

Arguments:
row

a persistent IObject to be deleted Exceptions:

ValidationException

if the object does not exist or is nul

saveAndReturnArray_async(_cb, graph, current=None)
saveAndReturnIds_async(_cb, graph, current=None)
saveAndReturnObject_async(_cb, obj, current=None)
saveArray_async(_cb, graph, current=None)
saveCollection_async(_cb, objs, current=None)
saveObject_async(_cb, obj, current=None)
class omero.api.IUpdatePrx

Bases: omero.api.ServiceInterfacePrx

begin_deleteObject(row, _response=None, _ex=None, _sent=None, _ctx=None)
begin_indexObject(row, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveAndReturnArray(graph, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveAndReturnIds(graph, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveAndReturnObject(obj, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveArray(graph, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveCollection(objs, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveObject(obj, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
deleteObject(row, _ctx=None)
deleteObject_async(_cb, row, _ctx=None)
end_deleteObject(_r)
end_indexObject(_r)
end_saveAndReturnArray(_r)
end_saveAndReturnIds(_r)
end_saveAndReturnObject(_r)
end_saveArray(_r)
end_saveCollection(_r)
end_saveObject(_r)
indexObject(row, _ctx=None)
indexObject_async(_cb, row, _ctx=None)
saveAndReturnArray(graph, _ctx=None)
saveAndReturnArray_async(_cb, graph, _ctx=None)
saveAndReturnIds(graph, _ctx=None)
saveAndReturnIds_async(_cb, graph, _ctx=None)
saveAndReturnObject(obj, _ctx=None)
saveAndReturnObject_async(_cb, obj, _ctx=None)
saveArray(graph, _ctx=None)
saveArray_async(_cb, graph, _ctx=None)
saveCollection(objs, _ctx=None)
saveCollection_async(_cb, objs, _ctx=None)
saveObject(obj, _ctx=None)
saveObject_async(_cb, obj, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.JobHandle

Bases: omero.api.StatefulServiceInterface

Allows submission of asynchronous jobs.

NOTE: The calling order for the service is as follows:

submit or attach any of the other methods close

Calling close does not cancel or otherwise change the Job state. See cancelJob.

_ice_type = <IcePy.TypeInfo object at 0x3dbbe88>
_op_attach = <IcePy.Operation object at 0x11febc78>
_op_cancelJob = <IcePy.Operation object at 0x11febd20>
_op_getJob = <IcePy.Operation object at 0x11febc90>
_op_jobError = <IcePy.Operation object at 0x11febd08>
_op_jobFinished = <IcePy.Operation object at 0x11febcc0>
_op_jobMessage = <IcePy.Operation object at 0x11febcd8>
_op_jobRunning = <IcePy.Operation object at 0x11febcf0>
_op_jobStatus = <IcePy.Operation object at 0x11febca8>
_op_setMessage = <IcePy.Operation object at 0x11febd50>
_op_setStatus = <IcePy.Operation object at 0x11febd38>
_op_setStatusAndMessage = <IcePy.Operation object at 0x11febd68>
_op_submit = <IcePy.Operation object at 0x11febc60>
attach_async(_cb, jobId, current=None)

Returns the current omero.model.JobStatus for the Job id.

Exceptions:
ApiUsageException

if the Job id does not exist.

cancelJob_async(_cb, current=None)

Marks a job for cancellation. Not every processor will check for the cancelled flag for a running job, but no non-running job will start if it has been cancelled.

getJob_async(_cb, current=None)

Returns the current omero.model.Job

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
jobError_async(_cb, current=None)

Returns true if the omero.model.Job has thrown an error.

jobFinished_async(_cb, current=None)

Returns null if the omero.model.Job is not finished, otherwise the omero.RTime for when it completed.

jobMessage_async(_cb, current=None)

Returns the current message for job. May be set during processing.

jobRunning_async(_cb, current=None)

Returns true if the omero.model.Job is running, i.e. has an attached process.

jobStatus_async(_cb, current=None)

Returns the current omero.model.JobStatus. Will never return null.

setMessage_async(_cb, message, current=None)

Sets the job’s message string, and returns the previous value.

Returns:
the previous message value
setStatusAndMessage_async(_cb, status, message, current=None)

Like setStatus but also sets the message.

setStatus_async(_cb, status, current=None)

Updates the omero.model.JobStatus for the current job. The previous status is returned as a string. If the status is CANCELLED, this method is equivalent to cancelJob.

submit_async(_cb, j, current=None)

Submits a omero.model.Job and returns its database id. The only fields directly on status which are editable are message, scheduledFor and status. The latter two must be sensible.

Arguments:
job Not null
class omero.api.JobHandlePrx

Bases: omero.api.StatefulServiceInterfacePrx

Submits a omero.model.Job and returns its database id. The only fields directly on status which are editable are message, scheduledFor and status. The latter two must be sensible.

Arguments:
job Not null
attach(jobId, _ctx=None)
attach_async(_cb, jobId, _ctx=None)
begin_attach(jobId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_cancelJob(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getJob(_response=None, _ex=None, _sent=None, _ctx=None)
begin_jobError(_response=None, _ex=None, _sent=None, _ctx=None)
begin_jobFinished(_response=None, _ex=None, _sent=None, _ctx=None)
begin_jobMessage(_response=None, _ex=None, _sent=None, _ctx=None)
begin_jobRunning(_response=None, _ex=None, _sent=None, _ctx=None)
begin_jobStatus(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setMessage(message, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setStatus(status, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setStatusAndMessage(status, message, _response=None, _ex=None, _sent=None, _ctx=None)
begin_submit(j, _response=None, _ex=None, _sent=None, _ctx=None)
cancelJob(_ctx=None)
cancelJob_async(_cb, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_attach(_r)
end_cancelJob(_r)
end_getJob(_r)
end_jobError(_r)
end_jobFinished(_r)
end_jobMessage(_r)
end_jobRunning(_r)
end_jobStatus(_r)
end_setMessage(_r)
end_setStatus(_r)
end_setStatusAndMessage(_r)
end_submit(_r)
getJob(_ctx=None)
getJob_async(_cb, _ctx=None)
jobError(_ctx=None)
jobError_async(_cb, _ctx=None)
jobFinished(_ctx=None)
jobFinished_async(_cb, _ctx=None)
jobMessage(_ctx=None)
jobMessage_async(_cb, _ctx=None)
jobRunning(_ctx=None)
jobRunning_async(_cb, _ctx=None)
jobStatus(_ctx=None)
jobStatus_async(_cb, _ctx=None)
setMessage(message, _ctx=None)
setMessage_async(_cb, message, _ctx=None)
setStatus(status, _ctx=None)
setStatusAndMessage(status, message, _ctx=None)
setStatusAndMessage_async(_cb, status, message, _ctx=None)
setStatus_async(_cb, status, _ctx=None)
submit(j, _ctx=None)
submit_async(_cb, j, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.LongPair(first=0, second=0)

Bases: object

_LongPair__compare(other)
class omero.api.MetadataStore

Bases: omero.api.StatefulServiceInterface

Server-side interface for import.

_ice_type = <IcePy.TypeInfo object at 0x3fa2978>
_op_createRoot = <IcePy.Operation object at 0x3fa2990>
_op_populateMinMax = <IcePy.Operation object at 0x3fa29f0>
_op_postProcess = <IcePy.Operation object at 0x3fa2a20>
_op_saveToDB = <IcePy.Operation object at 0x3fa29d8>
_op_setPixelsFile = <IcePy.Operation object at 0x3fa2a08>
_op_updateObjects = <IcePy.Operation object at 0x3fa29a8>
_op_updateReferences = <IcePy.Operation object at 0x3fa29c0>
createRoot_async(_cb, current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
populateMinMax_async(_cb, imageChannelGlobalMinMax, current=None)
postProcess_async(_cb, current=None)
saveToDB_async(_cb, activity, current=None)
setPixelsFile_async(_cb, pixelsId, file, repo, current=None)
updateObjects_async(_cb, objects, current=None)
updateReferences_async(_cb, references, current=None)
class omero.api.MetadataStorePrx

Bases: omero.api.StatefulServiceInterfacePrx

begin_createRoot(_response=None, _ex=None, _sent=None, _ctx=None)
begin_populateMinMax(imageChannelGlobalMinMax, _response=None, _ex=None, _sent=None, _ctx=None)
begin_postProcess(_response=None, _ex=None, _sent=None, _ctx=None)
begin_saveToDB(activity, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setPixelsFile(pixelsId, file, repo, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateObjects(objects, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateReferences(references, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
createRoot(_ctx=None)
createRoot_async(_cb, _ctx=None)
end_createRoot(_r)
end_populateMinMax(_r)
end_postProcess(_r)
end_saveToDB(_r)
end_setPixelsFile(_r)
end_updateObjects(_r)
end_updateReferences(_r)
populateMinMax(imageChannelGlobalMinMax, _ctx=None)
populateMinMax_async(_cb, imageChannelGlobalMinMax, _ctx=None)
postProcess(_ctx=None)
postProcess_async(_cb, _ctx=None)
saveToDB(activity, _ctx=None)
saveToDB_async(_cb, activity, _ctx=None)
setPixelsFile(pixelsId, file, repo, _ctx=None)
setPixelsFile_async(_cb, pixelsId, file, repo, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateObjects(objects, _ctx=None)
updateObjects_async(_cb, objects, _ctx=None)
updateReferences(references, _ctx=None)
updateReferences_async(_cb, references, _ctx=None)
class omero.api.PyramidService

Bases: omero.api.StatefulServiceInterface

_ice_type = <IcePy.TypeInfo object at 0x122d5030>
_op_getResolutionDescriptions = <IcePy.Operation object at 0x122d5078>
_op_getResolutionLevel = <IcePy.Operation object at 0x122d5090>
_op_getResolutionLevels = <IcePy.Operation object at 0x122d5060>
_op_getTileSize = <IcePy.Operation object at 0x122d50c0>
_op_requiresPixelsPyramid = <IcePy.Operation object at 0x122d5048>
_op_setResolutionLevel = <IcePy.Operation object at 0x122d50a8>
getResolutionDescriptions_async(_cb, current=None)

Retrieves a more complete definition of the resolution level in question. The size of this array will be of length getResolutionLevels.

getResolutionLevel_async(_cb, current=None)

Retrieves the active resolution level. Returns:

The active resolution level.
getResolutionLevels_async(_cb, current=None)

Retrieves the number of resolution levels that the backing pixels pyramid contains. Returns:

The number of resolution levels. This value does not

necessarily indicate either the presence or absence of a pixels pyramid.

getTileSize_async(_cb, current=None)

Retrieves the tile size for the pixel store. Returns:

An array of length = 2 where the first

value of the array is the tile width and the second value is the tile height.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
requiresPixelsPyramid_async(_cb, current=None)

Whether or not this raw pixels store requires a backing pixels pyramid to provide sub-resolutions of the data. Returns:

true if the pixels store requires a

pixels pyramid and false otherwise.

setResolutionLevel_async(_cb, resolutionLevel, current=None)

Sets the active resolution level. Arguments:

resolutionLevel The resolution level to be used by

the pixel buffer.

class omero.api.PyramidServicePrx

Bases: omero.api.StatefulServiceInterfacePrx

Whether or not this raw pixels store requires a backing pixels pyramid to provide sub-resolutions of the data. Returns:

true if the pixels store requires a

pixels pyramid and false otherwise.

begin_getResolutionDescriptions(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getResolutionLevel(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getResolutionLevels(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTileSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_requiresPixelsPyramid(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setResolutionLevel(resolutionLevel, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_getResolutionDescriptions(_r)
end_getResolutionLevel(_r)
end_getResolutionLevels(_r)
end_getTileSize(_r)
end_requiresPixelsPyramid(_r)
end_setResolutionLevel(_r)
getResolutionDescriptions(_ctx=None)
getResolutionDescriptions_async(_cb, _ctx=None)
getResolutionLevel(_ctx=None)
getResolutionLevel_async(_cb, _ctx=None)
getResolutionLevels(_ctx=None)
getResolutionLevels_async(_cb, _ctx=None)
getTileSize(_ctx=None)
getTileSize_async(_cb, _ctx=None)
requiresPixelsPyramid(_ctx=None)
requiresPixelsPyramid_async(_cb, _ctx=None)
setResolutionLevel(resolutionLevel, _ctx=None)
setResolutionLevel_async(_cb, resolutionLevel, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.RawFileStore

Bases: omero.api.StatefulServiceInterface

Raw file gateway which provides access to the OMERO file repository.

Note: methods on this service are protected by a DOWNLOAD restriction.

_ice_type = <IcePy.TypeInfo object at 0x3dbbeb8>
_op_exists = <IcePy.Operation object at 0x11febe10>
_op_getFileId = <IcePy.Operation object at 0x11febd98>
_op_read = <IcePy.Operation object at 0x11febdb0>
_op_save = <IcePy.Operation object at 0x11febe28>
_op_setFileId = <IcePy.Operation object at 0x11febd80>
_op_size = <IcePy.Operation object at 0x11febdc8>
_op_truncate = <IcePy.Operation object at 0x11febde0>
_op_write = <IcePy.Operation object at 0x11febdf8>
exists_async(_cb, current=None)

Checks to see if a raw file exists with the file ID that the service was initialized with.

Returns:
true if there is an accessible file

within the original file repository with the correct ID. Otherwise false. Exceptions:

ResourceError if there is a problem accessing the

file due to permissions errors within the repository or any other I/O error.

getFileId_async(_cb, current=None)

Returns the current file id or null if none has been set.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
read_async(_cb, position, length, current=None)

Reads length bytes of data at the position from the raw file into an array of bytes.

save_async(_cb, current=None)

Saves the omero.model.OriginalFile associated with the service if it has been modified. The returned valued should replace all instances of the omero.model.OriginalFile in the client.

If save has not been called, omero.api.RawFileStore instances will save the omero.model.OriginalFile object associated with it on close.

See also ticket 1651 and ticket 2161.

setFileId_async(_cb, fileId, current=None)

This method manages the state of the service. This method will throw a omero.SecurityViolation if for the current user context either the file is not readable or a omero.constants.permissions#DOWNLOAD restriction is in place.

size_async(_cb, current=None)

Returns the size of the file on disk (not as stored in the database since that value will only be updated on save. If the file has not yet been written to, and therefore does not exist, a omero.ResourceError will be thrown.

truncate_async(_cb, length, current=None)

Limits the size of a file to the given length. If the file is already shorter than length, no action is taken in which case false is returned.

write_async(_cb, buf, position, length, current=None)

Writes length bytes of data from the specified buf byte array starting at at position to the raw file.

class omero.api.RawFileStorePrx

Bases: omero.api.StatefulServiceInterfacePrx

This method manages the state of the service. This method will throw a omero.SecurityViolation if for the current user context either the file is not readable or a omero.constants.permissions#DOWNLOAD restriction is in place.

begin_exists(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getFileId(_response=None, _ex=None, _sent=None, _ctx=None)
begin_read(position, length, _response=None, _ex=None, _sent=None, _ctx=None)
begin_save(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setFileId(fileId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_size(_response=None, _ex=None, _sent=None, _ctx=None)
begin_truncate(length, _response=None, _ex=None, _sent=None, _ctx=None)
begin_write(buf, position, length, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_exists(_r)
end_getFileId(_r)
end_read(_r)
end_save(_r)
end_setFileId(_r)
end_size(_r)
end_truncate(_r)
end_write(_r)
exists(_ctx=None)
exists_async(_cb, _ctx=None)
getFileId(_ctx=None)
getFileId_async(_cb, _ctx=None)
read(position, length, _ctx=None)
read_async(_cb, position, length, _ctx=None)
save(_ctx=None)
save_async(_cb, _ctx=None)
setFileId(fileId, _ctx=None)
setFileId_async(_cb, fileId, _ctx=None)
size(_ctx=None)
size_async(_cb, _ctx=None)
truncate(length, _ctx=None)
truncate_async(_cb, length, _ctx=None)
static uncheckedCast(proxy, facet=None)
write(buf, position, length, _ctx=None)
write_async(_cb, buf, position, length, _ctx=None)
class omero.api.RawPixelsStore

Bases: omero.api.PyramidService

Binary data provider. Initialized with the ID of a omero.model.Pixels instance, this service can provide various slices, stacks, regions of the 5-dimensional (X-Y planes with multiple Z-sections and Channels over Time). The byte array returned by the getter methods and passed to the setter methods can and will be interpreted according to results of getByteWidth, isFloat, and isSigned.

Read-only caveat:

Mutating methods (set*) are only available during the first access. Once the Pixels data has been successfully saved (via the save or close methods on this interface), then the data should be treated read-only. If Pixels data writing fails and the service is inadvertently closed, delete the Pixels object, and create a new one. Any partially written data will be removed.

_ice_type = <IcePy.TypeInfo object at 0x3dbbee8>
_op_calculateMessageDigest = <IcePy.Operation object at 0x122d53d8>
_op_getByteWidth = <IcePy.Operation object at 0x122d5390>
_op_getCol = <IcePy.Operation object at 0x122d5270>
_op_getHistogram = <IcePy.Operation object at 0x122d5378>
_op_getHypercube = <IcePy.Operation object at 0x122d5228>
_op_getPixelsId = <IcePy.Operation object at 0x122d50f0>
_op_getPixelsPath = <IcePy.Operation object at 0x122d5108>
_op_getPlane = <IcePy.Operation object at 0x122d5288>
_op_getPlaneOffset = <IcePy.Operation object at 0x122d51c8>
_op_getPlaneRegion = <IcePy.Operation object at 0x122d52a0>
_op_getPlaneSize = <IcePy.Operation object at 0x122d5138>
_op_getRegion = <IcePy.Operation object at 0x122d5240>
_op_getRow = <IcePy.Operation object at 0x122d5258>
_op_getRowOffset = <IcePy.Operation object at 0x122d51b0>
_op_getRowSize = <IcePy.Operation object at 0x122d5150>
_op_getStack = <IcePy.Operation object at 0x122d52b8>
_op_getStackOffset = <IcePy.Operation object at 0x122d51e0>
_op_getStackSize = <IcePy.Operation object at 0x122d5168>
_op_getTile = <IcePy.Operation object at 0x122d5210>
_op_getTimepoint = <IcePy.Operation object at 0x122d52d0>
_op_getTimepointOffset = <IcePy.Operation object at 0x122d51f8>
_op_getTimepointSize = <IcePy.Operation object at 0x122d5180>
_op_getTotalSize = <IcePy.Operation object at 0x122d5198>
_op_isFloat = <IcePy.Operation object at 0x122d53c0>
_op_isSigned = <IcePy.Operation object at 0x122d53a8>
_op_prepare = <IcePy.Operation object at 0x122d5120>
_op_save = <IcePy.Operation object at 0x122d53f0>
_op_setPixelsId = <IcePy.Operation object at 0x122d50d8>
_op_setPlane = <IcePy.Operation object at 0x122d5330>
_op_setRegion = <IcePy.Operation object at 0x122d5300>
_op_setRow = <IcePy.Operation object at 0x122d5318>
_op_setStack = <IcePy.Operation object at 0x122d5348>
_op_setTile = <IcePy.Operation object at 0x122d52e8>
_op_setTimepoint = <IcePy.Operation object at 0x122d5360>
calculateMessageDigest_async(_cb, current=None)

Calculates a SHA-1 message digest for the entire pixel store. Returns:

byte array containing the message digest.
getByteWidth_async(_cb, current=None)

Returns the byte width for the pixel store. Returns:

See above.
getCol_async(_cb, x, z, c, t, current=None)

Retrieves a particular column from this pixel store. Arguments:

x offset across the X-axis of the pixel store. z offset across the Z-axis of the pixel store. c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store.
Returns:
buffer containing the data which comprises this column.
getHistogram_async(_cb, channels, binCount, globalRange, plane, current=None)

Retrieves the histogram data for the specified plane and channels. This method can currently only handle non-pyramid images. Arguments:

channels the channels to generate the histogram data for binCount the number of the histogram bins (optional, default: 256) plane the plane (optional, default: whole region of first z/t plane) globalRange use the global minimum/maximum to determine the histogram range, otherwise use plane minimum/maximum value
Returns:
See above.
getHypercube_async(_cb, offset, size, step, current=None)

Retrieves a n-dimensional block from this pixel store. Arguments:

start offset for each dimension within pixel store. size of each dimension (dependent on dimension). step needed of each dimension (dependent on

dimension). Returns:

buffer containing the data.
getPixelsId_async(_cb, current=None)

Returns the current Pixels set identifier. Returns:

See above.
getPixelsPath_async(_cb, current=None)

Returns the current Pixels path. Returns:

See above.
getPlaneOffset_async(_cb, z, c, t, current=None)

Retrieves the offset for a particular 2D image plane in this pixel store. Arguments:

z offset across the Z-axis of the pixel buffer. c offset across the C-axis of the pixel buffer. t offset across the T-axis of the pixel buffer.
Returns:
offset of the 2D image plane.
getPlaneRegion_async(_cb, z, c, t, size, offset, current=None)

Retrieves a region from a given plane from this pixel store. Arguments:

z offset across the Z-axis of the pixel store. c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store. count the number of pixels to retrieve. offset the offset at which to retrieve count pixels.
Returns:
buffer containing the data which comprises the region of the

given 2D image plane. It is guaranteed that this buffer will have been byte swapped.

getPlaneSize_async(_cb, current=None)

Retrieves the in memory size of a 2D image plane in this pixel store. Returns:

2D image plane size in bytes

sizeX*sizeY*byteWidth.

getPlane_async(_cb, z, c, t, current=None)

Retrieves a particular 2D image plane from this pixel store. Arguments:

z offset across the Z-axis of the pixel store. c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store.
Returns:
buffer containing the data which comprises this 2D image plane.
getRegion_async(_cb, size, offset, current=None)

Retrieves a region from this pixel store. Arguments:

size byte width of the region to retrieve. offset offset within the pixel store.
Returns:
buffer containing the data.
getRowOffset_async(_cb, y, z, c, t, current=None)

Retrieves the offset for a particular row or scanline in this pixel store. Arguments:

y offset across the Y-axis of the pixel buffer. z offset across the Z-axis of the pixel buffer. c offset across the C-axis of the pixel buffer. t offset across the T-axis of the pixel buffer.
Returns:
offset of the row or scanline.
getRowSize_async(_cb, current=None)

Retrieves the in memory size of a row or scanline of pixels in this pixel store. Returns:

row or scanline size in bytes
getRow_async(_cb, y, z, c, t, current=None)

Retrieves a particular row or scanline from this pixel store. Arguments:

y offset across the Y-axis of the pixel store. z offset across the Z-axis of the pixel store. c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store.
Returns:
buffer containing the data which comprises this row

or scanline.

getStackOffset_async(_cb, c, t, current=None)

Retrieves the offset for the entire number of optical sections for a single wavelength or channel at a particular timepoint in this pixel store.

Arguments:
c offset across the C-axis of the pixel buffer. t offset across the T-axis of the pixel buffer.
Returns:
offset of the stack.
getStackSize_async(_cb, current=None)

Retrieves the in memory size of the entire number of optical sections for a single wavelength or channel at a particular timepoint in this pixel store.

Returns:
stack size in bytes

sizeX*sizeY*byteWidth.

getStack_async(_cb, c, t, current=None)

Retrieves the the entire number of optical sections for a single wavelength or channel at a particular timepoint in this pixel store. Arguments:

c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store.
Returns:
buffer containing the data which comprises this stack.
getTile_async(_cb, z, c, t, x, y, w, h, current=None)

Retrieves a tile from this pixel buffer. Arguments:

z offset across the Z-axis of the pixel buffer. c offset across the C-axis of the pixel buffer. t offset across the T-axis of the pixel buffer. x Top left corner of the tile, X offset. y Top left corner of the tile, Y offset. w Width of the tile. h Height of the tile.
Returns:
buffer containing the data.
getTimepointOffset_async(_cb, t, current=None)

Retrieves the in memory size of the entire number of optical sections for all wavelengths or channels at a particular timepoint in this pixel store.

Arguments:
t offset across the T-axis of the pixel buffer.
Returns:
offset of the timepoint.
getTimepointSize_async(_cb, current=None)

Retrieves the in memory size of the entire number of optical sections for all wavelengths or channels at a particular timepoint in this pixel store. Returns:

timepoint size in bytes

sizeX*sizeY*sizeZ*sizeC*byteWidth.

getTimepoint_async(_cb, t, current=None)

Retrieves the entire number of optical sections for all wavelengths or channels at a particular timepoint in this pixel store. Arguments:

t offset across the T-axis of the pixel store.
getTotalSize_async(_cb, current=None)

Retrieves the in memory size of the entire pixel store. Returns:

total size of the pixel size in bytes

sizeX*sizeY*sizeZ*sizeC*sizeT*byteWidth.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isFloat_async(_cb, current=None)

Returns whether or not the pixel buffer has floating point pixels. Returns:

isSigned_async(_cb, current=None)

Returns whether or not the pixel store has signed pixels. Returns:

See above.
prepare_async(_cb, pixelsIds, current=None)

Prepares the stateful service with a cache of loaded Pixels objects. This method is designed to combat query overhead, where many sets of Pixels are to be read from or written to, by loading all the Pixels sets at once. Multiple calls will result in the existing cache being overwritten.

Arguments:
pixelsIds Pixels IDs to cache.
save_async(_cb, current=None)

Save the current state of the pixels, updating the SHA1. This should only be called AFTER all data is successfully set. Future invocations of set methods may be disallowed. This read-only status will allow background processing (generation of thumbnails, compression, etc) to begin. More information under RawPixelsStore.

A null instance will be returned if no save was performed.

setPixelsId_async(_cb, pixelsId, bypassOriginalFile, current=None)

Initializes the stateful service for a given Pixels set.

Arguments:
pixelsId Pixels set identifier. bypassOriginalFile Whether or not to bypass checking

for an original file to back the pixel buffer used by this service. If requests are predominantly write-only or involve the population of a brand new pixel buffer using true here is a safe optimization otherwise false is expected.

See Read-only caveat under RawPixelsStore

setPlane_async(_cb, buf, z, c, t, current=None)

Sets a particular 2D image plane in this pixel store. Arguments:

buf a byte array of the data comprising this 2D image plane. z offset across the Z-axis of the pixel store. c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store.

See Read-only caveat under RawPixelsStore

setRegion_async(_cb, size, offset, buf, current=None)

Sets a region in this pixel buffer. Arguments:

size byte width of the region to set. offset offset within the pixel buffer. buf a byte array of the data.

See Read-only caveat under RawPixelsStore

setRow_async(_cb, buf, y, z, c, t, current=None)

Sets a particular row or scanline in this pixel store. Arguments:

buf a byte array of the data comprising this row or scanline. y offset across the Y-axis of the pixel store. z offset across the Z-axis of the pixel store. c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store.

See Read-only caveat under RawPixelsStore

setStack_async(_cb, buf, z, c, t, current=None)

Sets the entire number of optical sections for a single wavelength or channel at a particular timepoint in this pixel store. Arguments:

buf a byte array of the data comprising this stack. c offset across the C-axis of the pixel store. t offset across the T-axis of the pixel store.

See Read-only caveat under RawPixelsStore

setTile_async(_cb, buf, z, c, t, x, y, w, h, current=None)

Sets a tile in this pixel buffer. Arguments:

buf A byte array of the data. z offset across the Z-axis of the pixel buffer. c offset across the C-axis of the pixel buffer. t offset across the T-axis of the pixel buffer. x Top left corner of the tile, X offset. y Top left corner of the tile, Y offset. w Width of the tile. h Height of the tile.
Exceptions:
IOException if there is a problem writing to the pixel buffer. BufferOverflowException if an attempt is made to write off the

end of the file.

See Read-only caveat under RawPixelsStore

setTimepoint_async(_cb, buf, t, current=None)

Sets the entire number of optical sections for all wavelengths or channels at a particular timepoint in this pixel store. Arguments:

buf a byte array of the data comprising this timepoint. t offset across the T-axis of the pixel buffer.

See Read-only caveat under RawPixelsStore

class omero.api.RawPixelsStorePrx

Bases: omero.api.PyramidServicePrx

Initializes the stateful service for a given Pixels set.

Arguments:
pixelsId Pixels set identifier. bypassOriginalFile Whether or not to bypass checking

for an original file to back the pixel buffer used by this service. If requests are predominantly write-only or involve the population of a brand new pixel buffer using true here is a safe optimization otherwise false is expected.

See Read-only caveat under RawPixelsStore

begin_calculateMessageDigest(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getByteWidth(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getCol(x, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getHistogram(channels, binCount, globalRange, plane, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getHypercube(offset, size, step, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsId(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsPath(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlane(z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlaneOffset(z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlaneRegion(z, c, t, size, offset, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlaneSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getRegion(size, offset, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRow(y, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRowOffset(y, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRowSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getStack(c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getStackOffset(c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getStackSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTile(z, c, t, x, y, w, h, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTimepoint(t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTimepointOffset(t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTimepointSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTotalSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isFloat(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isSigned(_response=None, _ex=None, _sent=None, _ctx=None)
begin_prepare(pixelsIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_save(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setPixelsId(pixelsId, bypassOriginalFile, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setPlane(buf, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setRegion(size, offset, buf, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setRow(buf, y, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setStack(buf, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setTile(buf, z, c, t, x, y, w, h, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setTimepoint(buf, t, _response=None, _ex=None, _sent=None, _ctx=None)
calculateMessageDigest(_ctx=None)
calculateMessageDigest_async(_cb, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_calculateMessageDigest(_r)
end_getByteWidth(_r)
end_getCol(_r)
end_getHistogram(_r)
end_getHypercube(_r)
end_getPixelsId(_r)
end_getPixelsPath(_r)
end_getPlane(_r)
end_getPlaneOffset(_r)
end_getPlaneRegion(_r)
end_getPlaneSize(_r)
end_getRegion(_r)
end_getRow(_r)
end_getRowOffset(_r)
end_getRowSize(_r)
end_getStack(_r)
end_getStackOffset(_r)
end_getStackSize(_r)
end_getTile(_r)
end_getTimepoint(_r)
end_getTimepointOffset(_r)
end_getTimepointSize(_r)
end_getTotalSize(_r)
end_isFloat(_r)
end_isSigned(_r)
end_prepare(_r)
end_save(_r)
end_setPixelsId(_r)
end_setPlane(_r)
end_setRegion(_r)
end_setRow(_r)
end_setStack(_r)
end_setTile(_r)
end_setTimepoint(_r)
getByteWidth(_ctx=None)
getByteWidth_async(_cb, _ctx=None)
getCol(x, z, c, t, _ctx=None)
getCol_async(_cb, x, z, c, t, _ctx=None)
getHistogram(channels, binCount, globalRange, plane, _ctx=None)
getHistogram_async(_cb, channels, binCount, globalRange, plane, _ctx=None)
getHypercube(offset, size, step, _ctx=None)
getHypercube_async(_cb, offset, size, step, _ctx=None)
getPixelsId(_ctx=None)
getPixelsId_async(_cb, _ctx=None)
getPixelsPath(_ctx=None)
getPixelsPath_async(_cb, _ctx=None)
getPlane(z, c, t, _ctx=None)
getPlaneOffset(z, c, t, _ctx=None)
getPlaneOffset_async(_cb, z, c, t, _ctx=None)
getPlaneRegion(z, c, t, size, offset, _ctx=None)
getPlaneRegion_async(_cb, z, c, t, size, offset, _ctx=None)
getPlaneSize(_ctx=None)
getPlaneSize_async(_cb, _ctx=None)
getPlane_async(_cb, z, c, t, _ctx=None)
getRegion(size, offset, _ctx=None)
getRegion_async(_cb, size, offset, _ctx=None)
getRow(y, z, c, t, _ctx=None)
getRowOffset(y, z, c, t, _ctx=None)
getRowOffset_async(_cb, y, z, c, t, _ctx=None)
getRowSize(_ctx=None)
getRowSize_async(_cb, _ctx=None)
getRow_async(_cb, y, z, c, t, _ctx=None)
getStack(c, t, _ctx=None)
getStackOffset(c, t, _ctx=None)
getStackOffset_async(_cb, c, t, _ctx=None)
getStackSize(_ctx=None)
getStackSize_async(_cb, _ctx=None)
getStack_async(_cb, c, t, _ctx=None)
getTile(z, c, t, x, y, w, h, _ctx=None)
getTile_async(_cb, z, c, t, x, y, w, h, _ctx=None)
getTimepoint(t, _ctx=None)
getTimepointOffset(t, _ctx=None)
getTimepointOffset_async(_cb, t, _ctx=None)
getTimepointSize(_ctx=None)
getTimepointSize_async(_cb, _ctx=None)
getTimepoint_async(_cb, t, _ctx=None)
getTotalSize(_ctx=None)
getTotalSize_async(_cb, _ctx=None)
isFloat(_ctx=None)
isFloat_async(_cb, _ctx=None)
isSigned(_ctx=None)
isSigned_async(_cb, _ctx=None)
prepare(pixelsIds, _ctx=None)
prepare_async(_cb, pixelsIds, _ctx=None)
save(_ctx=None)
save_async(_cb, _ctx=None)
setPixelsId(pixelsId, bypassOriginalFile, _ctx=None)
setPixelsId_async(_cb, pixelsId, bypassOriginalFile, _ctx=None)
setPlane(buf, z, c, t, _ctx=None)
setPlane_async(_cb, buf, z, c, t, _ctx=None)
setRegion(size, offset, buf, _ctx=None)
setRegion_async(_cb, size, offset, buf, _ctx=None)
setRow(buf, y, z, c, t, _ctx=None)
setRow_async(_cb, buf, y, z, c, t, _ctx=None)
setStack(buf, z, c, t, _ctx=None)
setStack_async(_cb, buf, z, c, t, _ctx=None)
setTile(buf, z, c, t, x, y, w, h, _ctx=None)
setTile_async(_cb, buf, z, c, t, x, y, w, h, _ctx=None)
setTimepoint(buf, t, _ctx=None)
setTimepoint_async(_cb, buf, t, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.RenderingEngine

Bases: omero.api.PyramidService

Defines a service to render a given pixels set.

A pixels set is a 5D array that stores the pixels data of an image, that is the pixels intensity values. Every instance of this service is paired up to a pixels set. Use this service to transform planes within the pixels set onto an RGB image.

The RenderingEngine allows to fine-tune the settings that define the transformation context &#151; that is, a specification of how raw pixels data is to be transformed into an image that can be displayed on screen. Those settings are referred to as rendering settings or display options. After tuning those settings it is possible to save them to the metadata repository so that they can be used the next time the pixels set is accessed for rendering; for example by another RenderingEngine instance. Note that the display options are specific to the given pixels set and are experimenter scoped &#151; that is, two different users can specify different display options for the same pixels set. (A RenderingEngine instance takes this into account automatically as it is always bound to a given experimenter.)

This service is thread-safe.

_ice_type = <IcePy.TypeInfo object at 0x3dbbf18>
_op_addCodomainMap = <IcePy.Operation object at 0x122d5780>
_op_addCodomainMapToChannel = <IcePy.Operation object at 0x122d57c8>
_op_getAvailableFamilies = <IcePy.Operation object at 0x122d55d0>
_op_getAvailableModels = <IcePy.Operation object at 0x122d55b8>
_op_getChannelCurveCoefficient = <IcePy.Operation object at 0x122d5690>
_op_getChannelFamily = <IcePy.Operation object at 0x122d5648>
_op_getChannelLookupTable = <IcePy.Operation object at 0x122d5768>
_op_getChannelNoiseReduction = <IcePy.Operation object at 0x122d5660>
_op_getChannelStats = <IcePy.Operation object at 0x122d5678>
_op_getChannelWindowEnd = <IcePy.Operation object at 0x122d56d8>
_op_getChannelWindowStart = <IcePy.Operation object at 0x122d56c0>
_op_getCodomainMapContext = <IcePy.Operation object at 0x122d58b8>
_op_getCompressionLevel = <IcePy.Operation object at 0x122d5858>
_op_getDefaultT = <IcePy.Operation object at 0x122d5558>
_op_getDefaultZ = <IcePy.Operation object at 0x122d5540>
_op_getModel = <IcePy.Operation object at 0x122d5528>
_op_getPixels = <IcePy.Operation object at 0x122d55a0>
_op_getPixelsTypeLowerBound = <IcePy.Operation object at 0x122d58a0>
_op_getPixelsTypeUpperBound = <IcePy.Operation object at 0x122d5888>
_op_getQuantumDef = <IcePy.Operation object at 0x122d5618>
_op_getRGBA = <IcePy.Operation object at 0x122d5708>
_op_getRenderingDefId = <IcePy.Operation object at 0x122d5480>
_op_isActive = <IcePy.Operation object at 0x122d5738>
_op_isPixelsTypeSigned = <IcePy.Operation object at 0x122d5870>
_op_load = <IcePy.Operation object at 0x122d54f8>
_op_loadRenderingDef = <IcePy.Operation object at 0x122d54c8>
_op_lookupPixels = <IcePy.Operation object at 0x122d5498>
_op_lookupRenderingDef = <IcePy.Operation object at 0x122d54b0>
_op_removeCodomainMap = <IcePy.Operation object at 0x122d57b0>
_op_removeCodomainMapFromChannel = <IcePy.Operation object at 0x122d57e0>
_op_render = <IcePy.Operation object at 0x122d5408>
_op_renderAsPackedInt = <IcePy.Operation object at 0x122d5420>
_op_renderCompressed = <IcePy.Operation object at 0x122d5450>
_op_renderProjectedAsPackedInt = <IcePy.Operation object at 0x122d5438>
_op_renderProjectedCompressed = <IcePy.Operation object at 0x122d5468>
_op_resetDefaultSettings = <IcePy.Operation object at 0x122d5828>
_op_saveAsNewSettings = <IcePy.Operation object at 0x122d5810>
_op_saveCurrentSettings = <IcePy.Operation object at 0x122d57f8>
_op_setActive = <IcePy.Operation object at 0x122d5720>
_op_setChannelLookupTable = <IcePy.Operation object at 0x122d5750>
_op_setChannelWindow = <IcePy.Operation object at 0x122d56a8>
_op_setCodomainInterval = <IcePy.Operation object at 0x122d5600>
_op_setCompressionLevel = <IcePy.Operation object at 0x122d5840>
_op_setDefaultT = <IcePy.Operation object at 0x122d5588>
_op_setDefaultZ = <IcePy.Operation object at 0x122d5570>
_op_setModel = <IcePy.Operation object at 0x122d5510>
_op_setOverlays = <IcePy.Operation object at 0x122d54e0>
_op_setQuantizationMap = <IcePy.Operation object at 0x122d5630>
_op_setQuantumStrategy = <IcePy.Operation object at 0x122d55e8>
_op_setRGBA = <IcePy.Operation object at 0x122d56f0>
_op_updateCodomainMap = <IcePy.Operation object at 0x122d5798>
addCodomainMapToChannel_async(_cb, mapCtx, w, current=None)

Adds the context to the mapping chain. Only one context of the same type can be added to the chain. The codomain transformations are functions from the device space to device space. Each time a new context is added, the second LUT is rebuilt.

Arguments:
mapCtx The context to add. w The channel to add the context to.
addCodomainMap_async(_cb, mapCtx, current=None)

Adds the context to the mapping chain. Only one context of the same type can be added to the chain. The codomain transformations are functions from the device space to device space. Each time a new context is added, the second LUT is rebuilt.

Arguments:
mapCtx The context to add.
getAvailableFamilies_async(_cb, current=None)

Returns the list of mapping families supported by the Rendering engine.

getAvailableModels_async(_cb, current=None)

Returns the list of color models supported by the Rendering engine.

getChannelCurveCoefficient_async(_cb, w, current=None)

Returns the coefficient identifying a map in the family. Each channel has a map associated to it.

Arguments:
w The channel index.
Returns:
See above.
getChannelFamily_async(_cb, w, current=None)

Returns the family associated to the specified channel.

Arguments:
w The channel index.
Returns:
See above.
getChannelLookupTable_async(_cb, w, current=None)
getChannelNoiseReduction_async(_cb, w, current=None)

Returns true if the noise reduction algorithm used to map the pixels intensity values is turned on, false if the algorithm is turned off. Each channel has an algorithm associated to it.

Arguments:
w The channel index.
Returns:
See above.
getChannelStats_async(_cb, w, current=None)
getChannelWindowEnd_async(_cb, w, current=None)

Returns the upper bound of the pixels intensity interval. Each channel has a pixels intensity interval associated to it.

Arguments:
w The channel index.
getChannelWindowStart_async(_cb, w, current=None)

Returns the lower bound of the pixels intensity interval. Each channel has a pixels intensity interval associated to it.

Arguments:
w The channel index.
getCodomainMapContext_async(_cb, w, current=None)

Returns the list of codomain contexts for the specified channel.

Arguments:
w The channel index.
getCompressionLevel_async(_cb, current=None)

Returns the current compression level for the service.

getDefaultT_async(_cb, current=None)

Returns the default timepoint index.

getDefaultZ_async(_cb, current=None)

Returns the index of the default focal section.

getModel_async(_cb, current=None)

Returns the model that dictates how transformed raw data has to be mapped onto a color space.

getPixelsTypeLowerBound_async(_cb, w, current=None)

Returns the maximum value for that channels depending on the pixels type and the original range (globalmax, globalmin)

Arguments:
w The channel index.
getPixelsTypeUpperBound_async(_cb, w, current=None)

Returns the minimum value for that channels depending on the pixels type and the original range (globalmax, globalmin)

Arguments:
w The channel index.
getPixels_async(_cb, current=None)

Returns the omero.model.Pixels set the Rendering engine is for.

getQuantumDef_async(_cb, current=None)

Returns the quantization object.

getRGBA_async(_cb, w, current=None)

Returns a 4D-array representing the color associated to the specified channel. The first element corresponds to the red component (value between 0 and 255). The second corresponds to the green component (value between 0 and 255). The third corresponds to the blue component (value between 0 and 255). The fourth corresponds to the alpha component (value between 0 and 255).

Arguments:
w The channel index.
getRenderingDefId_async(_cb, current=None)

Returns the id of the omero.model.RenderingDef loaded by either lookupRenderingDef or loadRenderingDef.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isActive_async(_cb, w, current=None)

Returns true if the channel is mapped, false otherwise.

Arguments:
w The channel index.
isPixelsTypeSigned_async(_cb, current=None)

Returns true if the pixels type is signed, false otherwise.

loadRenderingDef_async(_cb, renderingDefId, current=None)

Loads a specific set of rendering settings that does not necessarily have to be linked to the given Pixels set. However, the rendering settings must be linked to a compatible Pixels set as defined by omero.api.IRenderingSettings#sanityCheckPixels.

Arguments:
renderingDefId The rendering definition ID.
Exceptions:
ValidationException If a RenderingDef does not

exist with the ID renderingDefId or if the RenderingDef is incompatible due to differing pixels sets.

load_async(_cb, current=None)

Creates an instance of the rendering engine.

lookupPixels_async(_cb, pixelsId, current=None)

Loads the Pixels set this Rendering Engine is for.

Arguments:
pixelsId The pixels set ID.
lookupRenderingDef_async(_cb, pixelsId, current=None)

Loads the rendering settings associated to the specified pixels set.

Arguments:
pixelsId The pixels set ID.
Returns:
true if a RenderingDef exists for the

Pixels set, otherwise false.

removeCodomainMapFromChannel_async(_cb, mapCtx, w, current=None)

Removes the specified context from the chain. Each time a new context is removed, the second LUT is rebuilt.

Arguments:
mapCtx The context to remove. w The channel to remove the context from.
removeCodomainMap_async(_cb, mapCtx, current=None)

Removes the specified context from the chain. Each time a new context is removed, the second LUT is rebuilt.

Arguments:
mapCtx The context to remove.
renderAsPackedInt_async(_cb, _def, current=None)

Renders the data selected by def according to the current rendering settings. The passed argument selects a plane orthogonal to one of the X, Y, or Z axes. How many wavelengths are rendered and what color model is used depends on the current rendering settings.

Arguments:
def Selects a plane orthogonal to one of the

X, Y, or Z axes. Returns:

An RGB image ready to be displayed on screen.
Exceptions:
ValidationException

If def is null.

renderCompressed_async(_cb, _def, current=None)

Renders the data selected by def according to the current rendering settings and compresses the resulting RGBA composite image.

Arguments:
def Selects a plane orthogonal to one of the

X, Y or Z axes. Returns:

A compressed RGBA JPEG for display.
Exceptions:
ValidationException

If def is null.

renderProjectedAsPackedInt_async(_cb, algorithm, timepoint, stepping, start, end, current=None)

Performs a projection through selected optical sections of a particular timepoint with the currently active channels and renders the data for display.

Arguments:
algorithm ome.api.IProjection#MAXIMUM_INTENSITY,

ome.api.IProjection#MEAN_INTENSITY or ome.api.IProjection#SUM_INTENSITY.

stepping Stepping value to use while calculating the

projection. For example, stepping=1 will use every optical section from start to end where stepping=2 will use every other section from start to end to perform the projection.

start Optical section to start projecting from. end Optical section to finish projecting.
Returns:
A packed-integer RGBA rendered image of the

projected pixels. Exceptions:

ValidationException Where:

algorithm is unknown timepoint is out of range start is out of range end is out of range start > end

renderProjectedCompressed_async(_cb, algorithm, timepoint, stepping, start, end, current=None)

Performs a projection through selected optical sections of a particular timepoint with the currently active channels, renders the data for display and compresses the resulting RGBA composite image.

Arguments:
algorithm ome.api.IProjection#MAXIMUM_INTENSITY,

ome.api.IProjection#MEAN_INTENSITY or ome.api.IProjection#SUM_INTENSITY.

stepping Stepping value to use while calculating the

projection. For example, stepping=1 will use every optical section from start to end where stepping=2 will use every other section from start to end to perform the projection.

start Optical section to start projecting from. end Optical section to finish projecting.
Returns:
A compressed RGBA rendered JPEG image of the

projected pixels. Exceptions:

ValidationException Where:

algorithm is unknown timepoint is out of range start is out of range end is out of range start > end

render_async(_cb, _def, current=None)

Renders the data selected by def according to the current rendering settings. The passed argument selects a plane orthogonal to one of the X, Y, or Z axes. How many wavelengths are rendered and what color model is used depends on the current rendering settings.

Arguments:
def Selects a plane orthogonal to one of the

X, Y, or Z axes. Returns:

An RGB image ready to be displayed on screen.
Exceptions:
ValidationException

If def is null.

resetDefaultSettings_async(_cb, save, current=None)

Resets the default settings i.e. the default values internal to the Rendering engine. The settings will be saved.

Arguments:
save Pass true to save the settings,

false otherwise.

saveAsNewSettings_async(_cb, current=None)

Saves the current rendering settings in the database as a new omero.model.RenderingDef and loads the object into the current omero.api.RenderingEngine.

saveCurrentSettings_async(_cb, current=None)

Saves the current rendering settings in the database.

setActive_async(_cb, w, active, current=None)

Maps the specified channel if true, unmaps the channel otherwise.

Arguments:
w The channel index. active Pass true to map the channel,

false otherwise.

setChannelLookupTable_async(_cb, w, lookup, current=None)
setChannelWindow_async(_cb, w, start, end, current=None)

Returns the pixels intensity interval. Each channel has a pixels intensity interval associated to it.

Arguments:
w The channel index. start The lower bound of the interval. end The upper bound of the interval.
setCodomainInterval_async(_cb, start, end, current=None)

Sets the sub-interval of the device space i.e. a discrete sub-interval of [0, 255].

Arguments:
start The lower bound of the interval. end The upper bound of the interval.
setCompressionLevel_async(_cb, percentage, current=None)

Sets the current compression level for the service. (The default is 85%)

Arguments:
percentage A percentage compression level from 1.00

(100%) to 0.01 (1%). Exceptions:

ValidationException if the percentage</code

is out of range.

setDefaultT_async(_cb, t, current=None)

Sets the default timepoint index. This index is used to define a default plane.

Arguments:
t The value to set.
setDefaultZ_async(_cb, z, current=None)

Sets the index of the default focal section. This index is used to define a default plane.

Arguments:
z The value to set.
setModel_async(_cb, model, current=None)

Specifies the model that dictates how transformed raw data has to be mapped onto a color space.

Arguments:
model Identifies the color space model.
setOverlays_async(_cb, tablesId, imageId, rowColorMap, current=None)

Informs the rendering engine that it should render a set of overlays on each rendered frame. These are expected to be binary masks. Arguments:

overlays Binary mask to color map.
setQuantizationMap_async(_cb, w, fam, coefficient, noiseReduction, current=None)

Sets the quantization map, one per channel.

Arguments:
w The channel index. family The mapping family. coefficient The coefficient identifying a curve in
the family.
noiseReduction Pass true to turn the

noise reduction algorithm on, false otherwise.

setQuantumStrategy_async(_cb, bitResolution, current=None)

Sets the quantization strategy. The strategy is common to all channels.

Arguments:
bitResolution The bit resolution defining associated

to the strategy.

setRGBA_async(_cb, w, red, green, blue, alpha, current=None)

Sets the four components composing the color associated to the specified channel.

Arguments:
w The channel index. red The red component. A value between 0 and 255. green The green component. A value between 0 and 255. blue The blue component. A value between 0 and 255. alpha The alpha component. A value between 0 and 255.
updateCodomainMap_async(_cb, mapCtx, current=None)

Updates the specified context. The codomain chain already contains the specified context. Each time a new context is updated, the second LUT is rebuilt.

Arguments:
mapCtx The context to update.
class omero.api.RenderingEnginePrx

Bases: omero.api.PyramidServicePrx

Renders the data selected by def according to the current rendering settings. The passed argument selects a plane orthogonal to one of the X, Y, or Z axes. How many wavelengths are rendered and what color model is used depends on the current rendering settings.

Arguments:
def Selects a plane orthogonal to one of the

X, Y, or Z axes. Returns:

An RGB image ready to be displayed on screen.
Exceptions:
ValidationException

If def is null.

addCodomainMap(mapCtx, _ctx=None)
addCodomainMapToChannel(mapCtx, w, _ctx=None)
addCodomainMapToChannel_async(_cb, mapCtx, w, _ctx=None)
addCodomainMap_async(_cb, mapCtx, _ctx=None)
begin_addCodomainMap(mapCtx, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addCodomainMapToChannel(mapCtx, w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAvailableFamilies(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getAvailableModels(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelCurveCoefficient(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelFamily(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelLookupTable(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelNoiseReduction(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelStats(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelWindowEnd(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelWindowStart(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getCodomainMapContext(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getCompressionLevel(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getDefaultT(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getDefaultZ(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getModel(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixels(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsTypeLowerBound(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsTypeUpperBound(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getQuantumDef(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getRGBA(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRenderingDefId(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isActive(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_isPixelsTypeSigned(_response=None, _ex=None, _sent=None, _ctx=None)
begin_load(_response=None, _ex=None, _sent=None, _ctx=None)
begin_loadRenderingDef(renderingDefId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupPixels(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupRenderingDef(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeCodomainMap(mapCtx, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeCodomainMapFromChannel(mapCtx, w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_render(_def, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderAsPackedInt(_def, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderCompressed(_def, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderProjectedAsPackedInt(algorithm, timepoint, stepping, start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderProjectedCompressed(algorithm, timepoint, stepping, start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultSettings(save, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveAsNewSettings(_response=None, _ex=None, _sent=None, _ctx=None)
begin_saveCurrentSettings(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setActive(w, active, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setChannelLookupTable(w, lookup, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setChannelWindow(w, start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setCodomainInterval(start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setCompressionLevel(percentage, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setDefaultT(t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setDefaultZ(z, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setModel(model, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setOverlays(tablesId, imageId, rowColorMap, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setQuantizationMap(w, fam, coefficient, noiseReduction, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setQuantumStrategy(bitResolution, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setRGBA(w, red, green, blue, alpha, _response=None, _ex=None, _sent=None, _ctx=None)
begin_updateCodomainMap(mapCtx, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_addCodomainMap(_r)
end_addCodomainMapToChannel(_r)
end_getAvailableFamilies(_r)
end_getAvailableModels(_r)
end_getChannelCurveCoefficient(_r)
end_getChannelFamily(_r)
end_getChannelLookupTable(_r)
end_getChannelNoiseReduction(_r)
end_getChannelStats(_r)
end_getChannelWindowEnd(_r)
end_getChannelWindowStart(_r)
end_getCodomainMapContext(_r)
end_getCompressionLevel(_r)
end_getDefaultT(_r)
end_getDefaultZ(_r)
end_getModel(_r)
end_getPixels(_r)
end_getPixelsTypeLowerBound(_r)
end_getPixelsTypeUpperBound(_r)
end_getQuantumDef(_r)
end_getRGBA(_r)
end_getRenderingDefId(_r)
end_isActive(_r)
end_isPixelsTypeSigned(_r)
end_load(_r)
end_loadRenderingDef(_r)
end_lookupPixels(_r)
end_lookupRenderingDef(_r)
end_removeCodomainMap(_r)
end_removeCodomainMapFromChannel(_r)
end_render(_r)
end_renderAsPackedInt(_r)
end_renderCompressed(_r)
end_renderProjectedAsPackedInt(_r)
end_renderProjectedCompressed(_r)
end_resetDefaultSettings(_r)
end_saveAsNewSettings(_r)
end_saveCurrentSettings(_r)
end_setActive(_r)
end_setChannelLookupTable(_r)
end_setChannelWindow(_r)
end_setCodomainInterval(_r)
end_setCompressionLevel(_r)
end_setDefaultT(_r)
end_setDefaultZ(_r)
end_setModel(_r)
end_setOverlays(_r)
end_setQuantizationMap(_r)
end_setQuantumStrategy(_r)
end_setRGBA(_r)
end_updateCodomainMap(_r)
getAvailableFamilies(_ctx=None)
getAvailableFamilies_async(_cb, _ctx=None)
getAvailableModels(_ctx=None)
getAvailableModels_async(_cb, _ctx=None)
getChannelCurveCoefficient(w, _ctx=None)
getChannelCurveCoefficient_async(_cb, w, _ctx=None)
getChannelFamily(w, _ctx=None)
getChannelFamily_async(_cb, w, _ctx=None)
getChannelLookupTable(w, _ctx=None)
getChannelLookupTable_async(_cb, w, _ctx=None)
getChannelNoiseReduction(w, _ctx=None)
getChannelNoiseReduction_async(_cb, w, _ctx=None)
getChannelStats(w, _ctx=None)
getChannelStats_async(_cb, w, _ctx=None)
getChannelWindowEnd(w, _ctx=None)
getChannelWindowEnd_async(_cb, w, _ctx=None)
getChannelWindowStart(w, _ctx=None)
getChannelWindowStart_async(_cb, w, _ctx=None)
getCodomainMapContext(w, _ctx=None)
getCodomainMapContext_async(_cb, w, _ctx=None)
getCompressionLevel(_ctx=None)
getCompressionLevel_async(_cb, _ctx=None)
getDefaultT(_ctx=None)
getDefaultT_async(_cb, _ctx=None)
getDefaultZ(_ctx=None)
getDefaultZ_async(_cb, _ctx=None)
getModel(_ctx=None)
getModel_async(_cb, _ctx=None)
getPixels(_ctx=None)
getPixelsTypeLowerBound(w, _ctx=None)
getPixelsTypeLowerBound_async(_cb, w, _ctx=None)
getPixelsTypeUpperBound(w, _ctx=None)
getPixelsTypeUpperBound_async(_cb, w, _ctx=None)
getPixels_async(_cb, _ctx=None)
getQuantumDef(_ctx=None)
getQuantumDef_async(_cb, _ctx=None)
getRGBA(w, _ctx=None)
getRGBA_async(_cb, w, _ctx=None)
getRenderingDefId(_ctx=None)
getRenderingDefId_async(_cb, _ctx=None)
isActive(w, _ctx=None)
isActive_async(_cb, w, _ctx=None)
isPixelsTypeSigned(_ctx=None)
isPixelsTypeSigned_async(_cb, _ctx=None)
load(_ctx=None)
loadRenderingDef(renderingDefId, _ctx=None)
loadRenderingDef_async(_cb, renderingDefId, _ctx=None)
load_async(_cb, _ctx=None)
lookupPixels(pixelsId, _ctx=None)
lookupPixels_async(_cb, pixelsId, _ctx=None)
lookupRenderingDef(pixelsId, _ctx=None)
lookupRenderingDef_async(_cb, pixelsId, _ctx=None)
removeCodomainMap(mapCtx, _ctx=None)
removeCodomainMapFromChannel(mapCtx, w, _ctx=None)
removeCodomainMapFromChannel_async(_cb, mapCtx, w, _ctx=None)
removeCodomainMap_async(_cb, mapCtx, _ctx=None)
render(_def, _ctx=None)
renderAsPackedInt(_def, _ctx=None)
renderAsPackedInt_async(_cb, _def, _ctx=None)
renderCompressed(_def, _ctx=None)
renderCompressed_async(_cb, _def, _ctx=None)
renderProjectedAsPackedInt(algorithm, timepoint, stepping, start, end, _ctx=None)
renderProjectedAsPackedInt_async(_cb, algorithm, timepoint, stepping, start, end, _ctx=None)
renderProjectedCompressed(algorithm, timepoint, stepping, start, end, _ctx=None)
renderProjectedCompressed_async(_cb, algorithm, timepoint, stepping, start, end, _ctx=None)
render_async(_cb, _def, _ctx=None)
resetDefaultSettings(save, _ctx=None)
resetDefaultSettings_async(_cb, save, _ctx=None)
saveAsNewSettings(_ctx=None)
saveAsNewSettings_async(_cb, _ctx=None)
saveCurrentSettings(_ctx=None)
saveCurrentSettings_async(_cb, _ctx=None)
setActive(w, active, _ctx=None)
setActive_async(_cb, w, active, _ctx=None)
setChannelLookupTable(w, lookup, _ctx=None)
setChannelLookupTable_async(_cb, w, lookup, _ctx=None)
setChannelWindow(w, start, end, _ctx=None)
setChannelWindow_async(_cb, w, start, end, _ctx=None)
setCodomainInterval(start, end, _ctx=None)
setCodomainInterval_async(_cb, start, end, _ctx=None)
setCompressionLevel(percentage, _ctx=None)
setCompressionLevel_async(_cb, percentage, _ctx=None)
setDefaultT(t, _ctx=None)
setDefaultT_async(_cb, t, _ctx=None)
setDefaultZ(z, _ctx=None)
setDefaultZ_async(_cb, z, _ctx=None)
setModel(model, _ctx=None)
setModel_async(_cb, model, _ctx=None)
setOverlays(tablesId, imageId, rowColorMap, _ctx=None)
setOverlays_async(_cb, tablesId, imageId, rowColorMap, _ctx=None)
setQuantizationMap(w, fam, coefficient, noiseReduction, _ctx=None)
setQuantizationMap_async(_cb, w, fam, coefficient, noiseReduction, _ctx=None)
setQuantumStrategy(bitResolution, _ctx=None)
setQuantumStrategy_async(_cb, bitResolution, _ctx=None)
setRGBA(w, red, green, blue, alpha, _ctx=None)
setRGBA_async(_cb, w, red, green, blue, alpha, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateCodomainMap(mapCtx, _ctx=None)
updateCodomainMap_async(_cb, mapCtx, _ctx=None)
class omero.api.ResolutionDescription(sizeX=0, sizeY=0)

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object at 0x11febfa8>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.ResolutionDescriptionPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.RoiOptions(shapes=None, limit=None, offset=None, userId=None, groupId=None)

Bases: Ice.Object

Specifies filters used when querying the ROIs.

_ice_type = <IcePy.TypeInfo object at 0x11feb030>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.RoiOptionsPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.RoiResult(opts=None, rois=None, byZ=None, byT=None)

Bases: Ice.Object

Returned by most search methods. The RoiOptions is the options object passed into a method, possibly modified by the server if some value was out of range. The RoiList contains all the Rois which matched the given query.

The individual shapes of the Rois which matched can be found in the indexes. For example, all the shapes on z=1 can by found by:

ShapeList shapes = byZ.get(1);

Shapes which are found on all z or t can be found with:

byZ.get(-1); byT.get(-1);

respectively.

_ice_type = <IcePy.TypeInfo object at 0x11feb060>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.RoiResultPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.RoiStats(roiId=0, imageId=0, pixelsId=0, combined=None, perShape=None)

Bases: Ice.Object

Container for ShapeStats, one with the combined values, and one per shape.

_ice_type = <IcePy.TypeInfo object at 0x11feb120>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.RoiStatsPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.Save(obj=None)

Bases: omero.cmd.Request

_ice_type = <IcePy.TypeInfo object at 0x11febbb8>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.SavePrx

Bases: omero.cmd.RequestPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.SaveRsp(obj=None)

Bases: omero.cmd.Response

_ice_type = <IcePy.TypeInfo object at 0x11febbe8>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.SaveRspPrx

Bases: omero.cmd.ResponsePrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.Search

Bases: omero.api.StatefulServiceInterface

Central search interface, allowing Web2.0 style queries. Each omero.api.Search instance keeps up with several queries and lazily-loads the results as hasNext, next and results are called. These queries are created by the by* methods.

Each instance also has a number of settings which can all be changed from their defaults via accessors, e.g. setBatchSize or setCaseSentivice.

The only methods which are required for the proper functioning of a Search instance are:

onlyType, onlyTypes OR allTypes Any by* method to create a query

Use of the allTypes method is discouraged, since it is possibly very resource intensive, which is why any attempt to receive results without specifically setting types or allowing all is prohibited.

_ice_type = <IcePy.TypeInfo object at 0x3dbbf48>
_op_activeQueries = <IcePy.Operation object at 0x122d58d0>
_op_addOrderByAsc = <IcePy.Operation object at 0x122d5b28>
_op_addOrderByDesc = <IcePy.Operation object at 0x122d5b40>
_op_allTypes = <IcePy.Operation object at 0x122d5a38>
_op_and = <IcePy.Operation object at 0x122d5c90>
_op_byAnnotatedWith = <IcePy.Operation object at 0x122d5c60>
_op_byFullText = <IcePy.Operation object at 0x122d5be8>
_op_byGroupForTags = <IcePy.Operation object at 0x122d5bb8>
_op_byHqlQuery = <IcePy.Operation object at 0x122d5c30>
_op_byLuceneQueryBuilder = <IcePy.Operation object at 0x122d5c00>
_op_bySimilarTerms = <IcePy.Operation object at 0x122d5c18>
_op_bySomeMustNone = <IcePy.Operation object at 0x122d5c48>
_op_byTagForGroups = <IcePy.Operation object at 0x122d5bd0>
_op_clearQueries = <IcePy.Operation object at 0x122d5c78>
_op_currentMetadata = <IcePy.Operation object at 0x122d5d20>
_op_currentMetadataList = <IcePy.Operation object at 0x122d5d38>
_op_fetchAlso = <IcePy.Operation object at 0x122d5b88>
_op_fetchAnnotations = <IcePy.Operation object at 0x122d5b70>
_op_getBatchSize = <IcePy.Operation object at 0x122d5900>
_op_hasNext = <IcePy.Operation object at 0x122d5cd8>
_op_isAllowLeadingWildcard = <IcePy.Operation object at 0x122d59f0>
_op_isCaseSensitive = <IcePy.Operation object at 0x122d5960>
_op_isMergedBatches = <IcePy.Operation object at 0x122d5930>
_op_isReturnUnloaded = <IcePy.Operation object at 0x122d59c0>
_op_isUseProjections = <IcePy.Operation object at 0x122d5990>
_op_next = <IcePy.Operation object at 0x122d5cf0>
_op_not = <IcePy.Operation object at 0x122d5cc0>
_op_notAnnotatedBy = <IcePy.Operation object at 0x122d5af8>
_op_notOwnedBy = <IcePy.Operation object at 0x122d5a80>
_op_onlyAnnotatedBetween = <IcePy.Operation object at 0x122d5ac8>
_op_onlyAnnotatedBy = <IcePy.Operation object at 0x122d5ae0>
_op_onlyAnnotatedWith = <IcePy.Operation object at 0x122d5b10>
_op_onlyCreatedBetween = <IcePy.Operation object at 0x122d5a98>
_op_onlyIds = <IcePy.Operation object at 0x122d5a50>
_op_onlyModifiedBetween = <IcePy.Operation object at 0x122d5ab0>
_op_onlyOwnedBy = <IcePy.Operation object at 0x122d5a68>
_op_onlyType = <IcePy.Operation object at 0x122d5a08>
_op_onlyTypes = <IcePy.Operation object at 0x122d5a20>
_op_or = <IcePy.Operation object at 0x122d5ca8>
_op_remove = <IcePy.Operation object at 0x122d5d50>
_op_resetDefaults = <IcePy.Operation object at 0x122d5ba0>
_op_results = <IcePy.Operation object at 0x122d5d08>
_op_setAllowLeadingWildcard = <IcePy.Operation object at 0x122d59d8>
_op_setBatchSize = <IcePy.Operation object at 0x122d58e8>
_op_setCaseSentivice = <IcePy.Operation object at 0x122d5948>
_op_setMergedBatches = <IcePy.Operation object at 0x122d5918>
_op_setReturnUnloaded = <IcePy.Operation object at 0x122d59a8>
_op_setUseProjections = <IcePy.Operation object at 0x122d5978>
_op_unordered = <IcePy.Operation object at 0x122d5b58>
activeQueries_async(_cb, current=None)

Returns the number of active queries. This means that activeQueries gives the minimum number of remaining calls to results when batches are not merged.

Returns:
number of active queries
addOrderByAsc_async(_cb, path, current=None)

A path from the target entity which will be added to the current stack of order statements applied to the query.

Arguments:
path Non-null.
addOrderByDesc_async(_cb, path, current=None)

A path from the target entity which will be added to the current stack of order statements applied to the query.

Arguments:
path Non-null.
allTypes_async(_cb, current=None)

Permits all types to be returned. For some types of queries, this carries a performance penalty as every database table must be hit.

and_async(_cb, current=None)

Applies the next by* method to the previous by* method, so that a call hasNext, next, or results sees only the intersection of the two calls.

For example,

service.onlyType(Image.class); service.byFullText(&quot;foo&quot;); service.intersection(); service.byAnnotatedWith(TagAnnotation.class);

will return only the Images with TagAnnotations.

Calling this method overrides a previous setting of _or or _not. If there is no active queries (i.e. activeQueries > 0), then an ApiUsageException will be thrown.

byAnnotatedWith_async(_cb, examples, current=None)

Finds entities annotated with an omero.model.Annotation similar to the example. This does not use Hibernate’s omero.api.IQuery#findByExample Query-By-Example} mechanism, since that cannot handle joins. The fields which are used are:

the main content of the annotation : String, omero.model.OriginalFile#getId, etc.

If the main content is null it is assumed to be a wildcard searched, and only the type of the annotation is searched. Currently, ListAnnotations are not supported.

Arguments:
examples Not empty.
byFullText_async(_cb, query, current=None)

Passes the query as is to the Lucene backend.

Arguments:
query May not be null or of zero length.
byGroupForTags_async(_cb, group, current=None)

Returns transient (without ID) omero.model.TagAnnotation instances which represent all the omero.model.TagAnnotation tags in the given group. The entities are transient and without ownership since multiple users can own the same tag. This method will override settings for types.

Arguments:
group Can be null or empty to return all tags.
byHqlQuery_async(_cb, query, params, current=None)

Delegates to omero.api.IQuery#findAllByQuery method to take advantage of the _and, _or, and _not methods, or queue-semantics.

Arguments:
query Not null. p May be null. Defaults are then in effect.
byLuceneQueryBuilder_async(_cb, fields, _from, to, dateType, query, current=None)

Builds a Lucene query and passes it to the Lucene backend.

Arguments:
fields The fields (comma separated) to search in
(name, description, ...)
from The date range from, in the form YYYYMMDD
(may be null)
to The date range to (inclusive), in the form
YYYYMMDD (may be null)
dateType DATE_TYPE_ACQUISITION or
DATE_TYPE_IMPORT
query May not be null or of zero length.
bySimilarTerms_async(_cb, terms, current=None)

Returns transient (without ID) omero.model.TextAnnotation instances which represent terms which are similar to the given terms. For example, if the argument is cell, one return value might have as its textValue: cellular while another has cellularize.

No filtering or fetching is performed.

Arguments:
terms Cannot be empty.
bySomeMustNone_async(_cb, some, must, none, current=None)

Builds a Lucene query and passes it to byFullText.

Arguments:
some Some (at least one) of these terms must be
present in the document. May be null.
must All of these terms must be present in the
document. May be null.
none None of these terms may be present in the

document. May be null.

byTagForGroups_async(_cb, tag, current=None)

Creates a query which will return transient (without ID) omero.model.TagAnnotation instances which represent all the omero.model.TagAnnotation tag groups which the given tag belongs to. The entities are transient and without ownership since multiple users can own the same tag group. This method will override settings for types.

Arguments:
tag Can be null or empty to return all groups.
clearQueries_async(_cb, current=None)

Removes all active queries (leaving resetDefaults settings alone), such that activeQueries will return 0.

currentMetadataList_async(_cb, current=None)

Provides access to the extra query information (for example Lucene score and boost values) for a single call to results. This method may only be called once for any given call to results.

currentMetadata_async(_cb, current=None)

Provides access to the extra query information (for example Lucene score and boost values) for a single call to next. This method may only be called once for any given call to next.

fetchAlso_async(_cb, fetches, current=None)

Adds a fetch clause for loading non-annotation fields of returned entities. Each fetch is a hibernate clause in dot notation.

Arguments:
fetches Can be empty, which removes previous fetch

setting.

fetchAnnotations_async(_cb, classes, current=None)

Queries the database for all omero.model.Annotation annotations of the given types for all returned instances.

Arguments:
classes Can be empty, which removes previous fetch

setting.

getBatchSize_async(_cb, current=None)

Returns the current batch size. If setBatchSize has not been called, the default value will be in effect.

Returns:
maximum number of results per call to

results

hasNext_async(_cb, current=None)

Returns true if another call to next is valid. A call to next may throw an exception for another reason, however.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isAllowLeadingWildcard_async(_cb, current=None)

Returns the current leading-wildcard setting. If false, byFullText and bySomeMustNone will throw an omero.ApiUsageException, since leading-wildcard searches are quite slow. Use setAllowLeadingWildcard in order to permit this usage.

isCaseSensitive_async(_cb, current=None)

Returns the current case sensitivity setting. If setCaseSentivice has not been called, the default value will be in effect.

isMergedBatches_async(_cb, current=None)

Returns the current merged-batches setting. If setMergedBatches has not been called, the default value will be in effect.

isReturnUnloaded_async(_cb, current=None)

Returns the current return-unloaded setting. If true, all returned entities will be unloaded. If setReturnUnloaded has not been called, the default value will be in effect.

isUseProjections_async(_cb, current=None)

Returns the current use-projection setting. If true, the client must be careful with all results that are returned. See setUseProjections for more. If setUseProjections has not been called, the default value will be in effect.

next_async(_cb, current=None)

Returns the next entity from the current query. If the previous call returned the last entity from a given query, the first entity from the next query will be returned and activeQueries decremented. Since this method only returns the entity itself, a single call to currentMetadata may follow this call to gather the extra metadata which is returned in the map via results.

Exceptions:
ApiUsageException if hasNext returns false.
notAnnotatedBy_async(_cb, d, current=None)

Restricts entities by who has not annotated them with an omero.model.Annotation matching the other filters. As notOwnedBy, the omero.model.Details#getOwner and omero.model.Details#getGroup information is combined with an AND condition.

Arguments:
d Can be null, in which case any previous

restriction is removed.

notOwnedBy_async(_cb, d, current=None)

Uses the omero.model.Details#getOwner and omero.model.Details#getGroup information to restrict the entities which will be returned. If both are non-null, the two restrictions are joined by an AND.

Arguments:
d Can be null, in which case the previous

restriction is removed.

not_async(_cb, current=None)

Applies the next by* method to the previous by* method, so that a call hasNext, next, or results sees only the intersection of the two calls.

For example,

service.onlyType(Image.class); service.byFullText(&quot;foo&quot;); service.complement(); service.byAnnotatedWith(TagAnnotation.class);

will return all the Images not annotated with TagAnnotation. Calling this method overrides a previous setting of _or or _and. If there is no active queries (i.e. activeQueries > 0), then an ApiUsageException will be thrown.

onlyAnnotatedBetween_async(_cb, start, stop, current=None)

Restricts entities by the time in which any annotation (which matches the other filters) was added them. This matches the omero.model.Details#getCreationEvent creation event of the omero..model.Annotation.

Arguments:
start Can be null, i.e. interval open to negative
infinity.
stop Can be null, i.e. interval open to positive

infinity.

onlyAnnotatedBy_async(_cb, d, current=None)

Restricts entities by who has annotated them with an omero.model.Annotation matching the other filters. As onlyOwnedBy, the omero.model.Details#getOwner and omero.model.Details#getGroup information is combined with an AND condition.

Arguments:
d Can be null, in which case any previous

restriction is removed.

onlyAnnotatedWith_async(_cb, classes, current=None)

Restricts entities to having an omero.model.Annotation of all the given types. This is useful in combination with the other onlyAnnotated* methods to say, e.g., only annotated with a file by user X. By default, this value is null and imposes no restriction. Passing an empty array implies an object that is not annotated at all.

Note: If the semantics were OR, then a client would have to query each class individually, and compare all the various values, checking which ids are where. However, since this method defaults to AND, multiple calls (optionally with isMergedBatches and isReturnUnloaded) and combine the results. Duplicate ids are still possible so a set of some form should be used to collect the results.

Arguments:
classes Can be empty, in which case restriction is

removed.

onlyCreatedBetween_async(_cb, start, stop, current=None)

Restricts the time between which an entity may have been created.

Arguments:
start Can be null, i.e. interval open to negative
infinity.
stop Can be null, i.e. interval opens to positive

infinity.

onlyIds_async(_cb, ids, current=None)

Restricts the set of ids which will be checked. This is useful for testing one of the given restrictions on a reduced set of objects.

Arguments:
ids Can be null, in which case the previous

restriction is removed.

onlyModifiedBetween_async(_cb, start, stop, current=None)

Restricts the time between which an entity may have last been modified.

Arguments:
start Can be null, i.e. interval open to negative
infinity.
stop Can be null, i.e. interval open to positive

infinity.

onlyOwnedBy_async(_cb, d, current=None)

Uses the omero.model.Details#getOwner and omero.model.Details#getGroup information to restrict the entities which will be returned. If both are non-null, the two restrictions are joined by an AND.

Arguments:
d Can be null, in which case the previous

restriction is removed.

onlyType_async(_cb, klass, current=None)

Restricts the search to a single type. All return values will match this type.

onlyTypes_async(_cb, classes, current=None)

Restricts searches to a set of types. The entities returned are guaranteed to be one of these types.

or_async(_cb, current=None)

Applies the next by* method to the previous by* method, so that a call hasNext, next or results sees only the union of the two calls.

For example,

service.onlyType(Image.class); service.byFullText(&quot;foo&quot;); service.or(); service.onlyType(Dataset.class); service.byFullText(&quot;foo&quot;);

will return both Images and Datasets together.

Calling this method overrides a previous setting of _and or _not. If there is no active queries (i.e. activeQueries > 0), then an omero.ApiUsageException will be thrown.

remove_async(_cb, current=None)

Unsupported operation.

resetDefaults_async(_cb, current=None)

Resets all settings (non-query state) to the original default values, as if the instance had just be created.

results_async(_cb, current=None)

Returns up to getBatchSize batch size number of results along with the related query metadata. If isMergedBatches batches are merged then the results from multiple queries may be returned together.

Exceptions:
ApiUsageException if hasNext returns false.
setAllowLeadingWildcard_async(_cb, allowLeadingWildcard, current=None)

Permits full-text queries with a leading query if true.

setBatchSize_async(_cb, size, current=None)

Sets the maximum number of results that will be returned by one call to results. If batches are not merged, then results may often be less than the batch size. If batches are merged, then only the last call to results can be less than batch size.

Note: some query types may not support batching at the query level, and all instances must then be loaded into memory simultaneously.

Arguments:
size maximum number of results per call to

results

setCaseSentivice_async(_cb, caseSensitive, current=None)

Sets the case sensitivity on all queries where case-sensitivity is supported.

setMergedBatches_async(_cb, merge, current=None)

Set whether or not results from two separate queries can be returned in the same call to results.

setReturnUnloaded_async(_cb, returnUnloaded, current=None)

Determines if all results should be returned as unloaded objects. This is particularly useful for creating lists for further querying via omero.api.IQuery. This value overrides the setUseProjections setting.

setUseProjections_async(_cb, useProjections, current=None)

Determines if Lucene queries should not hit the database. Instead all values which are stored in the index will be loaded into the object, which includes the id. However, the entity will not be marked unloaded and therefore it is especially important to not allow a projection-instance to be saved back to the server. This can result in DATA LOSS.

unordered_async(_cb, current=None)

Removes the current stack of order statements.

class omero.api.SearchPrx

Bases: omero.api.StatefulServiceInterfacePrx

Returns the number of active queries. This means that activeQueries gives the minimum number of remaining calls to results when batches are not merged.

Returns:
number of active queries
_and(_ctx=None)
_not(_ctx=None)
_or(_ctx=None)
activeQueries(_ctx=None)
activeQueries_async(_cb, _ctx=None)
addOrderByAsc(path, _ctx=None)
addOrderByAsc_async(_cb, path, _ctx=None)
addOrderByDesc(path, _ctx=None)
addOrderByDesc_async(_cb, path, _ctx=None)
allTypes(_ctx=None)
allTypes_async(_cb, _ctx=None)
and_async(_cb, _ctx=None)
begin_activeQueries(_response=None, _ex=None, _sent=None, _ctx=None)
begin_addOrderByAsc(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addOrderByDesc(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_allTypes(_response=None, _ex=None, _sent=None, _ctx=None)
begin_and(_response=None, _ex=None, _sent=None, _ctx=None)
begin_byAnnotatedWith(examples, _response=None, _ex=None, _sent=None, _ctx=None)
begin_byFullText(query, _response=None, _ex=None, _sent=None, _ctx=None)
begin_byGroupForTags(group, _response=None, _ex=None, _sent=None, _ctx=None)
begin_byHqlQuery(query, params, _response=None, _ex=None, _sent=None, _ctx=None)
begin_byLuceneQueryBuilder(fields, _from, to, dateType, query, _response=None, _ex=None, _sent=None, _ctx=None)
begin_bySimilarTerms(terms, _response=None, _ex=None, _sent=None, _ctx=None)
begin_bySomeMustNone(some, must, none, _response=None, _ex=None, _sent=None, _ctx=None)
begin_byTagForGroups(tag, _response=None, _ex=None, _sent=None, _ctx=None)
begin_clearQueries(_response=None, _ex=None, _sent=None, _ctx=None)
begin_currentMetadata(_response=None, _ex=None, _sent=None, _ctx=None)
begin_currentMetadataList(_response=None, _ex=None, _sent=None, _ctx=None)
begin_fetchAlso(fetches, _response=None, _ex=None, _sent=None, _ctx=None)
begin_fetchAnnotations(classes, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getBatchSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_hasNext(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isAllowLeadingWildcard(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isCaseSensitive(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isMergedBatches(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isReturnUnloaded(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isUseProjections(_response=None, _ex=None, _sent=None, _ctx=None)
begin_next(_response=None, _ex=None, _sent=None, _ctx=None)
begin_not(_response=None, _ex=None, _sent=None, _ctx=None)
begin_notAnnotatedBy(d, _response=None, _ex=None, _sent=None, _ctx=None)
begin_notOwnedBy(d, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyAnnotatedBetween(start, stop, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyAnnotatedBy(d, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyAnnotatedWith(classes, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyCreatedBetween(start, stop, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyIds(ids, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyModifiedBetween(start, stop, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyOwnedBy(d, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyType(klass, _response=None, _ex=None, _sent=None, _ctx=None)
begin_onlyTypes(classes, _response=None, _ex=None, _sent=None, _ctx=None)
begin_or(_response=None, _ex=None, _sent=None, _ctx=None)
begin_remove(_response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaults(_response=None, _ex=None, _sent=None, _ctx=None)
begin_results(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setAllowLeadingWildcard(allowLeadingWildcard, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setBatchSize(size, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setCaseSentivice(caseSensitive, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setMergedBatches(merge, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setReturnUnloaded(returnUnloaded, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setUseProjections(useProjections, _response=None, _ex=None, _sent=None, _ctx=None)
begin_unordered(_response=None, _ex=None, _sent=None, _ctx=None)
byAnnotatedWith(examples, _ctx=None)
byAnnotatedWith_async(_cb, examples, _ctx=None)
byFullText(query, _ctx=None)
byFullText_async(_cb, query, _ctx=None)
byGroupForTags(group, _ctx=None)
byGroupForTags_async(_cb, group, _ctx=None)
byHqlQuery(query, params, _ctx=None)
byHqlQuery_async(_cb, query, params, _ctx=None)
byLuceneQueryBuilder(fields, _from, to, dateType, query, _ctx=None)
byLuceneQueryBuilder_async(_cb, fields, _from, to, dateType, query, _ctx=None)
bySimilarTerms(terms, _ctx=None)
bySimilarTerms_async(_cb, terms, _ctx=None)
bySomeMustNone(some, must, none, _ctx=None)
bySomeMustNone_async(_cb, some, must, none, _ctx=None)
byTagForGroups(tag, _ctx=None)
byTagForGroups_async(_cb, tag, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
clearQueries(_ctx=None)
clearQueries_async(_cb, _ctx=None)
currentMetadata(_ctx=None)
currentMetadataList(_ctx=None)
currentMetadataList_async(_cb, _ctx=None)
currentMetadata_async(_cb, _ctx=None)
end_activeQueries(_r)
end_addOrderByAsc(_r)
end_addOrderByDesc(_r)
end_allTypes(_r)
end_and(_r)
end_byAnnotatedWith(_r)
end_byFullText(_r)
end_byGroupForTags(_r)
end_byHqlQuery(_r)
end_byLuceneQueryBuilder(_r)
end_bySimilarTerms(_r)
end_bySomeMustNone(_r)
end_byTagForGroups(_r)
end_clearQueries(_r)
end_currentMetadata(_r)
end_currentMetadataList(_r)
end_fetchAlso(_r)
end_fetchAnnotations(_r)
end_getBatchSize(_r)
end_hasNext(_r)
end_isAllowLeadingWildcard(_r)
end_isCaseSensitive(_r)
end_isMergedBatches(_r)
end_isReturnUnloaded(_r)
end_isUseProjections(_r)
end_next(_r)
end_not(_r)
end_notAnnotatedBy(_r)
end_notOwnedBy(_r)
end_onlyAnnotatedBetween(_r)
end_onlyAnnotatedBy(_r)
end_onlyAnnotatedWith(_r)
end_onlyCreatedBetween(_r)
end_onlyIds(_r)
end_onlyModifiedBetween(_r)
end_onlyOwnedBy(_r)
end_onlyType(_r)
end_onlyTypes(_r)
end_or(_r)
end_remove(_r)
end_resetDefaults(_r)
end_results(_r)
end_setAllowLeadingWildcard(_r)
end_setBatchSize(_r)
end_setCaseSentivice(_r)
end_setMergedBatches(_r)
end_setReturnUnloaded(_r)
end_setUseProjections(_r)
end_unordered(_r)
fetchAlso(fetches, _ctx=None)
fetchAlso_async(_cb, fetches, _ctx=None)
fetchAnnotations(classes, _ctx=None)
fetchAnnotations_async(_cb, classes, _ctx=None)
getBatchSize(_ctx=None)
getBatchSize_async(_cb, _ctx=None)
hasNext(_ctx=None)
hasNext_async(_cb, _ctx=None)
isAllowLeadingWildcard(_ctx=None)
isAllowLeadingWildcard_async(_cb, _ctx=None)
isCaseSensitive(_ctx=None)
isCaseSensitive_async(_cb, _ctx=None)
isMergedBatches(_ctx=None)
isMergedBatches_async(_cb, _ctx=None)
isReturnUnloaded(_ctx=None)
isReturnUnloaded_async(_cb, _ctx=None)
isUseProjections(_ctx=None)
isUseProjections_async(_cb, _ctx=None)
next(_ctx=None)
next_async(_cb, _ctx=None)
notAnnotatedBy(d, _ctx=None)
notAnnotatedBy_async(_cb, d, _ctx=None)
notOwnedBy(d, _ctx=None)
notOwnedBy_async(_cb, d, _ctx=None)
not_async(_cb, _ctx=None)
onlyAnnotatedBetween(start, stop, _ctx=None)
onlyAnnotatedBetween_async(_cb, start, stop, _ctx=None)
onlyAnnotatedBy(d, _ctx=None)
onlyAnnotatedBy_async(_cb, d, _ctx=None)
onlyAnnotatedWith(classes, _ctx=None)
onlyAnnotatedWith_async(_cb, classes, _ctx=None)
onlyCreatedBetween(start, stop, _ctx=None)
onlyCreatedBetween_async(_cb, start, stop, _ctx=None)
onlyIds(ids, _ctx=None)
onlyIds_async(_cb, ids, _ctx=None)
onlyModifiedBetween(start, stop, _ctx=None)
onlyModifiedBetween_async(_cb, start, stop, _ctx=None)
onlyOwnedBy(d, _ctx=None)
onlyOwnedBy_async(_cb, d, _ctx=None)
onlyType(klass, _ctx=None)
onlyType_async(_cb, klass, _ctx=None)
onlyTypes(classes, _ctx=None)
onlyTypes_async(_cb, classes, _ctx=None)
or_async(_cb, _ctx=None)
remove(_ctx=None)
remove_async(_cb, _ctx=None)
resetDefaults(_ctx=None)
resetDefaults_async(_cb, _ctx=None)
results(_ctx=None)
results_async(_cb, _ctx=None)
setAllowLeadingWildcard(allowLeadingWildcard, _ctx=None)
setAllowLeadingWildcard_async(_cb, allowLeadingWildcard, _ctx=None)
setBatchSize(size, _ctx=None)
setBatchSize_async(_cb, size, _ctx=None)
setCaseSentivice(caseSensitive, _ctx=None)
setCaseSentivice_async(_cb, caseSensitive, _ctx=None)
setMergedBatches(merge, _ctx=None)
setMergedBatches_async(_cb, merge, _ctx=None)
setReturnUnloaded(returnUnloaded, _ctx=None)
setReturnUnloaded_async(_cb, returnUnloaded, _ctx=None)
setUseProjections(useProjections, _ctx=None)
setUseProjections_async(_cb, useProjections, _ctx=None)
static uncheckedCast(proxy, facet=None)
unordered(_ctx=None)
unordered_async(_cb, _ctx=None)
class omero.api.ServiceFactory

Bases: omero.cmd.Session

Starting point for all OMERO.blitz interaction.

A ServiceFactory once acquired can be used to create any number

of service proxies to the server. Most services implement ServiceInterface or its subinterface StatefulServiceInterface.

_ice_type = <IcePy.TypeInfo object at 0x11de6d08>
_op_activeServices = <IcePy.Operation object at 0x121f8090>
_op_closeOnDestroy = <IcePy.Operation object at 0x121f8060>
_op_createByName = <IcePy.Operation object at 0x11de6fd8>
_op_createExporter = <IcePy.Operation object at 0x11de6f00>
_op_createJobHandle = <IcePy.Operation object at 0x11de6f18>
_op_createRawFileStore = <IcePy.Operation object at 0x11de6f30>
_op_createRawPixelsStore = <IcePy.Operation object at 0x11de6f48>
_op_createRenderingEngine = <IcePy.Operation object at 0x11de6f60>
_op_createSearchService = <IcePy.Operation object at 0x11de6f78>
_op_createThumbnailStore = <IcePy.Operation object at 0x11de6f90>
_op_detachOnDestroy = <IcePy.Operation object at 0x121f8078>
_op_getAdminService = <IcePy.Operation object at 0x11de6d68>
_op_getByName = <IcePy.Operation object at 0x11de6fc0>
_op_getConfigService = <IcePy.Operation object at 0x11de6d80>
_op_getContainerService = <IcePy.Operation object at 0x11de6d98>
_op_getLdapService = <IcePy.Operation object at 0x11de6db0>
_op_getMetadataService = <IcePy.Operation object at 0x11de6ee8>
_op_getPixelsService = <IcePy.Operation object at 0x11de6dc8>
_op_getProjectionService = <IcePy.Operation object at 0x11de6de0>
_op_getQueryService = <IcePy.Operation object at 0x11de6df8>
_op_getRenderingSettingsService = <IcePy.Operation object at 0x11de6e10>
_op_getRepositoryInfoService = <IcePy.Operation object at 0x11de6e28>
_op_getRoiService = <IcePy.Operation object at 0x11de6e40>
_op_getScriptService = <IcePy.Operation object at 0x11de6e58>
_op_getSecurityContexts = <IcePy.Operation object at 0x11de6d20>
_op_getSessionService = <IcePy.Operation object at 0x11de6e70>
_op_getShareService = <IcePy.Operation object at 0x11de6e88>
_op_getTimelineService = <IcePy.Operation object at 0x11de6ea0>
_op_getTypesService = <IcePy.Operation object at 0x11de6eb8>
_op_getUpdateService = <IcePy.Operation object at 0x11de6ed0>
_op_keepAlive = <IcePy.Operation object at 0x121f80c0>
_op_keepAllAlive = <IcePy.Operation object at 0x121f80a8>
_op_setCallback = <IcePy.Operation object at 0x121f8048>
_op_setSecurityContext = <IcePy.Operation object at 0x11de6d38>
_op_setSecurityPassword = <IcePy.Operation object at 0x11de6d50>
_op_sharedResources = <IcePy.Operation object at 0x11de6fa8>
_op_subscribe = <IcePy.Operation object at 0x121f8030>
activeServices(current=None)

Returns a list of string ids for currently active services. This will _not_ keep services alive, and in fact checks for all expired services and removes them.

closeOnDestroy(current=None)

Marks the session for closure rather than detachment, which will be triggered by the destruction of the Glacier2 connection via router.destroySession()

Closing the session rather the detaching is more secure, since all resources are removed from the server and can safely be set once it is clear that a client is finished with those resources.

createByName(name, current=None)

Allows looking up any stateful service by name.

See Constants.ice for examples of services. If a service has been added by third-parties, createByName can be used even though no concrete method is available.

createExporter(current=None)
createJobHandle(current=None)
createRawFileStore(current=None)
createRawPixelsStore(current=None)
createRenderingEngine(current=None)
createSearchService(current=None)
createThumbnailStore(current=None)
detachOnDestroy(current=None)

Marks the session for detachment rather than closure, which will be triggered by the destruction of the Glacier2 connection via router.destroySession()

This is the default and allows a lost session to be reconnected, at a slight security cost since the session will persist longer and can be used by others if the UUID is intercepted.

getAdminService(current=None)
getByName(name, current=None)

Allows looking up any stateless service by name.

See Constants.ice for examples of services. If a service has been added by third-parties, getByName can be used even though no concrete method is available.

getConfigService(current=None)
getContainerService(current=None)
getLdapService(current=None)
getMetadataService(current=None)
getPixelsService(current=None)
getProjectionService(current=None)
getQueryService(current=None)
getRenderingSettingsService(current=None)
getRepositoryInfoService(current=None)
getRoiService(current=None)
getScriptService(current=None)
getSecurityContexts(current=None)

Provides a list of all valid security contexts for this session. Each of the returned omero.model.IObject instances can be passed to setSecurityContext.

getSessionService(current=None)
getShareService(current=None)
getTimelineService(current=None)
getTypesService(current=None)
getUpdateService(current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
keepAlive(proxy, current=None)

Returns true if the given service is alive.

Except for fatal server or session errors, this method should never throw an exception.

keepAllAlive(proxies, current=None)

Requests that the given services be marked as alive. It is possible that one of the services has already timed out, in which case the returned long value will be non-zero.

Specifically, the bit representing the 0-based index will be 1:

if (retval & 1&lt;&lt;idx == 1&lt;&lt;idx) { // not alive }

Except for fatal server or session errors, this method should never throw an exception.

setCallback(callback, current=None)

Sets the single callback used by the ServiceFactory to communicate with the client application. A default callback is set by the omero::client object on session creation which should suffice for most usage.

See the client object’s documentation in each language mapping for ways to use the callback.

setSecurityContext(obj, current=None)

Changes the security context for the current session.

A security context limits the set of objects which will

be returned by all queries and restricts what updates can be made.

Current valid values for security context:

omero.model.ExperimenterGroup - logs into a specific group omero.model.Share - uses IShare to activate a share

Passing an unloaded version of either object type will change

the way the current session operates. Note: only objects which are returned by the getSecurityContexts method are considered valid. Any other instance will cause an exception to be thrown.

Example usage in Python:

sf = client.createSession() objs = sf.getSecurityContexts() old = sf.setSecurityContext(objs[-1])

setSecurityPassword(password, current=None)

Re-validates the password for the current session. This prevents

See methods that mention “HasPassword”.

sharedResources(current=None)

Returns a reference to a back-end manager. The omero.grid.SharedResources service provides look ups for various facilities offered by OMERO:

OMERO.scripts OMERO.tables

These facilities may or may not be available on first request.

subscribe(topicName, prx, current=None)

Subscribe to a given topic. The topic must exist and the user must have sufficient permissions for that topic. Further the proxy object must match the required type for the topic as encoded in the topic name.

class omero.api.ServiceFactoryPrx

Bases: omero.cmd.SessionPrx

Provides a list of all valid security contexts for this session. Each of the returned omero.model.IObject instances can be passed to setSecurityContext.

activeServices(_ctx=None)
begin_activeServices(_response=None, _ex=None, _sent=None, _ctx=None)
begin_closeOnDestroy(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createByName(name, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createExporter(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createJobHandle(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createRawFileStore(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createRawPixelsStore(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createRenderingEngine(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createSearchService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createThumbnailStore(_response=None, _ex=None, _sent=None, _ctx=None)
begin_detachOnDestroy(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getAdminService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getByName(name, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getConfigService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getContainerService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getLdapService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getMetadataService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getProjectionService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getQueryService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getRenderingSettingsService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getRepositoryInfoService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getRoiService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getSecurityContexts(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getSessionService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getShareService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTimelineService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTypesService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getUpdateService(_response=None, _ex=None, _sent=None, _ctx=None)
begin_keepAlive(proxy, _response=None, _ex=None, _sent=None, _ctx=None)
begin_keepAllAlive(proxies, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setCallback(callback, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setSecurityContext(obj, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setSecurityPassword(password, _response=None, _ex=None, _sent=None, _ctx=None)
begin_sharedResources(_response=None, _ex=None, _sent=None, _ctx=None)
begin_subscribe(topicName, prx, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
closeOnDestroy(_ctx=None)
createByName(name, _ctx=None)
createExporter(_ctx=None)
createJobHandle(_ctx=None)
createRawFileStore(_ctx=None)
createRawPixelsStore(_ctx=None)
createRenderingEngine(_ctx=None)
createSearchService(_ctx=None)
createThumbnailStore(_ctx=None)
detachOnDestroy(_ctx=None)
end_activeServices(_r)
end_closeOnDestroy(_r)
end_createByName(_r)
end_createExporter(_r)
end_createJobHandle(_r)
end_createRawFileStore(_r)
end_createRawPixelsStore(_r)
end_createRenderingEngine(_r)
end_createSearchService(_r)
end_createThumbnailStore(_r)
end_detachOnDestroy(_r)
end_getAdminService(_r)
end_getByName(_r)
end_getConfigService(_r)
end_getContainerService(_r)
end_getLdapService(_r)
end_getMetadataService(_r)
end_getPixelsService(_r)
end_getProjectionService(_r)
end_getQueryService(_r)
end_getRenderingSettingsService(_r)
end_getRepositoryInfoService(_r)
end_getRoiService(_r)
end_getScriptService(_r)
end_getSecurityContexts(_r)
end_getSessionService(_r)
end_getShareService(_r)
end_getTimelineService(_r)
end_getTypesService(_r)
end_getUpdateService(_r)
end_keepAlive(_r)
end_keepAllAlive(_r)
end_setCallback(_r)
end_setSecurityContext(_r)
end_setSecurityPassword(_r)
end_sharedResources(_r)
end_subscribe(_r)
getAdminService(_ctx=None)
getByName(name, _ctx=None)
getConfigService(_ctx=None)
getContainerService(_ctx=None)
getLdapService(_ctx=None)
getMetadataService(_ctx=None)
getPixelsService(_ctx=None)
getProjectionService(_ctx=None)
getQueryService(_ctx=None)
getRenderingSettingsService(_ctx=None)
getRepositoryInfoService(_ctx=None)
getRoiService(_ctx=None)
getScriptService(_ctx=None)
getSecurityContexts(_ctx=None)
getSessionService(_ctx=None)
getShareService(_ctx=None)
getTimelineService(_ctx=None)
getTypesService(_ctx=None)
getUpdateService(_ctx=None)
keepAlive(proxy, _ctx=None)
keepAllAlive(proxies, _ctx=None)
setCallback(callback, _ctx=None)
setSecurityContext(obj, _ctx=None)
setSecurityPassword(password, _ctx=None)
sharedResources(_ctx=None)
subscribe(topicName, prx, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.ServiceInterface

Bases: Ice.Object

Service marker similar to ome.api.ServiceInterface. Any object which IS-A ServiceInterface but IS-NOT-A StatefulServiceInterface (below) is by definition a “”stateless service”“

_ice_type = <IcePy.TypeInfo object at 0x3dbba68>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.ServiceInterfacePrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.ShapePoints(x=None, y=None)

Bases: Ice.Object

Contains a discrete representation of the geometry of an omero::model::Shape. The x and y array are of the same size with each pair of entries representing a single point in the 2D plane.

_ice_type = <IcePy.TypeInfo object at 0x11feb090>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.ShapePointsPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.ShapeStats(shapeId=0, channelIds=None, pointsCount=None, min=None, max=None, sum=None, mean=None, stdDev=None)

Bases: Ice.Object

Contains arrays, one entry per channel, of the statistics for a given shape. All arrays are the same size, except for the channelIds array, which specifies the ids of the logical channels which compose this Shape. If the user specified no logical channels for the Shape, then all logical channels from the Pixels will be in channelIds.

_ice_type = <IcePy.TypeInfo object at 0x11feb0c0>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.api.ShapeStatsPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.StatefulServiceInterface

Bases: omero.api.ServiceInterface

Service marker for stateful services which permits the closing of a particular service before the destruction of the session.

_ice_type = <IcePy.TypeInfo object at 0x3dbbab0>
_op_activate = <IcePy.Operation object at 0x3dbbae0>
_op_close = <IcePy.Operation object at 0x3dbbaf8>
_op_getCurrentEventContext = <IcePy.Operation object at 0x3dbbb10>
_op_passivate = <IcePy.Operation object at 0x3dbbac8>
activate_async(_cb, current=None)

Load a service implementation from disk if it was previously passivated. It is unnecessary to call this method since activation happens automatically, but calling this may prevent a short lapse when the service is first accessed after passivation.

It is safe to call this method at any time, even when the service is not passivated.

close_async(_cb, current=None)

Frees all resources – passivated or active – for the given stateful service and removes its name from the object adapter. Any further method calls will fail with a Ice::NoSuchObjectException.

Note: with JavaEE, the close method was called publically, and internally this called destroy(). As of the OmeroBlitz migration, this functionality has been combined.

getCurrentEventContext_async(_cb, current=None)

To free clients from tracking the mapping from session to stateful service, each stateful service can returns its own context information.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
passivate_async(_cb, current=None)

Causes the blitz server to store the service implementation to disk to free memory. This is typically done automatically by the server when a pre-defined memory limit is reached, but can be used by the client if it clear that a stateful service will not be used for some time.

Activation will happen automatically whether passivation was done manually or automatically.

class omero.api.StatefulServiceInterfacePrx

Bases: omero.api.ServiceInterfacePrx

Causes the blitz server to store the service implementation to disk to free memory. This is typically done automatically by the server when a pre-defined memory limit is reached, but can be used by the client if it clear that a stateful service will not be used for some time.

Activation will happen automatically whether passivation was done manually or automatically.

activate(_ctx=None)
activate_async(_cb, _ctx=None)
begin_activate(_response=None, _ex=None, _sent=None, _ctx=None)
begin_close(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getCurrentEventContext(_response=None, _ex=None, _sent=None, _ctx=None)
begin_passivate(_response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
close(_ctx=None)
close_async(_cb, _ctx=None)
end_activate(_r)
end_close(_r)
end_getCurrentEventContext(_r)
end_passivate(_r)
getCurrentEventContext(_ctx=None)
getCurrentEventContext_async(_cb, _ctx=None)
passivate(_ctx=None)
passivate_async(_cb, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.ThumbnailStore

Bases: omero.api.StatefulServiceInterface

Provides methods for dealing with thumbnails. Provision is provided to retrieve thumbnails using the on-disk cache (provided by ROMIO) or on the fly.

NOTE: The calling order for the service is as follows:

setPixelsId any of the thumbnail accessor methods or resetDefaults

_ice_type = <IcePy.TypeInfo object at 0x3dbbf78>
_op_createThumbnail = <IcePy.Operation object at 0x122d5ea0>
_op_createThumbnails = <IcePy.Operation object at 0x122d5e88>
_op_createThumbnailsByLongestSideSet = <IcePy.Operation object at 0x122d5eb8>
_op_getRenderingDefId = <IcePy.Operation object at 0x122d5db0>
_op_getThumbnail = <IcePy.Operation object at 0x122d5dc8>
_op_getThumbnailByLongestSide = <IcePy.Operation object at 0x122d5e10>
_op_getThumbnailByLongestSideDirect = <IcePy.Operation object at 0x122d5e28>
_op_getThumbnailByLongestSideSet = <IcePy.Operation object at 0x122d5df8>
_op_getThumbnailDirect = <IcePy.Operation object at 0x122d5e40>
_op_getThumbnailForSectionByLongestSideDirect = <IcePy.Operation object at 0x122d5e70>
_op_getThumbnailForSectionDirect = <IcePy.Operation object at 0x122d5e58>
_op_getThumbnailSet = <IcePy.Operation object at 0x122d5de0>
_op_isInProgress = <IcePy.Operation object at 0x122d5d80>
_op_resetDefaults = <IcePy.Operation object at 0x122d5ee8>
_op_setPixelsId = <IcePy.Operation object at 0x122d5d68>
_op_setRenderingDefId = <IcePy.Operation object at 0x122d5d98>
_op_thumbnailExists = <IcePy.Operation object at 0x122d5ed0>
createThumbnail_async(_cb, sizeX, sizeY, current=None)

Creates a thumbnail for a pixels set using a given set of rendering settings (RenderingDef) in the on-disk cache.

Arguments:
sizeX the X-axis width of the thumbnail.

null specifies the default size of 48.

sizeY the Y-axis width of the thumbnail.

null specifies the default size of 48. Exceptions:

ApiUsageException

if:

sizeX > pixels.sizeX sizeX is negative sizeY > pixels.sizeY sizeY is negative setPixelsId has not yet been called

createThumbnailsByLongestSideSet_async(_cb, size, pixelsIds, current=None)

Creates thumbnails for a number of pixels sets using a given set of rendering settings (RenderingDef) in the on-disk cache. Unlike the other thumbnail creation methods, this method may be called without first calling setPixelsId. This method will not reset or modify rendering settings in any way. If rendering settings for a pixels set are not present, thumbnail creation for that pixels set will not be performed.

Arguments:
size the size of the longest side of the thumbnail

requested. null specifies the default size of 48.

pixelsIds the Pixels sets to retrieve thumbnails for.
Exceptions:
ApiUsageException

if:

size > pixels.sizeX and pixels.sizeY size is negative

createThumbnails_async(_cb, current=None)

Creates thumbnails for a pixels set using a given set of rendering settings (RenderingDef) in the on-disk cache for every sizeX/sizeY combination already cached.

getRenderingDefId_async(_cb, current=None)

Return the id of the omero.model.RenderingDef loaded in this instance.

getThumbnailByLongestSideDirect_async(_cb, size, current=None)

Retrieves a thumbnail for a pixels set using a given set of rendering settings (RenderingDef). The Thumbnail will always be created directly, ignoring the on-disk cache. The longest side of the image will be used to calculate the size for the smaller side in order to keep the aspect ratio of the original image.

Arguments:
size the size of the longest side of the thumbnail

requested. null specifies the default size of 48. Exceptions:

ApiUsageException

if:

size > pixels.sizeX and pixels.sizeY setPixelsId has not yet been called

Returns:
a JPEG thumbnail byte buffer.
getThumbnailByLongestSideSet_async(_cb, size, pixelsIds, current=None)

Retrieves a number of thumbnails for pixels sets using given sets of rendering settings (RenderingDef). If the Thumbnails exist in the on-disk cache they will be returned directly, otherwise they will be created as in getThumbnailByLongestSideDirect. The longest side of the image will be used to calculate the size for the smaller side in order to keep the aspect ratio of the original image. Unlike the other thumbnail retrieval methods, this method may be called without first calling setPixelsId.

Arguments:
size the size of the longest side of the thumbnail

requested. null specifies the default size of 48.

pixelsIds the Pixels sets to retrieve thumbnails for.
Returns:
a map whose keys are pixels ids and values are JPEG

thumbnail byte buffers or null if an exception was thrown while attempting to retrieve the thumbnail for that particular Pixels set.

getThumbnailByLongestSide_async(_cb, size, current=None)

Retrieves a thumbnail for a pixels set using a given set of rendering settings (RenderingDef). If the thumbnail exists in the on-disk cache it will bereturned directly, otherwise it will be created as in getThumbnailDirect, placed in the on-disk cache and returned. The longest side of the image will be used to calculate the size for the smaller side in order to keep the aspect ratio of the original image.

Arguments:
size the size of the longest side of the thumbnail

requested. null specifies the default size of 48. Exceptions:

ApiUsageException if:

size > pixels.sizeX and pixels.sizeY setPixelsId has not yet been called

Returns:
a JPEG thumbnail byte buffer.
getThumbnailDirect_async(_cb, sizeX, sizeY, current=None)

Retrieves a thumbnail for a pixels set using a given set of rendering settings (RenderingDef). The Thumbnail will always be created directly, ignoring the on-disk cache.

Arguments:
sizeX the X-axis width of the thumbnail.

null specifies the default size of 48.

sizeY the Y-axis width of the thumbnail.

null specifies the default size of 48. Exceptions:

ApiUsageException

if:

sizeX > pixels.sizeX sizeX is negative sizeY > pixels.sizeY sizeY is negative setPixelsId has not yet been called

Returns:
a JPEG thumbnail byte buffer.
getThumbnailForSectionByLongestSideDirect_async(_cb, theZ, theT, size, current=None)

Retrieves a thumbnail for a pixels set using a given set of rendering settings (RenderingDef) for a particular section. The Thumbnail will always be created directly, ignoring the on-disk cache. The longest side of the image will be used to calculate the size for the smaller side in order to keep the aspect ratio of the original image.

Arguments:
theZ the optical section (offset across the Z-axis)
to use.
theT the timepoint (offset across the T-axis) to use. size the size of the longest side of the thumbnail

requested. null specifies the default size of 48. Exceptions:

ApiUsageException

if:

size > pixels.sizeX and pixels.sizeY setPixelsId has not yet been called

Returns:
a JPEG thumbnail byte buffer.
getThumbnailForSectionDirect_async(_cb, theZ, theT, sizeX, sizeY, current=None)

Retrieves a thumbnail for a pixels set using a given set of rendering settings (RenderingDef) for a particular section. The Thumbnail will always be created directly, ignoring the on-disk cache.

Arguments:
theZ the optical section (offset across the Z-axis)
to use.
theT the timepoint (offset across the T-axis) to use. sizeX the X-axis width of the thumbnail.

null specifies the default size of 48.

sizeY the Y-axis width of the thumbnail.

null specifies the default size of 48. Exceptions:

ApiUsageException

if:

sizeX > pixels.sizeX sizeX is negative sizeY > pixels.sizeY sizeY is negative theZ is out of range theT is out of range setPixelsId has not yet been called

Returns:
a JPEG thumbnail byte buffer.
getThumbnailSet_async(_cb, sizeX, sizeY, pixelsIds, current=None)

Retrieves a number of thumbnails for pixels sets using given sets of rendering settings (RenderingDef). If the thumbnails exist in the on-disk cache they will be returned directly, otherwise they will be created as in getThumbnailDirect, placed in the on-disk cache and returned. Unlike the other thumbnail retrieval methods, this method may be called without first calling setPixelsId.

Arguments:
sizeX the X-axis width of the thumbnail.

null specifies the default size of 48.

sizeY the Y-axis width of the thumbnail.

null specifies the default size of 48.

pixelsIds the Pixels sets to retrieve thumbnails for.
Returns:
a map whose keys are pixels ids and values are JPEG

thumbnail byte buffers or null if an exception was thrown while attempting to retrieve the thumbnail for that particular Pixels set.

getThumbnail_async(_cb, sizeX, sizeY, current=None)

Retrieves a thumbnail for a pixels set using a given set of rendering settings (RenderingDef). If the thumbnail exists in the on-disk cache it will be returned directly, otherwise it will be created as in getThumbnailDirect, placed in the on-disk cache and returned.

Arguments:
sizeX the X-axis width of the thumbnail.

null specifies the default size of 48.

sizeY the Y-axis width of the thumbnail.

null specifies the default size of 48. Exceptions:

ApiUsageException

if:

sizeX > pixels.sizeX sizeX is negative sizeY > pixels.sizeY sizeY is negative setPixelsId has not yet been called

Returns:
a JPEG thumbnail byte buffer.
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isInProgress_async(_cb, current=None)

This returns the last available in progress state for a thumbnail. Its return value is only expected to be valid after the call to any of the individual thumbnail retrieval methods. Returns:

true if the image is in the process of

being imported or a pyramid is being generated for it.

resetDefaults_async(_cb, current=None)

Resets the rendering definition for the active pixels set to its default settings.

setPixelsId_async(_cb, pixelsId, current=None)

This method manages the state of the service; it must be invoked before using any other methods. As the omero.api.ThumbnailStore relies on the omero.api.RenderingEngine, a valid rendering definition must be available for it to work.

Arguments:
pixelsId an omero.model.Pixels id.
Exceptions:
ApiUsageException if no pixels object exists with

the ID pixelsId. Returns:

true if a

omero.model.RenderingDef exists for the omero.model.Pixels set, otherwise false

setRenderingDefId_async(_cb, renderingDefId, current=None)

This method manages the state of the service; it should be invoked directly after setPixelsId. If it is not invoked with a valid rendering definition ID before using the thumbnail accessor methods execution continues as if renderingDefId were set to null.

Arguments:
renderingDefId

an omero.model.RenderingDef id. null specifies the user’s currently active rendering settings to be used. Exceptions:

ValidationException

if no rendering definition exists with the ID renderingDefId.

thumbnailExists_async(_cb, sizeX, sizeY, current=None)

Checks if a thumbnail of a particular size exists for a pixels set.

Arguments:
sizeX the X-axis width of the thumbnail.

null specifies the default size of 48.

sizeY the Y-axis width of the thumbnail.

null specifies the default size of 48. Exceptions:

ApiUsageException

if:

sizeX is negative sizeY is negative setPixelsId has not yet been called

class omero.api.ThumbnailStorePrx

Bases: omero.api.StatefulServiceInterfacePrx

This method manages the state of the service; it must be invoked before using any other methods. As the omero.api.ThumbnailStore relies on the omero.api.RenderingEngine, a valid rendering definition must be available for it to work.

Arguments:
pixelsId an omero.model.Pixels id.
Exceptions:
ApiUsageException if no pixels object exists with

the ID pixelsId. Returns:

true if a

omero.model.RenderingDef exists for the omero.model.Pixels set, otherwise false

begin_createThumbnail(sizeX, sizeY, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createThumbnails(_response=None, _ex=None, _sent=None, _ctx=None)
begin_createThumbnailsByLongestSideSet(size, pixelsIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRenderingDefId(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnail(sizeX, sizeY, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnailByLongestSide(size, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnailByLongestSideDirect(size, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnailByLongestSideSet(size, pixelsIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnailDirect(sizeX, sizeY, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnailForSectionByLongestSideDirect(theZ, theT, size, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnailForSectionDirect(theZ, theT, sizeX, sizeY, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getThumbnailSet(sizeX, sizeY, pixelsIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_isInProgress(_response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaults(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setPixelsId(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setRenderingDefId(renderingDefId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_thumbnailExists(sizeX, sizeY, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
createThumbnail(sizeX, sizeY, _ctx=None)
createThumbnail_async(_cb, sizeX, sizeY, _ctx=None)
createThumbnails(_ctx=None)
createThumbnailsByLongestSideSet(size, pixelsIds, _ctx=None)
createThumbnailsByLongestSideSet_async(_cb, size, pixelsIds, _ctx=None)
createThumbnails_async(_cb, _ctx=None)
end_createThumbnail(_r)
end_createThumbnails(_r)
end_createThumbnailsByLongestSideSet(_r)
end_getRenderingDefId(_r)
end_getThumbnail(_r)
end_getThumbnailByLongestSide(_r)
end_getThumbnailByLongestSideDirect(_r)
end_getThumbnailByLongestSideSet(_r)
end_getThumbnailDirect(_r)
end_getThumbnailForSectionByLongestSideDirect(_r)
end_getThumbnailForSectionDirect(_r)
end_getThumbnailSet(_r)
end_isInProgress(_r)
end_resetDefaults(_r)
end_setPixelsId(_r)
end_setRenderingDefId(_r)
end_thumbnailExists(_r)
getRenderingDefId(_ctx=None)
getRenderingDefId_async(_cb, _ctx=None)
getThumbnail(sizeX, sizeY, _ctx=None)
getThumbnailByLongestSide(size, _ctx=None)
getThumbnailByLongestSideDirect(size, _ctx=None)
getThumbnailByLongestSideDirect_async(_cb, size, _ctx=None)
getThumbnailByLongestSideSet(size, pixelsIds, _ctx=None)
getThumbnailByLongestSideSet_async(_cb, size, pixelsIds, _ctx=None)
getThumbnailByLongestSide_async(_cb, size, _ctx=None)
getThumbnailDirect(sizeX, sizeY, _ctx=None)
getThumbnailDirect_async(_cb, sizeX, sizeY, _ctx=None)
getThumbnailForSectionByLongestSideDirect(theZ, theT, size, _ctx=None)
getThumbnailForSectionByLongestSideDirect_async(_cb, theZ, theT, size, _ctx=None)
getThumbnailForSectionDirect(theZ, theT, sizeX, sizeY, _ctx=None)
getThumbnailForSectionDirect_async(_cb, theZ, theT, sizeX, sizeY, _ctx=None)
getThumbnailSet(sizeX, sizeY, pixelsIds, _ctx=None)
getThumbnailSet_async(_cb, sizeX, sizeY, pixelsIds, _ctx=None)
getThumbnail_async(_cb, sizeX, sizeY, _ctx=None)
isInProgress(_ctx=None)
isInProgress_async(_cb, _ctx=None)
resetDefaults(_ctx=None)
resetDefaults_async(_cb, _ctx=None)
setPixelsId(pixelsId, _ctx=None)
setPixelsId_async(_cb, pixelsId, _ctx=None)
setRenderingDefId(renderingDefId, _ctx=None)
setRenderingDefId_async(_cb, renderingDefId, _ctx=None)
thumbnailExists(sizeX, sizeY, _ctx=None)
thumbnailExists_async(_cb, sizeX, sizeY, _ctx=None)
static uncheckedCast(proxy, facet=None)