omero.grid package

Module contents

class omero.grid.BoolColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.BoolColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.Column(name='', description='')

Bases: Ice.Object

Base type for dealing working with tabular data. For efficiency, data is grouped by type, i.e. column. These value objects are passed through the {@code Table} interface.

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.ColumnPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.Data(lastModification=0, rowNumbers=None, columns=None)

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.DataPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.DatasetColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.DatasetColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.DoubleArrayColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.DoubleArrayColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.DoubleColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.DoubleColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.FileColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.FileColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
exception omero.grid.FileDeleteException(serverStackTrace='', serverExceptionClass='', message='')

Bases: omero.grid.RepositoryException

Specifies that a file with the given path has failed to be deleted from the file system.

_ice_name = 'omero::grid::FileDeleteException'
_ice_type = <IcePy.ExceptionInfo object at 0x3561510>
class omero.grid.FloatArrayColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.FloatArrayColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.ImageColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.ImageColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.ImportLocation(sharedPath='', omittedLevels=0, usedFiles=None, directory=None)

Bases: Ice.Object

Returned by {@code ManagedRepository.importFileset} with the information needed to proceed with an FS import. For the examples that follow, assume that the used files passed to importFileset were: /Users/jack/Documents/Data/Experiment-1/1.dv /Users/jack/Documents/Data/Experiment-1/1.dv.log /Users/jack/Documents/Data/Experiment-2/2.dv /Users/jack/Documents/Data/Experiment-2/2.dv.log Members: sharedPath – The shared base of all the paths passed to the server. omittedLevels – Number of directories which have been omitted from the original paths passed to the server. usedFiles – Parsed string names which should be used by the clients during upload. This array will be of the same length as the argument passed to {@code ManagedRepository.importFileset} but will have shortened paths. Experiment/1.dv Experiment/1.dv.log directory – Represents the directory to which all files will be uploaded.

_ice_type = <IcePy.TypeInfo object at 0x3561690>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.ImportLocationPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.ImportProcess

Bases: omero.api.StatefulServiceInterface

User configuration options. These are likely set in the UI before the import is initiated.

_ice_type = <IcePy.TypeInfo object at 0x35616f0>
_op_getHandle = <IcePy.Operation object at 0x3561750>
_op_getImportSettings = <IcePy.Operation object at 0x3561768>
_op_getUploadOffset = <IcePy.Operation object at 0x3561738>
_op_getUploader = <IcePy.Operation object at 0x3561708>
_op_verifyUpload = <IcePy.Operation object at 0x3561720>
getHandle(current=None)

Reacquire the handle which was returned by {@code verifyUpload}. This is useful in case a new client is re-attaching to a running import. From the omero.cmd.Handle instance, the original {@code ImportRequest} can also be found. Arguments: current – The Current object for the invocation.

getImportSettings(current=None)
getUploadOffset(i, current=None)

In case an upload must be resumed, this provides the location of the last successful upload. Arguments: i – current – The Current object for the invocation.

getUploader(i, current=None)

Step 1: Returns a RawFileStore that can be used to upload one of the used files. The index is the same as the used file listed in {@code ImportLocation}. {@code omero.api.RawFileStore.close} should be called once all data has been transferred. If the file must be re-written, call {@code getUploader} with the same index again. Once all uploads have been completed, {@code verifyUpload} should be called to initiate background processing Arguments: i – current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
verifyUpload(hash, current=None)

Step 2: Passes a set of client-side calculated hashes to the server for verifying that all of the files were correctly uploaded. If this passes then a omero.cmd.Handle proxy is returned, which completes all the necessary import steps. A successful import will return an {@code ImportResponse}. Otherwise, some omero.cmd.ERR will be returned. Arguments: hash – current – The Current object for the invocation.

class omero.grid.ImportProcessPrx

Bases: omero.api.StatefulServiceInterfacePrx

Step 1: Returns a RawFileStore that can be used to upload one of the used files. The index is the same as the used file listed in {@code ImportLocation}. {@code omero.api.RawFileStore.close} should be called once all data has been transferred. If the file must be re-written, call {@code getUploader} with the same index again. Once all uploads have been completed, {@code verifyUpload} should be called to initiate background processing Arguments: i – _ctx – The request context for the invocation.

begin_getHandle(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getImportSettings(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getUploadOffset(i, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getUploader(i, _response=None, _ex=None, _sent=None, _ctx=None)
begin_verifyUpload(hash, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_getHandle(_r)
end_getImportSettings(_r)
end_getUploadOffset(_r)
end_getUploader(_r)
end_verifyUpload(_r)
getHandle(_ctx=None)
getImportSettings(_ctx=None)
getUploadOffset(i, _ctx=None)
getUploader(i, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
verifyUpload(hash, _ctx=None)
class omero.grid.ImportRequest(clientUuid='', repoUuid='', process=None, activity=None, settings=None, location=None, logFile=None)

Bases: omero.cmd.Request

Command object which will be used to create the omero.cmd.Handle instances passed back by the {@code ImportProcess}. Members: clientUuid – Lookup value for the session that import is taking part in. repoUuid – Repository which is responsible for this import. All files which are uploaded will be available from it. process – Proxy of the process which this request will be running in. This value will be filled in for possible later re-use, but is not read by the server. activity – Activity that this will be filling out in the database. This always points to a omero.model.MetadataImportJob which is the first server-side phase after the omero.model.UploadJob. settings – ImportSettings which are provided by the client on the call to {@code ManagedRepository.importFileset}. location – ImportLocation which is calculated during the call to {@code ManagedRepository.importFileset}. logFile – omero.model.OriginalFile object representing the import log file.

_ice_type = <IcePy.TypeInfo object at 0x35617b0>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.ImportRequestPrx

Bases: omero.cmd.RequestPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.ImportResponse(pixels=None, objects=None)

Bases: omero.cmd.OK

Successful response returned from execution of ImportRequest. This is the simplest way to return the results, but is likely not the overall best strategy. Members: pixels – objects – Top-level OME-XML objects which are created during the import. This will not contain any pixels which were imported, but images, plates, etc. which may be useful for user feedback.

_ice_type = <IcePy.TypeInfo object at 0x35617e0>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.ImportResponsePrx

Bases: omero.cmd.OKPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.ImportSettings(userSpecifiedTarget=None, userSpecifiedName=None, userSpecifiedDescription=None, userSpecifiedPixels=None, userSpecifiedAnnotationList=None, doThumbnails=None, noStatsInfo=None, checksumAlgorithm=None)

Bases: Ice.Object

User configuration options. These are likely set in the UI before the import is initiated. Members: userSpecifiedTarget – The container which this object should be added to. userSpecifiedName – Custom name suggested by the user. userSpecifiedDescription – Custom description suggested by the user. userSpecifiedPixels – User choice of pixels sizes. userSpecifiedAnnotationList – Annotations that the user doThumbnails – Whether or not the thumbnailing action should be performed. noStatsInfo – Whether we are to disable StatsInfo population. checksumAlgorithm – User choice of checksum algorithm for verifying upload.

_ice_type = <IcePy.TypeInfo object at 0x35616c0>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.ImportSettingsPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.InteractiveProcessor

Bases: Ice.Object

Client facing interface to the background processing framework. If a user needs interactivity, one of these processors should be acquired from the ServiceFactory. Otherwise, a Job can be submitted via JobHandle.

_ice_type = <IcePy.TypeInfo object at 0x213f360>
_op_execute = <IcePy.Operation object at 0x213f3c0>
_op_expires = <IcePy.Operation object at 0x213f378>
_op_getJob = <IcePy.Operation object at 0x213f390>
_op_getResults = <IcePy.Operation object at 0x213f3d8>
_op_params = <IcePy.Operation object at 0x213f3a8>
_op_setDetach = <IcePy.Operation object at 0x213f3f0>
_op_stop = <IcePy.Operation object at 0x213f408>
execute(inputs, current=None)

Executes an instance of the job returned by getJob() using the given map as inputs. Arguments: inputs – current – The Current object for the invocation.

expires(current=None)

Returns the system clock time in milliseconds since the epoch at which this processor will be reaped. Arguments: current – The Current object for the invocation.

getJob(current=None)

Returns the job which defines this processor. This may be only the last job associated with the processor if execute is called multiple times. Arguments: current – The Current object for the invocation.

getResults(proc, current=None)

Retrieve the results for the given process. This will throw an ApiUsageException if called before the process has returned. Use either process.poll() or process.wait() or a ProcessCallback to wait for completion before calling. If the user has not overridden or disabled the output values “stdout” and “stderr”, these will be filled with the OriginalFile instances uploaded after completion under the key values of the same name. Arguments: proc – current – The Current object for the invocation.

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

Retrieves the parameters needed to be passed in an execution and the results which will be passed back out. This method is guaranteed to return a non-null value or throw an exception. Arguments: current – The Current object for the invocation.

setDetach(detach, current=None)

Sets whether or not cancel will be called on the current Process on stop. If detach is true, then the Process will continue running. Otherwise, Process#cancel will be called, before preparing for another run. false by default Arguments: detach – current – The Current object for the invocation.

stop(current=None)

Clears the current execution of omero.model.Job from the processor to prepare for another execution. cancel() will be called on the current Process if detach is set to false. Arguments: current – The Current object for the invocation.

class omero.grid.InteractiveProcessorPrx

Bases: IcePy.ObjectPrx

Returns the system clock time in milliseconds since the epoch at which this processor will be reaped. Arguments: _ctx – The request context for the invocation.

begin_execute(inputs, _response=None, _ex=None, _sent=None, _ctx=None)
begin_expires(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getJob(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getResults(proc, _response=None, _ex=None, _sent=None, _ctx=None)
begin_params(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setDetach(detach, _response=None, _ex=None, _sent=None, _ctx=None)
begin_stop(_response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_execute(_r)
end_expires(_r)
end_getJob(_r)
end_getResults(_r)
end_params(_r)
end_setDetach(_r)
end_stop(_r)
execute(inputs, _ctx=None)
expires(_ctx=None)
getJob(_ctx=None)
getResults(proc, _ctx=None)
static ice_staticId()
params(_ctx=None)
setDetach(detach, _ctx=None)
stop(_ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.grid.InternalRepository

Bases: Ice.Object

Internal portion of the API used for management. Not available to clients.

_ice_type = <IcePy.TypeInfo object at 0x35618e8>
_op_createRawFileStore = <IcePy.Operation object at 0x3561900>
_op_createRawPixelsStore = <IcePy.Operation object at 0x3561918>
_op_createRenderingEngine = <IcePy.Operation object at 0x3561930>
_op_createThumbnailStore = <IcePy.Operation object at 0x3561948>
_op_getDescription = <IcePy.Operation object at 0x3561960>
_op_getFilePath = <IcePy.Operation object at 0x35619a8>
_op_getProxy = <IcePy.Operation object at 0x3561978>
_op_rawAccess = <IcePy.Operation object at 0x3561990>
createRawFileStore(file, current=None)
createRawPixelsStore(file, current=None)
createRenderingEngine(file, current=None)
createThumbnailStore(file, current=None)
getDescription(current=None)
getFilePath(file, current=None)
getProxy(current=None)
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
rawAccess(raw, current=None)
class omero.grid.InternalRepositoryPrx

Bases: IcePy.ObjectPrx

begin_createRawFileStore(file, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createRawPixelsStore(file, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createRenderingEngine(file, _response=None, _ex=None, _sent=None, _ctx=None)
begin_createThumbnailStore(file, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getDescription(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getFilePath(file, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getProxy(_response=None, _ex=None, _sent=None, _ctx=None)
begin_rawAccess(raw, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
createRawFileStore(file, _ctx=None)
createRawPixelsStore(file, _ctx=None)
createRenderingEngine(file, _ctx=None)
createThumbnailStore(file, _ctx=None)
end_createRawFileStore(_r)
end_createRawPixelsStore(_r)
end_createRenderingEngine(_r)
end_createThumbnailStore(_r)
end_getDescription(_r)
end_getFilePath(_r)
end_getProxy(_r)
end_rawAccess(_r)
getDescription(_ctx=None)
getFilePath(file, _ctx=None)
getProxy(_ctx=None)
static ice_staticId()
rawAccess(raw, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.grid.JobParams(name='', version='', description='', contact='', authors=None, institutions=None, authorsInstitutions=None, inputs=None, outputs=None, stdoutFormat='', stderrFormat='', namespaces=None)

Bases: omero.Internal

Complete job description with all input and output Params. JobParams contain information about who wrote a script, what its purpose is, and how it should be used, and are defined via the “omero.scripts.client” method. c = omero.scripts.client(name=”my algorithm”, version=”0.0.1”) Alternatively, a JobParams instance can be passed into the constructor: params = omero.grid.JobParams() params.authors = [“Andy”, “Kathy”] params.version = “0.0.1” params.description = “”” Clever way to count to 5 “”” c = omero.scripts.client(params) A single JobParam instance is parsed from a script and stored by the server. Later invocations re-use this instance until the script changes. Members: name – Descriptive name for this script. This value should be unique where possible, but no assurance is provided by the server that multiple scripts with the same name are not present. version – Author-given version number for this script. Please see the script authors’ guide for information about choosing version numbers. description – A general description of a script, including documentation on how it should be used, what data it will access, and other metrics like how long it takes to execute, etc. contact – Single, human-readable string for how to contact the script author. authors – Information about the authors who took part in creating this script. No particular format is required. institutions – Information about the institutions which took part in creating this script. No particular format is required. authorsInstitutions – For authors[i], authorInstitutions[i] should be and array of indexes j such that author i is a member of authorsInstitutions[i][j]. Example: authors = [“Jane”, “Mike”] institutions = [“Acme U.”, “Private Corp.”] authorsInstitutions = [[1, 2], [1]] which means that Jane is a member of both “Acme U.” and “Private Corp.” while Mike is only a member of “Acme U.” An empty authorsInstitutions array implies that all authors are from all institutions. inputs – Definitive list of the inputs which MAY or MUST be provided to the script, based on the “optional” flag. outputs – Definitive list of the outputs which MAY or MUST be provided to the script, based on the “optional” flag. stdoutFormat – {@code omero.model.Format.value} of the stdout stream produced by the script. If this value is not otherwise set (i.e. is None), the default of “text/plain” will be set. This is typically a good idea if the script uses “print” or the logging module. If you would like to disable stdout upload, set the value to “” (the empty string). “text/html” or “application/octet-stream” might also be values of interest. stderrFormat – {@code omero.model.Format.value} of the stderr stream produced by the script. If this value is not otherwise set (i.e. is None), the default of “text/plain” will be set. This is typically a good idea if the script uses “print” or the logging module. If you would like to disable stderr upload, set the value to “” (the empty string). “text/html” or “application/octet-stream” might also be values of interest. namespaces – Defines machine readable interpretations for this {@code JobParams}. Where the description field should provide information for users, the assigned namespaces can define how clients may interpret the script, including which categories or algorithm types the script belongs to.

_ice_type = <IcePy.TypeInfo object at 0x213f048>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.JobParamsPrx

Bases: omero.InternalPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.LongArrayColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.LongArrayColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.LongColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.LongColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.ManagedRepository

Bases: omero.grid.Repository

FS-enabled repository which can convert uploaded files into Images by using Bio-Formats to import them.

_ice_type = <IcePy.TypeInfo object at 0x35610d8>
_op_importFileset = <IcePy.Operation object at 0x35617f8>
_op_importPaths = <IcePy.Operation object at 0x3561810>
_op_listChecksumAlgorithms = <IcePy.Operation object at 0x3561840>
_op_listImports = <IcePy.Operation object at 0x3561828>
_op_setChecksumAlgorithm = <IcePy.Operation object at 0x3561888>
_op_suggestChecksumAlgorithm = <IcePy.Operation object at 0x3561858>
_op_verifyChecksums = <IcePy.Operation object at 0x3561870>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
importFileset(fs, settings, current=None)

Returns an ImportProcess which can be used to upload files. On ImportProcess#verifyUpload, an omero.cmd.Handle will be returned which can be watched for knowing when the server-side import is complete. Client paths set in the fileset entries must /-separate their components. Once the upload is complete, the ImportProcess must be closed. Once omero.cmd.Handle#getResponse returns a non-null value, the handle instance can and must be closed. Arguments: fs – settings – current – The Current object for the invocation.

importPaths(filePaths, current=None)

For clients without access to Bio-Formats, the simplified {@code importPaths} method allows passing solely the absolute path of the files to be uploaded (no directories) and all configuration happens server-side. Much of the functionality provided via omero.model.Fileset and omero.grid.ImportSettings is of course lost. Arguments: filePaths – current – The Current object for the invocation.

listChecksumAlgorithms(current=None)

Return the list of checksum algorithms supported by this repository for verifying the integrity of uploaded files. They are named as “”algorithm-integer””, integer being the bit width of the resulting hash code. It is possible for the same algorithm to be offered with different bit widths. They are listed in descending order of preference, as set by the server administrator, and any of them may be specified for ImportSettings#checksumAlgorithm. Arguments: current – The Current object for the invocation.

listImports(current=None)

List imports that are currently running in this importer. These will be limited based on user/group membership for the omero.model.Fileset object which is being created by the import. If the user has write permissions for the fileset, then the import will be included. Arguments: current – The Current object for the invocation.

setChecksumAlgorithm(hasher, ids, current=None)

Set the checksum algorithm for the original files identified by the given IDs and calculate their checksum accordingly. The files must be in this repository. Existing checksums are checked before being changed. If a checksum does not match, ServerError will be thrown; in this case some other files may already have had their checksum algorithm set. Returns the IDs of the original files that did not already have a checksum set for the given algorithm. Arguments: hasher – ids – current – The Current object for the invocation.

suggestChecksumAlgorithm(supported, current=None)

Suggest a checksum algorithm to use for ImportSettings#checksumAlgorithm according to the preferences set by the server administrator. Provide a list of the algorithms supported by the client, and the server will report which of them is most preferred by the server, or return null if none of them are supported. Arguments: supported – current – The Current object for the invocation.

verifyChecksums(ids, current=None)

Verify the checksum for the original files identified by the given IDs. The files must be in this repository. Returns the IDs of the original files whose checksums do not match the file on disk. Arguments: ids – current – The Current object for the invocation.

class omero.grid.ManagedRepositoryPrx

Bases: omero.grid.RepositoryPrx

Returns an ImportProcess which can be used to upload files. On ImportProcess#verifyUpload, an omero.cmd.Handle will be returned which can be watched for knowing when the server-side import is complete. Client paths set in the fileset entries must /-separate their components. Once the upload is complete, the ImportProcess must be closed. Once omero.cmd.Handle#getResponse returns a non-null value, the handle instance can and must be closed. Arguments: fs – settings – _ctx – The request context for the invocation.

begin_importFileset(fs, settings, _response=None, _ex=None, _sent=None, _ctx=None)
begin_importPaths(filePaths, _response=None, _ex=None, _sent=None, _ctx=None)
begin_listChecksumAlgorithms(_response=None, _ex=None, _sent=None, _ctx=None)
begin_listImports(_response=None, _ex=None, _sent=None, _ctx=None)
begin_setChecksumAlgorithm(hasher, ids, _response=None, _ex=None, _sent=None, _ctx=None)
begin_suggestChecksumAlgorithm(supported, _response=None, _ex=None, _sent=None, _ctx=None)
begin_verifyChecksums(ids, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_importFileset(_r)
end_importPaths(_r)
end_listChecksumAlgorithms(_r)
end_listImports(_r)
end_setChecksumAlgorithm(_r)
end_suggestChecksumAlgorithm(_r)
end_verifyChecksums(_r)
static ice_staticId()
importFileset(fs, settings, _ctx=None)
importPaths(filePaths, _ctx=None)
listChecksumAlgorithms(_ctx=None)
listImports(_ctx=None)
setChecksumAlgorithm(hasher, ids, _ctx=None)
suggestChecksumAlgorithm(supported, _ctx=None)
static uncheckedCast(proxy, facet=None)
verifyChecksums(ids, _ctx=None)
class omero.grid.MaskColumn(name='', description='', imageId=None, theZ=None, theT=None, x=None, y=None, w=None, h=None, bytes=None)

Bases: omero.grid.Column

Column requiring special handling.

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.MaskColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.Param(description='', optional=False, useDefault=False, prototype=None, min=None, max=None, values=None, grouping='', namespaces=None)

Bases: Ice.Object

A single parameter to a Job. For example, used by ScriptJobs to define what the input and output environment variables should be. Helper classes are available in the Python omero.scripts module, so that the following are equivalent: # 1 a = omero.grid.Params() a.optional = True a.prototype = omero.rtypes.rstring(“”) a.description = “An optional string which will be ignored by the script” omero.scripts.client(inputs = {“a”:a}) # 2 a = omero.scripts.String(“a”, optional=True, description= * “An optional string which will be ignored by the script”) omero.scripts.client(a) For advanced setters not available on the Type classes (like omero.script.String) use the getter type.param() and then set values directly. a = omero.scripts.String(“a”) a.param().values = [“hi”, “bye”] Members: description – Usage documentation of this param for script users. Example of a bad description: “”a long value”” Example of a good description: “”long representing the number of bins to be used by . A sensible value would be between 16 and 32”” optional – Whether or not a script will require this value to be present in the input or output. If an input is missing or None when non-optional, then a omero.ValidationException will be thrown on {@code processJob}. A missing output param will be marked after execution. useDefault – Whether or not the prototype should be used as a default. If true, then if the value is missing from the input OR output values, the prototype will be substituted. param = ...; inputs = ...; if name in inputs: value = inputs[name] elif param.inputs[name].useDefault: value = param.inputs[name].prototype prototype – omero.RType which represents what the input or output value should look like. If this is a collection type (i.e. omero.RCollection or omero.RMap or their subclasses), then the first contents of the collection will be used (recursively). param.prototype = rlist(rlist(rstring))) requires that a list of list of strings be passed. min – Minimum value which an input may contain. If the prototype is a collection type, then the min type must match the type of the innermost non-collection instance. For example, param.prototype = rlong(0) param.min = rlong(-5) but param.prototype = rlist(rlong(0)) param.min = rlong(-5) max – Maximum value which an input may contain. If the prototype is a collection type, then the max type must match the type of the innermost non-collection instance. For example, param.prototype = rlong(0) param.max = rlong(5) but param.prototype = rlist(rlong(0)) param.max = rlong(5) values – An enumeration of acceptable values which can be used for this parameter. If {@code min} and {@code max} are set, this value will be ignored. If {@code prototype} is an omero.RCollection or omero.RMap instance, then the values in this omero.RList will be of the member types of the collection or map, and not a collection or map instance. grouping – Defines the grouping strategy for this Param. A set of {@code Param} objects in a single {@code JobParams} can use dot notation to specify that they belong together, and in which order they should be presented to the user. inputs = {“a” : Param(..., grouping = “1.1”), “b” : Param(..., grouping = “1.2”), “c” : Param(..., grouping = “2.2”), “d” : Param(..., grouping = “2.1”)} defines two groups of parameters which might be display to the user so: Group 1: Group 2: +———————–+ +———————–+ | a: | | d: | +———————–+ +———————–+ | b: | | c: | +———————–+ +———————–+ Further dots (e.g. “1.2.3.5”) can be used to specify deeper trees of parameters. By most clients, Params missing grouping values (e.g. “”) will be ordered after params with grouping values. A group which has a boolean as the top-level object can be thought of as a checkbox which turns on or off all of the other group members. For example, inputs = {“Image_Ids” : Param(prototype=rlist(), grouping = “1”), “Scale_Bar” : Param(prototype=rbool(), grouping = “2”), “Color” : Param(prototype=rinternal(Color()), grouping = “2.1”), “Size” : Param(prototype=rlong(), grouping = “2.2”)} might be displayed as: Scale Bar: [ on/off ] ====================== Color: [rgb] Size: [ 10] namespaces – Defines machine readable interpretations for this parameter. Where the description field should provide information for users, the assigned namespaces can define how clients may interpret the param. {@code omero.constants.namespaces.NSDOWNLOAD}, for example, indicates that users may want to download the resulting file. The {@code prototype} of the {@code Param} should be one of: omero.model.OriginalFile, omero.model.FileAnnotation, or an annotation link (like omero.model.ImageAnnotationLink) which points to a file annotation.

_ice_type = <IcePy.TypeInfo object at 0x1e34fc0>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.ParamPrx

Bases: IcePy.ObjectPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.PlateColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.PlateColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.Process

Bases: Ice.Object

Thin wrapper around a system-level process. Most closely resembles Python’s subprocess.Popen class.

_ice_type = <IcePy.TypeInfo object at 0x213f0f0>
_op_cancel = <IcePy.Operation object at 0x213f138>
_op_kill = <IcePy.Operation object at 0x213f150>
_op_poll = <IcePy.Operation object at 0x213f108>
_op_registerCallback = <IcePy.Operation object at 0x213f180>
_op_shutdown = <IcePy.Operation object at 0x213f168>
_op_unregisterCallback = <IcePy.Operation object at 0x213f198>
_op_wait = <IcePy.Operation object at 0x213f120>
cancel(current=None)

Signal to the Process that it should terminate. This may be done “softly” for a given time period. Arguments: current – The Current object for the invocation.

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

Terminate the Process immediately. Arguments: current – The Current object for the invocation.

poll(current=None)

Returns the return code of the process, or null if unfinished. Arguments: current – The Current object for the invocation.

registerCallback(cb, current=None)

Add a callback for end-of-life events Arguments: cb – current – The Current object for the invocation.

shutdown(current=None)

First attempts cancel() several times and finally resorts to kill to force the process to shutdown cleanly. This method doesn’t return any value or throw an exception so that it can be called oneway. Arguments: current – The Current object for the invocation.

unregisterCallback(cb, current=None)

Remove a callback for end-of-life events Arguments: cb – current – The Current object for the invocation.

wait(current=None)

Blocks until poll() would return a non-null return code. Arguments: current – The Current object for the invocation.

class omero.grid.ProcessCallback

Bases: Ice.Object

Callback which can be attached to a Process with notification of any of the possible ends-of-life that a Process might experience

_ice_type = <IcePy.TypeInfo object at 0x213f078>
_op_processCancelled = <IcePy.Operation object at 0x213f0a8>
_op_processFinished = <IcePy.Operation object at 0x213f090>
_op_processKilled = <IcePy.Operation object at 0x213f0c0>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
processCancelled(success, current=None)

cancel() was called on this Process. If the Process failed to terminate, argument is false, in which calling kill() is the last resort. Arguments: success – current – The Current object for the invocation.

processFinished(returncode, current=None)

Process terminated normally. Return code provided. In the case that a non-Blitz process sent a signal (KILL, TERM, ... ), that will represented in the return code. Arguments: returncode – current – The Current object for the invocation.

processKilled(success, current=None)

kill() was called on this Process. If this does not succeed, there is nothing else that Blitz can do to stop its execution. Arguments: success – current – The Current object for the invocation.

class omero.grid.ProcessCallbackPrx

Bases: IcePy.ObjectPrx

Process terminated normally. Return code provided. In the case that a non-Blitz process sent a signal (KILL, TERM, ... ), that will represented in the return code. Arguments: returncode – _ctx – The request context for the invocation.

begin_processCancelled(success, _response=None, _ex=None, _sent=None, _ctx=None)
begin_processFinished(returncode, _response=None, _ex=None, _sent=None, _ctx=None)
begin_processKilled(success, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_processCancelled(_r)
end_processFinished(_r)
end_processKilled(_r)
static ice_staticId()
processCancelled(success, _ctx=None)
processFinished(returncode, _ctx=None)
processKilled(success, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.grid.ProcessPrx

Bases: IcePy.ObjectPrx

Returns the return code of the process, or null if unfinished. Arguments: _ctx – The request context for the invocation.

begin_cancel(_response=None, _ex=None, _sent=None, _ctx=None)
begin_kill(_response=None, _ex=None, _sent=None, _ctx=None)
begin_poll(_response=None, _ex=None, _sent=None, _ctx=None)
begin_registerCallback(cb, _response=None, _ex=None, _sent=None, _ctx=None)
begin_shutdown(_response=None, _ex=None, _sent=None, _ctx=None)
begin_unregisterCallback(cb, _response=None, _ex=None, _sent=None, _ctx=None)
begin_wait(_response=None, _ex=None, _sent=None, _ctx=None)
cancel(_ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_cancel(_r)
end_kill(_r)
end_poll(_r)
end_registerCallback(_r)
end_shutdown(_r)
end_unregisterCallback(_r)
end_wait(_r)
static ice_staticId()
kill(_ctx=None)
poll(_ctx=None)
registerCallback(cb, _ctx=None)
shutdown(_ctx=None)
static uncheckedCast(proxy, facet=None)
unregisterCallback(cb, _ctx=None)
wait(_ctx=None)
class omero.grid.Processor

Bases: Ice.Object

Simple controller for Processes. Uses the session id given to create an Ice.Config file which is used as the sole argument to an execution of the given job. Jobs are responsible for loading arguments from the environment via the session id.

_ice_type = <IcePy.TypeInfo object at 0x213f240>
_op_parseJob = <IcePy.Operation object at 0x213f318>
_op_processJob = <IcePy.Operation object at 0x213f330>
_op_requestRunning = <IcePy.Operation object at 0x213f300>
_op_willAccept = <IcePy.Operation object at 0x213f2e8>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
parseJob(session, jobObject, current=None)

Parses a job and returns metadata definition required for properly submitting the job. This object will be cached by the server, and passed back into {@code processJob} Arguments: session – jobObject – current – The Current object for the invocation.

processJob(session, params, jobObject, current=None)

Starts a process based on the given job If this processor cannot handle the given job, a null process will be returned. The {@code params} argument was created by a previously call to {@code parseJob}. Arguments: session – params – jobObject – current – The Current object for the invocation.

requestRunning(cb, current=None)

Used by servers to find out what jobs are still active. Response will be sent to {@code ProcessorCallback.responseRunning} Arguments: cb – current – The Current object for the invocation.

willAccept(userContext, groupContext, scriptContext, cb, current=None)

Called by omero.grid.SharedResources to find a suitable target for {@code omero.grid.SharedResources.acquireProcessor}. New processor instances are added to the checklist by using {@code omero.grid.SharedResources.addProcessor}. All processors must respond with their session uuid in order to authorize the action. Arguments: userContext – groupContext – scriptContext – cb – current – The Current object for the invocation.

class omero.grid.ProcessorCallback

Bases: Ice.Object

Internal callback interface which is passed to the {@code Processor.accepts} method to query whether or not a processor will accept a certain operation.

_ice_type = <IcePy.TypeInfo object at 0x213f288>
_op_isAccepted = <IcePy.Operation object at 0x213f2a0>
_op_isProxyAccepted = <IcePy.Operation object at 0x213f2b8>
_op_responseRunning = <IcePy.Operation object at 0x213f2d0>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
isAccepted(accepted, sessionUuid, procConn, current=None)
isProxyAccepted(accepted, sessionUuid, procProxy, current=None)
responseRunning(jobIds, current=None)
class omero.grid.ProcessorCallbackPrx

Bases: IcePy.ObjectPrx

begin_isAccepted(accepted, sessionUuid, procConn, _response=None, _ex=None, _sent=None, _ctx=None)
begin_isProxyAccepted(accepted, sessionUuid, procProxy, _response=None, _ex=None, _sent=None, _ctx=None)
begin_responseRunning(jobIds, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_isAccepted(_r)
end_isProxyAccepted(_r)
end_responseRunning(_r)
static ice_staticId()
isAccepted(accepted, sessionUuid, procConn, _ctx=None)
isProxyAccepted(accepted, sessionUuid, procProxy, _ctx=None)
responseRunning(jobIds, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.grid.ProcessorPrx

Bases: IcePy.ObjectPrx

Called by omero.grid.SharedResources to find a suitable target for {@code omero.grid.SharedResources.acquireProcessor}. New processor instances are added to the checklist by using {@code omero.grid.SharedResources.addProcessor}. All processors must respond with their session uuid in order to authorize the action. Arguments: userContext – groupContext – scriptContext – cb – _ctx – The request context for the invocation.

begin_parseJob(session, jobObject, _response=None, _ex=None, _sent=None, _ctx=None)
begin_processJob(session, params, jobObject, _response=None, _ex=None, _sent=None, _ctx=None)
begin_requestRunning(cb, _response=None, _ex=None, _sent=None, _ctx=None)
begin_willAccept(userContext, groupContext, scriptContext, cb, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_parseJob(_r)
end_processJob(_r)
end_requestRunning(_r)
end_willAccept(_r)
static ice_staticId()
parseJob(session, jobObject, _ctx=None)
processJob(session, params, jobObject, _ctx=None)
requestRunning(cb, _ctx=None)
static uncheckedCast(proxy, facet=None)
willAccept(userContext, groupContext, scriptContext, cb, _ctx=None)
class omero.grid.RawAccessRequest(repoUuid='', command='', args=None, path='')

Bases: omero.cmd.Request

Command object which will be parsed by the internal repository given by “”repo””. This command will only be processed if the user has sufficient rights (e.g. is a member of “system”) and is largely intended for testing and diagnosis rather than actual client functionality.

_ice_type = <IcePy.TypeInfo object at 0x35618b8>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.RawAccessRequestPrx

Bases: omero.cmd.RequestPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.Repository

Bases: Ice.Object

Client-accessible interface representing a single mount point on the server-side.

_ice_type = <IcePy.TypeInfo object at 0x3561558>
_op_deletePaths = <IcePy.Operation object at 0x3561660>
_op_file = <IcePy.Operation object at 0x35615e8>
_op_fileById = <IcePy.Operation object at 0x3561600>
_op_fileExists = <IcePy.Operation object at 0x3561618>
_op_list = <IcePy.Operation object at 0x35615a0>
_op_listFiles = <IcePy.Operation object at 0x35615b8>
_op_makeDir = <IcePy.Operation object at 0x3561630>
_op_mimetype = <IcePy.Operation object at 0x3561588>
_op_register = <IcePy.Operation object at 0x35615d0>
_op_root = <IcePy.Operation object at 0x3561570>
_op_treeList = <IcePy.Operation object at 0x3561648>
deletePaths(paths, recursively, force, current=None)

Delete several individual paths. Internally, this converts all of the paths into a single omero.cmd.Delete2 command and submits it. If a “”recursively”” is true, then directories will be searched and all of their contained files will be placed before them in the delete order. When the directory is removed from the database, it will removed from the filesystem if and only if it is empty. If “”recursively”” is false, then the delete will produce an error according to the “”force”” flag. If “”force”” is false, this method attempts the delete of all given paths in a single transaction, and any failure will cause the entire transaction to fail. If “”force”” is true, however, then all the other deletes will succeed. which could possibly leave dangling files within no longer extant directories. Arguments: paths – recursively – force – current – The Current object for the invocation.

file(path, mode, current=None)

Returns a special RawFileStore which permits only the operations set out in the options string “”wb””, “”a+””, etc. FIXME: Initially only “”r”” and “”rw”” are supported as these are handled directly by RandomAccessFile and so don’t break the current implementation. Any call to that tries to break the options will throw an ApiUsageException. If a file exists at the given path, a ValidationException will be thrown. Arguments: path – mode – current – The Current object for the invocation.

fileById(id, current=None)
fileExists(path, current=None)

Returns true if the file or path exists within the repository. In other words, if a call on dirname path to {@code listFiles} would return an object for this path. Arguments: path – current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
list(path, current=None)

Returns a set of strings naming the files and directories in the directory denoted by an abstract pathname. Arguments: path – current – The Current object for the invocation.

listFiles(path, current=None)

Returns an array of abstract pathname objects denoting the files in the directory denoted by an abstract pathname. It is expected that at a minimum the “”name””, “”path””, “”size”” and “”mtime”” attributes will be present for each omero.model.OriginalFile instance. Arguments: path – current – The Current object for the invocation.

makeDir(path, parents, current=None)

Create a directory at the given path. If parents is true, then all preceding paths will be generated and no exception will be thrown if the directory already exists. Otherwise, all parent directories must exist in both the DB and on the filesystem and be readable. Arguments: path – parents – current – The Current object for the invocation.

mimetype(path, current=None)

Returns the best-guess mimetype for the given path. Arguments: path – current – The Current object for the invocation.

register(path, mimetype, current=None)

Create an OriginalFile in the database for the given path. Arguments: path – mimetype – current – The Current object for the invocation.

root(current=None)

Return the OriginalFile descriptor for this Repository. It will have the path of the repository’s root on the underlying filesystem. Arguments: current – The Current object for the invocation.

treeList(path, current=None)

Similar to {@code list} but recursive and returns only primitive values for the file at each location. Guaranteed for each path is only the values id and mimetype. After a call to unwrap, the returned omero.RMap for a call to treeList(“/user_1/dir0”) might look something like: {@code { “/user_1/dir0/file1.txt” : { “id”:10, “mimetype”: “binary”, “size”: 10000L }, “/user_1/dir0/dir1” : { “id”: 100, “mimetype”: “Directory”, “size”: 0L, “files”: { “/user_1/dir0/dir1/file1indir.txt” : { “id”: 1, “mimetype”: “png”, “size”: 500 } } } } } Arguments: path – current – The Current object for the invocation.

exception omero.grid.RepositoryException(serverStackTrace='', serverExceptionClass='', message='')

Bases: omero.ServerError

Base repository exception.

_ice_name = 'omero::grid::RepositoryException'
_ice_type = <IcePy.ExceptionInfo object at 0x35614f8>
class omero.grid.RepositoryMap(descriptions=None, proxies=None)

Bases: object

Return value for omero.grid.SharedResources#repositories The descriptions and proxies arrays will have the same size and each index in descriptions (non-null) will match a possibly null proxy, if the given repository is not currently accessible.

class omero.grid.RepositoryPrx

Bases: IcePy.ObjectPrx

Return the OriginalFile descriptor for this Repository. It will have the path of the repository’s root on the underlying filesystem. Arguments: _ctx – The request context for the invocation.

begin_deletePaths(paths, recursively, force, _response=None, _ex=None, _sent=None, _ctx=None)
begin_file(path, mode, _response=None, _ex=None, _sent=None, _ctx=None)
begin_fileById(id, _response=None, _ex=None, _sent=None, _ctx=None)
begin_fileExists(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_list(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_listFiles(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_makeDir(path, parents, _response=None, _ex=None, _sent=None, _ctx=None)
begin_mimetype(path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_register(path, mimetype, _response=None, _ex=None, _sent=None, _ctx=None)
begin_root(_response=None, _ex=None, _sent=None, _ctx=None)
begin_treeList(path, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
deletePaths(paths, recursively, force, _ctx=None)
end_deletePaths(_r)
end_file(_r)
end_fileById(_r)
end_fileExists(_r)
end_list(_r)
end_listFiles(_r)
end_makeDir(_r)
end_mimetype(_r)
end_register(_r)
end_root(_r)
end_treeList(_r)
file(path, mode, _ctx=None)
fileById(id, _ctx=None)
fileExists(path, _ctx=None)
static ice_staticId()
list(path, _ctx=None)
listFiles(path, _ctx=None)
makeDir(path, parents, _ctx=None)
mimetype(path, _ctx=None)
register(path, mimetype, _ctx=None)
root(_ctx=None)
treeList(path, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.grid.RoiColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.RoiColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.ScriptProcess

Bases: omero.grid.Process

Extension of the {@code Process} interface which is returned by {@code IScript} when an omero.model.ScriptJob is launched. It is critical that instances of (@code ScriptProcess} are closed on completion. See the close method for more information.

_ice_type = <IcePy.TypeInfo object at 0x213f1c8>
_op_close = <IcePy.Operation object at 0x213f228>
_op_getJob = <IcePy.Operation object at 0x213f1e0>
_op_getResults = <IcePy.Operation object at 0x213f1f8>
_op_setMessage = <IcePy.Operation object at 0x213f210>
close(detach, current=None)

Closes this process and frees server resources attached to it. If the detach argument is True, then the background process will continue executing. The user can reconnect to the process via the {@code IScript} service. If the detach argument is False, then the background process will be shutdown immediately, and all intermediate results (stdout, stderr, ...) will be uploaded. Arguments: detach – current – The Current object for the invocation.

getJob(current=None)

Returns the job which started this process. Several scheduling fields (submitted, scheduledFor, started, finished) may be of interest. Arguments: current – The Current object for the invocation.

getResults(waitSecs, current=None)

Returns the results immediately if present. If the process is not yet finished, waits “waitSecs” before throwing an omero.ApiUsageException. If poll has returned a non-null value, then this method will always return a non-null value. Arguments: waitSecs – current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
setMessage(message, current=None)

Sets the message on the omero.model.ScriptJob object. This value MAY be overwritten by the server if the script fails. Arguments: message – current – The Current object for the invocation.

class omero.grid.ScriptProcessPrx

Bases: omero.grid.ProcessPrx

Returns the job which started this process. Several scheduling fields (submitted, scheduledFor, started, finished) may be of interest. Arguments: _ctx – The request context for the invocation.

begin_close(detach, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getJob(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getResults(waitSecs, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setMessage(message, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
close(detach, _ctx=None)
end_close(_r)
end_getJob(_r)
end_getResults(_r)
end_setMessage(_r)
getJob(_ctx=None)
getResults(waitSecs, _ctx=None)
static ice_staticId()
setMessage(message, _ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.grid.SharedResources

Bases: Ice.Object

Resource manager provided by each Blitz session for acquiring shared resources in the OmeroGrid. Unlike the other services provided by ServiceFactory instances, it is not guaranteed that a service instance returned from this interface will be returned if that resource happens to be busy. In that case, a null will be returned.

_ice_type = <IcePy.TypeInfo object at 0x3561138>
_op_acquireProcessor = <IcePy.Operation object>
_op_addProcessor = <IcePy.Operation object>
_op_areTablesEnabled = <IcePy.Operation object>
_op_getScriptRepository = <IcePy.Operation object>
_op_newTable = <IcePy.Operation object>
_op_openTable = <IcePy.Operation object>
_op_removeProcessor = <IcePy.Operation object>
_op_repositories = <IcePy.Operation object>
acquireProcessor(job, seconds, current=None)

Waits up to seconds to acquire a slot in a processor which can handle the given job. Arguments: job – seconds – current – The Current object for the invocation.

addProcessor(proc, current=None)

Registers a omero.grid.Processor for Storm notifications so that other sessions can query whether or not a given processor would accept a given task. Arguments: proc – current – The Current object for the invocation.

areTablesEnabled(current=None)

Returns true if a {@code Tables} service is active in the grid. If this value is false, then all calls to {@code #ewTable} or {@code openTable} will either fail or return null (possibly blocking while waiting for a service to startup) Arguments: current – The Current object for the invocation.

getScriptRepository(current=None)

Returns the single (possibly mirrored) script repository which makes all official scripts available. Arguments: current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
newTable(repoId, path, current=None)

Creates a new Format(“”OMERO.tables””) file at the given path on the given repository. The returned Table proxy follows the same semantics as the openTable method. Arguments: repoId – path – current – The Current object for the invocation.

openTable(file, current=None)

Returns a Table instance or null. Table instances are not exclusively owned by the client and may throw an OptimisticLockException if background modifications take place. The file instance must be managed (i.e. have a non-null id) and be of the format “”OMERO.tables””. Use newTable() to create a new instance. Arguments: file – current – The Current object for the invocation.

removeProcessor(proc, current=None)

Unregisters a omero.grid.Processor from Storm notifications. If the processor was not already registered via {@code addProcessor} this is a no-op. Arguments: proc – current – The Current object for the invocation.

repositories(current=None)

Returns a map between Repository descriptions (omero::model::OriginalFile instances) and RepositoryPrx instances (possibly null). Arguments: current – The Current object for the invocation.

class omero.grid.SharedResourcesPrx

Bases: IcePy.ObjectPrx

Waits up to seconds to acquire a slot in a processor which can handle the given job. Arguments: job – seconds – _ctx – The request context for the invocation.

acquireProcessor(job, seconds, _ctx=None)
addProcessor(proc, _ctx=None)
areTablesEnabled(_ctx=None)
begin_acquireProcessor(job, seconds, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addProcessor(proc, _response=None, _ex=None, _sent=None, _ctx=None)
begin_areTablesEnabled(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getScriptRepository(_response=None, _ex=None, _sent=None, _ctx=None)
begin_newTable(repoId, path, _response=None, _ex=None, _sent=None, _ctx=None)
begin_openTable(file, _response=None, _ex=None, _sent=None, _ctx=None)
begin_removeProcessor(proc, _response=None, _ex=None, _sent=None, _ctx=None)
begin_repositories(_response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_acquireProcessor(_r)
end_addProcessor(_r)
end_areTablesEnabled(_r)
end_getScriptRepository(_r)
end_newTable(_r)
end_openTable(_r)
end_removeProcessor(_r)
end_repositories(_r)
getScriptRepository(_ctx=None)
static ice_staticId()
newTable(repoId, path, _ctx=None)
openTable(file, _ctx=None)
removeProcessor(proc, _ctx=None)
repositories(_ctx=None)
static uncheckedCast(proxy, facet=None)
class omero.grid.StringColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.StringColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
class omero.grid.Table

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object at 0x3561168>
_op_addColumn = <IcePy.Operation object>
_op_addData = <IcePy.Operation object>
_op_close = <IcePy.Operation object>
_op_delete = <IcePy.Operation object>
_op_getAllMetadata = <IcePy.Operation object>
_op_getHeaders = <IcePy.Operation object>
_op_getMetadata = <IcePy.Operation object>
_op_getNumberOfRows = <IcePy.Operation object>
_op_getOriginalFile = <IcePy.Operation object>
_op_getWhereList = <IcePy.Operation object>
_op_initialize = <IcePy.Operation object>
_op_read = <IcePy.Operation object>
_op_readCoordinates = <IcePy.Operation object>
_op_setAllMetadata = <IcePy.Operation object>
_op_setMetadata = <IcePy.Operation object>
_op_slice = <IcePy.Operation object>
_op_update = <IcePy.Operation object>
addColumn(col, current=None)

Adds a column and returns the position index of the new column. Arguments: col – current – The Current object for the invocation.

addData(cols, current=None)
close(current=None)
delete(current=None)
getAllMetadata(current=None)
getHeaders(current=None)

Returns empty columns. Arguments: current – The Current object for the invocation.

getMetadata(key, current=None)
getNumberOfRows(current=None)
getOriginalFile(current=None)
getWhereList(condition, variables, start, stop, step, current=None)

http://www.pytables.org/docs/manual/apb.html Leave all three of start, stop, step to 0 to disable. TODO:Test effect of returning a billion rows matching getWhereList() Arguments: condition – variables – start – stop – step – current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
initialize(cols, current=None)

Initializes the structure based on Arguments: cols – current – The Current object for the invocation.

read(colNumbers, start, stop, current=None)

http://www.pytables.org/docs/manual/ch04.html#Table.read Arguments: colNumbers – start – stop – current – The Current object for the invocation.

readCoordinates(rowNumbers, current=None)

Read the given rows of data. Arguments: rowNumbers – must contain at least one element or an omero.ApiUsageException will be thrown. current – The Current object for the invocation.

setAllMetadata(dict, current=None)
setMetadata(key, value, current=None)
slice(colNumbers, rowNumbers, current=None)

Simple slice method which will return only the given columns and rows in the order supplied. If colNumbers or rowNumbers is empty (or None), then all values will be returned. Python examples: data = table.slice(None, None) assert len(data.rowNumbers) == table.getNumberOfRows() data = table.slice(None, [3,2,1]) assert data.rowNumbers == [3,2,1] Arguments: colNumbers – rowNumbers – current – The Current object for the invocation.

update(modifiedData, current=None)

Allows the user to modify a Data instance passed back from a query method and have the values modified. It is critical that the {@code Data.lastModification} and the {@code Data.rowNumbers} fields are properly set. An exception will be thrown if the data has since been modified. Arguments: modifiedData – current – The Current object for the invocation.

class omero.grid.TablePrx

Bases: IcePy.ObjectPrx

addColumn(col, _ctx=None)
addData(cols, _ctx=None)
begin_addColumn(col, _response=None, _ex=None, _sent=None, _ctx=None)
begin_addData(cols, _response=None, _ex=None, _sent=None, _ctx=None)
begin_close(_response=None, _ex=None, _sent=None, _ctx=None)
begin_delete(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getAllMetadata(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getHeaders(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getMetadata(key, _response=None, _ex=None, _sent=None, _ctx=None)
begin_getNumberOfRows(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getOriginalFile(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getWhereList(condition, variables, start, stop, step, _response=None, _ex=None, _sent=None, _ctx=None)
begin_initialize(cols, _response=None, _ex=None, _sent=None, _ctx=None)
begin_read(colNumbers, start, stop, _response=None, _ex=None, _sent=None, _ctx=None)
begin_readCoordinates(rowNumbers, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setAllMetadata(dict, _response=None, _ex=None, _sent=None, _ctx=None)
begin_setMetadata(key, value, _response=None, _ex=None, _sent=None, _ctx=None)
begin_slice(colNumbers, rowNumbers, _response=None, _ex=None, _sent=None, _ctx=None)
begin_update(modifiedData, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
close(_ctx=None)
delete(_ctx=None)
end_addColumn(_r)
end_addData(_r)
end_close(_r)
end_delete(_r)
end_getAllMetadata(_r)
end_getHeaders(_r)
end_getMetadata(_r)
end_getNumberOfRows(_r)
end_getOriginalFile(_r)
end_getWhereList(_r)
end_initialize(_r)
end_read(_r)
end_readCoordinates(_r)
end_setAllMetadata(_r)
end_setMetadata(_r)
end_slice(_r)
end_update(_r)
getAllMetadata(_ctx=None)
getHeaders(_ctx=None)
getMetadata(key, _ctx=None)
getNumberOfRows(_ctx=None)
getOriginalFile(_ctx=None)
getWhereList(condition, variables, start, stop, step, _ctx=None)
static ice_staticId()
initialize(cols, _ctx=None)
read(colNumbers, start, stop, _ctx=None)
readCoordinates(rowNumbers, _ctx=None)
setAllMetadata(dict, _ctx=None)
setMetadata(key, value, _ctx=None)
slice(colNumbers, rowNumbers, _ctx=None)
static uncheckedCast(proxy, facet=None)
update(modifiedData, _ctx=None)
class omero.grid.Tables

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object>
_op_getRepository = <IcePy.Operation object>
_op_getTable = <IcePy.Operation object>
getRepository(current=None)

Returns the Repository which this Tables service is watching. Arguments: current – The Current object for the invocation.

getTable(file, sf, current=None)

Returns the Table service for the given “”OMERO.tables”” file. This service will open the file locally to access the data. After any modification, the file will be saved locally and the server asked to update the database record. This is done via services in the omero.api.ServiceFactory. Arguments: file – sf – current – The Current object for the invocation.

ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.TablesPrx

Bases: IcePy.ObjectPrx

Returns the Repository which this Tables service is watching. Arguments: _ctx – The request context for the invocation.

begin_getRepository(_response=None, _ex=None, _sent=None, _ctx=None)
begin_getTable(file, sf, _response=None, _ex=None, _sent=None, _ctx=None)
static checkedCast(proxy, facetOrCtx=None, _ctx=None)
end_getRepository(_r)
end_getTable(_r)
getRepository(_ctx=None)
getTable(file, sf, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)
exception omero.grid.UnregisteredFileException(serverStackTrace='', serverExceptionClass='', message='', file=None)

Bases: omero.grid.RepositoryException

Specifies that a file is located at the given location that is not otherwise known by the repository. A subsequent call to {@code Repository.register} will create the given file. The mimetype field of the file may or may not be set. If it is set, clients are suggested to either omit the mimetype argument to the register method or to pass the same value.

_ice_name = 'omero::grid::UnregisteredFileException'
_ice_type = <IcePy.ExceptionInfo object at 0x3561528>
class omero.grid.WellColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object>
ice_id(current=None)
ice_ids(current=None)
static ice_staticId()
class omero.grid.WellColumnPrx

Bases: omero.grid.ColumnPrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
static ice_staticId()
static uncheckedCast(proxy, facet=None)