Full Reference

ibridges.data_operations module

Data transfers.

Transfer data between local file system and iRODS, includes upload, download and sync.

ibridges.data_operations.create_collection(session, coll_path)

Create a collection and all parent collections that do not exist yet.

Alias for ibridges.path.IrodsPath.create_collection()

Parameters:

  • session (Session) – Session to create the collection for.

  • coll_path (IrodsPath) – Collection path

Raises:

PermissionError: – If creating a collection is not allowed by the server.

Return type:

iRODSCollection

Examples

>>> create_collection(session, IrodsPath("~/new_collection"))
ibridges.data_operations.download(session, irods_path, local_path, overwrite=False, ignore_err=False, resc_name='', copy_empty_folders=True, options=None, dry_run=False)

Download a collection or data object to the local filesystem.

Parameters:

  • session (Session) – Session to download the collection from.

  • irods_path (IrodsPath) – Absolute irods source path pointing to a collection

  • local_path (Path) – Absolute path to the destination directory

  • overwrite (bool) – If an error occurs during download, and ignore_err is set to True, any errors encountered will be transformed into warnings and iBridges will continue to download the remaining files. By default all errors will stop the process of downloading.

  • ignore_err (bool) – Collections: If download of an item fails print error and continue with next item.

  • resc_name (str) – Name of the resource from which data is downloaded, by default the server will decide.

  • copy_empty_folders (bool) – Create respective local directory for empty collections.

  • options (dict) – More options for the download

  • dry_run (bool) – Whether to do a dry run before uploading the files/folders.

Raises:

  • PermissionError: – If the iRODS server (for whatever reason) forbids downloading the file or (part of the) collection.

  • ValueError: – If the irods_path is not pointing to either a collection or a data object.

  • FileExistsError: – If the irods_path points to a data object and the local file already exists.

  • NotADirectoryError: – If the irods_path is a collection, while the destination is a file.

Examples

>>> download(session, "~/some_collection", "some_local_dir")
>>> download(session, IrodsPath(session, "some_obj.txt"), "some_local_dir")
>>> ops = download(session, "~/some_obj.txt", "some_local_dir", dry_run=True)
>>> print(ops)
{'create_dir': set(),
'create_collection': set(),
'upload': [],
'download': [(IrodsPath(~, some_obj.txt), PosixPath('some_local_dir'))],
'resc_name': '',
'options': None}
ibridges.data_operations.perform_operations(session, operations, ignore_err=False)

Execute data operations.

The operations can be obtained with a dry run of the upload/download/sync function.

Parameters:

  • session (Session) – Session to do the data operations for.

  • operations (dict) – Dictionary containing the operations to perform.

  • ignore_err (bool) – Ignore any errors and convert them into warnings if True.

Raises:

PermissionError: – When the operation is not allowed on either the iRODS server or locally.

Examples

>>> perform_operations(session, ops)
ibridges.data_operations.sync(session, source, target, max_level=None, dry_run=False, ignore_err=False, copy_empty_folders=False, resc_name='', options=None)

Synchronize the data between a local copy (local file system) and the copy stored in iRODS.

The command can be in one of the two modes: synchronization of data from the client’s local file system to iRODS, or from iRODS to the local file system. The mode is determined by the type of the values for source and target (IrodsPath or str/Path).

The command considers the file size and the checksum to determine whether a file should be synchronized.

Parameters:

  • session (ibridges.Session) – An authorized iBridges session.

  • source (str or Path or IrodsPath) – Existing local folder or iRODS collection. An exception will be raised if it doesn’t exist.

  • target (str or Path or IrodsPath) – Existing local folder or iRODS collection. An exception will be raised if it doesn’t exist.

  • max_level (int, default None) – Controls the depth up to which the file tree will be synchronized. A max level of 1 synchronizes only the source’s root, max level 2 also includes the first set of subfolders/subcollections and their contents, etc. Set to None, there is no limit (full recursive synchronization).

  • dry_run (bool, default False) – List all source files and folders that need to be synchronized without actually performing synchronization.

  • ignore_err (If an error occurs during the transfer, and ignore_err is set to True,) – any errors encountered will be transformed into warnings and iBridges will continue to transfer the remaining files.

  • copy_empty_folders (bool, default False) – Controls whether folders/collections that contain no files or subfolders/subcollections will be synchronized.

  • resc_name (str) – Name of the resource from which data is downloaded, by default the server will decide.

  • options (dict) – More options for the download/upload

Return type:

dict

Returns:

A dict object containing four keys:

’create_dir’ : Create local directories when sync from iRODS to local ‘create_collection’ : Create collections when sync from local to iRODS ‘upload’ : Tuple(local path, iRODS path) when sync from local to iRODS ‘download’ : Tuple(iRODS path, local path) when sync from iRODS to local

(or of to-be-changed folders and files, when in dry-run mode).

ibridges.data_operations.upload(session, local_path, irods_path, overwrite=False, ignore_err=False, resc_name='', copy_empty_folders=True, options=None, dry_run=False)

Upload a local directory or file to iRODS.

Parameters:

  • session (Session) – Session to upload the data to.

  • local_path (Path) – Absolute path to the directory to upload

  • irods_path (IrodsPath) – Absolute irods destination path

  • overwrite (bool) – If data object or collection already exists on iRODS, overwrite

  • ignore_err (bool) – If an error occurs during upload, and ignore_err is set to True, any errors encountered will be transformed into warnings and iBridges will continue to upload the remaining files. By default all errors will stop the process of uploading.

  • resc_name (str) – Name of the resource to which data is uploaded, by default the server will decide

  • copy_empty_folders (bool) – Create respective iRODS collection for empty folders. Default: True.

  • options (dict) – More options for the upload

  • dry_run (bool) – Whether to do a dry run before uploading the files/folders.

Raises:

  • ValueError: – If the local_path is not a valid filename of directory.

  • PermissionError: – If the iRODS server does not allow the collection or data object to be created.

Examples

>>> ipath = IrodsPath(session, "~/some_col")
>>> upload(session, Path("dir"), ipath)
>>> upload(session, Path("dir"), ipath, overwrite=True)
>>> ops = upload(session, Path("some_file.txt"), ipath, dry_run)  # Does not upload
>>> print(ops)
{'create_dir': set(),
'create_collection': set(),
'upload': [(PosixPath('some_file.txt'), IrodsPath(~, some_col))],
'download': [],
'resc_name': '',
'options': None}

ibridges.export_metadata module

Exporting metadata.

ibridges.export_metadata.export_metadata_to_dict(meta, session, recursive=True, keys=None)

Retrieve the metadata of the item and brings it into dict form.

If the item is a collection all metadata from all subcollections and data objects will also be exported.

{

“name”: name “irods_id”: iRODS database ID “metadata”: [(key, val, units), (key, val, units) ….] “collections”: [ # only if collection and recursive == True

{

“rel_path”: relative path to upper rel_path “irods_id”: iRODS database ID “metadata”: [(key, val, units), (key, val, units) ….]

}, {

“rel_path”: relative path to upper rel_path “irods_id”: iRODS database ID “metadata”: [(key, val, units), (key, val, units) ….]

}, …

] “data_objects”:[ # only if collection and recurisve == True

{

“rel_path”: relative path to upper rel_path “irods_id”: iRODS database ID “checksum”: <checksum> “metadata”: [(key, val, units), (key, val, units) ….]

}, {

“rel_path”: relative path to upper rel_path “irods_id”: iRODS database ID “checksum”: <checksum> “metadata”: [(key, val, units), (key, val, units) ….]

}, …

]

}

Parameters:

  • meta (MetaData) – Metadata object to the collection or data object.

  • session (Session) – Session for which the metadata is retrieved.

  • recursive (bool) – Whether to also retrieve metadata for the sub collections (if applicable).

  • keys (Optional[list]) – Select all entries that have a name within this list, other entries are discarded. If keys is None, then all metadata entries are selected.

Raises:

ValueError: – If the metadata object is not pointing to a collection or data object.

Return type:

dict

Returns:

Dictionary containing the requested metadata items.

ibridges.icat_columns module

Definition of keywors and operators for iCAT searches.

ibridges.interactive module

Interactive authentication with iRODS server.

ibridges.interactive.interactive_auth(password=None, irods_env_path=None)

Interactive authentication with iRODS server.

Stores the password in ~/.irods/.irodsA upon success.

Parameters:

  • password (Optional[str]) – Password to make the connection with. If not supplied, you will be asked interactively.

  • irods_env_path (Union[None, str, Path]) – Path to the irods environment.

Raises:

  • FileNotFoundError: – If the irods_env_path does not exist.

  • ValueError: – If the connection to the iRods server cannot be established.

Return type:

Session

Returns:

A connected session to the server.

ibridges.meta module

metadata operations.

class ibridges.meta.MetaData(item)

Bases: object

Irods metadata operations.

This allows for adding and deleting of metadata entries for data objects and collections.

Examples

>>> meta = MetaData(coll)
>>> "Author" in meta
True
>>> for entry in meta:
>>>     print(entry.key, entry.value, entry.units)
Author Ben
Mass 10 kg
>>> meta.add("Author", "Emma")
>>> meta.set("Author", "Alice")
>>> meta.delete("Author")
>>> print(meta)
{Mass, 10, kg}
add(key, value, units=None)

Add metadata to an item.

This will never overwrite an existing entry.

Parameters:

  • key (str) – Key of the new entry to add to the item.

  • value (str) – Value of the new entry to add to the item.

  • units (Optional[str]) – The units of the new entry.

Raises:

  • ValueError: – If the metadata already exists.

  • PermissionError: – If the metadata cannot be updated because the user does not have sufficient permissions.

Examples

>>> meta.add("Author", "Ben")
>>> meta.add("Mass", "10", "kg")
clear()

Delete all metadata belonging to the item.

Raises:

PermissionError: – If the user has insufficient permissions to delete the metadata.

delete(key, value, units=None)

Delete a metadata entry of an item.

Parameters:

  • key (str) – Key of the new entry to add to the item.

  • value (Optional[str]) – Value of the new entry to add to the item.

  • units (Optional[str]) – The units of the new entry.

Raises:

  • KeyError: – If the to be deleted key cannot be found.

  • PermissionError: – If the user has insufficient permissions to delete the metadata.

Examples

>>> # Delete the metadata entry with mass 10 kg
>>> meta.delete("mass", "10", "kg")
>>> # Delete all metadata with key mass  and value 10
>>> meta.delete("mass", "10")
>>> # Delete all metadata with the key mass
>>> meta.delete("mass")
set(key, value, units=None)

Set the metadata entry.

If the metadata entry already exists, then all metadata entries with the same key will be deleted before adding the new entry. An alternative is using the add method to only add to the metadata entries and not delete them.

Parameters:

  • key (str) – Key of the new entry to add to the item.

  • value (str) – Value of the new entry to add to the item.

  • units (Optional[str]) – The units of the new entry.

Raises:

PermissionError: – If the user does not have sufficient permissions to set the metadata.

Examples

>>> meta.set("Author", "Ben")
>>> meta.set("mass", "10", "kg")
to_dict(keys=None)

Convert iRODS metadata (AVUs) and system information to a python dictionary.

{

“name”: item.name, “irods_id”: item.id, #iCAT database ID

“checksum”: item.checksum if the item is a data object “metadata”: [(m.name, m.value, m.units)]

}

Parameters:

keys (Optional[list]) – List of Attribute names which should be exported to “metadata”. By default all will be exported.

Return type:

dict

Returns:

Dictionary containing the metadata.

ibridges.path module

A class to handle iRODS paths.

class ibridges.path.CachedIrodsPath(session, size, is_dataobj, checksum, *args)

Bases: IrodsPath

Cached version of the IrodsPath.

This version should generally not be used by users, but is used for performance reasons. It will cache the size checksum and whether it is a data object. This can be invalidated when other ibridges operations are used.

property checksum: str

See IrodsPath.

collection_exists()

See IrodsPath.

Return type:

bool

dataobject_exists()

See IrodsPath.

Return type:

bool

property size: int

See IrodsPath.

class ibridges.path.IrodsPath(session, *args)

Bases: object

A class analogous to the pathlib.Path for accessing iRods data.

The IrodsPath can be used in much the same way as a Path from the pathlib library. Not all methods and attributes are implemented, and some methods/attributes behave subtly different from the pathlib implementation. They mostly do with the expansion of the home directory. With the IrodsPath, the ‘~’ is used to denote the irods_home directory set in the Session object. So, for example the name of an irods path is always the name of the collection/subcollection, which is different from the pathlib behavior in some cases.

absolute()

Return the absolute path.

This method does the expansion of the ‘~’ and ‘.’ symbols.

Return type:

IrodsPath

Returns:

The absolute IrodsPath, without any ‘~’ or ‘.’.

Examples

>>> IrodsPath(session, "~").absolute()
IrodsPath(/, zone, user)
property checksum: str

Checksum of the data object.

If not calculated yet, it will be computed on the server.

Return type:

The checksum of the data object.

Raises:

ValueError – When the path does not point to a data object.

Examples

>>> IrodsPath(session, "~/some_dataobj.txt").checksum
'sha2:XGiECYZOtUfP9lnCGyZaBBkBGLaJJw1p6eoc0GxLeKU='
property collection: iRODSCollection

Instantiate an iRODS collection.

Raises:

  • ValueError: – If the path points to a dataobject and not a collection.

  • CollectionDoesNotExist: – If the path does not point to a dataobject or a collection.

Returns:

Instance of the collection with path.

Return type:

iRODSCollection

Examples

>>> IrodsPath(session, "~/some_collection").collection
<iRODSCollection 21260050 b'some_collection'>
collection_exists()

Check if the path points to an iRODS collection.

Return type:

bool

Examples

>>> IrodsPath(session, "~/does_not_exist").collection_exists()
False
>>> IrodsPath(session, "~/some_dataobj").collection_exists()
False
>>> IrodsPath(session, "~/some_collection").collection_exists()
True
static create_collection(session, coll_path)

Create a collection and all parent collections that do not exist yet.

Parameters:

  • session – Session for which the collection is created.

  • coll_path (Union[IrodsPath, str]) – Irods path to the collection to be created.

Raises:

PermissionError: – If the collection cannot be created due to insufficient permissions.

Returns:

The newly created collection.

Return type:

collection

Examples

>>> IrodsPath.create_collection(session, "/zone/home/user/some_collection")
>>> IrodsPath.create_collection(session, IrodsPath(session, "~/some_collection"))
property dataobject: iRODSDataObject

Instantiate an iRODS data object.

Raises:

ValueError: – If the path is pointing to a collection and not a data object.

Returns:

Instance of the data object with path.

Return type:

iRODSDataObject

Examples

>>> IrodsPath(session, "~/some_dataobj.txt").dataobject
<iRODSDataObject 24490075 some_dataobj.txt>
dataobject_exists()

Check if the path points to an iRODS data object.

Return type:

bool

Examples

>>> IrodsPath(session, "~/does_not_exist").dataobject_exists()
False
>>> IrodsPath(session, "~/some_collection").dataobject_exists()
False
>>> IrodsPath(session, "~/some_dataobj").dataobject_exists()
True
exists()

Check if the path already exists on the iRODS server.

Return type:

bool

Examples

>>> IrodsPath(session, "~/does_not_exist").exists()
False
>>> IrodsPath(session, "~/some_collection").exists()
True
>>> IrodsPath(session, "~/some_dataobj").exists()
True
joinpath(*args)

Concatenate another path to this one.

Return type:

IrodsPath

Returns:

The concatenated path.

Examples

>>> IrodsPath(session, "~").joinpath("x", "y")
IrodsPath(~, x, y)
property name: str

Return the name of the data object or collection.

Return type:

The name of the object/collction, similarly to pathlib.

Examples

>>> IrodsPath(session, "/zone/home/user")
"user"
property parent: IrodsPath

Return the parent directory of the current directory.

Return type:

The parent just above the current directory

Examples

>>> IrodsPath(session, "/zone/home/user").parent
IrodsPath("/", "zone", "home")
>>> IrodsPath(session, "~").parent
IrodsPath("/", "zone", "home")
relative_to(other)

Calculate the relative path compared to our path.

Can only calculate the relateive path compared to another irods path.

>>> IrodsPath(session, "~/col/dataobj.txt").relative_to(IrodsPath(session, "~"))
PurePosixPath(col, dataobj.txt)
:rtype: :sphinx_autodoc_typehints_type:`\:py\:class\:\`\~pathlib.PurePosixPath\``

>>> IrodsPath(session, "~/col/dataobj.txt").relative_to(IrodsPath(session, "~/col"))
PurePosixPath(dataobj.txt)
remove()

Remove the data behind an iRODS path.

Raises:

PermissionError: – If the user has insufficient permission to remove the data.

Examples

>>> IrodsPath(session, "/home/zone/user/some_collection").remove()
rename(new_name)

Change the name or the path of a data object or collection.

New collections on the path will be created.

Parameters:

new_name (str or IrodsPath) – new name or a new full path

Raises:

  • ValueError: – If the new path already exists, or the path is in a different zone.

  • PermissionError: – If the new collection cannot be created.

Return type:

IrodsPath

Examples

>>> IrodsPath(session, "~/some_collection").rename("~/new_collection")
property size: int

Collect the sizes of a data object or a collection.

Returns:

Total size [bytes] of the iRODS object or all iRODS objects in the collection.

Return type:

int

Raises:

ValueError: – If the path is neither a collection or data object.

Examples

>>> IrodsPath(session, "~/some_collection").size
12345
>>> IrodsPath(session, "~/some_dataobj.txt").size
623
walk(depth=None)

Walk on a collection.

This iterates over all collections and data object for the path. If the path is pointing to a data object, it will simply yield this data object.

Parameters:

depth (int) – The maximum depth relative to the starting collection over which is walked. For example if depth equals 1, then it will iterate only over the subcollections and data objects directly under the starting collection.

Return type:

Iterable[IrodsPath]

Returns:

Generator that generates all data objects and subcollections in the collection.

Examples

>>> for ipath in IrodsPath(session, "~").walk():
>>>     print(ipath)
IrodsPath(~, x)
IrodsPath(~, x, y)
IrodsPath(~, x, y, z.txt)
>>> for ipath in IrodsPath(session, "~").walk(depth=1):
>>>     print(ipath)
IrodsPath(~, x)

ibridges.permissions module

permission operations.

class ibridges.permissions.Permissions(session, item)

Bases: object

Irods permissions operations.

property available_permissions: dict

Get available permissions.

set(perm, user=None, zone=None, recursive=False, admin=False)

Set permissions (ACL) for an iRODS collection or data object.

Return type:

None

ibridges.resources module

resource operations.

class ibridges.resources.Resources(session)

Bases: object

Irods Resource operations.

get_free_space(resc_name)

Determine free space in a resource hierarchy.

Storeage resources: return annotation “free_space”. Coordinating resources: return sum of all free space of the resource subtree. If “free_space” is not set, set value to 0.

Parameters:

resc_name (str) – Name of monolithic resource or the top of a resource tree.

Return type:

int

Returns:

  • int – Number of bytes free in the resource hierarchy.

  • The return value can have one of two possible values if not the actual

  • free space –

    -1 if the resource does not exists (typo or otherwise)
    0 if no free space has been set in the whole resource tree

    starting at node resc_name.

get_resource(resc_name)

Instantiate an iRODS resource.

Prameters

resc_namestr

Name of the iRODS resource.

returns:

Instance of the resource with resc_name.

rtype:

iRODSResource

raises irods.exception.ResourceDoesNotExist::

If the resource does not exist.

get_resource_children(resc)

Get all the children for the resource resc.

Parameters:

resc (instance) – iRODS resource instance.

Returns:

Instances of child resources.

Return type:

list

resources(update=False)

IRODS resources and their metadata.

Parameters:

update (bool) – Fetch information from iRODS server and overwrite _resources

Return type:

dict

Returns:

  • dict – Name, parent, status, context, and free_space of all resources.

  • NOTE (free_space of a resource is the free_space annotated, if) – so annotated, otherwise it is the sum of the free_space of all its children.

property root_resources: list[tuple]

Filter resources for all root resources.

Data can only be written to root resources. Return their names, their status and their free space.

Return type:

List [(resource_name, status, free_space, context)]

ibridges.rules module

Rule operations.

ibridges.rules.execute_rule(session, rule_file, params, output='ruleExecOut', instance_name='irods_rule_engine_plugin-irods_rule_language-instance', **kwargs)

Execute an iRODS rule.

params format example: >>> # Notice extra quotes for string literals >>> params = { >>> ‘*obj’: ‘”/zone/home/user”’, >>> ‘*name’: ‘“attr_name”’, >>> ‘*value’: ‘“attr_value”’ >>> }

Parameters:

  • session (ibridges.session) – The irods session

  • rule_file (str) – Name of the iRODS rule file, or a file-like object representing it.

  • params (dict) – Rule input variable(s).

  • output (str) – Rule output variable(s).

  • instance_name (str) – Changes between irods rule language and python rules.

  • kwargs (dict) – optional irods rule parameters. For more information: https://github.com/irods/python-irodsclient

Returns:

(stdout, stderr)

Return type:

tuple

ibridges.search module

Data query.

ibridges.search.search_data(session, path=None, checksum=None, key_vals=None)

Retrieve all collections and data objects.

(the absolute collection path, data object or collection name) to the given user-defined and system metadata. By Default all accessible collections and data objects will be returned. Wildcard: %

Parameters:

  • session (Session) – Session to search with.

  • path (str) – (Partial) path or IrodsPath

  • checksum (str) – (Partial) checksum

  • key_vals (dict) – Attribute name mapping to values.

Raises:

ValueError: – If no search criterium is supplied.

Returns:

list – List of dictionaries with keys: COLL_NAME (absolute path of the collection), DATA_NAME (name of the data object), D_DATA_CHECKSUM (checksum of the data object) The latter two keys are only present of the found item is a data object.

Return type:

[dict]

ibridges.session module

session operations.

exception ibridges.session.LoginError

Bases: AttributeError

Error indicating a failure to log into the iRODS server due to the configuration.

exception ibridges.session.PasswordError

Bases: ValueError

Error indicating failure to log into the iRODS server due to wrong or outdated password.

class ibridges.session.Session(irods_env, password=None, irods_home=None)

Bases: object

Irods session authentication.

authenticate_using_auth_file()

Authenticate with an authentication file.

Return type:

iRODSSession

authenticate_using_password()

Authenticate with the iRODS server using a password.

Return type:

iRODSSession

close()

Disconnect the irods session.

This closes the connection, and makes the session available for reconnection with connect.

Return type:

None

connect()

Establish an iRODS session.

Return type:

iRODSSession

property default_resc: str

Default resource name from iRODS environment.

Returns:

Resource name.

Return type:

str

get_user_info()

Query for user type and groups.

Return type:

tuple[list, list]

Returns:

  • list – iRODS user type names

  • list – iRODS group names

has_valid_irods_session()

Check if the iRODS session is valid.

Returns:

Is the session valid?

Return type:

bool

property home: str

Current working directory for irods.

In the iRODS community this is known as ‘irods_home’, in file system terms it would be the current working directory.

Return type:

The current working directory in the current session.

Examples

>>> session.home
/zone/home/user
classmethod network_check(hostname, port)

Check connectivity to an iRODS server.

Parameters:

  • hostname (str) – FQDN/IP of an iRODS server.

  • port (int) – Port to which to connect to the server

Returns:

Connection to hostname possible.

Return type:

bool

property server_version: tuple

Retrieve version of the iRODS server.

Returns:

Server version: (major, minor, patch).

Return type:

tuple

write_pam_password()

Store the password in the iRODS authentication file in obfuscated form.

ibridges.tickets module

Ticket operations.

class ibridges.tickets.TicketData(name, type, path, expiration_date)

Bases: tuple

expiration_date

Alias for field number 3

name

Alias for field number 0

path

Alias for field number 2

type

Alias for field number 1

class ibridges.tickets.Tickets(session)

Bases: object

Irods Ticket operations.

property all_ticket_strings: list[str]

Get the names of all tickets.

clear()

Delete all tickets.

create_ticket(obj_path, ticket_type='read', expiry_date=None)

Create an iRODS ticket.

This allows read access to the object referenced by obj_path.

Parameters:

  • obj_path (str) – Collection or data object path to create a ticket for.

  • ticket_type (str) – read or write, default read

  • optional – read or write, default read

  • expiry_date (Union[str, datetime, date, None]) – Expiration date as a datetime, date or string in the form strftime(‘%Y-%m-%d.%H:%M:%S’).

  • optional – Expiration date as a datetime, date or string in the form strftime(‘%Y-%m-%d.%H:%M:%S’).

Raises:

  • TypeError: – If the expiry_date has the wrong type.

  • ValueError: – If the expiration date cannot be set for whatever reason.

Returns:

Name of ticket and if expiration string successfully set: (str, bool)

Return type:

tuple

delete_ticket(ticket, check=False)

Delete irods ticket.

Parameters:

  • ticket (Union[str, Ticket]) – Ticket or ticket string identifier to be deleted.

  • check (bool) – Whether to check whether the ticket actually exists.

Raises:

KeyError: – If check == True and the ticket does not exist.

get_ticket(ticket_str)

Obtain a ticket using its string identifier.

Parameters:

ticket_str (str) – Unique string identifier with which the ticket can be retrieved.

Raises:

KeyError: – If the ticket cannot be found.

Return type:

Ticket

Returns:

Ticket with the correct identifier.

update_tickets()

Retrieve all tickets and their metadata belonging to the user.

Parameters:

update (bool) – Refresh information from server.

Returns:

[(ticket string, ticket type, irods obj/coll path, expiry data in epoche)]

Return type:

list