Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
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.
Bases: IcePy.ObjectPrx
Bases: Ice.Object
Bases: IcePy.ObjectPrx
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: omero.grid.RepositoryException
Specifies that a file with the given path has failed to be deleted from the file system.
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
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
Bases: IcePy.ObjectPrx
Bases: omero.api.StatefulServiceInterface
User configuration options. These are likely set in the UI before the import is initiated.
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.
In case an upload must be resumed, this provides the location of the last successful upload.
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
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.
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
Bases: omero.cmd.Request
Command object which will be used to create the [omero::cmd::Handle] instances passed back by the [ImportProcess].
Bases: omero.cmd.RequestPrx
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.
Bases: omero.cmd.ResponsePrx
Bases: Ice.Object
User configuration options. These are likely set in the UI before the import is initiated.
Bases: IcePy.ObjectPrx
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.
Executes an instance of the job returned by getJob() using the given map as inputs.
Returns the system clock time in milliseconds since the epoch at which this processor will be reaped.
Returns the job which defines this processor. This may be only the last job associated with the processor if execute is called multiple times.
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.
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.
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
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.
Bases: IcePy.ObjectPrx
Returns the system clock time in milliseconds since the epoch at which this processor will be reaped.
Bases: Ice.Object
Internal portion of the API used for management. Not available to clients.
Bases: IcePy.ObjectPrx
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.
Bases: omero.InternalPrx
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: omero.grid.Repository
FS-enabled repository which can convert uploaded files into Images by using Bio-Formats to import them.
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.
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.
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].
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.
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.
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.
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.
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.
Bases: omero.grid.Column
Column requiring special handling.
Bases: omero.grid.ColumnPrx
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”]
Bases: IcePy.ObjectPrx
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: Ice.Object
Thin wrapper around a system-level process. Most closely resembles Python’s subprocess.Popen class.
Signal to the Process that it should terminate. This may be done “softly” for a given time period.
Terminate the Process immediately.
Returns the return code of the process, or null if unfinished.
Add a callback for end-of-life events
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.
Remove a callback for end-of-life events
Blocks until poll() would return a non-null return code.
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
cancel() was called on this Process. If the Process failed to terminate, argument is false, in which calling kill() is the last resort.
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.
kill() was called on this Process. If this does not succeed, there is nothing else that Blitz can do to stop its execution.
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.
Bases: IcePy.ObjectPrx
Returns the return code of the process, or null if unfinished.
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.
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]
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].
Used by servers to find out what jobs are still active. Response will be sent to [ProcessorCallback::responseRunning]
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.
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.
Bases: IcePy.ObjectPrx
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.
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.
Bases: omero.cmd.RequestPrx
Bases: Ice.Object
Client-accessible interface representing a single mount point on the server-side.
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.
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.
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.
Returns a set of strings naming the files and directories in the directory denoted by an abstract pathname.
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.
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.
Returns the best-guess mimetype for the given path.
Create an OriginalFile in the database for the given path.
Return the OriginalFile descriptor for this Repository. It will have the path of the repository’s root on the underlying filesystem.
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 } } } }
Bases: omero.ServerError
Base repository exception.
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.
Bases: IcePy.ObjectPrx
Return the OriginalFile descriptor for this Repository. It will have the path of the repository’s root on the underlying filesystem.
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
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.
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.
Returns the job which started this process. Several scheduling fields (submitted, scheduledFor, started, finished) may be of interest.
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.
Sets the message on the [omero::model::ScriptJob] object. This value MAY be overwritten by the server if the script fails.
Bases: omero.grid.ProcessPrx
Returns the job which started this process. Several scheduling fields (submitted, scheduledFor, started, finished) may be of interest.
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.
Waits up to seconds to acquire a slot in a processor which can handle the given job.
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.
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)
Returns the single (possibly mirrored) script repository which makes all official scripts available.
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.
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.
Unregisters a [omero::grid::Processor] from Storm notifications. If the processor was not already registered via [addProcessor] this is a no-op.
Returns a map between Repository descriptions (omero::model::OriginalFile instances) and RepositoryPrx instances (possibly null).
Bases: IcePy.ObjectPrx
Waits up to seconds to acquire a slot in a processor which can handle the given job.
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
Bases: Ice.Object
Adds a column and returns the position index of the new column.
Returns empty columns.
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()
Initializes the structure based on
Read the given rows of data.
[rowNumbers] must contain at least one element or an [omero::ApiUsageException] will be thrown.
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]
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.
Bases: IcePy.ObjectPrx
Bases: Ice.Object
Returns the Repository which this Tables service is watching.
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].
Bases: IcePy.ObjectPrx
Returns the Repository which this Tables service is watching.
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.
Bases: omero.grid.Column
Bases: omero.grid.ColumnPrx
