Page 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 0x1249a4f8>
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 0x1249a3d8>
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 0x1249a690>
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 0x1249a5e8>
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 0x1249a528>
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 0x1249a408>
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 0x444d3c0>
class omero.grid.FloatArrayColumn(name='', description='', size=0, values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x1249a5b8>
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 0x1249a438>
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 0x444d558>
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 0x444d5b8>
_op_getHandle = <IcePy.Operation object at 0x444d618>
_op_getImportSettings = <IcePy.Operation object at 0x444d630>
_op_getUploadOffset = <IcePy.Operation object at 0x444d600>
_op_getUploader = <IcePy.Operation object at 0x444d5d0>
_op_verifyUpload = <IcePy.Operation object at 0x444d5e8>
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 0x444d678>
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 0x444d6a8>
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 0x444d588>
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 0x2f652e8>
_op_execute = <IcePy.Operation object at 0x2f65348>
_op_expires = <IcePy.Operation object at 0x2f65300>
_op_getJob = <IcePy.Operation object at 0x2f65318>
_op_getResults = <IcePy.Operation object at 0x2f65360>
_op_params = <IcePy.Operation object at 0x2f65330>
_op_setDetach = <IcePy.Operation object at 0x2f65378>
_op_stop = <IcePy.Operation object at 0x2f65390>
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() willl be called, before prepairing 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 0x444d7b0>
_op_createRawFileStore = <IcePy.Operation object at 0x444d7c8>
_op_createRawPixelsStore = <IcePy.Operation object at 0x444d7e0>
_op_createRenderingEngine = <IcePy.Operation object at 0x444d7f8>
_op_createThumbnailStore = <IcePy.Operation object at 0x444d810>
_op_getDescription = <IcePy.Operation object at 0x444d828>
_op_getFilePath = <IcePy.Operation object at 0x444d870>
_op_getProxy = <IcePy.Operation object at 0x444d840>
_op_rawAccess = <IcePy.Operation object at 0x444d858>
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 0x2df1f90>
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 0x1249a618>
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 0x1249a558>
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 0x43e4f48>
_op_importFileset = <IcePy.Operation object at 0x444d6c0>
_op_importPaths = <IcePy.Operation object at 0x444d6d8>
_op_listChecksumAlgorithms = <IcePy.Operation object at 0x444d708>
_op_listImports = <IcePy.Operation object at 0x444d6f0>
_op_setChecksumAlgorithm = <IcePy.Operation object at 0x444d750>
_op_suggestChecksumAlgorithm = <IcePy.Operation object at 0x444d720>
_op_verifyChecksums = <IcePy.Operation object at 0x444d738>
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 0x1249a648>
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 0x2df1f48>
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 0x1249a4c8>
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 0x2f65078>
_op_cancel = <IcePy.Operation object at 0x2f650c0>
_op_kill = <IcePy.Operation object at 0x2f650d8>
_op_poll = <IcePy.Operation object at 0x2f65090>
_op_registerCallback = <IcePy.Operation object at 0x2f65108>
_op_shutdown = <IcePy.Operation object at 0x2f650f0>
_op_unregisterCallback = <IcePy.Operation object at 0x2f65120>
_op_wait = <IcePy.Operation object at 0x2f650a8>
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 0x2df1fc0>
_op_processCancelled = <IcePy.Operation object at 0x2f65030>
_op_processFinished = <IcePy.Operation object at 0x2df1fd8>
_op_processKilled = <IcePy.Operation object at 0x2f65048>
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 0x2f651c8>
_op_parseJob = <IcePy.Operation object at 0x2f652a0>
_op_processJob = <IcePy.Operation object at 0x2f652b8>
_op_requestRunning = <IcePy.Operation object at 0x2f65288>
_op_willAccept = <IcePy.Operation object at 0x2f65270>
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 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 0x2f65210>
_op_isAccepted = <IcePy.Operation object at 0x2f65228>
_op_isProxyAccepted = <IcePy.Operation object at 0x2f65240>
_op_responseRunning = <IcePy.Operation object at 0x2f65258>
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 0x444d780>
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 0x444d408>
_op_deletePaths = <IcePy.Operation object at 0x444d528>
_op_file = <IcePy.Operation object at 0x444d498>
_op_fileById = <IcePy.Operation object at 0x444d4c8>
_op_fileExists = <IcePy.Operation object at 0x444d4e0>
_op_list = <IcePy.Operation object at 0x444d450>
_op_listFiles = <IcePy.Operation object at 0x444d468>
_op_makeDir = <IcePy.Operation object at 0x444d4f8>
_op_mimetype = <IcePy.Operation object at 0x444d438>
_op_pixels = <IcePy.Operation object at 0x444d4b0>
_op_register = <IcePy.Operation object at 0x444d480>
_op_root = <IcePy.Operation object at 0x444d420>
_op_treeList = <IcePy.Operation object at 0x444d510>
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 0x444d3a8>
class omero.grid.RepositoryMap(descriptions=None, proxies=None)

Bases: object

Return value for [omero::grid::SharedResources].acquireRepositories() 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 0x1249a468>
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 [ScriptProcess] are closed on completetion. See the close method for more information.

_ice_type = <IcePy.TypeInfo object at 0x2f65150>
_op_close = <IcePy.Operation object at 0x2f651b0>
_op_getJob = <IcePy.Operation object at 0x2f65168>
_op_getResults = <IcePy.Operation object at 0x2f65180>
_op_setMessage = <IcePy.Operation object at 0x2f65198>
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 0x43e4fa8>
_op_acquireProcessor = <IcePy.Operation object at 0x1249a8a0>
_op_addProcessor = <IcePy.Operation object at 0x1249a8b8>
_op_areTablesEnabled = <IcePy.Operation object at 0x1249a918>
_op_getScriptRepository = <IcePy.Operation object at 0x1249a900>
_op_newTable = <IcePy.Operation object at 0x1249a930>
_op_openTable = <IcePy.Operation object at 0x1249a948>
_op_removeProcessor = <IcePy.Operation object at 0x1249a8d0>
_op_repositories = <IcePy.Operation object at 0x1249a8e8>
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 0x1249a588>
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 0x43e4fd8>
_op_addColumn = <IcePy.Operation object at 0x1249a7f8>
_op_addData = <IcePy.Operation object at 0x1249a750>
_op_close = <IcePy.Operation object at 0x1249a828>
_op_delete = <IcePy.Operation object at 0x1249a810>
_op_getAllMetadata = <IcePy.Operation object at 0x1249a780>
_op_getHeaders = <IcePy.Operation object at 0x1249a6c0>
_op_getMetadata = <IcePy.Operation object at 0x1249a798>
_op_getNumberOfRows = <IcePy.Operation object at 0x1249a6d8>
_op_getOriginalFile = <IcePy.Operation object at 0x1249a6a8>
_op_getWhereList = <IcePy.Operation object at 0x1249a6f0>
_op_initialize = <IcePy.Operation object at 0x1249a7e0>
_op_read = <IcePy.Operation object at 0x1249a720>
_op_readCoordinates = <IcePy.Operation object at 0x1249a708>
_op_setAllMetadata = <IcePy.Operation object at 0x1249a7b0>
_op_setMetadata = <IcePy.Operation object at 0x1249a7c8>
_op_slice = <IcePy.Operation object at 0x1249a738>
_op_update = <IcePy.Operation object at 0x1249a768>
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.

[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 0x1249a858>
_op_getRepository = <IcePy.Operation object at 0x1249a870>
_op_getTable = <IcePy.Operation object at 0x1249a888>
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 0x444d3d8>
class omero.grid.WellColumn(name='', description='', values=None)

Bases: omero.grid.Column

_ice_type = <IcePy.TypeInfo object at 0x1249a498>
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)