REST Handle Client

Note

The REST client documentation is based mainly on the B2Handle documentation. Here we describe only the main functionalities of the REST client.

Important

If you encounter security warnings when using the library, contact your Handle server administrators and ask them to set up the server certificates correctly! (see Handle Server Configuration)

The RESTHandleClient class provides a Python-level interface for interactions with a Handle server through its native REST interface. The class provides common methods for working with Handles and their records:

  • Create and modify Handles

  • Search across Handles (using an additional servlet)

General usage

First, you create an instance of the client. It holds all necessary information, such as from which handle server to read, which user credentials to use etc. Several different instantiation methods are available for different usages (see PyHandleClient).

from pyhandle.handleclient import PyHandleClient
client = PyHandleClient('rest').instantiate_...(...)

Then, use the client’s methods to read, create and modify handles.

value = client.some_method(...)

Search functionality is not offered by the Handle System. For searching, you need access to a customized search servlet.

Instantiation

When instantiating the REST client there are several constructors with differences in the permissions and thus possible actions on the Handle server. Aside from the default constructor __init__(), there are several shorthand constructors:

instantiate_for_read_access()

Anonymous read-only access, no credentials needed, no search capabilities. Handles are read from the global Handle Registry.

instantiate_for_read_and_search()

Read-only access, credentials for search functions required.

instantiate_with_username_and_password()

Full read and write access, credentials required (username and password).

instantiate_with_credentials()

Full read and write access, credentials required (username and password or client certificates). Credentials can conveniently be loaded from a JSON file. For this, please see documentation of clientcredentials.

On top of the required arguments, more arguments can be passed to the constructors as key-value pairs. Please see the documentation of the default constructor to find out which values are understood.

Instantiation can be performed when specifying the client as follows:

from pyhandle.handleclient import PyHandleClient
client = PyHandleClient('rest').instantiate_...()

Note

The instantiation methods mentioned above concern only the REST client. Concerning the DB client there is for now no restriction for creating or modifying Handles in the database.

Authentication

For creating and modifying handles* you need to authenticate at the Handle Server you’d like to write to. Authentication using pyhandle is straightforward. There are two possibilities:

  • Authenticating using username and password

  • Authenticating using client certificates

Important

Here we assume that you know your username and password or have your private key file and your certificate file ready. If you need to set these up, please see Authentication at a Handle Server.

Authentication using client certificates

Using client certificates, you need to provide paths to the file containing your private key and to the certificate in a JSON file. The class PIDClientCredentials provides a method load_from_JSON(). This can be read as follows:

from pyhandle.clientcredentials import PIDClientCredentials
cred = PIDClientCredentials.load_from_JSON('my_credentials.json')
client = PyHandleClient('rest').instantiate_with_credentials(cred)

The JSON file should look like this:

{
  "client":"rest",
  "handle_server_url": "https://my.handle.server",
  "private_key": "my_private_key.pem",
  "certificate_only": "my_certificate.pem"
}

Authentication using username and password

If you have a username (something that looks like 300:foo/bar) and a password, we recommend using this constructor: instantiate_with_username_and_password():

client = PyHandleClient('rest').instantiate_with_username_and_password(
  'https://my.handle.server',
  '300:foo/bar',
  'mypassword123'
)
Alternatively, you can store your username and password in a JSON file, instead of paths to certificate and key::

{ “baseuri”: “https://my.handle.server”, “username”: “300:foo/bar”, “password”: “mypassword123” }

Like above, you can read the JSON like as shown above:

cred = PIDClientCredentials.load_from_JSON('my_credentials.json')
client = PyHandleClient('rest').instantiate_with_credentials(cred)

Credentials JSON file

The JSON file can contain more information. All items it contains are passed to the client constructor as config. Please see __init__() to find out which configuration items the client constructor understands.

Basic Handle interaction

Creating a Handle

Use register_handle() to create a Handle with a custom name or generate_and_register_handle() to create a Handle with a random UUID-based name.

Deleting a Handle

Use delete_handle().

Retrieving a full Handle record

This can be done either through retrieve_handle_record() or retrieve_handle_record_json().

Retrieving a single value

Use get_value_from_handle() to retrieve a single Handle record value.

Modifying a Handle record

Use modify_handle_value() to modify any number of values in a specific Handle record. To remove individual values, use delete_handle_value().

Searching for a Handle

Use search_handle() to search for Handles with a specific key and value. Please note that searching requires access to a search servlet whose access information, if it differs from the handle server, has to be specified at client instantiation.

Full method documentation

Constructors

RESTHandleClient.__init__(handle_server_url=None, **args)[source]

Initialize the client. Depending on the arguments passed, it is set to read-only, write and/or search mode. All arguments are optional. If none is set, the client is in read-only mode, reading from the global handle resolver.

Parameters:

  • handle_server_url – Optional. The URL of the Handle System server to read from. Defaults to ‘https://hdl.handle.net’

  • username – Optional. This must be a handle value reference in the format “index:prefix/suffix”. The method will throw an exception upon bad syntax or non-existing Handle. The existence or validity of the password in the handle is not checked at this moment.

  • password – Optional. This is the password stored as secret key in the actual Handle value the username points to.

  • REST_API_url_extension – Optional. The extension of a Handle Server’s URL to access its REST API. Defaults to ‘/api/handles/’.

  • allowed_search_keys – Optional. The keys that can be used for reverse lookup of handles, as a list of strings. Defaults to ‘URL’ and ‘CHECKSUM’. If the list is empty, all keys are passed to the reverse lookup servlet and exceptions are passed on to the user.

  • modify_HS_ADMIN – Optional. Advanced usage. Determines whether the HS_ADMIN handle record entry can be modified using this library. Defaults to False and should not be modified.

  • HTTPS_verify – Optional. This parameter can have three values. ‘True’, ‘False’ or ‘the path to a CA_BUNDLE file or directory with certificates of trusted CAs’. If set to False, the certificate is not verified in HTTP requests. Defaults to True.

  • reverselookup_baseuri – Optional. The base URL of the reverse lookup service. If not set, the handle server base URL is used.

  • reverselookup_url_extension – Optional. The path to append to the reverse lookup base URL to reach the reverse lookup service. Defaults to ‘/hrls/handles/’.

  • handleowner – Optional. The username that will be given admin permissions over every newly created handle. By default, it is ‘200:0.NA/xyz’ (where xyz is the prefix of the handle being created.

  • HS_ADMIN_permissions – Optional. Advanced usage. This indicates the permissions that are given to the handle owner of newly created handles in the HS_ADMIN entry.

  • private_key – Optional. The path to a file containing the private key that will be used for authentication in write mode. If this is specified, a certificate needs to be specified too.

  • certificate_only – Optional. The path to a file containing the client certificate that will be used for authentication in write mode. If this is specified, a private key needs to be specified too.

  • certificate_and_key – Optional. The path to a file containing both certificate and private key, used for authentication in write mode.

static RESTHandleClient.instantiate_for_read_access(handle_server_url=None, **config)[source]

Initialize the client in read-only mode. Access is anonymous, thus no credentials are required.

Parameters:

  • handle_server_url – Optional. The URL of the Handle System server to read from. Defaults to ‘https://hdl.handle.net’

  • **config –

    More key-value pairs may be passed that will be passed on to the constructor as config. Config options from the credentials object are overwritten by this.

Returns:

An instance of the client.

Initialize client with read access and with search function.

Parameters:

  • handle_server_url – The URL of the Handle Server. May be None (then, the default ‘https://hdl.handle.net’ is used).

  • reverselookup_username – The username to authenticate at the reverse lookup servlet.

  • reverselookup_password – The password to authenticate at the reverse lookup servlet.

  • **config –

    More key-value pairs may be passed that will be passed on to the constructor as config. Config options from the credentials object are overwritten by this.

Returns:

An instance of the client.

static RESTHandleClient.instantiate_with_username_and_password(handle_server_url, username, password, **config)[source]

Initialize client against an HSv8 instance with full read/write access.

The method will throw an exception upon bad syntax or non-existing Handle. The existence or validity of the password in the handle is not checked at this moment.

Parameters:

  • handle_server_url – The URL of the Handle System server.

  • username – This must be a handle value reference in the format “index:prefix/suffix”.

  • password – This is the password stored as secret key in the actual Handle value the username points to.

  • **config –

    More key-value pairs may be passed that will be passed on to the constructor as config.

Raises:

HandleNotFoundException: If the username handle is not found.

Raises:

HandleSyntaxError

Returns:

An instance of the client.

static RESTHandleClient.instantiate_with_credentials(credentials, **config)[source]

Initialize the client against an HSv8 instance with full read/write access.

Parameters:

  • credentials – A credentials object, see separate class PIDClientCredentials.

  • **config –

    More key-value pairs may be passed that will be passed on to the constructor as config. Config options from the credentials object are overwritten by this.

Raises:

HandleNotFoundException: If the username handle is not found.

Returns:

An instance of the client.

Handle record methods

RESTHandleClient.register_handle(handle, location, checksum=None, additional_URLs=None, overwrite=False, **extratypes)[source]

Registers a new Handle with given name. If the handle already exists and overwrite is not set to True, the method will throw an exception. Note: This is just a wrapper for register_handle_kv. It was made for legacy reasons, as this library was created to replace an earlier library that had a method with specifically this signature.

Note 2: It allows to pass (additionally to the handle name) a mandatory URL, and optionally a CHECKSUM, and more types as key-value pairs. Old method, made for legacy reasons, as this library was created to replace an earlier library that had a method with specifically this signature.

Parameters:

  • handle – The full name of the handle to be registered (prefix and suffix)

  • location – The URL of the data entity to be referenced

  • checksum – Optional. The checksum string.

  • extratypes – Optional. Additional key value pairs such as: additional_URLs for 10320/loc

  • additional_URLs – Optional. A list of URLs (as strings) to be added to the handle record as 10320/LOC entry. Note: This is currently not implemented.

  • overwrite – Optional. If set to True, an existing handle record will be overwritten. Defaults to False.

Raises:

HandleAlreadyExistsException Only if overwrite is not set or set to False.

Raises:

HandleAuthenticationError

Raises:

HandleSyntaxError

Returns:

The handle name.

RESTHandleClient.register_handle_kv(handle, overwrite=False, **kv_pairs)[source]

Registers a new Handle with given name. If the handle already exists and overwrite is not set to True, the method will throw an exception.

Parameters:

  • handle – The full name of the handle to be registered (prefix and suffix)

  • kv_pairs – The key value pairs to be included in the record, e.g. URL, CHECKSUM, …

  • overwrite – Optional. If set to True, an existing handle record will be overwritten. Defaults to False.

Raises:

HandleAlreadyExistsException Only if overwrite is not set or set to False.

Raises:

HandleAuthenticationError

Raises:

HandleSyntaxError

Returns:

The handle name.

RESTHandleClient.register_handle_json(handle, list_of_entries, overwrite=False)[source]

Registers a new Handle with given name. If the handle already exists and overwrite is not set to True, the method will throw an exception.

Note:It allows to pass JSON snippets instead of key-value pairs, so you can specify the indices. An entry looks like this: {‘index’:index, ‘type’:entrytype, ‘data’:data}. This is the format in which the changes are communicated to the handle server via its REST interface. An entry of type HS_ADMIN will be added if you do not provide one.

Parameters:

  • handle – The full name of the handle to be registered (prefix and suffix)

  • list_of_entries – The entries to be included in the record, e.g. URL, CHECKSUM, … Example for an entry: {‘index’:index, ‘type’:entrytype, ‘data’:data} Optionally you can add ‘ttl’.

  • overwrite – Optional. If set to True, an existing handle record will be overwritten. Defaults to False.

Raises:

HandleAlreadyExistsException Only if overwrite is not set or set to False.

Raises:

HandleAuthenticationError

Raises:

HandleSyntaxError

Returns:

The handle name.

RESTHandleClient.generate_and_register_handle(prefix, location, checksum=None, overwrite=False, **extratypes)[source]

Register a new Handle with a unique random name (random UUID).

Note: is a similar legacy method. Instead, just use generate_PID_name(prefix) to create a handle name and use one of the above.

Parameters:

  • prefix – The prefix of the handle to be registered. The method will generate a suffix.

  • location – The URL of the data entity to be referenced.

  • checksum – Optional. The checksum string.

  • extratypes – Optional. Additional key value pairs as dict.

Raises:

HandleAuthenticationError

Returns:

The new handle name.

RESTHandleClient.delete_handle(handle, *other)[source]

Delete the handle and its handle record. If the Handle is not found, an Exception is raised.

Parameters:

  • handle – Handle to be deleted.

  • other – Deprecated. This only exists to catch wrong method usage by users who are used to delete handle VALUES with the method.

Returns:

The deleted handle.

Raises:

HandleAuthenticationError

Raises:

HandleNotFoundException

Raises:

HandleSyntaxError

RESTHandleClient.retrieve_handle_record(handle, handlerecord_json=None, auth=False, indices=None, **hs_options)[source]

Retrieve a handle record from the Handle server as a dict. If there is several entries of the same type, only the first one is returned. Values of complex types (such as HS_ADMIN) are transformed to strings.

Parameters:

  • handle – The handle whose record to retrieve.

  • handlerecord_json – Optional. If the handlerecord has already been retrieved from the server, it can be reused.

  • auth – Optional. If set to True, the handle record will be retrieved from the primary server and not from cache, so changes from the last max. 24 hours or so will be included. Defaults to False.

  • indices – Optional. A list of indices to retrieve. Defaults to None (i.e. the entire handle is retrieved.). The list can contain integers or strings.

  • hs_options – Optional. A list of key-value pairs which will be appended to the URL as parameters, to be passed to the Handle Server during the GET request (e.g. “&type=xyz”). Please see the Handle Tech Manual for possible values. To add several “?index=xyz” options, pass a list or use the parameter “indices”. To add several “?type=xyz” options, add them as a list.

Returns:

A dict where the keys are keys from the Handle record (except for hidden entries) and every value is a string. The result will be None if the Handle does not exist.

Raises:

HandleSyntaxError

RESTHandleClient.retrieve_handle_record_json(handle, auth=False, indices=None, **hs_options)[source]

Retrieve a handle record from the Handle server as a complete nested dict (including index, ttl, timestamp, …) for later use.

Note: For retrieving a simple dict with only the keys and values, please use retrieve_handle_record().

Parameters:

  • handle – The Handle whose record to retrieve.

  • auth – Optional. If set to True, the handle record will be retrieved from the primary server and not from cache, so changes from the last max. 24 hours will be included. Defaults to False.

  • indices – Optional. A list of indices to retrieve. Defaults to None (i.e. the entire handle record is retrieved). The list can contain integers or strings.

  • hs_options – Optional. A list of key-value pairs which will be appended to the URL as parameters, to be passed to the Handle Server during the GET request (e.g. “&type=xyz”). Please see the Handle Tech Manual for possible values. To add several “?index=xyz” options, pass a list or use the parameter “indices”. To add several “?type=xyz” options, add them as a list.

Raises:

HandleSyntaxError

Returns:

The handle record as a nested dict. If the handle does not exist, returns None.

RESTHandleClient.get_value_from_handle(handle, key, handlerecord_json=None, auth=False, indices=None, **hs_options)[source]

Retrieve a single value from a single Handle. If several entries with this key exist, the methods returns the first one. If the handle does not exist, the method will raise a HandleNotFoundException.

Parameters:

  • handle – The handle to take the value from.

  • key – The key.

  • auth – Optional. If set to True, the handle record will be retrieved from the primary server and not from cache, so changes from the last max. 24 hours or so will be included. Defaults to False.

  • indices – Optional. A list of indices to retrieve. Defaults to None (i.e. the entire handle is retrieved.). The list can contain integers or strings.

  • hs_options – Optional. A list of key-value pairs which will be appended to the URL as parameters, to be passed to the Handle Server during the GET request (e.g. “&type=xyz”). Please see the Handle Tech Manual for possible values. To add several “?index=xyz” options, pass a list or use the parameter “indices”. To add several “?type=xyz” options, add them as a list.

Returns:

A string containing the value or None if the Handle record does not contain the key.

Raises:

HandleSyntaxError

Raises:

HandleNotFoundException

RESTHandleClient.modify_handle_value(handle, ttl=None, add_if_not_exist=True, **kvpairs)[source]

Modify entries (key-value-pairs) in a handle record. If the key does not exist yet, it is created.

Note: We assume that a key exists only once. In case a key exists several time, an exception will be raised.

Parameters:

  • handle – Handle whose record is to be modified

  • ttl – Optional. Integer value. If ttl should be set to a non-default value.

  • add_if_not_exist – Optional. Whether a kv pair should be added if the key does not exist yet.

  • args (all other) – The user can specify several key-value-pairs. These will be the handle value types and values that will be modified. The keys are the names or the handle value types (e.g. “URL”). The values are the new values to store in “data”. If the key is ‘HS_ADMIN’, the new value needs to be of the form {‘handle’:’xyz’, ‘index’:xyz}. The permissions will be set to the default permissions.

Returns:

The modified handle.

Raises:

HandleAuthenticationError

Raises:

HandleNotFoundException

Raises:

HandleSyntaxError

RESTHandleClient.delete_handle_value(handle, key)[source]

Delete a key-value pair from a handle record. If the key exists more than once, all key-value pairs with this key are deleted.

Parameters:

  • handle – Handle from whose record the entry should be deleted.

  • key – Key to be deleted. Also accepts a list of keys.

Returns:

The deleted handle.

Raises:

HandleAuthenticationError

Raises:

HandleNotFoundException

Raises:

HandleSyntaxError

RESTHandleClient.search_handle(URL=None, prefix=None, **key_value_pairs)[source]

Search for handles containing the specified key with the specified value. The search terms are passed on to the reverse lookup servlet as-is. The servlet is supposed to be case-insensitive, but if it isn’t, the wrong case will cause a ReverseLookupException.

Note: If allowed search keys are configured, only these are used. If no allowed search keys are specified, all key-value pairs are passed on to the reverse lookup servlet, possibly causing a ReverseLookupException.

Example calls:

list_of_handles = search_handle('http://www.foo.com')
list_of_handles = search_handle('http://www.foo.com', CHECKSUM=99999)
list_of_handles = search_handle(URL='http://www.foo.com', CHECKSUM=99999)
Parameters:

  • URL – Optional. The URL to search for (reverse lookup). [This is NOT the URL of the search servlet!]

  • prefix – Optional. The Handle prefix to which the search should be limited to. If unspecified, the method will search across all prefixes present at the server given to the constructor.

  • key_value_pairs – Optional. Several search fields and values can be specified as key-value-pairs, e.g. CHECKSUM=123456, URL=www.foo.com

Raise:

ReverseLookupException: If a search field is specified that cannot be used, or if something else goes wrong.

Returns:

A list of all Handles (strings) that bear the given key with given value of given prefix or server. The list may be empty and may also contain more than one element.

Helper methods

RESTHandleClient.generate_PID_name(prefix=None)[source]

Generate a unique random Handle name (random UUID). The Handle is not registered. If a prefix is specified, the PID name has the syntax <prefix>/<generatedname>, otherwise it just returns the generated random name (suffix for the Handle).

Parameters:

prefix – Optional. The prefix to be used for the Handle name.

Returns:

The handle name in the form <prefix>/<generatedsuffix> or <generatedsuffix>.

RESTHandleClient.get_handlerecord_indices_for_key(key, list_of_entries)[source]

Finds the Handle entry indices of all entries that have a specific type.

Important: It finds the Handle System indices! These are not the python indices of the list, so they can not be used for iteration.

Parameters:

  • key – The key (Handle Record type)

  • list_of_entries – A list of the existing entries in which to find the indices.

Returns:

A list of strings, the indices of the entries of type “key” in the given handle record.

Utilities

This module provides some handle-related functions that are needed across various modules of the pyhandle library.

pyhandle.utilhandle.check_handle_syntax(string)[source]

Checks the syntax of a handle without an index (are prefix and suffix there, are there too many slashes?).

String:

The handle without index, as string prefix/suffix.

Raise:

HandleSyntaxError

Returns:

True. If it’s not ok, exceptions are raised.

pyhandle.utilhandle.check_handle_syntax_with_index(string, base_already_checked=False)[source]

Checks the syntax of a handle with an index (is index there, is it an integer?), and of the handle itself.

String:

The handle with index, as string index:prefix/suffix.

Raise:

HandleSyntaxError

Returns:

True. If it’s not ok, exceptions are raised.

pyhandle.utilhandle.create_authentication_string(username, password)[source]

Creates an authentication string from the username and password.

Username:

Username.

Password:

Password.

Returns:

The encoded string.

pyhandle.utilhandle.make_request_log_message(**args)[source]

Creates a string containing all relevant information about a request made to the Handle System, for logging purposes.

Handle:

The handle that the request is about.

Url:

The url the request is sent to.

Headers:

The headers sent along with the request.

Verify:

Boolean parameter passed to the requests module (https verification).

Resp:

The request’s response.

Op:

The library operation during which the request was sent.

Payload:

Optional. The payload sent with the request.

Returns:

A formatted string.

pyhandle.utilhandle.remove_index_from_handle(handle_with_index)[source]

Returns index and handle separately, in a tuple.

Handle_with_index:

The handle string with an index (e.g. 500:prefix/suffix)

Returns:

index and handle as a tuple, where index is integer.

Client credentials

This module provides the class PIDClientCredentials which handles the credentials for Handle server Interaction and for the Search Servlet.

Author: Merret Buurman (DKRZ), 2015-2016

static PIDClientCredentials.load_from_JSON(json_filename)[source]

Create a new instance of a PIDClientCredentials with information read from a local JSON file.

Parameters:

json_filename –

The path to the json credentials file. The json file should have the following format:

{
    "handle_server_url": "https://url.to.your.handle.server",
    "username": "index:prefix/suffix",
    "password": "ZZZZZZZ",
    "prefix": "prefix_to_use_for_writing_handles",
    "handleowner": "username_to_own_handles"
}

Any additional key-value-pairs are stored in the instance as config.

Raises:

CredentialsFormatError

Raises:

HandleSyntaxError

Returns:

An instance.

PIDClientCredentials.__init__(**args)[source]

Initialize client credentials instance.

The constructor checks if enough arguments are passed to authenticate at a handle server or search servlet. For this, the following parameters are checked. Depending on the chosen authentication method, only a subset of them are required.

All other parameters passed are stored and can be retrieved using ‘get_config()’. If a credentials objects is used to initialize the client, these key-value pairs are passed on to the client constructor.

Parameters:

  • client – Client object to the HS (‘rest’ or ‘db’)

  • handle_server_url – Optional. The URL of the Handle System server to read from. Defaults to ‘https://hdl.handle.net’

  • username – Optional. This must be a handle value reference in the format “index:prefix/suffix”. The method will throw an exception upon bad syntax or non-existing Handle. The existence or validity of the password in the handle is not checked at this moment.

  • password – Optional. This is the password stored as secret key in the actual Handle value the username points to.

  • handleowner – Optional. The username that will be given admin permissions over every newly created handle. By default, it is ‘200:0.NA/xyz’ (where xyz is the prefix of the handle being created.

  • private_key – Optional. The path to a file containing the private key that will be used for authentication in write mode. If this is specified, a certificate needs to be specified too.

  • certificate_only – Optional. The path to a file containing the client certificate that will be used for authentication in write mode. If this is specified, a private key needs to be specified too.

  • certificate_and_key – Optional. The path to a file containing both certificate and private key, used for authentication in write mode.

  • prefix – Prefix. This is not used by the library, but may be retrieved by the user.

  • **args – Any other key-value pairs are stored and can be accessed using ‘get_config()’.

Credentials_filename:

This is the file location of the credentials file, if read from JSON. It is used to find the certificate/key files, if any.

Raises:

HandleSyntaxError

Exceptions

This module contains the exceptions that may occur in libraries interacting with the Handle System.

Author: Merret Buurman (DKRZ), 2015-2016

exception pyhandle.handleexceptions.BrokenHandleRecordException(**args)[source]
exception pyhandle.handleexceptions.CredentialsFormatError(**args)[source]

To be raised if credentials are ill-formatted or miss essential items.

exception pyhandle.handleexceptions.GenericHandleError(**args)[source]

To be raised when the Handle Server returned an unexpected status code that does not map to any other specific exception.

exception pyhandle.handleexceptions.HandleAlreadyExistsException(**args)[source]

To be raised if self.handle already exists.

exception pyhandle.handleexceptions.HandleAuthenticationError(**args)[source]

To be raised if authentication failed, if there was no write permission for creating, modifying, deleting.

exception pyhandle.handleexceptions.HandleNotFoundException(**args)[source]

To be raised if the self.handle was not found on the Handle Server.

exception pyhandle.handleexceptions.HandleSyntaxError(**args)[source]

To be raised if the Handle does not have correct syntax.

exception pyhandle.handleexceptions.IllegalOperationException(**args)[source]

To be raised when the user tries to create a HS_ADMIN self.handle, when he wants to create or remove 10320/loc entries using the wrong method, …

exception pyhandle.handleexceptions.ReverseLookupException(**args)[source]

To be raised if the reverse lookup servlet returns an error.