Acquire.Client._par module

class PAR(url=None, key=None, encrypt_key=None, expires_datetime=None, is_readable=False, is_writeable=False, is_executable=False, driver_details=None)

Bases: object

This class holds the result of a pre-authenticated request (a PAR - also called a pre-signed request). This holds a pre-authenticated URL to access either;

1. A individual object in an object store (read or write)
2. An entire bucket in the object store (write only)
3. A calculation to be performed on the compute service (start or stop)

The PAR is created encrypted, so can only be used by the person or service that has access to the decryption key

static checksum(data)

Return the checksum of the passed data. This is used either for validating data, and is also used to create a checksum of the URL so that the user can demonstrate that they can decrypt this PAR

close(decrypt_key=None)

Close this PAR - this closes and deletes the PAR. You must pass in the decryption key so that you can validate that you have permission to read (and thus close) this PAR

driver()

Return the driver behind this PAR - this is only available on the service

driver_details()

Return the driver details for this PAR. This is used only on the service that created the PAR, and returns an empty dictionary if the details are not available

execute(decrypt_key=None)

Return an object that can be used to control execution of this PAR

expires_when()

Return when this PAR expires (or expired)

fingerprint()

Return a fingerprint for this PAR that can be used in authorisations

static from_data(data, passphrase=None)

Return a PAR constructed from the passed json-deserliased dictionary

is_bucket()

Return whether or not this PAR is for an entire bucket

is_calculation()

Return whether or not this PAR is for a calculation

is_executable()

Return whether or not this is an executable job

is_null()

Return whether or not this is null

is_object()

Return whether or not this PAR is for a single object

is_readable()

Return whether or not this PAR gives read access

is_writeable()

Return whether or not this PAR gives write access

key()

Return the key for the object this accesses - this is None if the PAR grants access to the entire bucket

read(decrypt_key=None)

Return an object that can be used to read data from this PAR

seconds_remaining(buffer=30)

Return the number of seconds remaining before this PAR expires. This will return 0 if the PAR has already expired. To be safe, you should renew PARs if the number of seconds remaining is less than 60. This will subtract ‘buffer’ seconds from the actual validity to provide a buffer against race conditions (function says this is valid when it is not)

service()

Return the service that created this PAR

service_url()

Return the URL of the service that created this PAR

to_data(passphrase=None)

Return a json-serialisable dictionary that contains all data for this object

uid()

Return the UID of this PAR

url(decrypt_key=None)

Return the URL at which the bucket/object can be accessed. This will raise a PARTimeoutError if the url has less than 30 seconds of validity left. Note that you must pass in the key used to decrypt the PAR

write(decrypt_key=None)

Return an object that can be used to write data to this PAR

class BucketReader(par=None, decrypt_key=None)

Bases: object

This class provides functions to enable reading data from a bucket via a PAR

get_all_object_names(prefix=None)

Returns the names of all objects in the passed bucket

get_all_objects(prefix=None)

Return all of the objects in the passed bucket

get_all_strings(prefix=None)

Return all of the strings in the passed bucket

get_object(key)

Return the binary data contained in the key ‘key’ in the passed bucket

get_object_as_file(key, filename)

Get the object contained in the key ‘key’ in the passed ‘bucket’ and writing this to the file called ‘filename’

get_object_from_json(key)

Return an object constructed from json stored at ‘key’ in the passed bucket. This raises an exception if there is no data or the PAR has expired

get_string_object(key)

Return the string in ‘bucket’ associated with ‘key’

class BucketWriter(par=None, decrypt_key=None)

Bases: object

This class provides functions to enable writing data to a bucket via a PAR

set_object(key, data)

Set the value of ‘key’ in ‘bucket’ to binary ‘data’

set_object_from_file(key, filename)

Set the value of ‘key’ in ‘bucket’ to equal the contents of the file located by ‘filename’

set_object_from_json(key, data)

Set the value of ‘key’ in ‘bucket’ to equal to contents of ‘data’, which has been encoded to json

set_string_object(key, string_data)

Set the value of ‘key’ in ‘bucket’ to the string ‘string_data’

class ObjectReader(par=None, decrypt_key=None)

Bases: object

This class provides functions for reading an object via a PAR

get_object()

Return the binary data contained in this object

get_object_as_file(filename)

Get the object contained in this PAR and write this to the file called ‘filename’

get_object_from_json()

Return an object constructed from json stored at behind this PAR. This raises an exception if there is no data or the PAR has expired

get_string_object()

Return the object behind this PAR as a string (raises exception if it is not a string)’

class ObjectWriter(par=None, decrypt_key=None)

Bases: Acquire.Client._par.ObjectReader

This is an extension of ObjectReader that also allows writing to the object via the PAR

set_object(data)

Set the value of the object behind this PAR to the binary ‘data’

set_object_from_file(filename)

Set the value of the object behind this PAR to equal the contents of the file located by ‘filename’

set_object_from_json(data)

Set the value of the object behind this PAR to equal to contents of ‘data’, which has been encoded to json

set_string_object(string_data)

Set the value of the object behind this PAR to the string ‘string_data’

class ComputeRunner(par=None, decrypt_key=None)

Bases: object

This class provides functions for executing a calculation pre-authorised by the passed PAR