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 0x1193f5a0>
_op_requestHeartbeat = <IcePy.Operation object at 0x1193f5b8>
_op_sessionClosed = <IcePy.Operation object at 0x1193f5d0>
_op_shutdownIn = <IcePy.Operation object at 0x1193f5e8>
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 0x371bd68>
_op_addImage = <IcePy.Operation object at 0x119f04e0>
_op_generateTiff = <IcePy.Operation object at 0x119f0510>
_op_generateXml = <IcePy.Operation object at 0x119f04f8>
_op_read = <IcePy.Operation object at 0x119f0528>
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 0x371ba38>
_op_addGroupOwners = <IcePy.Operation object at 0x11a5ed20>
_op_addGroups = <IcePy.Operation object at 0x11a5eca8>
_op_canUpdate = <IcePy.Operation object at 0x11a5ea50>
_op_changeExpiredCredentials = <IcePy.Operation object at 0x11a5ee40>
_op_changeGroup = <IcePy.Operation object at 0x11a5ed98>
_op_changeOwner = <IcePy.Operation object at 0x11a5ed80>
_op_changePassword = <IcePy.Operation object at 0x11a5ede0>
_op_changePasswordWithOldPassword = <IcePy.Operation object at 0x11a5edf8>
_op_changePermissions = <IcePy.Operation object at 0x11a5edb0>
_op_changeUserPassword = <IcePy.Operation object at 0x11a5ee10>
_op_containedExperimenters = <IcePy.Operation object at 0x11a5eaf8>
_op_containedGroups = <IcePy.Operation object at 0x11a5eb10>
_op_createExperimenter = <IcePy.Operation object at 0x11a5ec60>
_op_createExperimenterWithPassword = <IcePy.Operation object at 0x11a5ec78>
_op_createGroup = <IcePy.Operation object at 0x11a5ec90>
_op_createSystemUser = <IcePy.Operation object at 0x11a5ec48>
_op_createUser = <IcePy.Operation object at 0x11a5ec30>
_op_deleteExperimenter = <IcePy.Operation object at 0x11a5ed50>
_op_deleteGroup = <IcePy.Operation object at 0x11a5ed68>
_op_getDefaultGroup = <IcePy.Operation object at 0x11a5eb28>
_op_getEventContext = <IcePy.Operation object at 0x11a5ee88>
_op_getExperimenter = <IcePy.Operation object at 0x11a5ea68>
_op_getGroup = <IcePy.Operation object at 0x11a5eab0>
_op_getLeaderOfGroupIds = <IcePy.Operation object at 0x11a5eb88>
_op_getMemberOfGroupIds = <IcePy.Operation object at 0x11a5eb70>
_op_getMyUserPhotos = <IcePy.Operation object at 0x11a5ebd0>
_op_getSecurityRoles = <IcePy.Operation object at 0x11a5ee70>
_op_lookupExperimenter = <IcePy.Operation object at 0x11a5ea80>
_op_lookupExperimenters = <IcePy.Operation object at 0x11a5ea98>
_op_lookupGroup = <IcePy.Operation object at 0x11a5eac8>
_op_lookupGroups = <IcePy.Operation object at 0x11a5eae0>
_op_lookupLdapAuthExperimenter = <IcePy.Operation object at 0x11a5eb40>
_op_lookupLdapAuthExperimenters = <IcePy.Operation object at 0x11a5eb58>
_op_moveToCommonSpace = <IcePy.Operation object at 0x11a5edc8>
_op_removeGroupOwners = <IcePy.Operation object at 0x11a5ed38>
_op_removeGroups = <IcePy.Operation object at 0x11a5ecc0>
_op_reportForgottenPassword = <IcePy.Operation object at 0x11a5ee58>
_op_setDefaultGroup = <IcePy.Operation object at 0x11a5ecd8>
_op_setGroupOwner = <IcePy.Operation object at 0x11a5ecf0>
_op_synchronizeLoginCache = <IcePy.Operation object at 0x11a5ee28>
_op_unsetGroupOwner = <IcePy.Operation object at 0x11a5ed08>
_op_updateExperimenter = <IcePy.Operation object at 0x11a5ebe8>
_op_updateExperimenterWithPassword = <IcePy.Operation object at 0x11a5ec00>
_op_updateGroup = <IcePy.Operation object at 0x11a5ec18>
_op_updateSelf = <IcePy.Operation object at 0x11a5eba0>
_op_uploadMyUserPhoto = <IcePy.Operation object at 0x11a5ebb8>
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 0x371ba68>
_op_getClientConfigDefaults = <IcePy.Operation object at 0x11a5ef18>
_op_getClientConfigValues = <IcePy.Operation object at 0x11a5ef00>
_op_getConfigDefaults = <IcePy.Operation object at 0x11a5eee8>
_op_getConfigValue = <IcePy.Operation object at 0x11a5eeb8>
_op_getConfigValues = <IcePy.Operation object at 0x11a5eed0>
_op_getDatabaseTime = <IcePy.Operation object at 0x11a5ef78>
_op_getDatabaseUuid = <IcePy.Operation object at 0x11a5ef60>
_op_getServerTime = <IcePy.Operation object at 0x11a5ef90>
_op_getVersion = <IcePy.Operation object at 0x11a5eea0>
_op_setConfigValue = <IcePy.Operation object at 0x11a5ef30>
_op_setConfigValueIfEquals = <IcePy.Operation object at 0x11a5ef48>
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 it’s 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 0x371ba98>
_op_createDataObject = <IcePy.Operation object at 0x11e1a0a8>
_op_createDataObjects = <IcePy.Operation object at 0x11e1a0c0>
_op_findContainerHierarchies = <IcePy.Operation object at 0x11a5efc0>
_op_getCollectionCount = <IcePy.Operation object at 0x11e1a078>
_op_getImages = <IcePy.Operation object at 0x11a5efd8>
_op_getImagesByOptions = <IcePy.Operation object at 0x11e1a048>
_op_getImagesBySplitFilesets = <IcePy.Operation object at 0x11e1a060>
_op_getUserImages = <IcePy.Operation object at 0x11e1a030>
_op_loadContainerHierarchy = <IcePy.Operation object at 0x11a5efa8>
_op_retrieveCollection = <IcePy.Operation object at 0x11e1a090>
_op_updateDataObject = <IcePy.Operation object at 0x11e1a108>
_op_updateDataObjects = <IcePy.Operation object at 0x11e1a120>
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 0x371bac8>
_op_createUser = <IcePy.Operation object at 0x11e1a270>
_op_discover = <IcePy.Operation object at 0x11e1a240>
_op_discoverGroups = <IcePy.Operation object at 0x11e1a258>
_op_findDN = <IcePy.Operation object at 0x11e1a1b0>
_op_findExperimenter = <IcePy.Operation object at 0x11e1a1e0>
_op_findGroup = <IcePy.Operation object at 0x11e1a1f8>
_op_findGroupDN = <IcePy.Operation object at 0x11e1a1c8>
_op_getSetting = <IcePy.Operation object at 0x11e1a228>
_op_searchAll = <IcePy.Operation object at 0x11e1a138>
_op_searchByAttribute = <IcePy.Operation object at 0x11e1a168>
_op_searchByAttributes = <IcePy.Operation object at 0x11e1a180>
_op_searchByDN = <IcePy.Operation object at 0x11e1a198>
_op_searchDnInGroups = <IcePy.Operation object at 0x11e1a150>
_op_setDN = <IcePy.Operation object at 0x11e1a210>
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 0x371baf8>
_op_countAnnotationsUsedNotOwned = <IcePy.Operation object at 0x11e1a378>
_op_countSpecifiedAnnotations = <IcePy.Operation object at 0x11e1a318>
_op_getTaggedObjectsCount = <IcePy.Operation object at 0x11e1a300>
_op_loadAnnotation = <IcePy.Operation object at 0x11e1a330>
_op_loadAnnotations = <IcePy.Operation object at 0x11e1a2a0>
_op_loadAnnotationsUsedNotOwned = <IcePy.Operation object at 0x11e1a360>
_op_loadChannelAcquisitionData = <IcePy.Operation object at 0x11e1a288>
_op_loadInstrument = <IcePy.Operation object at 0x11e1a348>
_op_loadLogFiles = <IcePy.Operation object at 0x11e1a3a8>
_op_loadSpecifiedAnnotations = <IcePy.Operation object at 0x11e1a2b8>
_op_loadSpecifiedAnnotationsLinkedTo = <IcePy.Operation object at 0x11e1a390>
_op_loadTagContent = <IcePy.Operation object at 0x11e1a2d0>
_op_loadTagSets = <IcePy.Operation object at 0x11e1a2e8>
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 0x371bb28>
_op_copyAndResizeImage = <IcePy.Operation object at 0x11e1a4b0>
_op_copyAndResizePixels = <IcePy.Operation object at 0x11e1a498>
_op_createImage = <IcePy.Operation object at 0x11e1a4c8>
_op_getAllEnumerations = <IcePy.Operation object at 0x11e1a480>
_op_getBitDepth = <IcePy.Operation object at 0x11e1a450>
_op_getEnumeration = <IcePy.Operation object at 0x11e1a468>
_op_loadRndSettings = <IcePy.Operation object at 0x11e1a420>
_op_retrieveAllRndSettings = <IcePy.Operation object at 0x11e1a408>
_op_retrievePixDescription = <IcePy.Operation object at 0x11e1a3c0>
_op_retrieveRndSettings = <IcePy.Operation object at 0x11e1a3d8>
_op_retrieveRndSettingsFor = <IcePy.Operation object at 0x11e1a3f0>
_op_saveRndSettings = <IcePy.Operation object at 0x11e1a438>
_op_setChannelGlobalMinMax = <IcePy.Operation object at 0x11e1a4e0>
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 0x371bb58>
_op_projectPixels = <IcePy.Operation object at 0x11e1a510>
_op_projectStack = <IcePy.Operation object at 0x11e1a4f8>
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 0x371bb88>
_op_find = <IcePy.Operation object at 0x11e1a540>
_op_findAll = <IcePy.Operation object at 0x11e1a558>
_op_findAllByExample = <IcePy.Operation object at 0x11e1a588>
_op_findAllByFullText = <IcePy.Operation object at 0x11e1a600>
_op_findAllByQuery = <IcePy.Operation object at 0x11e1a5e8>
_op_findAllByString = <IcePy.Operation object at 0x11e1a5b8>
_op_findByExample = <IcePy.Operation object at 0x11e1a570>
_op_findByQuery = <IcePy.Operation object at 0x11e1a5d0>
_op_findByString = <IcePy.Operation object at 0x11e1a5a0>
_op_get = <IcePy.Operation object at 0x11e1a528>
_op_projection = <IcePy.Operation object at 0x11e1a618>
_op_refresh = <IcePy.Operation object at 0x11e1a630>
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 0x371bcd8>
_op_applySettingsToDataset = <IcePy.Operation object at 0x11e1a780>
_op_applySettingsToImage = <IcePy.Operation object at 0x11e1a7b0>
_op_applySettingsToImages = <IcePy.Operation object at 0x11e1a798>
_op_applySettingsToPixels = <IcePy.Operation object at 0x11e1a7c8>
_op_applySettingsToProject = <IcePy.Operation object at 0x11e1a768>
_op_applySettingsToSet = <IcePy.Operation object at 0x11e1a750>
_op_createNewRenderingDef = <IcePy.Operation object at 0x11e1a678>
_op_getRenderingSettings = <IcePy.Operation object at 0x11e1a660>
_op_resetDefaults = <IcePy.Operation object at 0x11e1a690>
_op_resetDefaultsByOwnerInSet = <IcePy.Operation object at 0x11e1a720>
_op_resetDefaultsForPixels = <IcePy.Operation object at 0x11e1a6d8>
_op_resetDefaultsInDataset = <IcePy.Operation object at 0x11e1a6f0>
_op_resetDefaultsInImage = <IcePy.Operation object at 0x11e1a6c0>
_op_resetDefaultsInSet = <IcePy.Operation object at 0x11e1a708>
_op_resetDefaultsNoSave = <IcePy.Operation object at 0x11e1a6a8>
_op_resetMinMaxInSet = <IcePy.Operation object at 0x11e1a738>
_op_sanityCheckPixels = <IcePy.Operation object at 0x11e1a648>
_op_setOriginalSettingsForPixels = <IcePy.Operation object at 0x11e1a7f8>
_op_setOriginalSettingsInDataset = <IcePy.Operation object at 0x11e1a810>
_op_setOriginalSettingsInImage = <IcePy.Operation object at 0x11e1a7e0>
_op_setOriginalSettingsInSet = <IcePy.Operation object at 0x11e1a828>
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 0x371bd08>
_op_getFreeSpaceInKilobytes = <IcePy.Operation object at 0x11e1a858>
_op_getUsageFraction = <IcePy.Operation object at 0x11e1a870>
_op_getUsedSpaceInKilobytes = <IcePy.Operation object at 0x11e1a840>
_op_removeUnusedFiles = <IcePy.Operation object at 0x11e1a8a0>
_op_sanityCheckRepository = <IcePy.Operation object at 0x11e1a888>
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 0x371bbb8>
_op_findByImage = <IcePy.Operation object at 0x11e1a9f0>
_op_findByPlane = <IcePy.Operation object at 0x11e1aa08>
_op_findByRoi = <IcePy.Operation object at 0x11e1a9d8>
_op_getMeasuredRois = <IcePy.Operation object at 0x11e1aa98>
_op_getMeasuredRoisMap = <IcePy.Operation object at 0x11e1aab0>
_op_getPoints = <IcePy.Operation object at 0x11e1aa20>
_op_getRoiMeasurements = <IcePy.Operation object at 0x11e1aa80>
_op_getRoiStats = <IcePy.Operation object at 0x11e1aa38>
_op_getShapeStats = <IcePy.Operation object at 0x11e1aa50>
_op_getShapeStatsList = <IcePy.Operation object at 0x11e1aa68>
_op_getTable = <IcePy.Operation object at 0x11e1aac8>
_op_uploadMask = <IcePy.Operation object at 0x11e1aae0>
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 0x371bbe8>
_op_canRunScript = <IcePy.Operation object at 0x11e1ac00>
_op_deleteScript = <IcePy.Operation object at 0x11e1abd0>
_op_editScript = <IcePy.Operation object at 0x11e1ab88>
_op_getParams = <IcePy.Operation object at 0x11e1abb8>
_op_getScriptID = <IcePy.Operation object at 0x11e1ab28>
_op_getScriptText = <IcePy.Operation object at 0x11e1ab40>
_op_getScriptWithDetails = <IcePy.Operation object at 0x11e1aba0>
_op_getScripts = <IcePy.Operation object at 0x11e1aaf8>
_op_getUserScripts = <IcePy.Operation object at 0x11e1ab10>
_op_runScript = <IcePy.Operation object at 0x11e1abe8>
_op_uploadOfficialScript = <IcePy.Operation object at 0x11e1ab70>
_op_uploadScript = <IcePy.Operation object at 0x11e1ab58>
_op_validateScript = <IcePy.Operation object at 0x11e1ac18>
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
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) path = script.path.val[1:] # First symbol is a “/” 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) path = script.path.val[1:] # First symbol is a “/” 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_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_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)
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 0x371bc18>
_op_closeSession = <IcePy.Operation object at 0x11e1acc0>
_op_createSession = <IcePy.Operation object at 0x11e1ac30>
_op_createSessionWithTimeout = <IcePy.Operation object at 0x11e1ac60>
_op_createSessionWithTimeouts = <IcePy.Operation object at 0x11e1ac78>
_op_createUserSession = <IcePy.Operation object at 0x11e1ac48>
_op_getInput = <IcePy.Operation object at 0x11e1ad20>
_op_getInputKeys = <IcePy.Operation object at 0x11e1ad80>
_op_getInputs = <IcePy.Operation object at 0x11e1adb0>
_op_getMyOpenAgentSessions = <IcePy.Operation object at 0x11e1acf0>
_op_getMyOpenClientSessions = <IcePy.Operation object at 0x11e1ad08>
_op_getMyOpenSessions = <IcePy.Operation object at 0x11e1acd8>
_op_getOutput = <IcePy.Operation object at 0x11e1ad38>
_op_getOutputKeys = <IcePy.Operation object at 0x11e1ad98>
_op_getOutputs = <IcePy.Operation object at 0x11e1adc8>
_op_getReferenceCount = <IcePy.Operation object at 0x11e1aca8>
_op_getSession = <IcePy.Operation object at 0x11e1ac90>
_op_setInput = <IcePy.Operation object at 0x11e1ad50>
_op_setOutput = <IcePy.Operation object at 0x11e1ad68>
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.

TODO Review the security of this method.

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 0x371bc48>
_op_activate = <IcePy.Operation object at 0x11e1ade0>
_op_addComment = <IcePy.Operation object at 0x119f0048>
_op_addGuest = <IcePy.Operation object at 0x119f0150>
_op_addGuests = <IcePy.Operation object at 0x119f00f0>
_op_addObject = <IcePy.Operation object at 0x11e1af90>
_op_addObjects = <IcePy.Operation object at 0x11e1af78>
_op_addReply = <IcePy.Operation object at 0x119f0060>
_op_addUser = <IcePy.Operation object at 0x119f0138>
_op_addUsers = <IcePy.Operation object at 0x119f00d8>
_op_closeShare = <IcePy.Operation object at 0x11e1af60>
_op_createShare = <IcePy.Operation object at 0x11e1af00>
_op_deactivate = <IcePy.Operation object at 0x11e1adf8>
_op_deleteComment = <IcePy.Operation object at 0x119f0078>
_op_getActiveConnections = <IcePy.Operation object at 0x119f0198>
_op_getAllGuests = <IcePy.Operation object at 0x119f00a8>
_op_getAllMembers = <IcePy.Operation object at 0x119f0090>
_op_getAllUsers = <IcePy.Operation object at 0x119f00c0>
_op_getCommentCount = <IcePy.Operation object at 0x11e1afd8>
_op_getComments = <IcePy.Operation object at 0x119f0030>
_op_getContentMap = <IcePy.Operation object at 0x11e1aee8>
_op_getContentSize = <IcePy.Operation object at 0x11e1aed0>
_op_getContentSubList = <IcePy.Operation object at 0x11e1aeb8>
_op_getContents = <IcePy.Operation object at 0x11e1aea0>
_op_getEvents = <IcePy.Operation object at 0x119f01e0>
_op_getMemberCount = <IcePy.Operation object at 0x11e1ae28>
_op_getMemberShares = <IcePy.Operation object at 0x11e1ae58>
_op_getMemberSharesFor = <IcePy.Operation object at 0x11e1ae88>
_op_getOwnShares = <IcePy.Operation object at 0x11e1ae40>
_op_getPastConnections = <IcePy.Operation object at 0x119f01b0>
_op_getShare = <IcePy.Operation object at 0x11e1ae10>
_op_getSharesOwnedBy = <IcePy.Operation object at 0x11e1ae70>
_op_invalidateConnection = <IcePy.Operation object at 0x119f01c8>
_op_notifyMembersOfShare = <IcePy.Operation object at 0x119f01f8>
_op_removeGuest = <IcePy.Operation object at 0x119f0180>
_op_removeGuests = <IcePy.Operation object at 0x119f0120>
_op_removeObject = <IcePy.Operation object at 0x11e1afc0>
_op_removeObjects = <IcePy.Operation object at 0x11e1afa8>
_op_removeUser = <IcePy.Operation object at 0x119f0168>
_op_removeUsers = <IcePy.Operation object at 0x119f0108>
_op_setActive = <IcePy.Operation object at 0x11e1af48>
_op_setDescription = <IcePy.Operation object at 0x11e1af18>
_op_setExpiration = <IcePy.Operation object at 0x11e1af30>
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:

  • “Annotation”
  • “Dataset”
  • “Image”
  • “Project”
  • “RenderingDef”

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.

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.

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).

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 0x371bd38>
_op_countByPeriod = <IcePy.Operation object at 0x119f0270>
_op_getByPeriod = <IcePy.Operation object at 0x119f0258>
_op_getEventLogsByPeriod = <IcePy.Operation object at 0x119f0288>
_op_getMostRecentObjects = <IcePy.Operation object at 0x119f0240>
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 0x371bc78>
_op_allEnumerations = <IcePy.Operation object at 0x119f02d0>
_op_createEnumeration = <IcePy.Operation object at 0x119f02a0>
_op_deleteEnumeration = <IcePy.Operation object at 0x119f0318>
_op_getAnnotationTypes = <IcePy.Operation object at 0x119f0348>
_op_getEnumeration = <IcePy.Operation object at 0x119f02b8>
_op_getEnumerationTypes = <IcePy.Operation object at 0x119f0330>
_op_getEnumerationsWithEntries = <IcePy.Operation object at 0x119f0360>
_op_getOriginalEnumerations = <IcePy.Operation object at 0x119f0378>
_op_resetEnumerations = <IcePy.Operation object at 0x119f0390>
_op_updateEnumeration = <IcePy.Operation object at 0x119f02e8>
_op_updateEnumerations = <IcePy.Operation object at 0x119f0300>
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

See IUpdate.html

_ice_type = <IcePy.TypeInfo object at 0x371bca8>
_op_deleteObject = <IcePy.Operation object at 0x119f0450>
_op_indexObject = <IcePy.Operation object at 0x119f0468>
_op_saveAndReturnArray = <IcePy.Operation object at 0x119f0420>
_op_saveAndReturnIds = <IcePy.Operation object at 0x119f0438>
_op_saveAndReturnObject = <IcePy.Operation object at 0x119f03f0>
_op_saveArray = <IcePy.Operation object at 0x119f0408>
_op_saveCollection = <IcePy.Operation object at 0x119f03d8>
_op_saveObject = <IcePy.Operation object at 0x119f03c0>
deleteObject_async(_cb, row, current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
indexObject_async(_cb, row, current=None)
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

See JobHandle.html

_ice_type = <IcePy.TypeInfo object at 0x371bd98>
_op_attach = <IcePy.Operation object at 0x119f0570>
_op_cancelJob = <IcePy.Operation object at 0x119f0618>
_op_getJob = <IcePy.Operation object at 0x119f0588>
_op_jobError = <IcePy.Operation object at 0x119f0600>
_op_jobFinished = <IcePy.Operation object at 0x119f05b8>
_op_jobMessage = <IcePy.Operation object at 0x119f05d0>
_op_jobRunning = <IcePy.Operation object at 0x119f05e8>
_op_jobStatus = <IcePy.Operation object at 0x119f05a0>
_op_setMessage = <IcePy.Operation object at 0x119f0648>
_op_setStatus = <IcePy.Operation object at 0x119f0630>
_op_setStatusAndMessage = <IcePy.Operation object at 0x119f0660>
_op_submit = <IcePy.Operation object at 0x119f0558>
attach_async(_cb, jobId, current=None)
cancelJob_async(_cb, current=None)
getJob_async(_cb, current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
jobError_async(_cb, current=None)
jobFinished_async(_cb, current=None)
jobMessage_async(_cb, current=None)
jobRunning_async(_cb, current=None)
jobStatus_async(_cb, current=None)
setMessage_async(_cb, message, current=None)
setStatusAndMessage_async(_cb, status, message, current=None)
setStatus_async(_cb, status, current=None)
submit_async(_cb, j, current=None)
class omero.api.JobHandlePrx

Bases: omero.api.StatefulServiceInterfacePrx

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 0x38df888>
_op_createRoot = <IcePy.Operation object at 0x38df8a0>
_op_populateMinMax = <IcePy.Operation object at 0x38df900>
_op_postProcess = <IcePy.Operation object at 0x38df930>
_op_saveToDB = <IcePy.Operation object at 0x38df8e8>
_op_setPixelsFile = <IcePy.Operation object at 0x38df918>
_op_updateObjects = <IcePy.Operation object at 0x38df8b8>
_op_updateReferences = <IcePy.Operation object at 0x38df8d0>
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 0x119f0798>
_op_getResolutionDescriptions = <IcePy.Operation object at 0x119f07e0>
_op_getResolutionLevel = <IcePy.Operation object at 0x119f07f8>
_op_getResolutionLevels = <IcePy.Operation object at 0x119f07c8>
_op_getTileSize = <IcePy.Operation object at 0x119f0828>
_op_requiresPixelsPyramid = <IcePy.Operation object at 0x119f07b0>
_op_setResolutionLevel = <IcePy.Operation object at 0x119f0810>
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.

See also RawFileStore.html

_ice_type = <IcePy.TypeInfo object at 0x371bdc8>
_op_exists = <IcePy.Operation object at 0x119f0708>
_op_getFileId = <IcePy.Operation object at 0x119f0690>
_op_read = <IcePy.Operation object at 0x119f06a8>
_op_save = <IcePy.Operation object at 0x119f0720>
_op_setFileId = <IcePy.Operation object at 0x119f0678>
_op_size = <IcePy.Operation object at 0x119f06c0>
_op_truncate = <IcePy.Operation object at 0x119f06d8>
_op_write = <IcePy.Operation object at 0x119f06f0>
exists_async(_cb, current=None)
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)
save_async(_cb, current=None)
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)
truncate_async(_cb, length, current=None)
write_async(_cb, buf, position, length, current=None)
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 0x371bdf8>
_op_calculateMessageDigest = <IcePy.Operation object at 0x119f0b28>
_op_getByteWidth = <IcePy.Operation object at 0x119f0ae0>
_op_getCol = <IcePy.Operation object at 0x119f09d8>
_op_getHypercube = <IcePy.Operation object at 0x119f0990>
_op_getPixelsId = <IcePy.Operation object at 0x119f0858>
_op_getPixelsPath = <IcePy.Operation object at 0x119f0870>
_op_getPlane = <IcePy.Operation object at 0x119f09f0>
_op_getPlaneOffset = <IcePy.Operation object at 0x119f0930>
_op_getPlaneRegion = <IcePy.Operation object at 0x119f0a08>
_op_getPlaneSize = <IcePy.Operation object at 0x119f08a0>
_op_getRegion = <IcePy.Operation object at 0x119f09a8>
_op_getRow = <IcePy.Operation object at 0x119f09c0>
_op_getRowOffset = <IcePy.Operation object at 0x119f0918>
_op_getRowSize = <IcePy.Operation object at 0x119f08b8>
_op_getStack = <IcePy.Operation object at 0x119f0a20>
_op_getStackOffset = <IcePy.Operation object at 0x119f0948>
_op_getStackSize = <IcePy.Operation object at 0x119f08d0>
_op_getTile = <IcePy.Operation object at 0x119f0978>
_op_getTimepoint = <IcePy.Operation object at 0x119f0a38>
_op_getTimepointOffset = <IcePy.Operation object at 0x119f0960>
_op_getTimepointSize = <IcePy.Operation object at 0x119f08e8>
_op_getTotalSize = <IcePy.Operation object at 0x119f0900>
_op_isFloat = <IcePy.Operation object at 0x119f0b10>
_op_isSigned = <IcePy.Operation object at 0x119f0af8>
_op_prepare = <IcePy.Operation object at 0x119f0888>
_op_save = <IcePy.Operation object at 0x119f0b40>
_op_setPixelsId = <IcePy.Operation object at 0x119f0840>
_op_setPlane = <IcePy.Operation object at 0x119f0a98>
_op_setRegion = <IcePy.Operation object at 0x119f0a68>
_op_setRow = <IcePy.Operation object at 0x119f0a80>
_op_setStack = <IcePy.Operation object at 0x119f0ab0>
_op_setTile = <IcePy.Operation object at 0x119f0a50>
_op_setTimepoint = <IcePy.Operation object at 0x119f0ac8>
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.
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 scaline.
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 (sizeX*ByteWidth)
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*sizeZ*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_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_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)
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

See RenderingEngine.html

_ice_type = <IcePy.TypeInfo object at 0x371be28>
_op_addCodomainMap = <IcePy.Operation object at 0x119f0fd8>
_op_getAvailableFamilies = <IcePy.Operation object at 0x119f0e28>
_op_getAvailableModels = <IcePy.Operation object at 0x119f0e10>
_op_getChannelCurveCoefficient = <IcePy.Operation object at 0x119f0ee8>
_op_getChannelFamily = <IcePy.Operation object at 0x119f0ea0>
_op_getChannelLookupTable = <IcePy.Operation object at 0x119f0fc0>
_op_getChannelNoiseReduction = <IcePy.Operation object at 0x119f0eb8>
_op_getChannelStats = <IcePy.Operation object at 0x119f0ed0>
_op_getChannelWindowEnd = <IcePy.Operation object at 0x119f0f30>
_op_getChannelWindowStart = <IcePy.Operation object at 0x119f0f18>
_op_getCompressionLevel = <IcePy.Operation object at 0x11f1e0c0>
_op_getDefaultT = <IcePy.Operation object at 0x119f0db0>
_op_getDefaultZ = <IcePy.Operation object at 0x119f0d98>
_op_getModel = <IcePy.Operation object at 0x119f0d80>
_op_getPixels = <IcePy.Operation object at 0x119f0df8>
_op_getPixelsTypeLowerBound = <IcePy.Operation object at 0x11f1e108>
_op_getPixelsTypeUpperBound = <IcePy.Operation object at 0x11f1e0f0>
_op_getQuantumDef = <IcePy.Operation object at 0x119f0e70>
_op_getRGBA = <IcePy.Operation object at 0x119f0f60>
_op_getRenderingDefId = <IcePy.Operation object at 0x119f0cd8>
_op_isActive = <IcePy.Operation object at 0x119f0f90>
_op_isPixelsTypeSigned = <IcePy.Operation object at 0x11f1e0d8>
_op_load = <IcePy.Operation object at 0x119f0d50>
_op_loadRenderingDef = <IcePy.Operation object at 0x119f0d20>
_op_lookupPixels = <IcePy.Operation object at 0x119f0cf0>
_op_lookupRenderingDef = <IcePy.Operation object at 0x119f0d08>
_op_removeCodomainMap = <IcePy.Operation object at 0x11f1e048>
_op_render = <IcePy.Operation object at 0x119f0c60>
_op_renderAsPackedInt = <IcePy.Operation object at 0x119f0c78>
_op_renderCompressed = <IcePy.Operation object at 0x119f0ca8>
_op_renderProjectedAsPackedInt = <IcePy.Operation object at 0x119f0c90>
_op_renderProjectedCompressed = <IcePy.Operation object at 0x119f0cc0>
_op_resetDefaultSettings = <IcePy.Operation object at 0x11f1e090>
_op_saveAsNewSettings = <IcePy.Operation object at 0x11f1e078>
_op_saveCurrentSettings = <IcePy.Operation object at 0x11f1e060>
_op_setActive = <IcePy.Operation object at 0x119f0f78>
_op_setChannelLookupTable = <IcePy.Operation object at 0x119f0fa8>
_op_setChannelWindow = <IcePy.Operation object at 0x119f0f00>
_op_setCodomainInterval = <IcePy.Operation object at 0x119f0e58>
_op_setCompressionLevel = <IcePy.Operation object at 0x11f1e0a8>
_op_setDefaultT = <IcePy.Operation object at 0x119f0de0>
_op_setDefaultZ = <IcePy.Operation object at 0x119f0dc8>
_op_setModel = <IcePy.Operation object at 0x119f0d68>
_op_setOverlays = <IcePy.Operation object at 0x119f0d38>
_op_setQuantizationMap = <IcePy.Operation object at 0x119f0e88>
_op_setQuantumStrategy = <IcePy.Operation object at 0x119f0e40>
_op_setRGBA = <IcePy.Operation object at 0x119f0f48>
_op_updateCodomainMap = <IcePy.Operation object at 0x11f1e030>
addCodomainMap_async(_cb, mapCtx, current=None)
getAvailableFamilies_async(_cb, current=None)
getAvailableModels_async(_cb, current=None)
getChannelCurveCoefficient_async(_cb, w, current=None)
getChannelFamily_async(_cb, w, current=None)
getChannelLookupTable_async(_cb, w, current=None)
getChannelNoiseReduction_async(_cb, w, current=None)
getChannelStats_async(_cb, w, current=None)
getChannelWindowEnd_async(_cb, w, current=None)
getChannelWindowStart_async(_cb, w, current=None)
getCompressionLevel_async(_cb, current=None)
getDefaultT_async(_cb, current=None)
getDefaultZ_async(_cb, current=None)
getModel_async(_cb, current=None)
getPixelsTypeLowerBound_async(_cb, w, current=None)
getPixelsTypeUpperBound_async(_cb, w, current=None)
getPixels_async(_cb, current=None)
getQuantumDef_async(_cb, current=None)
getRGBA_async(_cb, w, current=None)
getRenderingDefId_async(_cb, current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isActive_async(_cb, w, current=None)
isPixelsTypeSigned_async(_cb, current=None)
loadRenderingDef_async(_cb, renderingDefId, current=None)
load_async(_cb, current=None)
lookupPixels_async(_cb, pixelsId, current=None)
lookupRenderingDef_async(_cb, pixelsId, current=None)
removeCodomainMap_async(_cb, mapCtx, current=None)
renderAsPackedInt_async(_cb, _def, current=None)
renderCompressed_async(_cb, _def, current=None)
renderProjectedAsPackedInt_async(_cb, algorithm, timepoint, stepping, start, end, current=None)
renderProjectedCompressed_async(_cb, algorithm, timepoint, stepping, start, end, current=None)
render_async(_cb, _def, current=None)
resetDefaultSettings_async(_cb, save, current=None)
saveAsNewSettings_async(_cb, current=None)
saveCurrentSettings_async(_cb, current=None)
setActive_async(_cb, w, active, current=None)
setChannelLookupTable_async(_cb, w, lookup, current=None)
setChannelWindow_async(_cb, w, start, end, current=None)
setCodomainInterval_async(_cb, start, end, current=None)
setCompressionLevel_async(_cb, percentage, current=None)
setDefaultT_async(_cb, t, current=None)
setDefaultZ_async(_cb, z, current=None)
setModel_async(_cb, model, current=None)
setOverlays_async(_cb, tablesId, imageId, rowColorMap, current=None)
setQuantizationMap_async(_cb, w, fam, coefficient, noiseReduction, current=None)
setQuantumStrategy_async(_cb, bitResolution, current=None)
setRGBA_async(_cb, w, red, green, blue, alpha, current=None)
updateCodomainMap_async(_cb, mapCtx, current=None)
class omero.api.RenderingEnginePrx

Bases: omero.api.PyramidServicePrx

addCodomainMap(mapCtx, _ctx=None)
addCodomainMap_async(_cb, mapCtx, _ctx=None)
begin_addCodomainMap(mapCtx, _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_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_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_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_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_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)
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)
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 0x119f0750>
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, namespace=None)

Bases: Ice.Object

Specifies filters used when querying the ROIs.

_ice_type = <IcePy.TypeInfo object at 0x11e1a8d0>
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, byG=None, groups=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, t, or do not belong to a group can be found with:

byZ.get(-1); byT.get(-1); byG.get(“”);

respectively. The groups string-string map provides the hierarchy of the group strings using unix-style filesystem paths. That is, if a returned shape is in the group “/a/b”, then there will be an entry in the groups map: ...TBD...

_ice_type = <IcePy.TypeInfo object at 0x11e1a900>
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 0x11e1a9c0>
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 0x119f0498>
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 0x119f04c8>
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

See Search.html

_ice_type = <IcePy.TypeInfo object at 0x371be58>
_op_activeQueries = <IcePy.Operation object at 0x11f1e120>
_op_addOrderByAsc = <IcePy.Operation object at 0x11f1e378>
_op_addOrderByDesc = <IcePy.Operation object at 0x11f1e390>
_op_allTypes = <IcePy.Operation object at 0x11f1e288>
_op_and = <IcePy.Operation object at 0x11f1e4e0>
_op_byAnnotatedWith = <IcePy.Operation object at 0x11f1e4b0>
_op_byFullText = <IcePy.Operation object at 0x11f1e438>
_op_byGroupForTags = <IcePy.Operation object at 0x11f1e408>
_op_byHqlQuery = <IcePy.Operation object at 0x11f1e480>
_op_byLuceneQueryBuilder = <IcePy.Operation object at 0x11f1e450>
_op_bySimilarTerms = <IcePy.Operation object at 0x11f1e468>
_op_bySomeMustNone = <IcePy.Operation object at 0x11f1e498>
_op_byTagForGroups = <IcePy.Operation object at 0x11f1e420>
_op_clearQueries = <IcePy.Operation object at 0x11f1e4c8>
_op_currentMetadata = <IcePy.Operation object at 0x11f1e570>
_op_currentMetadataList = <IcePy.Operation object at 0x11f1e588>
_op_fetchAlso = <IcePy.Operation object at 0x11f1e3d8>
_op_fetchAnnotations = <IcePy.Operation object at 0x11f1e3c0>
_op_getBatchSize = <IcePy.Operation object at 0x11f1e150>
_op_hasNext = <IcePy.Operation object at 0x11f1e528>
_op_isAllowLeadingWildcard = <IcePy.Operation object at 0x11f1e240>
_op_isCaseSensitive = <IcePy.Operation object at 0x11f1e1b0>
_op_isMergedBatches = <IcePy.Operation object at 0x11f1e180>
_op_isReturnUnloaded = <IcePy.Operation object at 0x11f1e210>
_op_isUseProjections = <IcePy.Operation object at 0x11f1e1e0>
_op_next = <IcePy.Operation object at 0x11f1e540>
_op_not = <IcePy.Operation object at 0x11f1e510>
_op_notAnnotatedBy = <IcePy.Operation object at 0x11f1e348>
_op_notOwnedBy = <IcePy.Operation object at 0x11f1e2d0>
_op_onlyAnnotatedBetween = <IcePy.Operation object at 0x11f1e318>
_op_onlyAnnotatedBy = <IcePy.Operation object at 0x11f1e330>
_op_onlyAnnotatedWith = <IcePy.Operation object at 0x11f1e360>
_op_onlyCreatedBetween = <IcePy.Operation object at 0x11f1e2e8>
_op_onlyIds = <IcePy.Operation object at 0x11f1e2a0>
_op_onlyModifiedBetween = <IcePy.Operation object at 0x11f1e300>
_op_onlyOwnedBy = <IcePy.Operation object at 0x11f1e2b8>
_op_onlyType = <IcePy.Operation object at 0x11f1e258>
_op_onlyTypes = <IcePy.Operation object at 0x11f1e270>
_op_or = <IcePy.Operation object at 0x11f1e4f8>
_op_remove = <IcePy.Operation object at 0x11f1e5a0>
_op_resetDefaults = <IcePy.Operation object at 0x11f1e3f0>
_op_results = <IcePy.Operation object at 0x11f1e558>
_op_setAllowLeadingWildcard = <IcePy.Operation object at 0x11f1e228>
_op_setBatchSize = <IcePy.Operation object at 0x11f1e138>
_op_setCaseSentivice = <IcePy.Operation object at 0x11f1e198>
_op_setMergedBatches = <IcePy.Operation object at 0x11f1e168>
_op_setReturnUnloaded = <IcePy.Operation object at 0x11f1e1f8>
_op_setUseProjections = <IcePy.Operation object at 0x11f1e1c8>
_op_unordered = <IcePy.Operation object at 0x11f1e3a8>
activeQueries_async(_cb, current=None)
addOrderByAsc_async(_cb, path, current=None)
addOrderByDesc_async(_cb, path, current=None)
allTypes_async(_cb, current=None)
and_async(_cb, current=None)
byAnnotatedWith_async(_cb, examples, current=None)
byFullText_async(_cb, query, current=None)
byGroupForTags_async(_cb, group, current=None)
byHqlQuery_async(_cb, query, params, current=None)
byLuceneQueryBuilder_async(_cb, fields, _from, to, dateType, query, current=None)
bySimilarTerms_async(_cb, terms, current=None)
bySomeMustNone_async(_cb, some, must, none, current=None)
byTagForGroups_async(_cb, tag, current=None)
clearQueries_async(_cb, current=None)
currentMetadataList_async(_cb, current=None)
currentMetadata_async(_cb, current=None)
fetchAlso_async(_cb, fetches, current=None)
fetchAnnotations_async(_cb, classes, current=None)
getBatchSize_async(_cb, current=None)
hasNext_async(_cb, current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isAllowLeadingWildcard_async(_cb, current=None)
isCaseSensitive_async(_cb, current=None)
isMergedBatches_async(_cb, current=None)
isReturnUnloaded_async(_cb, current=None)
isUseProjections_async(_cb, current=None)
next_async(_cb, current=None)
notAnnotatedBy_async(_cb, d, current=None)
notOwnedBy_async(_cb, d, current=None)
not_async(_cb, current=None)
onlyAnnotatedBetween_async(_cb, start, stop, current=None)
onlyAnnotatedBy_async(_cb, d, current=None)
onlyAnnotatedWith_async(_cb, classes, current=None)
onlyCreatedBetween_async(_cb, start, stop, current=None)
onlyIds_async(_cb, ids, current=None)
onlyModifiedBetween_async(_cb, start, stop, current=None)
onlyOwnedBy_async(_cb, d, current=None)
onlyType_async(_cb, klass, current=None)
onlyTypes_async(_cb, classes, current=None)
or_async(_cb, current=None)
remove_async(_cb, current=None)
resetDefaults_async(_cb, current=None)
results_async(_cb, current=None)
setAllowLeadingWildcard_async(_cb, allowLeadingWildcard, current=None)
setBatchSize_async(_cb, size, current=None)
setCaseSentivice_async(_cb, caseSensitive, current=None)
setMergedBatches_async(_cb, merge, current=None)
setReturnUnloaded_async(_cb, returnUnloaded, current=None)
setUseProjections_async(_cb, useProjections, current=None)
unordered_async(_cb, current=None)
class omero.api.SearchPrx

Bases: omero.api.StatefulServiceInterfacePrx

_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,