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>
_op_requestHeartbeat = <IcePy.Operation object>
_op_sessionClosed = <IcePy.Operation object>
_op_shutdownIn = <IcePy.Operation object>
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. Arguments: current – The Current object for the invocation.

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() Arguments: current – The Current object for the invocation.

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. Arguments: milliseconds – current – The Current object for the invocation.

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. Arguments: _ctx – The request context for the invocation.

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)
static ice_staticId()
requestHeartbeat(_ctx=None)
sessionClosed(_ctx=None)
shutdownIn(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: {@code 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 0x3522f48>
_op_addImage = <IcePy.Operation object>
_op_generateTiff = <IcePy.Operation object>
_op_generateXml = <IcePy.Operation object>
_op_read = <IcePy.Operation object>
addImage_async(_cb, id, current=None)

Adds a single image with basic metadata to the Exporter for inclusion on the next call to getBytes(). Arguments: _cb – The asynchronous callback object. id – current – The Current object for the invocation.

generateTiff_async(_cb, current=None)

Generates an OME-TIFF file. The return value is the length of the file produced. This method ends configuration. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

generateXml_async(_cb, current=None)

Generates an OME-XML file. The return value is the length of the file produced. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. position – length – current – The Current object for the invocation.

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(). Arguments: id – _ctx – The request context for the invocation.

addImage(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)
generateXml(_ctx=None)
static ice_staticId()
read(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 0x3522c18>
_op_addGroupOwners = <IcePy.Operation object>
_op_addGroups = <IcePy.Operation object>
_op_canUpdate = <IcePy.Operation object>
_op_changeExpiredCredentials = <IcePy.Operation object>
_op_changeGroup = <IcePy.Operation object>
_op_changeOwner = <IcePy.Operation object>
_op_changePassword = <IcePy.Operation object>
_op_changePasswordWithOldPassword = <IcePy.Operation object>
_op_changePermissions = <IcePy.Operation object>
_op_changeUserPassword = <IcePy.Operation object>
_op_containedExperimenters = <IcePy.Operation object>
_op_containedGroups = <IcePy.Operation object>
_op_createExperimenter = <IcePy.Operation object>
_op_createExperimenterWithPassword = <IcePy.Operation object>
_op_createGroup = <IcePy.Operation object>
_op_createRestrictedSystemUser = <IcePy.Operation object>
_op_createRestrictedSystemUserWithPassword = <IcePy.Operation object>
_op_createSystemUser = <IcePy.Operation object>
_op_createUser = <IcePy.Operation object>
_op_deleteExperimenter = <IcePy.Operation object>
_op_deleteGroup = <IcePy.Operation object>
_op_getAdminPrivileges = <IcePy.Operation object>
_op_getAdminsWithPrivileges = <IcePy.Operation object>
_op_getCurrentAdminPrivileges = <IcePy.Operation object>
_op_getDefaultGroup = <IcePy.Operation object>
_op_getEventContext = <IcePy.Operation object>
_op_getExperimenter = <IcePy.Operation object>
_op_getGroup = <IcePy.Operation object>
_op_getLeaderOfGroupIds = <IcePy.Operation object>
_op_getMemberOfGroupIds = <IcePy.Operation object>
_op_getMyUserPhotos = <IcePy.Operation object>
_op_getSecurityRoles = <IcePy.Operation object>
_op_lookupExperimenter = <IcePy.Operation object>
_op_lookupExperimenters = <IcePy.Operation object>
_op_lookupGroup = <IcePy.Operation object>
_op_lookupGroups = <IcePy.Operation object>
_op_lookupLdapAuthExperimenter = <IcePy.Operation object>
_op_lookupLdapAuthExperimenters = <IcePy.Operation object>
_op_moveToCommonSpace = <IcePy.Operation object>
_op_removeGroupOwners = <IcePy.Operation object>
_op_removeGroups = <IcePy.Operation object>
_op_reportForgottenPassword = <IcePy.Operation object>
_op_setAdminPrivileges = <IcePy.Operation object>
_op_setDefaultGroup = <IcePy.Operation object>
_op_setGroupOwner = <IcePy.Operation object>
_op_synchronizeLoginCache = <IcePy.Operation object>
_op_unsetGroupOwner = <IcePy.Operation object>
_op_updateExperimenter = <IcePy.Operation object>
_op_updateExperimenterWithPassword = <IcePy.Operation object>
_op_updateGroup = <IcePy.Operation object>
_op_updateSelf = <IcePy.Operation object>
_op_uploadMyUserPhoto = <IcePy.Operation object>
addGroupOwners_async(_cb, group, owners, current=None)

Adds the given users to the owner list for this group. Arguments: _cb – The asynchronous callback object. group – A currently managed omero.model.ExperimenterGroup. Not null. owners – A set of currently managed omero.model.Experimenters. Not null. current – The Current object for the invocation.

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

Adds a user to the given groups. Arguments: _cb – The asynchronous callback object. user – A currently managed entity. Not null. groups – Groups to which the user will be added. Not null. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. obj – current – The Current object for the invocation.

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

Used after an omero.ExpiredCredentialException instance is thrown. Arguments: _cb – The asynchronous callback object. name – oldCred – newCred – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. oldPassword – Not-null. Must pass validation in the security sub-system. newPassword – Possibly null to allow logging in with no password. current – The Current object for the invocation. Throws: 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 {@code changePasswordWithOldPassword}. See also ticket 911 and ticket 3201 Arguments: _cb – The asynchronous callback object. newPassword – Possibly null to allow logging in with no password. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. omeName – newPassword – Not-null. Might must pass validation in the security sub-system. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. groupId – id of the ExperimenterGroup current – The Current object for the invocation.

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: _cb – The asynchronous callback object. experimenterId – id of the Experimenter. Not null. current – The Current object for the invocation.

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

Creates and returns a new user in the given groups with password. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

createGroup_async(_cb, group, current=None)

Creates and returns a new group. The {@code 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 {@code 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: _cb – The asynchronous callback object. group – a new omero.model.ExperimenterGroup instance. Not null. current – The Current object for the invocation.

createRestrictedSystemUserWithPassword_async(_cb, experimenter, privileges, password, 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. Their light administrator privileges and password will be set as given. Arguments: _cb – The asynchronous callback object. experimenter – a new omero.model.Experimenter instance privileges – the privileges to set for the user password – Not-null. Must pass validation in the security sub-system. current – The Current object for the invocation.

createRestrictedSystemUser_async(_cb, experimenter, privileges, 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. Their light administrator privileges will be set as given. Arguments: _cb – The asynchronous callback object. experimenter – a new omero.model.Experimenter instance privileges – the privileges to set for the user current – The Current object for the invocation.

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: _cb – The asynchronous callback object. experimenter – a new omero.model.Experimenter instance current – The Current object for the invocation.

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

Creates and returns a new user. This user will be created with the default group specified. Arguments: _cb – The asynchronous callback object. experimenter – a new omero.model.Experimenter instance group – group name of the default group for this user current – The Current object for the invocation.

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: _cb – The asynchronous callback object. user – Experimenter to be deleted. Not null. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. group – omero.model.ExperimenterGroup to be deleted. Not null. current – The Current object for the invocation.

getAdminPrivileges_async(_cb, user, current=None)

Gets the light administrator privileges for the given user. Arguments: _cb – The asynchronous callback object. user – the user whose privileges are being queried current – The Current object for the invocation.

getAdminsWithPrivileges_async(_cb, privileges, current=None)

Gets the administrators who have all the given privileges. Consistent with the results from “getAdminPrivileges”. Arguments: _cb – The asynchronous callback object. privileges – the required privileges current – The Current object for the invocation.

getCurrentAdminPrivileges_async(_cb, current=None)

Gets the light administrator privileges for the current user. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getDefaultGroup_async(_cb, experimenterId, current=None)

Retrieves the default omero.model.ExperimenterGroup group for the given user id. Arguments: _cb – The asynchronous callback object. experimenterId – of the Experimenter. Not null. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getExperimenter_async(_cb, id, current=None)

Fetches an omero.model.Experimenter and all related omero.model.ExperimenterGroup. Arguments: _cb – The asynchronous callback object. id – id of the Experimenter current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. id – id of the ExperimenterGroup current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. exp – Non-null, managed (i.e. with id) current – The Current object for the invocation.

getMemberOfGroupIds_async(_cb, exp, current=None)

Finds the ids for all groups for which the given omero.model.Experimenter is a member. Arguments: _cb – The asynchronous callback object. exp – Non-null, managed (i.e. with id) current – The Current object for the invocation.

getMyUserPhotos_async(_cb, current=None)

Retrieves the omero.model.OriginalFile object attached to this user as specified by {@code uploadMyUserPhoto}. The return value is order by the most recently modified file first. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getSecurityRoles_async(_cb, current=None)

Returns the active omero.sys.Roles in use by the server. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. name – Name of the Experimenter current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

lookupGroup_async(_cb, name, current=None)

Looks up an omero.model.ExperimenterGroup and all contained omero.model.Experimenter users by name. Arguments: _cb – The asynchronous callback object. name – Name of the ExperimenterGroup current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

lookupLdapAuthExperimenter_async(_cb, id, current=None)

Looks up omero.model.Experimenter experimenters who use LDAP authentication (has set dn on password table). Arguments: _cb – The asynchronous callback object. id – id of the Experimenter. Not null. current – The Current object for the invocation.

lookupLdapAuthExperimenters_async(_cb, current=None)

Looks up all ids of omero.model.Experimenter experimenters who use LDAP authentication (has set dn on password table). Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. objects – current – The Current object for the invocation.

removeGroupOwners_async(_cb, group, owners, current=None)

removes the given users from the owner list for this group. Arguments: _cb – The asynchronous callback object. group – A currently managed omero.model.ExperimenterGroup. Not owners – A set of currently managed omero.model.Experimenters. Not null. current – The Current object for the invocation.

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 themselves 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: _cb – The asynchronous callback object. user – A currently managed entity. Not null. groups – Groups from which the user will be removed. Not null. current – The Current object for the invocation.

reportForgottenPassword_async(_cb, name, email, current=None)
setAdminPrivileges_async(_cb, user, privileges, current=None)

Sets the set of light administrator privileges for the given user. Arguments: _cb – The asynchronous callback object. user – the user whose privileges are to be set privileges – the privileges to set for the user current – The Current object for the invocation.

setDefaultGroup_async(_cb, user, group, current=None)

Sets the default group for a given user. Arguments: _cb – The asynchronous callback object. user – A currently managed omero.model.Experimenter. Not null. group – The group which should be set as default group for this user. Not null. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. group – A currently managed omero.model.ExperimenterGroup. Not null. owner – A currently managed omero.model.Experimenter. Not null. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. group – A currently managed omero.model.ExperimenterGroup. Not null. owner – A currently managed omero.model.Experimenter. Not null. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. experimenter – the Experimenter to update. password – Not-null. Must pass validation in the security sub-system. current – The Current object for the invocation.

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 {@code #updateSelf} if the current user matches the given experimenter. Arguments: _cb – The asynchronous callback object. experimenter – the Experimenter to update. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. group – the ExperimenterGroup to update. current – The Current object for the invocation.

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 {@code setDefaultGroup} Arguments: _cb – The asynchronous callback object. experimenter – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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. Arguments: obj – _ctx – The request context for the invocation.

addGroupOwners(group, owners, _ctx=None)
addGroups(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_createRestrictedSystemUser(experimenter, privileges, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createRestrictedSystemUserWithPassword(experimenter, privileges, password, _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_getAdminPrivileges(user, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAdminsWithPrivileges(privileges, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getCurrentAdminPrivileges(_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_setAdminPrivileges(user, privileges, _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)
changeExpiredCredentials(name, oldCred, newCred, _ctx=None)
changeGroup(obj, omeName, _ctx=None)
changeOwner(obj, omeName, _ctx=None)
changePassword(newPassword, _ctx=None)
changePasswordWithOldPassword(oldPassword, newPassword, _ctx=None)
changePermissions(obj, perms, _ctx=None)
changeUserPassword(omeName, newPassword, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
containedExperimenters(groupId, _ctx=None)
containedGroups(experimenterId, _ctx=None)
createExperimenter(user, defaultGroup, groups, _ctx=None)
createExperimenterWithPassword(user, password, defaultGroup, groups, _ctx=None)
createGroup(group, _ctx=None)
createRestrictedSystemUser(experimenter, privileges, _ctx=None)
createRestrictedSystemUserWithPassword(experimenter, privileges, password, _ctx=None)
createSystemUser(experimenter, _ctx=None)
createUser(experimenter, group, _ctx=None)
deleteExperimenter(user, _ctx=None)
deleteGroup(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_createRestrictedSystemUser(_r)
end_createRestrictedSystemUserWithPassword(_r)
end_createSystemUser(_r)
end_createUser(_r)
end_deleteExperimenter(_r)
end_deleteGroup(_r)
end_getAdminPrivileges(_r)
end_getAdminsWithPrivileges(_r)
end_getCurrentAdminPrivileges(_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_setAdminPrivileges(_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)
getAdminPrivileges(user, _ctx=None)
getAdminsWithPrivileges(privileges, _ctx=None)
getCurrentAdminPrivileges(_ctx=None)
getDefaultGroup(experimenterId, _ctx=None)
getEventContext(_ctx=None)
getExperimenter(id, _ctx=None)
getGroup(id, _ctx=None)
getLeaderOfGroupIds(exp, _ctx=None)
getMemberOfGroupIds(exp, _ctx=None)
getMyUserPhotos(_ctx=None)
getSecurityRoles(_ctx=None)
static ice_staticId()
lookupExperimenter(name, _ctx=None)
lookupExperimenters(_ctx=None)
lookupGroup(name, _ctx=None)
lookupGroups(_ctx=None)
lookupLdapAuthExperimenter(id, _ctx=None)
lookupLdapAuthExperimenters(_ctx=None)
moveToCommonSpace(objects, _ctx=None)
removeGroupOwners(group, owners, _ctx=None)
removeGroups(user, groups, _ctx=None)
reportForgottenPassword(name, email, _ctx=None)
setAdminPrivileges(user, privileges, _ctx=None)
setDefaultGroup(user, group, _ctx=None)
setGroupOwner(group, owner, _ctx=None)
synchronizeLoginCache(_ctx=None)
static uncheckedCast(proxy, facet=None)
unsetGroupOwner(group, owner, _ctx=None)
updateExperimenter(experimenter, _ctx=None)
updateExperimenterWithPassword(experimenter, password, _ctx=None)
updateGroup(group, _ctx=None)
updateSelf(experimenter, _ctx=None)
uploadMyUserPhoto(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 0x3522c48>
_op_getClientConfigDefaults = <IcePy.Operation object>
_op_getClientConfigValues = <IcePy.Operation object>
_op_getConfigDefaults = <IcePy.Operation object>
_op_getConfigValue = <IcePy.Operation object>
_op_getConfigValues = <IcePy.Operation object>
_op_getDatabaseTime = <IcePy.Operation object>
_op_getDatabaseUuid = <IcePy.Operation object>
_op_getServerTime = <IcePy.Operation object>
_op_getVersion = <IcePy.Operation object>
_op_setConfigValue = <IcePy.Operation object>
_op_setConfigValueIfEquals = <IcePy.Operation object>
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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getClientConfigValues_async(_cb, current=None)

Retrieves configuration values like {@code getConfigValues} but only those with the prefix omero.client. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getConfigValue_async(_cb, key, current=None)

Retrieves a configuration value from the backend store. Permissions applied to the configuration value may cause a omero.SecurityViolation to be thrown. Arguments: _cb – The asynchronous callback object. key – The non-null name of the desired configuration value current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. keyRegex – The non-null regex of the desired configuration values current – The Current object for the invocation.

getDatabaseTime_async(_cb, current=None)

Checks the database for its time using a SELECT statement. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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 {@code getVersion} Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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

Calls {@code 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: _cb – The asynchronous callback object. key – value – test – current – The Current object for the invocation. Throws: 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 omero.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 {@code getConfigValue} will return that value. Arguments: _cb – The asynchronous callback object. key – The non-null name of the desired configuration value value – The string value to assign to the given key. current – The Current object for the invocation. Throws: 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 {@code getVersion} Arguments: _ctx – The request context for the invocation.

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)
getClientConfigValues(_ctx=None)
getConfigDefaults(_ctx=None)
getConfigValue(key, _ctx=None)
getConfigValues(keyRegex, _ctx=None)
getDatabaseTime(_ctx=None)
getDatabaseUuid(_ctx=None)
getServerTime(_ctx=None)
getVersion(_ctx=None)
static ice_staticId()
setConfigValue(key, value, _ctx=None)
setConfigValueIfEquals(key, value, test, _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 omero.sys.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 0x3522c78>
_op_createDataObject = <IcePy.Operation object>
_op_createDataObjects = <IcePy.Operation object>
_op_findContainerHierarchies = <IcePy.Operation object>
_op_getCollectionCount = <IcePy.Operation object>
_op_getImages = <IcePy.Operation object>
_op_getImagesByOptions = <IcePy.Operation object>
_op_getImagesBySplitFilesets = <IcePy.Operation object>
_op_getUserImages = <IcePy.Operation object>
_op_loadContainerHierarchy = <IcePy.Operation object>
_op_retrieveCollection = <IcePy.Operation object>
_op_updateDataObject = <IcePy.Operation object>
_op_updateDataObjects = <IcePy.Operation object>
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 ome.model.ILink is created. Arguments: _cb – The asynchronous callback object. obj – IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. Not null. options – Parameters as above. current – The Current object for the invocation.

createDataObjects_async(_cb, dataObjects, options, current=None)

Convenience method to save network calls. Loops over the array of IObjects calling {@code createDataObject}. Arguments: _cb – The asynchronous callback object. dataObjects – Array of Omero IObjects options – Parameters as above. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

getImagesByOptions_async(_cb, options, current=None)

Retrieves images by options. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. included – the entities included options – parameters, presently ignored current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

getUserImages_async(_cb, options, current=None)

Retrieves a user’s images. Arguments: _cb – The asynchronous callback object. options – Parameters as above. No notion of leaves. experimenter|group apply at the Image level and must be present. current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()

Convenience method for creating links. Functionality also available from {@code createDataObject} Arguments: _cb – The asynchronous callback object. links – Array of links to be created. options – Parameters as above. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. obj – Can be unloaded. collectionName – public static final String from the IObject.class options – Parameters. Unused. current – The Current object for the invocation.

Removes links between OmeroDataObjects e.g Project-Dataset, Dataset-Image Note that the objects themselves aren’t deleted, only the Link objects. Arguments: _cb – The asynchronous callback object. links – Not null. options – Parameters as above. current – The Current object for the invocation.

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. Link has to be set as follows dataset&rarr;project and project&rarr;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: _cb – The asynchronous callback object. obj – Pojos-based IObject. Supported: Project, Dataset, Annotation, Group, Experimenter. options – Parameters as above. current – The Current object for the invocation.

updateDataObjects_async(_cb, objs, options, current=None)

Convenience method to save network calls. Loops over the array of IObjects calling {@code updateDataObject}. Arguments: _cb – The asynchronous callback object. objs – options – Parameters as above. current – The Current object for the invocation.

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. _ctx – The request context for the invocation. 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)
createDataObjects(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)
getCollectionCount(type, property, ids, options, _ctx=None)
getImages(rootType, rootIds, options, _ctx=None)
getImagesByOptions(options, _ctx=None)
getImagesBySplitFilesets(included, options, _ctx=None)
getUserImages(options, _ctx=None)
static ice_staticId()
loadContainerHierarchy(rootType, rootIds, options, _ctx=None)
retrieveCollection(obj, collectionName, options, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateDataObject(obj, options, _ctx=None)
updateDataObjects(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 0x3522ca8>
_op_createUser = <IcePy.Operation object>
_op_discover = <IcePy.Operation object>
_op_discoverGroups = <IcePy.Operation object>
_op_findDN = <IcePy.Operation object>
_op_findExperimenter = <IcePy.Operation object>
_op_findGroup = <IcePy.Operation object>
_op_findGroupDN = <IcePy.Operation object>
_op_getSetting = <IcePy.Operation object>
_op_searchAll = <IcePy.Operation object>
_op_searchByAttribute = <IcePy.Operation object>
_op_searchByAttributes = <IcePy.Operation object>
_op_searchByDN = <IcePy.Operation object>
_op_searchDnInGroups = <IcePy.Operation object>
_op_setDN = <IcePy.Operation object>
createUser_async(_cb, username, current=None)

Creates an omero.model.Experimenter entry in the OMERO DB based on the supplied LDAP username. Arguments: _cb – The asynchronous callback object. username – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. username – Name of the Experimenter equals CommonName. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. username – Name of the Experimenter equals CommonName. current – The Current object for the invocation. Throws: ApiUsageException – if more then one ‘cn’ under the specified base.

findGroupDN_async(_cb, groupname, current=None)

Looks up the DN for a group. Arguments: _cb – The asynchronous callback object. groupname – current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. groupname – current – The Current object for the invocation. Throws: ApiUsageException – if more then one group name matches under the specified base.

getSetting_async(_cb, current=None)

Gets config value from properties. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

searchByAttribute_async(_cb, dn, attribute, value, current=None)

Searches all omero.model.Experimenter in LDAP for specified attribute. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

searchByDN_async(_cb, userdn, current=None)

Searches one omero.model.Experimenter in LDAP for specified Distinguished Name. Arguments: _cb – The asynchronous callback object. userdn – unique Distinguished Name - string of user, Never null or empty. current – The Current object for the invocation.

searchDnInGroups_async(_cb, attr, value, current=None)

Searches Distinguished Name in groups. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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. Arguments: _ctx – The request context for the invocation. 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)
discover(_ctx=None)
discoverGroups(_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)
findExperimenter(username, _ctx=None)
findGroup(groupname, _ctx=None)
findGroupDN(groupname, _ctx=None)
getSetting(_ctx=None)
static ice_staticId()
searchAll(_ctx=None)
searchByAttribute(dn, attribute, value, _ctx=None)
searchByAttributes(dn, attributes, values, _ctx=None)
searchByDN(userdn, _ctx=None)
searchDnInGroups(attr, value, _ctx=None)
setDN(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 0x3522cd8>
_op_countAnnotationsUsedNotOwned = <IcePy.Operation object>
_op_countSpecifiedAnnotations = <IcePy.Operation object>
_op_getTaggedObjectsCount = <IcePy.Operation object>
_op_loadAnnotation = <IcePy.Operation object>
_op_loadAnnotations = <IcePy.Operation object>
_op_loadAnnotationsUsedNotOwned = <IcePy.Operation object>
_op_loadChannelAcquisitionData = <IcePy.Operation object>
_op_loadInstrument = <IcePy.Operation object>
_op_loadLogFiles = <IcePy.Operation object>
_op_loadSpecifiedAnnotations = <IcePy.Operation object>
_op_loadSpecifiedAnnotationsLinkedTo = <IcePy.Operation object>
_op_loadTagContent = <IcePy.Operation object>
_op_loadTagSets = <IcePy.Operation object>
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: _cb – The asynchronous callback object. annotationType – The type of annotations to load. userID – The identifier of the user. current – The Current object for the invocation.

countSpecifiedAnnotations_async(_cb, annotationType, include, exclude, options, current=None)

Counts the number of annotation of a given type. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. ids – The collection of ids. options – The POJO options. current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
loadAnnotation_async(_cb, annotationIds, current=None)

Loads the specified annotations. Arguments: _cb – The asynchronous callback object. annotationIds – The collection of annotation ids. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. annotationType – The type of annotations to load. userID – The identifier of the user. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. annotationTypes – 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 – current – The Current object for the invocation.

loadChannelAcquisitionData_async(_cb, ids, current=None)

Loads the logical channels and the acquisition metadata related to them. Arguments: _cb – The asynchronous callback object. ids – The collection of logical channel’s ids. Mustn’t be null. current – The Current object for the invocation.

loadInstrument_async(_cb, id, current=None)

Loads the instrument and its components i.e. detectors, objectives, etc. Arguments: _cb – The asynchronous callback object. id – The id of the instrument to load. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. rootType – 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 current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

loadTagContent_async(_cb, ids, options, current=None)

Loads the TagSet if the id is specified otherwise loads all the TagSet. Arguments: _cb – The asynchronous callback object. ids – The id of the tag to load or -1. options – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. options – The POJO options. current – The Current object for the invocation.

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. _ctx – The request context for the invocation. 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)
countSpecifiedAnnotations(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)
static ice_staticId()
loadAnnotation(annotationIds, _ctx=None)
loadAnnotations(rootType, rootIds, annotationTypes, annotatorIds, options, _ctx=None)
loadAnnotationsUsedNotOwned(annotationType, userID, _ctx=None)
loadChannelAcquisitionData(ids, _ctx=None)
loadInstrument(id, _ctx=None)
loadLogFiles(rootType, ids, _ctx=None)
loadSpecifiedAnnotations(annotationType, include, exclude, options, _ctx=None)
loadSpecifiedAnnotationsLinkedTo(annotationType, include, exclude, rootNodeType, rootNodeIds, options, _ctx=None)
loadTagContent(ids, options, _ctx=None)
loadTagSets(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 0x3522d08>
_op_copyAndResizeImage = <IcePy.Operation object>
_op_copyAndResizePixels = <IcePy.Operation object>
_op_createImage = <IcePy.Operation object>
_op_getAllEnumerations = <IcePy.Operation object>
_op_getBitDepth = <IcePy.Operation object>
_op_getEnumeration = <IcePy.Operation object>
_op_loadRndSettings = <IcePy.Operation object>
_op_retrieveAllRndSettings = <IcePy.Operation object>
_op_retrievePixDescription = <IcePy.Operation object>
_op_retrieveRndSettings = <IcePy.Operation object>
_op_retrieveRndSettingsFor = <IcePy.Operation object>
_op_saveRndSettings = <IcePy.Operation object>
_op_setChannelGlobalMinMax = <IcePy.Operation object>
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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. 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. channelList – pixelsType – The pixelsType name – The name of the new Image. description – The description of the new Image. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. enumClass – Enumeration class. current – The Current object for the invocation.

getBitDepth_async(_cb, type, current=None)

Bit depth for a given pixel type. Arguments: _cb – The asynchronous callback object. type – Pixels type. current – The Current object for the invocation.

getEnumeration_async(_cb, enumClass, value, current=None)

Retrieves a particular enumeration for a given enumeration class. Arguments: _cb – The asynchronous callback object. enumClass – Enumeration class. value – Enumeration string value. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. renderingSettingsId – Rendering definition id. current – The Current object for the invocation. Throws: ValidationException – If no RenderingDef matches the ID renderingDefId.

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: _cb – The asynchronous callback object. pixId – Pixels id. userId – The id of the user. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. pixId – Pixels id. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. pixId – Pixels id. userId – The id of the user. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. pixId – Pixels id. current – The Current object for the invocation.

saveRndSettings_async(_cb, rndSettings, current=None)

Saves the specified rendering settings. Arguments: _cb – The asynchronous callback object. rndSettings – Rendering settings. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. pixelsId – The source Pixels set id. channelIndex – The channel index within the Pixels set. min – The channel global minimum. max – The channel global maximum. current – The Current object for the invocation.

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. _ctx – The request context for the invocation. 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)
copyAndResizePixels(pixelsId, sizeX, sizeY, sizeZ, sizeT, channelList, methodology, copyStats, _ctx=None)
createImage(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)
getBitDepth(type, _ctx=None)
getEnumeration(enumClass, value, _ctx=None)
static ice_staticId()
loadRndSettings(renderingSettingsId, _ctx=None)
retrieveAllRndSettings(pixId, userId, _ctx=None)
retrievePixDescription(pixId, _ctx=None)
retrieveRndSettings(pixId, _ctx=None)
retrieveRndSettingsFor(pixId, userId, _ctx=None)
saveRndSettings(rndSettings, _ctx=None)
setChannelGlobalMinMax(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 0x3522d38>
_op_projectPixels = <IcePy.Operation object>
_op_projectStack = <IcePy.Operation object>
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 {@code omero.api.IPixels.copyAndResizeImage}. Arguments: _cb – The asynchronous callback object. 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. channelList – 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. current – The Current object for the invocation. Throws: ValidationException – Where: algorithm is unknown tStart is out of range tEnd is out of range tStart is greater than tEnd channelList is null or has indexes out of range zStart is out of range zEnd is out of range zStart is greater than zEnd the Pixels set qualified by pixelsId is not locatable.

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: _cb – The asynchronous callback object. 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. current – The Current object for the invocation. Throws: 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 is greater than end the Pixels set qualified by pixelsId is not locatable.

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. _ctx – The request context for the invocation. Returns: A byte array of projected pixel values whose length is equal to the Pixels set 8 sizeX * sizeY * bytesPerPixel in big-endian format. Throws: 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 is greater than end the Pixels set qualified by pixelsId is not locatable.

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)
static ice_staticId()
projectPixels(pixelsId, pixelsType, algorithm, tStart, tEnd, channelList, stepping, zStart, zEnd, name, _ctx=None)
projectStack(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 0x3522d68>
_op_find = <IcePy.Operation object>
_op_findAll = <IcePy.Operation object>
_op_findAllByExample = <IcePy.Operation object>
_op_findAllByFullText = <IcePy.Operation object>
_op_findAllByQuery = <IcePy.Operation object>
_op_findAllByString = <IcePy.Operation object>
_op_findByExample = <IcePy.Operation object>
_op_findByQuery = <IcePy.Operation object>
_op_findByString = <IcePy.Operation object>
_op_get = <IcePy.Operation object>
_op_projection = <IcePy.Operation object>
_op_refresh = <IcePy.Operation object>
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 {@code find}, {@code get}, {@code findByQuery}, or {@code findAllByQuery}. Arguments: _cb – The asynchronous callback object. example – Non-null example object. filter – filters the result set. Can be null. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. 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). current – The Current object for the invocation.

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: _cb – The asynchronous callback object. query – Query to execute. Not null. params – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. klass – type of entity to be searched. Not null. field – the name of the field, either as simple string or as public static final from the entity class, e.g. {@code 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. current – The Current object for the invocation.

findAll_async(_cb, klass, filter, current=None)

Looks up all entities that belong to this class and match filter. Arguments: _cb – The asynchronous callback object. klass – entity type to be searched. Not null. filter – filters the result set. Can be null. current – The Current object for the invocation.

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 {@code find}, {@code get}, {@code findByQuery}, or {@code findAllByQuery}. Arguments: _cb – The asynchronous callback object. example – Non-null example object. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. query – Query to execute params – current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. klass – type of entity to be searched field – the name of the field, either as simple string or as public static final from the entity class, e.g. {@code omero.model.Project.NAME} value – String used for search. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. klass – klass the type of the entity. Not null. id – the entity’s id current – The Current object for the invocation.

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: _cb – The asynchronous callback object. klass – the type of the entity. Not null. id – the entity’s id current – The Current object for the invocation. Throws: 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, canChgrp, canChown 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 Arguments: _cb – The asynchronous callback object. query – params – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. iObject – Non-null managed omero.model.IObject graph which should have all values re-assigned from the database current – The Current object for the invocation. Throws: 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 _ctx – The request context for the invocation. Returns: an initialized entity Throws: 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)
findAllByFullText(klass, query, params, _ctx=None)
findAllByQuery(query, params, _ctx=None)
findAllByString(klass, field, value, caseSensitive, filter, _ctx=None)
findByExample(example, _ctx=None)
findByQuery(query, params, _ctx=None)
findByString(klass, field, value, _ctx=None)
get(klass, id, _ctx=None)
static ice_staticId()
projection(query, params, _ctx=None)
refresh(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 0x3522eb8>
_op_applySettingsToDataset = <IcePy.Operation object>
_op_applySettingsToImage = <IcePy.Operation object>
_op_applySettingsToImages = <IcePy.Operation object>
_op_applySettingsToPixels = <IcePy.Operation object>
_op_applySettingsToProject = <IcePy.Operation object>
_op_applySettingsToSet = <IcePy.Operation object>
_op_createNewRenderingDef = <IcePy.Operation object>
_op_getRenderingSettings = <IcePy.Operation object>
_op_resetDefaults = <IcePy.Operation object>
_op_resetDefaultsByOwnerInSet = <IcePy.Operation object>
_op_resetDefaultsForPixels = <IcePy.Operation object>
_op_resetDefaultsInDataset = <IcePy.Operation object>
_op_resetDefaultsInImage = <IcePy.Operation object>
_op_resetDefaultsInSet = <IcePy.Operation object>
_op_resetDefaultsNoSave = <IcePy.Operation object>
_op_resetMinMaxInSet = <IcePy.Operation object>
_op_sanityCheckPixels = <IcePy.Operation object>
_op_setOriginalSettingsForPixels = <IcePy.Operation object>
_op_setOriginalSettingsInDataset = <IcePy.Operation object>
_op_setOriginalSettingsInImage = <IcePy.Operation object>
_op_setOriginalSettingsInSet = <IcePy.Operation object>
applySettingsToDataset_async(_cb, _from, to, current=None)

Applies rendering settings to all images in a given Dataset. Arguments: _cb – The asynchronous callback object. _from – The Id of the pixels set to copy the rendering settings from. to – The Id of the dataset container to apply settings to. current – The Current object for the invocation. Throws: ValidationException – if the rendering settings from is not locatable or the dataset to is not locatable.

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

Applies rendering settings to a given Image. Arguments: _cb – The asynchronous callback object. _from – The Id of the pixels set to copy the rendering settings from. to – The Id of the image container to apply settings to. current – The Current object for the invocation. Throws: ValidationException – if the rendering settings from is not locatable or the image to is not locatable.

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

Applies rendering settings to a given Image. Arguments: _cb – The asynchronous callback object. _from – The Id of the pixels set to copy the rendering settings from. to – The Id of the image container to apply settings to. current – The Current object for the invocation. Throws: ValidationException – if the rendering settings from is not locatable or the image to is not locatable.

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

Applies rendering settings to a given Pixels. Arguments: _cb – The asynchronous callback object. _from – The Id of the pixels set to copy the rendering settings from. to – The Id of the pixels container to apply settings to. current – The Current object for the invocation. Throws: ValidationException – if the rendering settings from is not locatable or the pixelsto is not locatable.

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

Applies rendering settings to all images in all Datasets of a given Project. Arguments: _cb – The asynchronous callback object. _from – The Id of the pixels set to copy the rendering settings from. to – The Id of the project container to apply settings to. current – The Current object for the invocation. Throws: ValidationException – if the rendering settings from is not locatable or the project to is not locatable.

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: _cb – The asynchronous callback object. _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. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. pixels – The Pixels set to link to the rendering definition. current – The Current object for the invocation.

getRenderingSettings_async(_cb, pixelsId, current=None)

Returns the default rendering settings for a given pixels for the current user. Arguments: _cb – The asynchronous callback object. pixelsId – The Id of the Pixels current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. type – The type of nodes to handle. nodeIds – Ids of the node type. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. pixelsId – The Id of the Pixels. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. datasetId – The Id of the Dataset. current – The Current object for the invocation. Throws: ValidationException – if the image qualified by datasetId is not locatable.

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: _cb – The asynchronous callback object. imageId – The Id of the Image. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. type – The type of nodes to handle. nodeIds – Ids of the node type. current – The Current object for the invocation. Throws: 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 {@code getRenderingSettings(long)} as it relies on certain objects being loaded. The rendering settings are not saved. Arguments: _cb – The asynchronous callback object. _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. current – The Current object for the invocation.

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 {@code getRenderingSettings} as it relies on certain objects being loaded. The rendering settings are saved upon completion. Arguments: _cb – The asynchronous callback object. _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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. type – The type of nodes to handle. nodeIds – Ids of the node type. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. pFrom – The pixels set to copy the settings from. pTo – The pixels set to copy the settings to. current – The Current object for the invocation.

setOriginalSettingsForPixels_async(_cb, pixelsId, current=None)

Resets an Pixels’ default rendering settings back to channel global minimum and maximum. Arguments: _cb – The asynchronous callback object. pixelsId – The Id of the Pixels set. current – The Current object for the invocation. Throws: ValidationException – if the image qualified by pixelsId is not locatable.

setOriginalSettingsInDataset_async(_cb, datasetId, current=None)

Resets a dataset’s rendering settings back to channel global minimum and maximum. Arguments: _cb – The asynchronous callback object. datasetId – The id of the dataset to handle. current – The Current object for the invocation. Throws: ValidationException – if the image qualified by datasetId is not locatable.

setOriginalSettingsInImage_async(_cb, imageId, current=None)

Resets an image’s default rendering settings back to channel global minimum and maximum. Arguments: _cb – The asynchronous callback object. imageId – The Id of the Image. current – The Current object for the invocation. Throws: ValidationException – if the image qualified by imageId is not locatable.

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: _cb – The asynchronous callback object. type – The type of nodes to handle. nodeIds – Ids of the node type. current – The Current object for the invocation. Throws: 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. _ctx – The request context for the invocation. Returns: See above.

applySettingsToDataset(_from, to, _ctx=None)
applySettingsToImage(_from, to, _ctx=None)
applySettingsToImages(_from, to, _ctx=None)
applySettingsToPixels(_from, to, _ctx=None)
applySettingsToProject(_from, to, _ctx=None)
applySettingsToSet(_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)
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)
static ice_staticId()
resetDefaults(_def, pixels, _ctx=None)
resetDefaultsByOwnerInSet(type, nodeIds, _ctx=None)
resetDefaultsForPixels(pixelsId, _ctx=None)
resetDefaultsInDataset(datasetId, _ctx=None)
resetDefaultsInImage(imageId, _ctx=None)
resetDefaultsInSet(type, nodeIds, _ctx=None)
resetDefaultsNoSave(_def, pixels, _ctx=None)
resetMinMaxInSet(type, nodeIds, _ctx=None)
sanityCheckPixels(pFrom, pTo, _ctx=None)
setOriginalSettingsForPixels(pixelsId, _ctx=None)
setOriginalSettingsInDataset(datasetId, _ctx=None)
setOriginalSettingsInImage(imageId, _ctx=None)
setOriginalSettingsInSet(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 0x3522ee8>
_op_getFreeSpaceInKilobytes = <IcePy.Operation object>
_op_getUsageFraction = <IcePy.Operation object>
_op_getUsedSpaceInKilobytes = <IcePy.Operation object>
_op_removeUnusedFiles = <IcePy.Operation object>
_op_sanityCheckRepository = <IcePy.Operation object>
getFreeSpaceInKilobytes_async(_cb, current=None)

Returns the free or available space on this file system including nested subdirectories. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: ResourceError – If deletion fails.

sanityCheckRepository_async(_cb, current=None)

Checks that image data repository has not exceeded 95% disk space use level. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: InternalException – If there is a critical failure while sanity checking the repository. ResourceError – If the repository usage has exceeded 95%.

class omero.api.IRepositoryInfoPrx

Bases: omero.api.ServiceInterfacePrx

Returns the total space in bytes for this file system including nested subdirectories. Arguments: _ctx – The request context for the invocation. Returns: Total space used on this file system. Throws: 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)
getUsageFraction(_ctx=None)
getUsedSpaceInKilobytes(_ctx=None)
static ice_staticId()
removeUnusedFiles(_ctx=None)
sanityCheckRepository(_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 0x3522d98>
_op_findByImage = <IcePy.Operation object>
_op_findByPlane = <IcePy.Operation object>
_op_findByRoi = <IcePy.Operation object>
_op_getMeasuredRois = <IcePy.Operation object>
_op_getMeasuredRoisMap = <IcePy.Operation object>
_op_getPoints = <IcePy.Operation object>
_op_getRoiMeasurements = <IcePy.Operation object>
_op_getRoiStats = <IcePy.Operation object>
_op_getShapeStats = <IcePy.Operation object>
_op_getShapeStatsList = <IcePy.Operation object>
_op_getShapeStatsRestricted = <IcePy.Operation object>
_op_getTable = <IcePy.Operation object>
_op_uploadMask = <IcePy.Operation object>
findByImage_async(_cb, imageId, opts, current=None)

Returns all the Rois in an Image, indexed via Shape. Loads Rois as findByRoi. Arguments: _cb – The asynchronous callback object. imageId – opts – current – The Current object for the invocation.

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

Returns all the Rois on the given plane, indexed via Shape. Loads Rois as findByRoi. Arguments: _cb – The asynchronous callback object. imageId – z – t – opts – current – The Current object for the invocation.

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? Arguments: _cb – The asynchronous callback object. roiId – opts – current – The Current object for the invocation.

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) Arguments: _cb – The asynchronous callback object. imageId – annotationIds – opts – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. imageId – annotationId – if -1, logic is identical to findByImage(imageId, opts) opts – current – The Current object for the invocation.

getPoints_async(_cb, shapeId, current=None)

Calculate the points contained within a given shape Arguments: _cb – The asynchronous callback object. shapeId – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. imageId – opts – current – The Current object for the invocation.

getRoiStats_async(_cb, roiId, current=None)

Calculate stats for all the shapes within the given Roi. Arguments: _cb – The asynchronous callback object. roiId – current – The Current object for the invocation.

getShapeStatsList_async(_cb, shapeIdList, current=None)

Calculate the stats for the points within the given Shapes. Arguments: _cb – The asynchronous callback object. shapeIdList – current – The Current object for the invocation.

getShapeStatsRestricted_async(_cb, shapeIdList, zForUnattached, tForUnattached, channels, current=None)

Calculate the stats for the points within the given Shapes. Varies to the above in the following ways: - does not allow tiled images - shapes have to be all belonging to the same image - unattached z/t use the fallback parameters zForUnattached/tForUnattached that is to say there is never more than 1 z/t combination queried - if channel list is given, only the channels in that list are iterated over - does not request data from reader on each iteration Arguments: _cb – The asynchronous callback object. shapeIdList – zForUnattached – tForUnattached – channels – current – The Current object for the invocation.

getShapeStats_async(_cb, shapeId, current=None)

Calculate the stats for the points within the given Shape. Arguments: _cb – The asynchronous callback object. shapeId – current – The Current object for the invocation.

getTable_async(_cb, annotationId, current=None)

Returns the OMERO.tables service via the omero.model.FileAnnotation id returned by {@code getImageMeasurements}. Arguments: _cb – The asynchronous callback object. annotationId – current – The Current object for the invocation.

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? Arguments: roiId – opts – _ctx – The request context for the invocation.

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_getShapeStatsRestricted(shapeIdList, zForUnattached, tForUnattached, channels, _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_getShapeStatsRestricted(_r)
end_getTable(_r)
end_uploadMask(_r)
findByImage(imageId, opts, _ctx=None)
findByPlane(imageId, z, t, opts, _ctx=None)
findByRoi(roiId, opts, _ctx=None)
getMeasuredRois(imageId, annotationId, opts, _ctx=None)
getMeasuredRoisMap(imageId, annotationIds, opts, _ctx=None)
getPoints(shapeId, _ctx=None)
getRoiMeasurements(imageId, opts, _ctx=None)
getRoiStats(roiId, _ctx=None)
getShapeStats(shapeId, _ctx=None)
getShapeStatsList(shapeIdList, _ctx=None)
getShapeStatsRestricted(shapeIdList, zForUnattached, tForUnattached, channels, _ctx=None)
getTable(annotationId, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
uploadMask(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): {@code 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 0x3522dc8>
_op_canRunScript = <IcePy.Operation object>
_op_deleteScript = <IcePy.Operation object>
_op_editScript = <IcePy.Operation object>
_op_getParams = <IcePy.Operation object>
_op_getScriptID = <IcePy.Operation object>
_op_getScriptText = <IcePy.Operation object>
_op_getScriptWithDetails = <IcePy.Operation object>
_op_getScripts = <IcePy.Operation object>
_op_getScriptsByMimetype = <IcePy.Operation object>
_op_getUserScripts = <IcePy.Operation object>
_op_runScript = <IcePy.Operation object>
_op_uploadOfficialScript = <IcePy.Operation object>
_op_uploadScript = <IcePy.Operation object>
_op_validateScript = <IcePy.Operation object>
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. Arguments: _cb – The asynchronous callback object. scriptID – current – The Current object for the invocation.

deleteScript_async(_cb, scriptID, current=None)

Delete the script on the server with id. The file will also be removed from disk. Arguments: _cb – The asynchronous callback object. scriptID – Id of the script to delete. current – The Current object for the invocation. Throws: ApiUsageException – SecurityViolation –

editScript_async(_cb, fileObject, scriptText, current=None)

Modify the text for the given script object. Arguments: _cb – The asynchronous callback object. fileObject – see above. scriptText – see above. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. scriptID – see above. current – The Current object for the invocation. Throws: 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. {@code getUserScriptID}) since the path is not guaranteed to be unique. Arguments: _cb – The asynchronous callback object. path – The name of the script. current – The Current object for the invocation. Throws: ApiUsageException – SecurityViolation –

getScriptText_async(_cb, scriptID, current=None)

Get the text from the server for the script with given id. Arguments: _cb – The asynchronous callback object. scriptID – see above. current – The Current object for the invocation. Throws: ApiUsageException –

getScriptWithDetails_async(_cb, scriptID, current=None)

Get the script from the server with details from OriginalFile Arguments: _cb – The asynchronous callback object. scriptID – see above current – The Current object for the invocation. Throws: ApiUsageException –

getScriptsByMimetype_async(_cb, mimetype, current=None)

This method returns official server scripts identified with the specified extension as a list of omero.model.OriginalFile objects. These scripts will be executed by the server if submitted via {@code runScript}. The input parameters necessary for proper functioning can be retrieved via {@code 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. {@code scripts = scriptService.getScripts(“py”) for script in scripts: text = scriptService.getScriptText(script.id.val) path = script.path.val[1:] # First symbol is a “/” path = path.replace(“/”,”.”) print “Possible import: %s” % path } Arguments: _cb – The asynchronous callback object. mimetype – the mimetype identifying the scripts. current – The Current object for the invocation. Throws: ApiUsageException – SecurityViolation –

getScripts_async(_cb, current=None)

This method returns official server scripts as a list of omero.model.OriginalFile objects. These scripts will be executed by the server if submitted via {@code runScript}. The input parameters necessary for proper functioning can be retrieved via {@code 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. {@code scripts = scriptService.getScripts() for script in scripts: text = scriptService.getScriptText(script.id.val) # First character is a “/” symbol path = script.path.val[1:] path = path.replace(“/”,”.”) print “Possible import: %s” % path } Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. acceptsList – current – The Current object for the invocation.

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

If omero.ResourceError is thrown, then no {@code Processor} is available. Use {@code scheduleJob} to create a omero.model.ScriptJob in the Waiting state. A {@code Processor} may become available. {@code try: proc = scriptService.runScript(1, {}, None) except ResourceError: job = scriptService.scheduleScript(1, {}, None) } The {@code ScriptProcess} proxy MUST be closed before exiting. If you would like the script execution to continue in the background, pass True as the argument. {@code 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. } Arguments: _cb – The asynchronous callback object. scriptID – inputs – waitSecs – current – The Current object for the invocation.

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

Like {@code uploadScript} but is only callable by administrators. The parameters for the script are also checked. Arguments: _cb – The asynchronous callback object. path – scriptText – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. path – see above. scriptText – see above. current – The Current object for the invocation. Throws: 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 {@code 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. Arguments: _cb – The asynchronous callback object. j – acceptsList – current – The Current object for the invocation.

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 {@code runScript}. The input parameters necessary for proper functioning can be retrieved via {@code 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. {@code scripts = scriptService.getScripts() for script in scripts: text = scriptService.getScriptText(script.id.val) # First character is a “/” symbol path = script.path.val[1:] path = path.replace(“/”,”.”) print “Possible import: %s” % path } Arguments: _ctx – The request context for the invocation. Returns: see above. Throws: ApiUsageException – SecurityViolation –

begin_canRunScript(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_deleteScript(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_editScript(fileObject, scriptText, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getParams(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptID(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptText(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptWithDetails(scriptID, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getScripts(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptsByMimetype(mimetype, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getUserScripts(acceptsList, _response=None, _ex=None, _sent=None, _ctx=None)
begin_runScript(scriptID, inputs, waitSecs, _response=None, _ex=None, _sent=None, _ctx=None)
begin_uploadOfficialScript(path, scriptText, _response=None, _ex=None, _sent=None, _ctx=None)
begin_uploadScript(path, scriptText, _response=None, _ex=None, _sent=None, _ctx=None)
begin_validateScript(j, acceptsList, _response=None, _ex=None, _sent=None, _ctx=None)
canRunScript(scriptID, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
deleteScript(scriptID, _ctx=None)
editScript(fileObject, scriptText, _ctx=None)
end_canRunScript(_r)
end_deleteScript(_r)
end_editScript(_r)
end_getParams(_r)
end_getScriptID(_r)
end_getScriptText(_r)
end_getScriptWithDetails(_r)
end_getScripts(_r)
end_getScriptsByMimetype(_r)
end_getUserScripts(_r)
end_runScript(_r)
end_uploadOfficialScript(_r)
end_uploadScript(_r)
end_validateScript(_r)
getParams(scriptID, _ctx=None)
getScriptID(path, _ctx=None)
getScriptText(scriptID, _ctx=None)
getScriptWithDetails(scriptID, _ctx=None)
getScripts(_ctx=None)
getScriptsByMimetype(mimetype, _ctx=None)
getUserScripts(acceptsList, _ctx=None)
static ice_staticId()
runScript(scriptID, inputs, waitSecs, _ctx=None)
static uncheckedCast(proxy, facet=None)
uploadOfficialScript(path, scriptText, _ctx=None)
uploadScript(path, scriptText, _ctx=None)
validateScript(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 ({@code 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 0x3522df8>
_op_closeSession = <IcePy.Operation object>
_op_createSession = <IcePy.Operation object>
_op_createSessionWithTimeout = <IcePy.Operation object>
_op_createSessionWithTimeouts = <IcePy.Operation object>
_op_createUserSession = <IcePy.Operation object>
_op_getInput = <IcePy.Operation object>
_op_getInputKeys = <IcePy.Operation object>
_op_getInputs = <IcePy.Operation object>
_op_getMyOpenAgentSessions = <IcePy.Operation object>
_op_getMyOpenClientSessions = <IcePy.Operation object>
_op_getMyOpenSessions = <IcePy.Operation object>
_op_getOutput = <IcePy.Operation object>
_op_getOutputKeys = <IcePy.Operation object>
_op_getOutputs = <IcePy.Operation object>
_op_getReferenceCount = <IcePy.Operation object>
_op_getSession = <IcePy.Operation object>
_op_setInput = <IcePy.Operation object>
_op_setOutput = <IcePy.Operation object>
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. Arguments: _cb – The asynchronous callback object. sess – current – The Current object for the invocation.

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

Allows an admin to create a ome.model.meta.Session for the give omero.sys.Principal. Arguments: _cb – The asynchronous callback object. principal – Non-null omero.sys.Principal with the target user’s name timeToLiveMilliseconds – The time that this ome.model.meta.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. current – The Current object for the invocation.

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

Allows an admin to create a ome.model.meta.Session for the given omero.sys.Principal. Arguments: _cb – The asynchronous callback object. principal – Non-null omero.sys.Principal with the target user’s name timeToLiveMilliseconds – The time that this ome.model.meta.Session has until destruction. Setting the value to 0 will prevent destruction unless the session remains idle. timeToIdleMilliseconds – The time that this ome.model.meta.Session can remain idle before being destroyed. Setting the value to 0 will prevent idleness based destruction. current – The Current object for the invocation.

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

Creates a new session and returns it to the user. Arguments: _cb – The asynchronous callback object. p – credentials – current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. timeToLiveMilliseconds – timeToIdleMilliseconds – defaultGroup – current – The Current object for the invocation.

getInputKeys_async(_cb, sess, current=None)

Retrieves all keys in the omero.model.Session input environment. Arguments: _cb – The asynchronous callback object. sess – current – The Current object for the invocation.

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

Retrieves an entry from the given omero.model.Session input environment. Arguments: _cb – The asynchronous callback object. sess – key – current – The Current object for the invocation.

getInputs_async(_cb, sess, current=None)

Retrieves all inputs from the given omero.model.Session input environment. Arguments: _cb – The asynchronous callback object. sess – current – The Current object for the invocation.

getMyOpenAgentSessions_async(_cb, agent, current=None)

Like {@code getMyOpenSessions} but returns only those sessions with the given agent string. Arguments: _cb – The asynchronous callback object. agent – current – The Current object for the invocation.

getMyOpenClientSessions_async(_cb, current=None)

Like {@code getMyOpenSessions} but returns only those sessions started by official OMERO clients. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getOutputKeys_async(_cb, sess, current=None)

Retrieves all keys in the omero.model.Session output environment. Arguments: _cb – The asynchronous callback object. sess – current – The Current object for the invocation.

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

Retrieves an entry from the omero.model.Session output environment. Arguments: _cb – The asynchronous callback object. sess – key – current – The Current object for the invocation.

getOutputs_async(_cb, sess, current=None)

Retrieves all outputs from the given omero.model.Session input environment. Arguments: _cb – The asynchronous callback object. sess – current – The Current object for the invocation.

getReferenceCount_async(_cb, sessionUuid, current=None)

Retrieves the current reference count for the given uuid. Has the same semantics as {@code getSession}. Arguments: _cb – The asynchronous callback object. sessionUuid – current – The Current object for the invocation.

getSession_async(_cb, sessionUuid, current=None)

Retrieves the session associated with this uuid, updating the last access time as well. Throws a omero.RemovedSessionException if not present, or a omero.SessionTimeoutException if expired. This method can be used as a ome.model.meta.Session ping. Arguments: _cb – The asynchronous callback object. sessionUuid – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. sess – key – value – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. sess – key – value – current – The Current object for the invocation.

class omero.api.ISessionPrx

Bases: omero.api.ServiceInterfacePrx

Creates a new session and returns it to the user. Arguments: p – credentials – _ctx – The request context for the invocation. Throws: 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(principal, timeToLiveMilliseconds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createSessionWithTimeouts(principal, 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)
createSession(p, credentials, _ctx=None)
createSessionWithTimeout(principal, timeToLiveMilliseconds, _ctx=None)
createSessionWithTimeouts(principal, timeToLiveMilliseconds, timeToIdleMilliseconds, _ctx=None)
createUserSession(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)
getInputs(sess, _ctx=None)
getMyOpenAgentSessions(agent, _ctx=None)
getMyOpenClientSessions(_ctx=None)
getMyOpenSessions(_ctx=None)
getOutput(sess, key, _ctx=None)
getOutputKeys(sess, _ctx=None)
getOutputs(sess, _ctx=None)
getReferenceCount(sessionUuid, _ctx=None)
getSession(sessionUuid, _ctx=None)
static ice_staticId()
setInput(sess, key, value, _ctx=None)
setOutput(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 0x3522e28>
_op_activate = <IcePy.Operation object>
_op_addComment = <IcePy.Operation object>
_op_addGuest = <IcePy.Operation object>
_op_addGuests = <IcePy.Operation object>
_op_addObject = <IcePy.Operation object>
_op_addObjects = <IcePy.Operation object>
_op_addReply = <IcePy.Operation object>
_op_addUser = <IcePy.Operation object>
_op_addUsers = <IcePy.Operation object>
_op_closeShare = <IcePy.Operation object>
_op_createShare = <IcePy.Operation object>
_op_deactivate = <IcePy.Operation object>
_op_deleteComment = <IcePy.Operation object>
_op_getActiveConnections = <IcePy.Operation object>
_op_getAllGuests = <IcePy.Operation object>
_op_getAllMembers = <IcePy.Operation object>
_op_getAllUsers = <IcePy.Operation object>
_op_getCommentCount = <IcePy.Operation object>
_op_getComments = <IcePy.Operation object>
_op_getContentMap = <IcePy.Operation object>
_op_getContentSize = <IcePy.Operation object>
_op_getContentSubList = <IcePy.Operation object>
_op_getContents = <IcePy.Operation object>
_op_getEvents = <IcePy.Operation object>
_op_getMemberCount = <IcePy.Operation object>
_op_getMemberShares = <IcePy.Operation object>
_op_getMemberSharesFor = <IcePy.Operation object>
_op_getOwnShares = <IcePy.Operation object>
_op_getPastConnections = <IcePy.Operation object>
_op_getShare = <IcePy.Operation object>
_op_getSharesOwnedBy = <IcePy.Operation object>
_op_invalidateConnection = <IcePy.Operation object>
_op_notifyMembersOfShare = <IcePy.Operation object>
_op_removeGuest = <IcePy.Operation object>
_op_removeGuests = <IcePy.Operation object>
_op_removeObject = <IcePy.Operation object>
_op_removeObjects = <IcePy.Operation object>
_op_removeUser = <IcePy.Operation object>
_op_removeUsers = <IcePy.Operation object>
_op_setActive = <IcePy.Operation object>
_op_setDescription = <IcePy.Operation object>
_op_setExpiration = <IcePy.Operation object>
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 omero.ValidationException is thrown. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

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

Creates omero.model.TextAnnotation comment for omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – comment – current – The Current object for the invocation.

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

Adds guest email address to the share. Arguments: _cb – The asynchronous callback object. shareId – emailAddress – current – The Current object for the invocation.

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

Adds guest email addresses to the share. Arguments: _cb – The asynchronous callback object. shareId – emailAddresses – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. shareId – iobject – current – The Current object for the invocation.

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

Adds new omero.model.IObject items to omero.model.Session share. Conceptually calls {@code addObjects} for every argument passed, but the graphs will be merged. Arguments: _cb – The asynchronous callback object. shareId – iobjects – current – The Current object for the invocation.

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

Creates omero.model.TextAnnotation comment which replies to an existing comment. Arguments: _cb – The asynchronous callback object. shareId – comment – replyTo – current – The Current object for the invocation.

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

Adds omero.model.Experimenter experimenter to omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – exp – current – The Current object for the invocation.

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

Adds omero.model.Experimenter experimenters to omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – exps – current – The Current object for the invocation.

closeShare_async(_cb, shareId, current=None)

Closes omero.model.Session share. No further logins will be possible and all getters (e.g. {@code getMemberShares}, {@code getOwnShares}, ...) will filter these results if {@code onlyActive} is true. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. description – expiration – items – exps – guests – 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 {@code activate}. Similarly, the share password cannot be used by guests to login. current – The Current object for the invocation.

deactivate_async(_cb, current=None)

Turns off the access control lists with the current share. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

deleteComment_async(_cb, comment, current=None)

Deletes omero.model.Annotation comment from the database. Arguments: _cb – The asynchronous callback object. comment – current – The Current object for the invocation.

getActiveConnections_async(_cb, shareId, current=None)

Gets actual active connections to omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

getAllGuests_async(_cb, shareId, current=None)

Get the email addresses for all share guests. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

getAllMembers_async(_cb, shareId, current=None)

Get all omero.model.Experimenter users who are a member of the share. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

getAllUsers_async(_cb, shareId, current=None)

Get a single set containing the {@code omero.model.Experimenter.getOmeName} login names of the users as well email addresses for guests. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. shareIds – Not null. current – The Current object for the invocation. Throws: 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. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

getContentMap_async(_cb, shareId, current=None)

Returns the contents of the share keyed by type. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

getContentSize_async(_cb, shareId, current=None)

Returns the number of items in the share. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

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

Returns a range of items from the share. Arguments: _cb – The asynchronous callback object. shareId – start – finish – current – The Current object for the invocation.

getContents_async(_cb, shareId, current=None)

Looks up all omero.model.IObject items belong to the omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. shareId – exp – _from – to – current – The Current object for the invocation.

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: _cb – The asynchronous callback object. shareIds – Not null. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. user – the experimenter active – if true, then only shares which can be used for login will be returned. All draft shares (see {@code createShare}) and closed shares (see {@code closeShare}) will be filtered. current – The Current object for the invocation.

getMemberShares_async(_cb, active, current=None)

Gets all shares where current omero.model.Experimenter is a member. Arguments: _cb – The asynchronous callback object. active – if true, then only shares which can be used for login will be returned. All draft shares (see {@code createShare}) and closed shares (see {@code closeShare}) will be filtered. current – The Current object for the invocation.

getOwnShares_async(_cb, active, current=None)

Gets all owned shares for the current omero.model.Experimenter. Arguments: _cb – The asynchronous callback object. active – if true, then only shares which can be used for login will be returned. All draft shares (see {@code createShare}) and closed shares (see {@code closeShare}) will be filtered. current – The Current object for the invocation.

getPastConnections_async(_cb, shareId, current=None)

Gets previous connections to omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. shareId – current – The Current object for the invocation.

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

Gets all shares owned by the given omero.model.Experimenter. Arguments: _cb – The asynchronous callback object. user – the experimenter active – if true, then only shares which can be used for login will be returned. All draft shares (see {@code createShare}) and closed shares (see {@code closeShare}) will be filtered. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. shareId – exp – current – The Current object for the invocation.

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

Notifies via email selected members of share. Arguments: _cb – The asynchronous callback object. shareId – subject – message – html – current – The Current object for the invocation.

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

Removes guest email address from share. Arguments: _cb – The asynchronous callback object. shareId – emailAddress – current – The Current object for the invocation.

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

Removes guest email addresses from the share. Arguments: _cb – The asynchronous callback object. shareId – emailAddresses – current – The Current object for the invocation.

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

Removes existing omero.model.IObject object from the omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – iobject – current – The Current object for the invocation.

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

Remove existing items from the share. Arguments: _cb – The asynchronous callback object. shareId – iobjects – current – The Current object for the invocation.

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

Removes omero.model.Experimenter experimenter from omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – exp – current – The Current object for the invocation.

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

Removes omero.model.Experimenter experimenters from omero.model.Session share. Arguments: _cb – The asynchronous callback object. shareId – exps – current – The Current object for the invocation.

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 omero.ValidationException is thrown. Arguments: shareId – _ctx – The request context for the invocation.

activate(shareId, _ctx=None)
addComment(shareId, comment, _ctx=None)
addGuest(shareId, emailAddress, _ctx=None)
addGuests(shareId, emailAddresses, _ctx=None)
addObject(shareId, iobject, _ctx=None)
addObjects(shareId, iobjects, _ctx=None)
addReply(shareId, comment, replyTo, _ctx=None)
addUser(shareId, exp, _ctx=None)
addUsers(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)
createShare(description, expiration, items, exps, guests, enabled, _ctx=None)
deactivate(_ctx=None)
deleteComment(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)
getAllGuests(shareId, _ctx=None)
getAllMembers(shareId, _ctx=None)
getAllUsers(shareId, _ctx=None)
getCommentCount(shareIds, _ctx=None)
getComments(shareId, _ctx=None)
getContentMap(shareId, _ctx=None)
getContentSize(shareId, _ctx=None)
getContentSubList(shareId, start, finish, _ctx=None)
getContents(shareId, _ctx=None)
getEvents(shareId, exp, _from, to, _ctx=None)
getMemberCount(shareIds, _ctx=None)
getMemberShares(active, _ctx=None)
getMemberSharesFor(user, active, _ctx=None)
getOwnShares(active, _ctx=None)
getPastConnections(shareId, _ctx=None)
getShare(shareId, _ctx=None)
getSharesOwnedBy(user, active, _ctx=None)
static ice_staticId()
invalidateConnection(shareId, exp, _ctx=None)
notifyMembersOfShare(shareId, subject, message, html, _ctx=None)
removeGuest(shareId, emailAddress, _ctx=None)
removeGuests(shareId, emailAddresses, _ctx=None)
removeObject(shareId, iobject, _ctx=None)
removeObjects(shareId, iobjects, _ctx=None)
removeUser(shareId, exp, _ctx=None)
removeUsers(shareId, exps, _ctx=None)
setActive(shareId, active, _ctx=None)
setDescription(shareId, description, _ctx=None)
setExpiration(shareId, expiration, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.ITimeline

Bases: omero.api.ServiceInterface

Service for the querying of OMERO metadata based on creation and modification time. Currently supported types for querying include: omero.model.Annotation omero.model.Dataset omero.model.Image omero.model.Project omero.model.RenderingDef Return maps The map return values will be indexed by the short type name above: Project, Image, ... All keys which are passed in the StringSet argument will be included in the returned map, even if they have no values. A default value of 0 or the empty list [] will be used. The only exception to this rule is that the null or empty StringSet implies all valid keys. Parameters All methods take a omero::sys::Parameters object and will apply the filter object for paging through the data in order to prevent loading too many objects. If the parameters argument is null or no paging is activated, then the default will be: OFFSET=0, LIMIT=50. Filter.ownerId and Filter.groupId will also be AND’ed to the query if either value is present. If both are null, then the current user id will be used. To retrieve for all users, use ownerId == rlong(-1) and groupId == null. Merging The methods which take a StringSet and a Parameters object, also have a bool merge argument. This argument defines whether or not the LIMIT applies to each object independently ([“a”,”b”] @ 100 == 200) or merges the lists together chronologically ([“a”,”b”] @ 100 merged == 100). Time used Except for Image, IObject.details.updateEvent is used in all cases for determining most recent events. Images are compared via Image.acquisitionDate which is unlike the other properties is modifiable by the user. A typical invocation might look like (in Python): {@code 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 0x3522f18>
_op_countByPeriod = <IcePy.Operation object>
_op_getByPeriod = <IcePy.Operation object>
_op_getEventLogsByPeriod = <IcePy.Operation object>
_op_getMostRecentObjects = <IcePy.Operation object>
countByPeriod_async(_cb, types, start, end, p, current=None)

Queries the same information as getByPeriod, but only returns the counts for the given objects. Arguments: _cb – The asynchronous callback object. types – start – end – p – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. types – start – end – p – merge – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. start – end – p – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. parentTypes – childTypes – namespaces – p – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. types – p – merge – current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. p – current – The Current object for the invocation.

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. Arguments: parentTypes – childTypes – namespaces – p – _ctx – The request context for the invocation.

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)
end_countByPeriod(_r)
end_getByPeriod(_r)
end_getEventLogsByPeriod(_r)
end_getMostRecentObjects(_r)
getByPeriod(types, start, end, p, merge, _ctx=None)
getEventLogsByPeriod(start, end, p, _ctx=None)
getMostRecentObjects(types, p, merge, _ctx=None)
static ice_staticId()
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 0x3522e58>
_op_allEnumerations = <IcePy.Operation object>
_op_createEnumeration = <IcePy.Operation object>
_op_deleteEnumeration = <IcePy.Operation object>
_op_getAnnotationTypes = <IcePy.Operation object>
_op_getEnumeration = <IcePy.Operation object>
_op_getEnumerationTypes = <IcePy.Operation object>
_op_getEnumerationsWithEntries = <IcePy.Operation object>
_op_getOriginalEnumerations = <IcePy.Operation object>
_op_resetEnumerations = <IcePy.Operation object>
_op_updateEnumeration = <IcePy.Operation object>
_op_updateEnumerations = <IcePy.Operation object>
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: _cb – The asynchronous callback object. oldEnum – An enumeration object which should be searched. current – The Current object for the invocation.

getAnnotationTypes_async(_cb, current=None)

Returns a list of classes which implement ome.model.IAnnotated. These can be used in combination with omero.api.Search. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getEnumerationTypes_async(_cb, current=None)

Gets all metadata classes which are IEnum type. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. type – An enumeration class which should be searched. value – The value for which an enumeration should be found. current – The Current object for the invocation. Throws: ApiUsageException – if ome.model.IEnum is not found.

getEnumerationsWithEntries_async(_cb, current=None)

Gets all metadata classes which are IEnum type with contained objects. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: RuntimeException – if xml parsing failure.

getOriginalEnumerations_async(_cb, current=None)

Gets all original values. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: 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: _cb – The asynchronous callback object. oldEnum – An enumeration object which should be searched. current – The Current object for the invocation.

updateEnumerations_async(_cb, oldEnums, current=None)

Updates enumeration value specified by object. Arguments: _cb – The asynchronous callback object. oldEnums – An enumeration collection of objects which should be searched. current – The Current object for the invocation.

class omero.api.ITypesPrx

Bases: omero.api.ServiceInterfacePrx

allEnumerations(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)
deleteEnumeration(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)
getEnumeration(type, value, _ctx=None)
getEnumerationTypes(_ctx=None)
getEnumerationsWithEntries(_ctx=None)
getOriginalEnumerations(_ctx=None)
static ice_staticId()
resetEnumerations(enumClass, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateEnumeration(oldEnum, _ctx=None)
updateEnumerations(oldEnums, _ctx=None)
class omero.api.IUpdate

Bases: omero.api.ServiceInterface

Provides methods for directly updating object graphs. IUpdate is the lowest level (level-1) interface which may make changes (INSERT, UPDATE, DELETE) to the database. All other methods of changing the database may leave it in an inconsistent state. All the save* methods act recursively on the entire object graph, replacing placeholders and details where necessary, and then merging the final graph. This means that the objects that are passed into IUpdate.save* methods are copied over to new instances which are then returned. The original objects should be discarded. {@code saveAndReturnIds} behaves slightly differently in that it does not handle object modifications. The graph of objects passed in can consist ONLY if either newly created objects without ids or of unloaded objects with ids. Note: The ids of the saved values may not be in order. This is caused by persistence-by-transitivity. Hibernate may detect an item later in the array if they are interconnected and therefore choose to save it first. All methods throw omero.ValidationException if the input objects do not pass validation, and omero.OptimisticLockException if the version of a given has already been incremented.

_ice_type = <IcePy.TypeInfo object at 0x3522e88>
_op_deleteObject = <IcePy.Operation object>
_op_indexObject = <IcePy.Operation object>
_op_saveAndReturnArray = <IcePy.Operation object>
_op_saveAndReturnIds = <IcePy.Operation object>
_op_saveAndReturnObject = <IcePy.Operation object>
_op_saveArray = <IcePy.Operation object>
_op_saveCollection = <IcePy.Operation object>
_op_saveObject = <IcePy.Operation object>
deleteObject_async(_cb, row, current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
indexObject_async(_cb, row, current=None)

Initiates full-text indexing for the given object. This may have to wait for the current {@code FullTextThread} to finish. Can only be executed by an admin. Other users must wait for the background Thread to complete. Arguments: _cb – The asynchronous callback object. row – a persistent omero.model.IObject to be deleted current – The Current object for the invocation. Throws: ValidationException – if the object does not exist or is nul

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

Bases: omero.api.ServiceInterfacePrx

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

Bases: omero.api.StatefulServiceInterface

Allows submission of asynchronous jobs. NOTE: The calling order for the service is as follows: {@code submit} or {@code attach} any of the other methods {@code close} Calling {@code close} does not cancel or otherwise change the Job state. See {@code cancelJob}.

_ice_type = <IcePy.TypeInfo object at 0x3522f78>
_op_attach = <IcePy.Operation object>
_op_cancelJob = <IcePy.Operation object>
_op_getJob = <IcePy.Operation object>
_op_jobError = <IcePy.Operation object>
_op_jobFinished = <IcePy.Operation object>
_op_jobMessage = <IcePy.Operation object>
_op_jobRunning = <IcePy.Operation object>
_op_jobStatus = <IcePy.Operation object>
_op_setMessage = <IcePy.Operation object>
_op_setStatus = <IcePy.Operation object>
_op_setStatusAndMessage = <IcePy.Operation object>
_op_submit = <IcePy.Operation object>
attach_async(_cb, jobId, current=None)

Returns the current omero.model.JobStatus for the Job id. Arguments: _cb – The asynchronous callback object. jobId – current – The Current object for the invocation. Throws: ApiUsageException – if the omero.model.Job does not exist.

cancelJob_async(_cb, current=None)

Marks a job for cancellation. Not every processor will check for the cancelled flag for a running job, but no non-running job will start if it has been cancelled. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getJob_async(_cb, current=None)

Returns the current omero.model.Job Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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

Returns true if the omero.model.Job has thrown an error. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

jobFinished_async(_cb, current=None)

Returns null if the omero.model.Job is not finished, otherwise the omero.RTime for when it completed. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

jobMessage_async(_cb, current=None)

Returns the current message for job. May be set during processing. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

jobRunning_async(_cb, current=None)

Returns true if the omero.model.Job is running, i.e. has an attached process. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

jobStatus_async(_cb, current=None)

Returns the current omero.model.JobStatus. Will never return null. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

setMessage_async(_cb, message, current=None)

Sets the job’s message string, and returns the previous value. Arguments: _cb – The asynchronous callback object. message – current – The Current object for the invocation.

setStatusAndMessage_async(_cb, status, message, current=None)

Like {@code setStatus} but also sets the message. Arguments: _cb – The asynchronous callback object. status – message – current – The Current object for the invocation.

setStatus_async(_cb, status, current=None)

Updates the omero.model.JobStatus for the current job. The previous status is returned as a string. If the status is {@code CANCELLED}, this method is equivalent to {@code cancelJob}. Arguments: _cb – The asynchronous callback object. status – current – The Current object for the invocation.

submit_async(_cb, job, current=None)

Submits a omero.model.Job and returns its database id. The only fields directly on status which are editable are message, scheduledFor and status. The latter two must be sensible. Arguments: _cb – The asynchronous callback object. job – Not null current – The Current object for the invocation.

class omero.api.JobHandlePrx

Bases: omero.api.StatefulServiceInterfacePrx

Submits a omero.model.Job and returns its database id. The only fields directly on status which are editable are message, scheduledFor and status. The latter two must be sensible. Arguments: job – Not null _ctx – The request context for the invocation.

attach(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(job, _response=None, _ex=None, _sent=None, _ctx=None)
cancelJob(_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)
static ice_staticId()
jobError(_ctx=None)
jobFinished(_ctx=None)
jobMessage(_ctx=None)
jobRunning(_ctx=None)
jobStatus(_ctx=None)
setMessage(message, _ctx=None)
setStatus(status, _ctx=None)
setStatusAndMessage(status, message, _ctx=None)
submit(job, _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 0x3561a50>
_op_createRoot = <IcePy.Operation object at 0x3561a68>
_op_populateMinMax = <IcePy.Operation object at 0x3561ac8>
_op_postProcess = <IcePy.Operation object at 0x3561af8>
_op_saveToDB = <IcePy.Operation object at 0x3561ab0>
_op_setPixelsFile = <IcePy.Operation object at 0x3561ae0>
_op_updateObjects = <IcePy.Operation object at 0x3561a80>
_op_updateReferences = <IcePy.Operation object at 0x3561a98>
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)
end_createRoot(_r)
end_populateMinMax(_r)
end_postProcess(_r)
end_saveToDB(_r)
end_setPixelsFile(_r)
end_updateObjects(_r)
end_updateReferences(_r)
static ice_staticId()
populateMinMax(imageChannelGlobalMinMax, _ctx=None)
postProcess(_ctx=None)
saveToDB(activity, _ctx=None)
setPixelsFile(pixelsId, file, repo, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateObjects(objects, _ctx=None)
updateReferences(references, _ctx=None)
class omero.api.PyramidService

Bases: omero.api.StatefulServiceInterface

_ice_type = <IcePy.TypeInfo object>
_op_getResolutionDescriptions = <IcePy.Operation object>
_op_getResolutionLevel = <IcePy.Operation object>
_op_getResolutionLevels = <IcePy.Operation object>
_op_getTileSize = <IcePy.Operation object>
_op_requiresPixelsPyramid = <IcePy.Operation object>
_op_setResolutionLevel = <IcePy.Operation object>
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 {@code getResolutionLevels}. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getResolutionLevel_async(_cb, current=None)

Retrieves the active resolution level. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getResolutionLevels_async(_cb, current=None)

Retrieves the number of resolution levels that the backing pixels pyramid contains. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getTileSize_async(_cb, current=None)

Retrieves the tile size for the pixel store. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

setResolutionLevel_async(_cb, resolutionLevel, current=None)

Sets the active resolution level. Arguments: _cb – The asynchronous callback object. resolutionLevel – The resolution level to be used by the pixel buffer. current – The Current object for the invocation.

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. Arguments: _ctx – The request context for the invocation. 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)
getResolutionLevel(_ctx=None)
getResolutionLevels(_ctx=None)
getTileSize(_ctx=None)
static ice_staticId()
requiresPixelsPyramid(_ctx=None)
setResolutionLevel(resolutionLevel, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.RawFileStore

Bases: omero.api.StatefulServiceInterface

Raw file gateway which provides access to the OMERO file repository. Note: methods on this service are protected by a DOWNLOAD restriction.

_ice_type = <IcePy.TypeInfo object at 0x3522fa8>
_op_exists = <IcePy.Operation object>
_op_getFileId = <IcePy.Operation object>
_op_read = <IcePy.Operation object>
_op_save = <IcePy.Operation object>
_op_setFileId = <IcePy.Operation object>
_op_size = <IcePy.Operation object>
_op_truncate = <IcePy.Operation object>
_op_write = <IcePy.Operation object>
exists_async(_cb, current=None)

Checks to see if a raw file exists with the file ID that the service was initialized with. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation. Throws: ResourceError – if there is a problem accessing the file due to permissions errors within the repository or any other I/O error.

getFileId_async(_cb, current=None)

Returns the current file id or null if none has been set. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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

Reads length bytes of data at the position from the raw file into an array of bytes. Arguments: _cb – The asynchronous callback object. position – length – current – The Current object for the invocation.

save_async(_cb, current=None)

Saves the omero.model.OriginalFile associated with the service if it has been modified. The returned valued should replace all instances of the omero.model.OriginalFile in the client. If save has not been called, omero.api.RawFileStore instances will save the omero.model.OriginalFile object associated with it on {@code close}. See also ticket 1651 and ticket 2161. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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 {@code omero.constants.permissions.BINARYACCESS} restriction is in place. Arguments: _cb – The asynchronous callback object. fileId – current – The Current object for the invocation.

size_async(_cb, current=None)

Returns the size of the file on disk (not as stored in the database since that value will only be updated on {@code save}. If the file has not yet been written to, and therefore does not exist, a omero.ResourceError will be thrown. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

truncate_async(_cb, length, current=None)

Limits the size of a file to the given length. If the file is already shorter than length, no action is taken in which case false is returned. Arguments: _cb – The asynchronous callback object. length – current – The Current object for the invocation.

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

Writes length bytes of data from the specified buf byte array starting at at position to the raw file. Arguments: _cb – The asynchronous callback object. buf – position – length – current – The Current object for the invocation.

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 {@code omero.constants.permissions.BINARYACCESS} restriction is in place. Arguments: fileId – _ctx – The request context for the invocation.

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)
getFileId(_ctx=None)
static ice_staticId()
read(position, length, _ctx=None)
save(_ctx=None)
setFileId(fileId, _ctx=None)
size(_ctx=None)
truncate(length, _ctx=None)
static uncheckedCast(proxy, facet=None)
write(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 {@code getByteWidth}, {@code isFloat}, and {@code 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 0x3522fd8>
_op_calculateMessageDigest = <IcePy.Operation object>
_op_findMinMax = <IcePy.Operation object>
_op_getByteWidth = <IcePy.Operation object>
_op_getCol = <IcePy.Operation object>
_op_getHistogram = <IcePy.Operation object>
_op_getHypercube = <IcePy.Operation object>
_op_getPixelsId = <IcePy.Operation object>
_op_getPixelsPath = <IcePy.Operation object>
_op_getPlane = <IcePy.Operation object>
_op_getPlaneOffset = <IcePy.Operation object>
_op_getPlaneRegion = <IcePy.Operation object>
_op_getPlaneSize = <IcePy.Operation object>
_op_getRegion = <IcePy.Operation object>
_op_getRow = <IcePy.Operation object>
_op_getRowOffset = <IcePy.Operation object>
_op_getRowSize = <IcePy.Operation object>
_op_getStack = <IcePy.Operation object>
_op_getStackOffset = <IcePy.Operation object>
_op_getStackSize = <IcePy.Operation object>
_op_getTile = <IcePy.Operation object>
_op_getTimepoint = <IcePy.Operation object>
_op_getTimepointOffset = <IcePy.Operation object>
_op_getTimepointSize = <IcePy.Operation object>
_op_getTotalSize = <IcePy.Operation object>
_op_isFloat = <IcePy.Operation object>
_op_isSigned = <IcePy.Operation object>
_op_prepare = <IcePy.Operation object>
_op_save = <IcePy.Operation object>
_op_setPixelsId = <IcePy.Operation object>
_op_setPlane = <IcePy.Operation object>
_op_setRegion = <IcePy.Operation object>
_op_setRow = <IcePy.Operation object>
_op_setStack = <IcePy.Operation object>
_op_setTile = <IcePy.Operation object>
_op_setTimepoint = <IcePy.Operation object>
calculateMessageDigest_async(_cb, current=None)

Calculates a SHA-1 message digest for the entire pixel store. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

findMinMax_async(_cb, channels, current=None)

Find the minimum and maximum pixel values for the specified channels by iterating over a full plane. In case of multi-z/t images only the ‘middle’ plane with index maxZ/2, respectively maxT/2 is taken into account. Note: This method can currently only handle non-pyramid images, otherwise an empty map will be returned. Arguments: _cb – The asynchronous callback object. channels – the channels current – The Current object for the invocation.

getByteWidth_async(_cb, current=None)

Returns the byte width for the pixel store. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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

Retrieves a particular column from this pixel store. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

getHistogram_async(_cb, channels, binCount, globalRange, plane, current=None)

Retrieves the histogram data for the specified plane and channels. This method can currently only handle non-pyramid images. Arguments: _cb – The asynchronous callback object. channels – the channels to generate the histogram data for binCount – the number of the histogram bins (optional, default: 256) globalRange – use the global minimum/maximum to determine the histogram range, otherwise use plane minimum/maximum value plane – the plane (optional, default: whole region of first z/t plane) current – The Current object for the invocation.

getHypercube_async(_cb, offset, size, step, current=None)

Retrieves a n-dimensional block from this pixel store. Arguments: _cb – The asynchronous callback object. offset – offset for each dimension within pixel store. size – of each dimension (dependent on dimension). step – needed of each dimension (dependent on dimension). current – The Current object for the invocation.

getPixelsId_async(_cb, current=None)

Returns the current Pixels set identifier. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getPixelsPath_async(_cb, current=None)

Returns the current Pixels path. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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

Retrieves the offset for a particular 2D image plane in this pixel store. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

getPlaneRegion_async(_cb, z, c, t, size, offset, current=None)

Retrieves a region from a given plane from this pixel store. Arguments: _cb – The asynchronous callback object. 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. size – the number of pixels to retrieve. offset – the offset at which to retrieve size pixels. current – The Current object for the invocation.

getPlaneSize_async(_cb, current=None)

Retrieves the in memory size of a 2D image plane in this pixel store. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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

Retrieves a particular 2D image plane from this pixel store. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

getRegion_async(_cb, size, offset, current=None)

Retrieves a region from this pixel store. Arguments: _cb – The asynchronous callback object. size – byte width of the region to retrieve. offset – offset within the pixel store. current – The Current object for the invocation.

getRowOffset_async(_cb, y, z, c, t, current=None)

Retrieves the offset for a particular row or scanline in this pixel store. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

getRowSize_async(_cb, current=None)

Retrieves the in memory size of a row or scanline of pixels in this pixel store. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getRow_async(_cb, y, z, c, t, current=None)

Retrieves a particular row or scanline from this pixel store. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. c – offset across the C-axis of the pixel buffer. t – offset across the T-axis of the pixel buffer. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. c – offset across the C-axis of the pixel store. t – offset across the T-axis of the pixel store. current – The Current object for the invocation.

getTile_async(_cb, z, c, t, x, y, w, h, current=None)

Retrieves a tile from this pixel buffer. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. t – offset across the T-axis of the pixel buffer. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. t – offset across the T-axis of the pixel store. current – The Current object for the invocation.

getTotalSize_async(_cb, current=None)

Retrieves the in memory size of the entire pixel store. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

isSigned_async(_cb, current=None)

Returns whether or not the pixel store has signed pixels. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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: _cb – The asynchronous callback object. pixelsIds – Pixels IDs to cache. current – The Current object for the invocation.

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. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

setPixelsId_async(_cb, pixelsId, bypassOriginalFile, current=None)

Initializes the stateful service for a given Pixels set. Arguments: _cb – The asynchronous callback object. 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 current – The Current object for the invocation.

setPlane_async(_cb, buf, z, c, t, current=None)

Sets a particular 2D image plane in this pixel store. Arguments: _cb – The asynchronous callback object. 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 current – The Current object for the invocation.

setRegion_async(_cb, size, offset, buf, current=None)

Sets a region in this pixel buffer. Arguments: _cb – The asynchronous callback object. 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 current – The Current object for the invocation.

setRow_async(_cb, buf, y, z, c, t, current=None)

Sets a particular row or scanline in this pixel store. Arguments: _cb – The asynchronous callback object. 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 current – The Current object for the invocation.

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: _cb – The asynchronous callback object. buf – a byte array of the data comprising this stack. z – 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 current – The Current object for the invocation.

setTile_async(_cb, buf, z, c, t, x, y, w, h, current=None)

Sets a tile in this pixel buffer. Arguments: _cb – The asynchronous callback object. 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. current – The Current object for the invocation. Throws: BufferOverflowException – if an attempt is made to write off the end of the file. See Read-only caveat under RawPixelsStore IOException – if there is a problem writing to the pixel buffer.

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: _cb – The asynchronous callback object. 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 current – The Current object for the invocation.

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 _ctx – The request context for the invocation.

begin_calculateMessageDigest(_response=None, _ex=None, _sent=None, _ctx=None)
begin_findMinMax(channels, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getByteWidth(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getCol(x, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getHistogram(channels, binCount, globalRange, plane, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getHypercube(offset, size, step, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsId(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsPath(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlane(z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlaneOffset(z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlaneRegion(z, c, t, size, offset, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPlaneSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getRegion(size, offset, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRow(y, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRowOffset(y, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRowSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getStack(c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getStackOffset(c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getStackSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTile(z, c, t, x, y, w, h, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTimepoint(t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTimepointOffset(t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getTimepointSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTotalSize(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isFloat(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isSigned(_response=None, _ex=None, _sent=None, _ctx=None)
begin_prepare(pixelsIds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_save(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setPixelsId(pixelsId, bypassOriginalFile, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setPlane(buf, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setRegion(size, offset, buf, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setRow(buf, y, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setStack(buf, z, c, t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setTile(buf, z, c, t, x, y, w, h, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setTimepoint(buf, t, _response=None, _ex=None, _sent=None, _ctx=None)
calculateMessageDigest(_ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_calculateMessageDigest(_r)
end_findMinMax(_r)
end_getByteWidth(_r)
end_getCol(_r)
end_getHistogram(_r)
end_getHypercube(_r)
end_getPixelsId(_r)
end_getPixelsPath(_r)
end_getPlane(_r)
end_getPlaneOffset(_r)
end_getPlaneRegion(_r)
end_getPlaneSize(_r)
end_getRegion(_r)
end_getRow(_r)
end_getRowOffset(_r)
end_getRowSize(_r)
end_getStack(_r)
end_getStackOffset(_r)
end_getStackSize(_r)
end_getTile(_r)
end_getTimepoint(_r)
end_getTimepointOffset(_r)
end_getTimepointSize(_r)
end_getTotalSize(_r)
end_isFloat(_r)
end_isSigned(_r)
end_prepare(_r)
end_save(_r)
end_setPixelsId(_r)
end_setPlane(_r)
end_setRegion(_r)
end_setRow(_r)
end_setStack(_r)
end_setTile(_r)
end_setTimepoint(_r)
findMinMax(channels, _ctx=None)
getByteWidth(_ctx=None)
getCol(x, z, c, t, _ctx=None)
getHistogram(channels, binCount, globalRange, plane, _ctx=None)
getHypercube(offset, size, step, _ctx=None)
getPixelsId(_ctx=None)
getPixelsPath(_ctx=None)
getPlane(z, c, t, _ctx=None)
getPlaneOffset(z, c, t, _ctx=None)
getPlaneRegion(z, c, t, size, offset, _ctx=None)
getPlaneSize(_ctx=None)
getRegion(size, offset, _ctx=None)
getRow(y, z, c, t, _ctx=None)
getRowOffset(y, z, c, t, _ctx=None)
getRowSize(_ctx=None)
getStack(c, t, _ctx=None)
getStackOffset(c, t, _ctx=None)
getStackSize(_ctx=None)
getTile(z, c, t, x, y, w, h, _ctx=None)
getTimepoint(t, _ctx=None)
getTimepointOffset(t, _ctx=None)
getTimepointSize(_ctx=None)
getTotalSize(_ctx=None)
static ice_staticId()
isFloat(_ctx=None)
isSigned(_ctx=None)
prepare(pixelsIds, _ctx=None)
save(_ctx=None)
setPixelsId(pixelsId, bypassOriginalFile, _ctx=None)
setPlane(buf, z, c, t, _ctx=None)
setRegion(size, offset, buf, _ctx=None)
setRow(buf, y, z, c, t, _ctx=None)
setStack(buf, z, c, t, _ctx=None)
setTile(buf, z, c, t, x, y, w, h, _ctx=None)
setTimepoint(buf, t, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.api.RenderingEngine

Bases: omero.api.PyramidService

Defines a service to render a given pixels set. A pixels set is a 5D array that stores the pixels data of an image, that is the pixels intensity values. Every instance of this service is paired up to a pixels set. Use this service to transform planes within the pixels set onto an RGB image. The RenderingEngine allows to fine-tune the settings that define the transformation context, that is, a specification of how raw pixels data is to be transformed into an image that can be displayed on screen. Those settings are referred to as rendering settings or display options. After tuning those settings it is possible to save them to the metadata repository so that they can be used the next time the pixels set is accessed for rendering; for example by another RenderingEngine instance. Note that the display options are specific to the given pixels set and are experimenter scoped i.e. two different users can specify different display options for the same pixels set. (A RenderingEngine instance takes this into account automatically as it is always bound to a given experimenter.) This service is thread-safe.

_ice_type = <IcePy.TypeInfo object at 0x3561048>
_op_addCodomainMap = <IcePy.Operation object>
_op_addCodomainMapToChannel = <IcePy.Operation object>
_op_getAvailableFamilies = <IcePy.Operation object>
_op_getAvailableModels = <IcePy.Operation object>
_op_getChannelCurveCoefficient = <IcePy.Operation object>
_op_getChannelFamily = <IcePy.Operation object>
_op_getChannelLookupTable = <IcePy.Operation object>
_op_getChannelNoiseReduction = <IcePy.Operation object>
_op_getChannelStats = <IcePy.Operation object>
_op_getChannelWindowEnd = <IcePy.Operation object>
_op_getChannelWindowStart = <IcePy.Operation object>
_op_getCodomainMapContext = <IcePy.Operation object>
_op_getCompressionLevel = <IcePy.Operation object>
_op_getDefaultT = <IcePy.Operation object>
_op_getDefaultZ = <IcePy.Operation object>
_op_getModel = <IcePy.Operation object>
_op_getPixels = <IcePy.Operation object>
_op_getPixelsTypeLowerBound = <IcePy.Operation object>
_op_getPixelsTypeUpperBound = <IcePy.Operation object>
_op_getQuantumDef = <IcePy.Operation object>
_op_getRGBA = <IcePy.Operation object>
_op_getRenderingDefId = <IcePy.Operation object>
_op_isActive = <IcePy.Operation object>
_op_isPixelsTypeSigned = <IcePy.Operation object>
_op_load = <IcePy.Operation object>
_op_loadRenderingDef = <IcePy.Operation object>
_op_lookupPixels = <IcePy.Operation object>
_op_lookupRenderingDef = <IcePy.Operation object>
_op_removeCodomainMap = <IcePy.Operation object>
_op_removeCodomainMapFromChannel = <IcePy.Operation object>
_op_render = <IcePy.Operation object>
_op_renderAsPackedInt = <IcePy.Operation object>
_op_renderCompressed = <IcePy.Operation object>
_op_renderProjectedAsPackedInt = <IcePy.Operation object>
_op_renderProjectedCompressed = <IcePy.Operation object>
_op_resetDefaultSettings = <IcePy.Operation object>
_op_saveAsNewSettings = <IcePy.Operation object>
_op_saveCurrentSettings = <IcePy.Operation object>
_op_setActive = <IcePy.Operation object>
_op_setChannelLookupTable = <IcePy.Operation object>
_op_setChannelWindow = <IcePy.Operation object>
_op_setCodomainInterval = <IcePy.Operation object>
_op_setCompressionLevel = <IcePy.Operation object>
_op_setDefaultT = <IcePy.Operation object>
_op_setDefaultZ = <IcePy.Operation object>
_op_setModel = <IcePy.Operation object>
_op_setOverlays = <IcePy.Operation object>
_op_setQuantizationMap = <IcePy.Operation object>
_op_setQuantumStrategy = <IcePy.Operation object>
_op_setRGBA = <IcePy.Operation object>
_op_updateCodomainMap = <IcePy.Operation object>
_op_updateSettings = <IcePy.Operation object>
addCodomainMapToChannel_async(_cb, mapCtx, w, current=None)

Adds the context to the mapping chain. Only one context of the same type can be added to the chain. The codomain transformations are functions from the device space to device space. Each time a new context is added, the second LUT is rebuilt. Arguments: _cb – The asynchronous callback object. mapCtx – The context to add. w – The channel to add the context to. current – The Current object for the invocation.

addCodomainMap_async(_cb, mapCtx, current=None)

Adds the context to the mapping chain. Only one context of the same type can be added to the chain. The codomain transformations are functions from the device space to device space. Each time a new context is added, the second LUT is rebuilt. Arguments: _cb – The asynchronous callback object. mapCtx – The context to add. current – The Current object for the invocation.

getAvailableFamilies_async(_cb, current=None)

Returns the list of mapping families supported by the Rendering engine. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getAvailableModels_async(_cb, current=None)

Returns the list of color models supported by the Rendering engine. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getChannelCurveCoefficient_async(_cb, w, current=None)

Returns the coefficient identifying a map in the family. Each channel has a map associated to it. Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getChannelFamily_async(_cb, w, current=None)

Returns the family associated to the specified channel. Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getChannelLookupTable_async(_cb, w, current=None)
getChannelNoiseReduction_async(_cb, w, current=None)

Returns true if the noise reduction algorithm used to map the pixels intensity values is turned on, false if the algorithm is turned off. Each channel has an algorithm associated to it. Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getChannelStats_async(_cb, w, current=None)
getChannelWindowEnd_async(_cb, w, current=None)

Returns the upper bound of the pixels intensity interval. Each channel has a pixels intensity interval associated to it. Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getChannelWindowStart_async(_cb, w, current=None)

Returns the lower bound of the pixels intensity interval. Each channel has a pixels intensity interval associated to it. Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getCodomainMapContext_async(_cb, w, current=None)

Returns the list of codomain contexts for the specified channel. Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getCompressionLevel_async(_cb, current=None)

Returns the current compression level for the service. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getDefaultT_async(_cb, current=None)

Returns the default timepoint index. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getDefaultZ_async(_cb, current=None)

Returns the index of the default focal section. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getModel_async(_cb, current=None)

Returns the model that dictates how transformed raw data has to be mapped onto a color space. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getPixelsTypeLowerBound_async(_cb, w, current=None)

Returns the maximum value for that channels depending on the pixels type and the original range (globalmin, globalmax) Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getPixelsTypeUpperBound_async(_cb, w, current=None)

Returns the minimum value for that channels depending on the pixels type and the original range (globalmin, globalmax) Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getPixels_async(_cb, current=None)

Returns the omero.model.Pixels set the Rendering engine is for. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getQuantumDef_async(_cb, current=None)

Returns the quantization object. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

getRGBA_async(_cb, w, current=None)

Returns a 4D-array representing the color associated to the specified channel. The first element corresponds to the red component (value between 0 and 255). The second corresponds to the green component (value between 0 and 255). The third corresponds to the blue component (value between 0 and 255). The fourth corresponds to the alpha component (value between 0 and 255). Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

getRenderingDefId_async(_cb, current=None)

Returns the id of the omero.model.RenderingDef loaded by either {@code lookupRenderingDef} or {@code loadRenderingDef}. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isActive_async(_cb, w, current=None)

Returns true if the channel is mapped, false otherwise. Arguments: _cb – The asynchronous callback object. w – The channel index. current – The Current object for the invocation.

isPixelsTypeSigned_async(_cb, current=None)

Returns true if the pixels type is signed, false otherwise. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

loadRenderingDef_async(_cb, renderingDefId, current=None)

Loads a specific set of rendering settings that does not necessarily have to be linked to the given Pixels set. However, the rendering settings must be linked to a compatible Pixels set as defined by {@code omero.api.IRenderingSettings.sanityCheckPixels}. Arguments: _cb – The asynchronous callback object. renderingDefId – The rendering definition ID. current – The Current object for the invocation. Throws: ValidationException – If a RenderingDef does not exist with the ID renderingDefId or if the RenderingDef is incompatible due to differing pixels sets.

load_async(_cb, current=None)

Creates an instance of the rendering engine. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

lookupPixels_async(_cb, pixelsId, current=None)

Loads the Pixels set this Rendering Engine is for. Arguments: _cb – The asynchronous callback object. pixelsId – The pixels set ID. current – The Current object for the invocation.

lookupRenderingDef_async(_cb, pixelsId, current=None)

Loads the rendering settings associated to the specified pixels set. Arguments: _cb – The asynchronous callback object. pixelsId – The pixels set ID. current – The Current object for the invocation.

removeCodomainMapFromChannel_async(_cb, mapCtx, w, current=None)

Removes the specified context from the chain. Each time a new context is removed, the second LUT is rebuilt. Arguments: _cb – The asynchronous callback object. mapCtx – The context to remove. w – The channel to remove the context from. current – The Current object for the invocation.

removeCodomainMap_async(_cb, mapCtx, current=None)

Removes the specified context from the chain. Each time a new context is removed, the second LUT is rebuilt. Arguments: _cb – The asynchronous callback object. mapCtx – The context to remove. current – The Current object for the invocation.

renderAsPackedInt_async(_cb, _def, current=None)

Renders the data selected by def according to the current rendering settings. The passed argument selects a plane orthogonal to one of the X, Y, or Z axes. How many wavelengths are rendered and what color model is used depends on the current rendering settings. Arguments: _cb – The asynchronous callback object. _def – Selects a plane orthogonal to one of the X, Y, or Z axes. current – The Current object for the invocation. Throws: ValidationException – If def is null.

renderCompressed_async(_cb, _def, current=None)

Renders the data selected by def according to the current rendering settings and compresses the resulting RGBA composite image. Arguments: _cb – The asynchronous callback object. _def – Selects a plane orthogonal to one of the X, Y or Z axes. current – The Current object for the invocation. Throws: ValidationException – If def is null.

renderProjectedAsPackedInt_async(_cb, algorithm, timepoint, stepping, start, end, current=None)

Performs a projection through selected optical sections of a particular timepoint with the currently active channels and renders the data for display. Arguments: _cb – The asynchronous callback object. algorithm – ome.api.IProjection#MAXIMUM_INTENSITY, ome.api.IProjection#MEAN_INTENSITY or ome.api.IProjection#SUM_INTENSITY. timepoint – 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. current – The Current object for the invocation. Throws: ValidationException – Where: algorithm is unknown timepoint is out of range start is out of range end is out of range start is greater than end

renderProjectedCompressed_async(_cb, algorithm, timepoint, stepping, start, end, current=None)

Performs a projection through selected optical sections of a particular timepoint with the currently active channels, renders the data for display and compresses the resulting RGBA composite image. Arguments: _cb – The asynchronous callback object. algorithm – ome.api.IProjection#MAXIMUM_INTENSITY, ome.api.IProjection#MEAN_INTENSITY or ome.api.IProjection#SUM_INTENSITY. timepoint – 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. current – The Current object for the invocation. Throws: ValidationException – Where: algorithm is unknown timepoint is out of range start is out of range end is out of range startis greater than end

render_async(_cb, _def, current=None)

Renders the data selected by def according to the current rendering settings. The passed argument selects a plane orthogonal to one of the X, Y, or Z axes. How many wavelengths are rendered and what color model is used depends on the current rendering settings. Arguments: _cb – The asynchronous callback object. _def – Selects a plane orthogonal to one of the X, Y, or Z axes. current – The Current object for the invocation. Throws: ValidationException – If def is null.

resetDefaultSettings_async(_cb, save, current=None)

Resets the default settings i.e. the default values internal to the Rendering engine. The settings will be saved. Arguments: _cb – The asynchronous callback object. save – Pass true to save the settings, false otherwise. current – The Current object for the invocation.

saveAsNewSettings_async(_cb, current=None)

Saves the current rendering settings in the database as a new omero.model.RenderingDef and loads the object into the current omero.api.RenderingEngine. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

saveCurrentSettings_async(_cb, current=None)

Saves the current rendering settings in the database. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

setActive_async(_cb, w, active, current=None)

Maps the specified channel if true, unmaps the channel otherwise. Arguments: _cb – The asynchronous callback object. w – The channel index. active – Pass true to map the channel, false otherwise. current – The Current object for the invocation.

setChannelLookupTable_async(_cb, w, lookup, current=None)
setChannelWindow_async(_cb, w, start, end, current=None)

Returns the pixels intensity interval. Each channel has a pixels intensity interval associated to it. Arguments: _cb – The asynchronous callback object. w – The channel index. start – The lower bound of the interval. end – The upper bound of the interval. current – The Current object for the invocation.

setCodomainInterval_async(_cb, start, end, current=None)

Sets the sub-interval of the device space i.e. a discrete sub-interval of [0, 255]. Arguments: _cb – The asynchronous callback object. start – The lower bound of the interval. end – The upper bound of the interval. current – The Current object for the invocation.

setCompressionLevel_async(_cb, percentage, current=None)

Sets the current compression level for the service. (The default is 85%) Arguments: _cb – The asynchronous callback object. percentage – A percentage compression level from 1.00 (100%) to 0.01 (1%). current – The Current object for the invocation. Throws: ValidationException – if the percentage is out of range.

setDefaultT_async(_cb, t, current=None)

Sets the default timepoint index. This index is used to define a default plane. Arguments: _cb – The asynchronous callback object. t – The value to set. current – The Current object for the invocation.

setDefaultZ_async(_cb, z, current=None)

Sets the index of the default focal section. This index is used to define a default plane. Arguments: _cb – The asynchronous callback object. z – The value to set. current – The Current object for the invocation.

setModel_async(_cb, model, current=None)

Specifies the model that dictates how transformed raw data has to be mapped onto a color space. Arguments: _cb – The asynchronous callback object. model – Identifies the color space model. current – The Current object for the invocation.

setOverlays_async(_cb, tablesId, imageId, rowColorMap, current=None)

Informs the rendering engine that it should render a set of overlays on each rendered frame. These are expected to be binary masks. Arguments: _cb – The asynchronous callback object. tablesId – imageId – rowColorMap – Binary mask to color map. current – The Current object for the invocation.

setQuantizationMap_async(_cb, w, family, coefficient, noiseReduction, current=None)

Sets the quantization map, one per channel. Arguments: _cb – The asynchronous callback object. w – The channel index. family – The mapping family. coefficient – The coefficient identifying a curve in the family. noiseReduction – Pass true to turn the noise reduction algorithm on, false otherwise. current – The Current object for the invocation.

setQuantumStrategy_async(_cb, bitResolution, current=None)

Sets the quantization strategy. The strategy is common to all channels. Arguments: _cb – The asynchronous callback object. bitResolution – The bit resolution defining associated to the strategy. current – The Current object for the invocation.

setRGBA_async(_cb, w, red, green, blue, alpha, current=None)

Sets the four components composing the color associated to the specified channel. Arguments: _cb – The asynchronous callback object. w – The channel index. red – The red component. A value between 0 and 255. green – The green component. A value between 0 and 255. blue – The blue component. A value between 0 and 255. alpha – The alpha component. A value between 0 and 255. current – The Current object for the invocation.

updateCodomainMap_async(_cb, mapCtx, current=None)

Updates the specified context. The codomain chain already contains the specified context. Each time a new context is updated, the second LUT is rebuilt. Arguments: _cb – The asynchronous callback object. mapCtx – The context to update. current – The Current object for the invocation.

updateSettings_async(_cb, settings, current=None)

Updates the current rendering settings based on a provided rendering definition and associated sub-objects. Arguments: _cb – The asynchronous callback object. settings – Rendering definition to copy from. Each sub-object will be processed as though the specific method was called with related attributes provided as arguments. The following methods are called underneath: {@code RenderingEngine.setModel} {@code RenderingEngine.setDefaultZ} {@code RenderingEngine.setDefaultT} {@code RenderingEngine.setQuantumStrategy} {@code RenderingEngine.setCodomainInterval} {@code RenderingEngine.setActive} {@code RenderingEngine.setChannelWindow} {@code RenderingEngine.setQuantizationMap} {@code RenderingEngine.setRGBA} {@code RenderingEngine.setChannelLookupTable} If one or more attributes that apply to a particular method are null it will be skipped in its entirety. The underlying Renderer is not able to handle partial field updates. Furthermore, ome.model.display.ChannelBinding references that are null and indexes in the {@code RenderingDef.WAVERENDERING} array greater than the currently looked up {@code Pixels.SIZEC} will be skipped. current – The Current object for the invocation.

class omero.api.RenderingEnginePrx

Bases: omero.api.PyramidServicePrx

Renders the data selected by def according to the current rendering settings. The passed argument selects a plane orthogonal to one of the X, Y, or Z axes. How many wavelengths are rendered and what color model is used depends on the current rendering settings. Arguments: _def – Selects a plane orthogonal to one of the X, Y, or Z axes. _ctx – The request context for the invocation. Returns: An RGB image ready to be displayed on screen. Throws: ValidationException – If def is null.

addCodomainMap(mapCtx, _ctx=None)
addCodomainMapToChannel(mapCtx, w, _ctx=None)
begin_addCodomainMap(mapCtx, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addCodomainMapToChannel(mapCtx, w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getAvailableFamilies(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getAvailableModels(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelCurveCoefficient(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelFamily(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelLookupTable(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelNoiseReduction(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelStats(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelWindowEnd(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getChannelWindowStart(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getCodomainMapContext(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getCompressionLevel(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getDefaultT(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getDefaultZ(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getModel(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixels(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsTypeLowerBound(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getPixelsTypeUpperBound(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getQuantumDef(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getRGBA(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getRenderingDefId(_response=None, _ex=None, _sent=None, _ctx=None)
begin_isActive(w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_isPixelsTypeSigned(_response=None, _ex=None, _sent=None, _ctx=None)
begin_load(_response=None, _ex=None, _sent=None, _ctx=None)
begin_loadRenderingDef(renderingDefId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupPixels(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_lookupRenderingDef(pixelsId, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeCodomainMap(mapCtx, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeCodomainMapFromChannel(mapCtx, w, _response=None, _ex=None, _sent=None, _ctx=None)
begin_render(_def, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderAsPackedInt(_def, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderCompressed(_def, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderProjectedAsPackedInt(algorithm, timepoint, stepping, start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_renderProjectedCompressed(algorithm, timepoint, stepping, start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_resetDefaultSettings(save, _response=None, _ex=None, _sent=None, _ctx=None)
begin_saveAsNewSettings(_response=None, _ex=None, _sent=None, _ctx=None)
begin_saveCurrentSettings(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setActive(w, active, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setChannelLookupTable(w, lookup, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setChannelWindow(w, start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setCodomainInterval(start, end, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setCompressionLevel(percentage, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setDefaultT(t, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setDefaultZ(z, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setModel(model, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setOverlays(tablesId, imageId, rowColorMap, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setQuantizationMap(w, family, 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)
begin_updateSettings(settings, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_addCodomainMap(_r)
end_addCodomainMapToChannel(_r)
end_getAvailableFamilies(_r)
end_getAvailableModels(_r)
end_getChannelCurveCoefficient(_r)
end_getChannelFamily(_r)
end_getChannelLookupTable(_r)
end_getChannelNoiseReduction(_r)
end_getChannelStats(_r)
end_getChannelWindowEnd(_r)
end_getChannelWindowStart(_r)
end_getCodomainMapContext(_r)
end_getCompressionLevel(_r)
end_getDefaultT(_r)
end_getDefaultZ(_r)
end_getModel(_r)
end_getPixels(_r)
end_getPixelsTypeLowerBound(_r)
end_getPixelsTypeUpperBound(_r)
end_getQuantumDef(_r)
end_getRGBA(_r)
end_getRenderingDefId(_r)
end_isActive(_r)
end_isPixelsTypeSigned(_r)
end_load(_r)
end_loadRenderingDef(_r)
end_lookupPixels(_r)
end_lookupRenderingDef(_r)
end_removeCodomainMap(_r)
end_removeCodomainMapFromChannel(_r)
end_render(_r)
end_renderAsPackedInt(_r)
end_renderCompressed(_r)
end_renderProjectedAsPackedInt(_r)
end_renderProjectedCompressed(_r)
end_resetDefaultSettings(_r)
end_saveAsNewSettings(_r)
end_saveCurrentSettings(_r)
end_setActive(_r)
end_setChannelLookupTable(_r)
end_setChannelWindow(_r)
end_setCodomainInterval(_r)
end_setCompressionLevel(_r)
end_setDefaultT(_r)
end_setDefaultZ(_r)
end_setModel(_r)
end_setOverlays(_r)
end_setQuantizationMap(_r)
end_setQuantumStrategy(_r)
end_setRGBA(_r)
end_updateCodomainMap(_r)
end_updateSettings(_r)
getAvailableFamilies(_ctx=None)
getAvailableModels(_ctx=None)
getChannelCurveCoefficient(w, _ctx=None)
getChannelFamily(w, _ctx=None)
getChannelLookupTable(w, _ctx=None)
getChannelNoiseReduction(w, _ctx=None)
getChannelStats(w, _ctx=None)
getChannelWindowEnd(w, _ctx=None)
getChannelWindowStart(w, _ctx=None)
getCodomainMapContext(w, _ctx=None)
getCompressionLevel(_ctx=None)
getDefaultT(_ctx=None)
getDefaultZ(_ctx=None)
getModel(_ctx=None)
getPixels(_ctx=None)
getPixelsTypeLowerBound(w, _ctx=None)
getPixelsTypeUpperBound(w, _ctx=None)
getQuantumDef(_ctx=None)
getRGBA(w, _ctx=None)
getRenderingDefId(_ctx=None)
static ice_staticId()
isActive(w, _ctx=None)
isPixelsTypeSigned(_ctx=None)
load(_ctx=None)
loadRenderingDef(renderingDefId, _ctx=None)
lookupPixels(pixelsId, _ctx=None)
lookupRenderingDef(pixelsId, _ctx=None)
removeCodomainMap(mapCtx, _ctx=None)
removeCodomainMapFromChannel(mapCtx, w, _ctx=None)
render(_def, _ctx=None)
renderAsPackedInt(_def, _ctx=None)
renderCompressed(_def, _ctx=None)
renderProjectedAsPackedInt(algorithm, timepoint, stepping, start, end, _ctx=None)
renderProjectedCompressed(algorithm, timepoint, stepping, start, end, _ctx=None)
resetDefaultSettings(save, _ctx=None)
saveAsNewSettings(_ctx=None)
saveCurrentSettings(_ctx=None)
setActive(w, active, _ctx=None)
setChannelLookupTable(w, lookup, _ctx=None)
setChannelWindow(w, start, end, _ctx=None)
setCodomainInterval(start, end, _ctx=None)
setCompressionLevel(percentage, _ctx=None)
setDefaultT(t, _ctx=None)
setDefaultZ(z, _ctx=None)
setModel(model, _ctx=None)
setOverlays(tablesId, imageId, rowColorMap, _ctx=None)
setQuantizationMap(w, family, coefficient, noiseReduction, _ctx=None)
setQuantumStrategy(bitResolution, _ctx=None)
setRGBA(w, red, green, blue, alpha, _ctx=None)
static uncheckedCast(proxy, facet=None)
updateCodomainMap(mapCtx, _ctx=None)
updateSettings(settings, _ctx=None)
class omero.api.ResolutionDescription(sizeX=0, sizeY=0)

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object>
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 ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.api.RoiOptions(shapes=None, limit=None, offset=None, userId=None, groupId=None)

Bases: Ice.Object

Specifies filters used when querying the ROIs.

_ice_type = <IcePy.TypeInfo object>
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 ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.api.RoiResult(opts=None, rois=None, byZ=None, byT=None)

Bases: Ice.Object

Returned by most search methods. The RoiOptions is the options object passed into a method, possibly modified by the server if some value was out of range. The RoiList contains all the Rois which matched the given query. The individual shapes of the Rois which matched can be found in the indexes. For example, all the shapes on z=1 can by found by: ShapeList shapes = byZ.get(1); Shapes which are found on all z or t can be found with: byZ.get(-1); byT.get(-1); respectively.

_ice_type = <IcePy.TypeInfo object>
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 ice_staticId()
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>
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 ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.api.Save(obj=None)

Bases: omero.cmd.Request

_ice_type = <IcePy.TypeInfo object>
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 ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.api.SaveRsp(obj=None)

Bases: omero.cmd.Response

_ice_type = <IcePy.TypeInfo object>
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 ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.api.Search

Bases: omero.api.StatefulServiceInterface

Central search interface, allowing Web2.0 style queries. Each omero.api.Search instance keeps up with several queries and lazily-loads the results as {@code hasNext}, {@code next} and {@code results} are called. These queries are created by the by* methods. Each instance also has a number of settings which can all be changed from their defaults via accessors, e.g. {@code setBatchSize} or {@code setCaseSensitive}. The only methods which are required for the proper functioning of a Search instance are: {@code onlyType}, {@code onlyTypes} OR {@code allTypes} Any by* method to create a query Use of the {@code allTypes} method is discouraged, since it is possibly very resource intensive, which is why any attempt to receive results without specifically setting types or allowing all is prohibited.

_ice_type = <IcePy.TypeInfo object at 0x3561078>
_op_activeQueries = <IcePy.Operation object>
_op_addOrderByAsc = <IcePy.Operation object>
_op_addOrderByDesc = <IcePy.Operation object>
_op_allTypes = <IcePy.Operation object>
_op_and = <IcePy.Operation object>
_op_byAnnotatedWith = <IcePy.Operation object>
_op_byFullText = <IcePy.Operation object>
_op_byGroupForTags = <IcePy.Operation object>
_op_byHqlQuery = <IcePy.Operation object>
_op_byLuceneQueryBuilder = <IcePy.Operation object>
_op_bySimilarTerms = <IcePy.Operation object>
_op_bySomeMustNone = <IcePy.Operation object>
_op_byTagForGroups = <IcePy.Operation object>
_op_clearQueries = <IcePy.Operation object>
_op_currentMetadata = <IcePy.Operation object>
_op_currentMetadataList = <IcePy.Operation object>
_op_fetchAlso = <IcePy.Operation object>
_op_fetchAnnotations = <IcePy.Operation object>
_op_getBatchSize = <IcePy.Operation object>
_op_hasNext = <IcePy.Operation object>
_op_isAllowLeadingWildcard = <IcePy.Operation object>
_op_isCaseSensitive = <IcePy.Operation object>
_op_isMergedBatches = <IcePy.Operation object>
_op_isReturnUnloaded = <IcePy.Operation object>
_op_isUseProjections = <IcePy.Operation object>
_op_next = <IcePy.Operation object>
_op_not = <IcePy.Operation object>
_op_notAnnotatedBy = <IcePy.Operation object>
_op_notOwnedBy = <IcePy.Operation object>
_op_onlyAnnotatedBetween = <IcePy.Operation object>
_op_onlyAnnotatedBy = <IcePy.Operation object>
_op_onlyAnnotatedWith = <IcePy.Operation object>
_op_onlyCreatedBetween = <IcePy.Operation object>
_op_onlyIds = <IcePy.Operation object>
_op_onlyModifiedBetween = <IcePy.Operation object>
_op_onlyOwnedBy = <IcePy.Operation object>
_op_onlyType = <IcePy.Operation object>
_op_onlyTypes = <IcePy.Operation object>
_op_or = <IcePy.Operation object>
_op_remove = <IcePy.Operation object>
_op_resetDefaults = <IcePy.Operation object>
_op_results = <IcePy.Operation object>
_op_setAllowLeadingWildcard = <IcePy.Operation object>
_op_setBatchSize = <IcePy.Operation object>
_op_setCaseSensitive = <IcePy.Operation object>
_op_setCaseSentivice = <IcePy.Operation object>
_op_setMergedBatches = <IcePy.Operation object>
_op_setReturnUnloaded = <IcePy.Operation object>
_op_setUseProjections = <IcePy.Operation object>
_op_unordered = <IcePy.Operation object>
activeQueries_async(_cb, current=None)

Returns the number of active queries. This means that {@code activeQueries} gives the minimum number of remaining calls to {@code results} when batches are not merged. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

addOrderByAsc_async(_cb, path, current=None)

A path from the target entity which will be added to the current stack of order statements applied to the query. Arguments: _cb – The asynchronous callback object. path – Non-null. current – The Current object for the invocation.

addOrderByDesc_async(_cb, path, current=None)

A path from the target entity which will be added to the current stack of order statements applied to the query. Arguments: _cb – The asynchronous callback object. path – Non-null. current – The Current object for the invocation.

allTypes_async(_cb, current=None)

Permits all types to be returned. For some types of queries, this carries a performance penalty as every database table must be hit. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

and_async(_cb, current=None)

Applies the next by* method to the previous by* method, so that a call {@code hasNext}, {@code next}, or {@code results} sees only the intersection of the two calls. For example, {@code service.onlyType(Image.class); service.byFullText(&quot;foo&quot;); service.intersection(); service.byAnnotatedWith(TagAnnotation.class); } will return only the Images with TagAnnotations. Calling this method overrides a previous setting of {@code or} or {@code not}. If there is no active queries (i.e. {@code activeQueries > 0}), then an omero.ApiUsageException will be thrown. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

byAnnotatedWith_async(_cb, examples, current=None)

Finds entities annotated with an omero.model.Annotation similar to the example. This does not use Hibernate’s {@code omero.api.IQuery.findByExample} Query-By-Example} mechanism, since that cannot handle joins. The fields which are used are: the main content of the annotation : String, omero.model.OriginalFile#getId(), etc. If the main content is null it is assumed to be a wildcard searched, and only the type of the annotation is searched. Currently, ListAnnotations are not supported. Arguments: _cb – The asynchronous callback object. examples – Not empty. current – The Current object for the invocation.

byFullText_async(_cb, query, current=None)

Passes the query as is to the Lucene backend. Arguments: _cb – The asynchronous callback object. query – May not be null or of zero length. current – The Current object for the invocation.

byGroupForTags_async(_cb, group, current=None)

Returns transient (without ID) omero.model.TagAnnotation instances which represent all the omero.model.TagAnnotation tags in the given group. The entities are transient and without ownership since multiple users can own the same tag. This method will override settings for types. Arguments: _cb – The asynchronous callback object. group – Can be null or empty to return all tags. current – The Current object for the invocation.

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

Delegates to {@code omero.api.IQuery.findAllByQuery} method to take advantage of the {@code and}, {@code or}, and {@code not} methods, or queue-semantics. Arguments: _cb – The asynchronous callback object. query – Not null. params – May be null. Defaults are then in effect. current – The Current object for the invocation.

byLuceneQueryBuilder_async(_cb, fields, _from, to, dateType, query, current=None)

Builds a Lucene query and passes it to the Lucene backend. Arguments: _cb – The asynchronous callback object. fields – The fields (comma separated) to search in (name, description, ...) _from – The date range from, in the form YYYYMMDD (may be null) to – The date range to (inclusive), in the form YYYYMMDD (may be null) dateType – {@code DATE_TYPE_ACQUISITION} or {@code DATE_TYPE_IMPORT} query – May not be null or of zero length. current – The Current object for the invocation.

bySimilarTerms_async(_cb, terms, current=None)

Returns transient (without ID) omero.model.TextAnnotation instances which represent terms which are similar to the given terms. For example, if the argument is cell, one return value might have as its textValue: cellular while another has cellularize. No filtering or fetching is performed. Arguments: _cb – The asynchronous callback object. terms – Cannot be empty. current – The Current object for the invocation.

bySomeMustNone_async(_cb, some, must, none, current=None)

Builds a Lucene query and passes it to {@code byFullText}. Arguments: _cb – The asynchronous callback object. some – Some (at least one) of these terms must be present in the document. May be null. must – All of these terms must be present in the document. May be null. none – None of these terms may be present in the document. May be null. current – The Current object for the invocation.

byTagForGroups_async(_cb, tag, current=None)

Creates a query which will return transient (without ID) omero.model.TagAnnotation instances which represent all the omero.model.TagAnnotation tag groups which the given tag belongs to. The entities are transient and without ownership since multiple users can own the same tag group. This method will override settings for types. Arguments: _cb – The asynchronous callback object. tag – Can be null or empty to return all groups. current – The Current object for the invocation.

clearQueries_async(_cb, current=None)

Removes all active queries (leaving {@code resetDefaults} settings alone), such that {@code activeQueries} will return 0. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

currentMetadataList_async(_cb, current=None)

Provides access to the extra query information (for example Lucene score and boost values) for a single call to {@code results}. This method may only be called once for any given call to {@code results}. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

currentMetadata_async(_cb, current=None)

Provides access to the extra query information (for example Lucene score and boost values) for a single call to {@code next}. This method may only be called once for any given call to {@code next}. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

fetchAlso_async(_cb, fetches, current=None)

Adds a fetch clause for loading non-annotation fields of returned entities. Each fetch is a hibernate clause in dot notation. Arguments: _cb – The asynchronous callback object. fetches – Can be empty, which removes previous fetch setting. current – The Current object for the invocation.

fetchAnnotations_async(_cb, classes, current=None)

Queries the database for all omero.model.Annotation annotations of the given types for all returned instances. Arguments: _cb – The asynchronous callback object. classes – Can be empty, which removes previous fetch setting. current – The Current object for the invocation.

getBatchSize_async(_cb, current=None)

Returns the current batch size. If {@code setBatchSize} has not been called, the default value will be in effect. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

hasNext_async(_cb, current=None)

Returns true if another call to {@code next} is valid. A call to {@code next} may throw an exception for another reason, however. Arguments: _cb – The asynchronous callback object. current – The Current object for the invocation.

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