Table Of Contents

Previous topic

omero.gateway.scripts package

Next topic

omero.grid.monitors package

This Page

omero.grid package

Module contents

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

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61558>
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 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 Table interface.

_ice_type = <IcePy.TypeInfo object at 0x12d61438>
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 uncheckedCast(proxy, facet=None)
class omero.grid.Data(lastModification=0, rowNumbers=None, columns=None)

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object at 0x12d616f0>
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 uncheckedCast(proxy, facet=None)
class omero.grid.DoubleArrayColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61648>
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 uncheckedCast(proxy, facet=None)
class omero.grid.DoubleColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61588>
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 uncheckedCast(proxy, facet=None)
class omero.grid.FileColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61468>
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 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 0x4de83a8>
class omero.grid.FloatArrayColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61618>
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 uncheckedCast(proxy, facet=None)
class omero.grid.ImageColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61498>
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 uncheckedCast(proxy, facet=None)
class omero.grid.ImportLocation(sharedPath='', omittedLevels=0, usedFiles=None, directory=None)

Bases: Ice.Object

Returned by 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

_ice_type = <IcePy.TypeInfo object at 0x4de8540>
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 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 0x4de85a0>
_op_getHandle = <IcePy.Operation object at 0x4de8600>
_op_getImportSettings = <IcePy.Operation object at 0x4de8618>
_op_getUploadOffset = <IcePy.Operation object at 0x4de85e8>
_op_getUploader = <IcePy.Operation object at 0x4de85b8>
_op_verifyUpload = <IcePy.Operation object at 0x4de85d0>
getHandle(current=None)

Reacquire the handle which was returned by verifyUpload. This is useful in case a new client is re-attaching to a running import. From the omero.cmd.Handle instance, the original ImportRequest can also be found.

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

In case an upload must be resumed, this provides the location of the last successful upload.

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 ImportLocation. omero.api.RawFileStore#close should be called once all data has been transferred. If the file must be re-written, call getUploader with the same index again. Once all uploads have been completed, verifyUpload should be called to initiate background processing

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 ImportResponse. Otherwise, some omero.cmd.ERR will be returned.

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 ImportLocation. omero.api.RawFileStore#close should be called once all data has been transferred. If the file must be re-written, call getUploader with the same index again. Once all uploads have been completed, verifyUpload should be called to initiate background processing

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

_ice_type = <IcePy.TypeInfo object at 0x4de8660>
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 uncheckedCast(proxy, facet=None)
class omero.grid.ImportResponse(pixels=None, objects=None)

Bases: omero.cmd.Response

Successful response returned from execution of ImportRequest. This is the simplest way to return the results, but is likely not the overall best strategy.

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

Bases: omero.cmd.ResponsePrx

static checkedCast(proxy, facetOrCtx=None, _ctx=None)
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.

_ice_type = <IcePy.TypeInfo object at 0x4de8570>
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 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 0x3a87270>
_op_execute = <IcePy.Operation object at 0x3a872d0>
_op_expires = <IcePy.Operation object at 0x3a87288>
_op_getJob = <IcePy.Operation object at 0x3a872a0>
_op_getResults = <IcePy.Operation object at 0x3a872e8>
_op_params = <IcePy.Operation object at 0x3a872b8>
_op_setDetach = <IcePy.Operation object at 0x3a87300>
_op_stop = <IcePy.Operation object at 0x3a87318>
execute(inputs, current=None)

Executes an instance of the job returned by getJob() using the given map as inputs.

expires(current=None)

Returns the system clock time in milliseconds since the epoch at which this processor will be reaped.

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.

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.

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.

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

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.

class omero.grid.InteractiveProcessorPrx

Bases: IcePy.ObjectPrx

Returns the system clock time in milliseconds since the epoch at which this processor will be reaped.

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)
execute_async(_cb, inputs, _ctx=None)
expires(_ctx=None)
expires_async(_cb, _ctx=None)
getJob(_ctx=None)
getJob_async(_cb, _ctx=None)
getResults(proc, _ctx=None)
getResults_async(_cb, proc, _ctx=None)
params(_ctx=None)
params_async(_cb, _ctx=None)
setDetach(detach, _ctx=None)
setDetach_async(_cb, detach, _ctx=None)
stop(_ctx=None)
stop_async(_cb, _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 0x4de8798>
_op_createRawFileStore = <IcePy.Operation object at 0x4de87b0>
_op_createRawPixelsStore = <IcePy.Operation object at 0x4de87c8>
_op_createRenderingEngine = <IcePy.Operation object at 0x4de87e0>
_op_createThumbnailStore = <IcePy.Operation object at 0x4de87f8>
_op_getDescription = <IcePy.Operation object at 0x4de8810>
_op_getFilePath = <IcePy.Operation object at 0x4de8858>
_op_getProxy = <IcePy.Operation object at 0x4de8828>
_op_rawAccess = <IcePy.Operation object at 0x4de8840>
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)
createRawFileStore_async(_cb, file, _ctx=None)
createRawPixelsStore(file, _ctx=None)
createRawPixelsStore_async(_cb, file, _ctx=None)
createRenderingEngine(file, _ctx=None)
createRenderingEngine_async(_cb, file, _ctx=None)
createThumbnailStore(file, _ctx=None)
createThumbnailStore_async(_cb, 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)
getDescription_async(_cb, _ctx=None)
getFilePath(file, _ctx=None)
getFilePath_async(_cb, file, _ctx=None)
getProxy(_ctx=None)
getProxy_async(_cb, _ctx=None)
rawAccess(raw, _ctx=None)
rawAccess_async(_cb, 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.

_ice_type = <IcePy.TypeInfo object at 0x3727f18>
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 uncheckedCast(proxy, facet=None)
class omero.grid.LongArrayColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61678>
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 uncheckedCast(proxy, facet=None)
class omero.grid.LongColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d615b8>
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 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 0x4a8ef30>
_op_importFileset = <IcePy.Operation object at 0x4de86a8>
_op_importPaths = <IcePy.Operation object at 0x4de86c0>
_op_listChecksumAlgorithms = <IcePy.Operation object at 0x4de86f0>
_op_listImports = <IcePy.Operation object at 0x4de86d8>
_op_setChecksumAlgorithm = <IcePy.Operation object at 0x4de8738>
_op_suggestChecksumAlgorithm = <IcePy.Operation object at 0x4de8708>
_op_verifyChecksums = <IcePy.Operation object at 0x4de8720>
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.

importPaths(filePaths, current=None)

For clients without access to Bio-Formats, the simplified 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.

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.

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.

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.

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.

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.

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.

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)
importFileset(fs, settings, _ctx=None)
importFileset_async(_cb, fs, settings, _ctx=None)
importPaths(filePaths, _ctx=None)
importPaths_async(_cb, filePaths, _ctx=None)
listChecksumAlgorithms(_ctx=None)
listChecksumAlgorithms_async(_cb, _ctx=None)
listImports(_ctx=None)
listImports_async(_cb, _ctx=None)
setChecksumAlgorithm(hasher, ids, _ctx=None)
setChecksumAlgorithm_async(_cb, hasher, ids, _ctx=None)
suggestChecksumAlgorithm(supported, _ctx=None)
suggestChecksumAlgorithm_async(_cb, supported, _ctx=None)
static uncheckedCast(proxy, facet=None)
verifyChecksums(ids, _ctx=None)
verifyChecksums_async(_cb, 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 at 0x12d616a8>
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 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”]

_ice_type = <IcePy.TypeInfo object at 0x3727ed0>
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 uncheckedCast(proxy, facet=None)
class omero.grid.PlateColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d61528>
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 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 0x3727fc0>
_op_cancel = <IcePy.Operation object at 0x3a87048>
_op_kill = <IcePy.Operation object at 0x3a87060>
_op_poll = <IcePy.Operation object at 0x3727fd8>
_op_registerCallback = <IcePy.Operation object at 0x3a87090>
_op_shutdown = <IcePy.Operation object at 0x3a87078>
_op_unregisterCallback = <IcePy.Operation object at 0x3a870a8>
_op_wait = <IcePy.Operation object at 0x3a87030>
cancel(current=None)

Signal to the Process that it should terminate. This may be done “softly” for a given time period.

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

Terminate the Process immediately.

poll(current=None)

Returns the return code of the process, or null if unfinished.

registerCallback(cb, current=None)

Add a callback for end-of-life events

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.

unregisterCallback(cb, current=None)

Remove a callback for end-of-life events

wait(current=None)

Blocks until poll() would return a non-null return code.

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 0x3727f48>
_op_processCancelled = <IcePy.Operation object at 0x3727f78>
_op_processFinished = <IcePy.Operation object at 0x3727f60>
_op_processKilled = <IcePy.Operation object at 0x3727f90>
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.

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.

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.

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.

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)
processCancelled(success, _ctx=None)
processCancelled_async(_cb, success, _ctx=None)
processFinished(returncode, _ctx=None)
processFinished_async(_cb, returncode, _ctx=None)
processKilled(success, _ctx=None)
processKilled_async(_cb, 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.

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)
cancel_async(_cb, _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)
kill(_ctx=None)
kill_async(_cb, _ctx=None)
poll(_ctx=None)
poll_async(_cb, _ctx=None)
registerCallback(cb, _ctx=None)
registerCallback_async(_cb, cb, _ctx=None)
shutdown(_ctx=None)
shutdown_async(_cb, _ctx=None)
static uncheckedCast(proxy, facet=None)
unregisterCallback(cb, _ctx=None)
unregisterCallback_async(_cb, cb, _ctx=None)
wait(_ctx=None)
wait_async(_cb, _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 0x3a87150>
_op_parseJob = <IcePy.Operation object at 0x3a87228>
_op_processJob = <IcePy.Operation object at 0x3a87240>
_op_requestRunning = <IcePy.Operation object at 0x3a87210>
_op_willAccept = <IcePy.Operation object at 0x3a871f8>
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 processJob

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

Starts a process based on the given job If this processor cannot handle the given job, a Arguments: null process will be returned. The { params} argument was created by a previously call to parseJob.

requestRunning(cb, current=None)

Used by servers to find out what jobs are still active. Response will be sent to ProcessorCallback#responseRunning

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

Called by omero.grid.SharedResources to find a suitable target for omero.grid.SharedResources#acquireProcessor. New processor instances are added to the checklist by using omero.grid.SharedResources#addProcessor. All processors must respond with their session uuid in order to authorize the action.

class omero.grid.ProcessorCallback

Bases: Ice.Object

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

_ice_type = <IcePy.TypeInfo object at 0x3a87198>
_op_isAccepted = <IcePy.Operation object at 0x3a871b0>
_op_isProxyAccepted = <IcePy.Operation object at 0x3a871c8>
_op_responseRunning = <IcePy.Operation object at 0x3a871e0>
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)
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 omero.grid.SharedResources#acquireProcessor. New processor instances are added to the checklist by using omero.grid.SharedResources#addProcessor. All processors must respond with their session uuid in order to authorize the action.

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)
parseJob(session, jobObject, _ctx=None)
parseJob_async(_cb, session, jobObject, _ctx=None)
processJob(session, params, jobObject, _ctx=None)
processJob_async(_cb, session, params, jobObject, _ctx=None)
requestRunning(cb, _ctx=None)
requestRunning_async(_cb, cb, _ctx=None)
static uncheckedCast(proxy, facet=None)
willAccept(userContext, groupContext, scriptContext, cb, _ctx=None)
willAccept_async(_cb, 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 0x4de8768>
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 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 0x4de83f0>
_op_deletePaths = <IcePy.Operation object at 0x4de8510>
_op_file = <IcePy.Operation object at 0x4de8480>
_op_fileById = <IcePy.Operation object at 0x4de84b0>
_op_fileExists = <IcePy.Operation object at 0x4de84c8>
_op_list = <IcePy.Operation object at 0x4de8438>
_op_listFiles = <IcePy.Operation object at 0x4de8450>
_op_makeDir = <IcePy.Operation object at 0x4de84e0>
_op_mimetype = <IcePy.Operation object at 0x4de8420>
_op_pixels = <IcePy.Operation object at 0x4de8498>
_op_register = <IcePy.Operation object at 0x4de8468>
_op_root = <IcePy.Operation object at 0x4de8408>
_op_treeList = <IcePy.Operation object at 0x4de84f8>
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.

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.

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 listFiles would return an object for this path.

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.

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.

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.

mimetype(path, current=None)

Returns the best-guess mimetype for the given path.

pixels(path, current=None)
register(path, mimetype, current=None)

Create an OriginalFile in the database for the given path.

root(current=None)

Return the OriginalFile descriptor for this Repository. It will have the path of the repository’s root on the underlying filesystem.

treeList(path, current=None)

Similar to 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:

{ “/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 } } } }

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

Bases: omero.ServerError

Base repository exception.

_ice_name = 'omero::grid::RepositoryException'
_ice_type = <IcePy.ExceptionInfo object at 0x4de8390>
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.

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_pixels(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)
deletePaths_async(_cb, 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_pixels(_r)
end_register(_r)
end_root(_r)
end_treeList(_r)
file(path, mode, _ctx=None)
fileById(id, _ctx=None)
fileById_async(_cb, id, _ctx=None)
fileExists(path, _ctx=None)
fileExists_async(_cb, path, _ctx=None)
file_async(_cb, path, mode, _ctx=None)
list(path, _ctx=None)
listFiles(path, _ctx=None)
listFiles_async(_cb, path, _ctx=None)
list_async(_cb, path, _ctx=None)
makeDir(path, parents, _ctx=None)
makeDir_async(_cb, path, parents, _ctx=None)
mimetype(path, _ctx=None)
mimetype_async(_cb, path, _ctx=None)
pixels(path, _ctx=None)
pixels_async(_cb, path, _ctx=None)
register(path, mimetype, _ctx=None)
register_async(_cb, path, mimetype, _ctx=None)
root(_ctx=None)
root_async(_cb, _ctx=None)
treeList(path, _ctx=None)
treeList_async(_cb, 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 at 0x12d614c8>
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 uncheckedCast(proxy, facet=None)
class omero.grid.ScriptProcess

Bases: omero.grid.Process

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

_ice_type = <IcePy.TypeInfo object at 0x3a870d8>
_op_close = <IcePy.Operation object at 0x3a87138>
_op_getJob = <IcePy.Operation object at 0x3a870f0>
_op_getResults = <IcePy.Operation object at 0x3a87108>
_op_setMessage = <IcePy.Operation object at 0x3a87120>
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 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.

getJob(current=None)

Returns the job which started this process. Several scheduling fields (submitted, scheduledFor, started, finished) may be of interest.

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.

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.

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.

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)
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 0x4a8ef90>
_op_acquireProcessor = <IcePy.Operation object at 0x12d61900>
_op_addProcessor = <IcePy.Operation object at 0x12d61918>
_op_areTablesEnabled = <IcePy.Operation object at 0x12d61978>
_op_getScriptRepository = <IcePy.Operation object at 0x12d61960>
_op_newTable = <IcePy.Operation object at 0x12d61990>
_op_openTable = <IcePy.Operation object at 0x12d619a8>
_op_removeProcessor = <IcePy.Operation object at 0x12d61930>
_op_repositories = <IcePy.Operation object at 0x12d61948>
acquireProcessor(job, seconds, current=None)

Waits up to seconds to acquire a slot in a processor which can handle the given job.

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.

areTablesEnabled(current=None)

Returns true if a Tables service is active in the grid. If this value is false, then all calls to newTable or openTable will either fail or return null (possibly blocking while waiting for a service to startup)

getScriptRepository(current=None)

Returns the single (possibly mirrored) script repository which makes all official scripts available.

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.

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.

removeProcessor(proc, current=None)

Unregisters a omero.grid.Processor from Storm notifications. If the processor was not already registered via addProcessor this is a no-op.

repositories(current=None)

Returns a map between Repository descriptions (omero::model::OriginalFile instances) and RepositoryPrx instances (possibly null).

class omero.grid.SharedResourcesPrx

Bases: IcePy.ObjectPrx

Waits up to seconds to acquire a slot in a processor which can handle the given job.

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)
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 at 0x12d615e8>
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 uncheckedCast(proxy, facet=None)
class omero.grid.Table

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object at 0x4a8efc0>
_op_addColumn = <IcePy.Operation object at 0x12d61858>
_op_addData = <IcePy.Operation object at 0x12d617b0>
_op_close = <IcePy.Operation object at 0x12d61888>
_op_delete = <IcePy.Operation object at 0x12d61870>
_op_getAllMetadata = <IcePy.Operation object at 0x12d617e0>
_op_getHeaders = <IcePy.Operation object at 0x12d61720>
_op_getMetadata = <IcePy.Operation object at 0x12d617f8>
_op_getNumberOfRows = <IcePy.Operation object at 0x12d61738>
_op_getOriginalFile = <IcePy.Operation object at 0x12d61708>
_op_getWhereList = <IcePy.Operation object at 0x12d61750>
_op_initialize = <IcePy.Operation object at 0x12d61840>
_op_read = <IcePy.Operation object at 0x12d61780>
_op_readCoordinates = <IcePy.Operation object at 0x12d61768>
_op_setAllMetadata = <IcePy.Operation object at 0x12d61810>
_op_setMetadata = <IcePy.Operation object at 0x12d61828>
_op_slice = <IcePy.Operation object at 0x12d61798>
_op_update = <IcePy.Operation object at 0x12d617c8>
addColumn(col, current=None)

Adds a column and returns the position index of the new column.

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

Returns empty columns.

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

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

Initializes the structure based on

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

http://www.pytables.org/docs/manual/ch04.html#Table.read

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.

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]

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 Data#lastModification and the Data#rowNumbers fields are properly set. An exception will be thrown if the data has since been modified.

class omero.grid.TablePrx

Bases: IcePy.ObjectPrx

addColumn(col, _ctx=None)
addColumn_async(_cb, col, _ctx=None)
addData(cols, _ctx=None)
addData_async(_cb, 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)
close_async(_cb, _ctx=None)
delete(_ctx=None)
delete_async(_cb, _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)
getAllMetadata_async(_cb, _ctx=None)
getHeaders(_ctx=None)
getHeaders_async(_cb, _ctx=None)
getMetadata(key, _ctx=None)
getMetadata_async(_cb, key, _ctx=None)
getNumberOfRows(_ctx=None)
getNumberOfRows_async(_cb, _ctx=None)
getOriginalFile(_ctx=None)
getOriginalFile_async(_cb, _ctx=None)
getWhereList(condition, variables, start, stop, step, _ctx=None)
getWhereList_async(_cb, condition, variables, start, stop, step, _ctx=None)
initialize(cols, _ctx=None)
initialize_async(_cb, cols, _ctx=None)
read(colNumbers, start, stop, _ctx=None)
readCoordinates(rowNumbers, _ctx=None)
readCoordinates_async(_cb, rowNumbers, _ctx=None)
read_async(_cb, colNumbers, start, stop, _ctx=None)
setAllMetadata(dict, _ctx=None)
setAllMetadata_async(_cb, dict, _ctx=None)
setMetadata(key, value, _ctx=None)
setMetadata_async(_cb, key, value, _ctx=None)
slice(colNumbers, rowNumbers, _ctx=None)
slice_async(_cb, colNumbers, rowNumbers, _ctx=None)
static uncheckedCast(proxy, facet=None)
update(modifiedData, _ctx=None)
update_async(_cb, modifiedData, _ctx=None)
class omero.grid.Tables

Bases: Ice.Object

_ice_type = <IcePy.TypeInfo object at 0x12d618b8>
_op_getRepository = <IcePy.Operation object at 0x12d618d0>
_op_getTable = <IcePy.Operation object at 0x12d618e8>
getRepository(current=None)

Returns the Repository which this Tables service is watching.

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.

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.

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)
getRepository_async(_cb, _ctx=None)
getTable(file, sf, _ctx=None)
getTable_async(_cb, file, sf, _ctx=None)
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 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 0x4de83c0>
class omero.grid.WellColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x12d614f8>
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 uncheckedCast(proxy, facet=None)