def get_ingest(self,
options=dict()):
"""Does a GET request to /ws/admin/ingest.
A webservice to ingest all or a CSV list of data resources into the
biocache. An ingest will perform all the steps required to publish a
data resource to the biocache.
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
api_key -- string -- An apiKey to use to perform the task.
Only validated api keys will be allowed to perform
this action.
dr -- string -- An optional CSV param that supports a list
of one of more data resources to ingest
Returns:
void: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/admin/ingest"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"apiKey": options.get('api_key', None),
"dr": options.get('dr', None)
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
def get_deleted_occurrences(self,
date):
"""Does a GET request to /ws/occurrence/deleted.
Returns the records uuids that have been deleted since the supplied
date inclusive. Records will be deleted if they have been erroneously
added as duplicates, or for datasets that require a full reload due to
a lack of consistent identifiers within the dataset.
Args:
date (string): Date in "yyyy-MM-dd" format
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/occurrence/deleted"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"date": date
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_compare_original_vs_processed(self,
uuid):
"""Does a GET request to /ws/occurrence/compare/{UUID}.
Compare the original record to the processed (interpreted) version of
the record.
Args:
uuid (string): The identifier for the record.
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/occurrence/compare/{UUID}"
# Process optional template parameters
query_builder = APIHelper.append_url_with_template_parameters(query_builder, {
"UUID": uuid
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_occurrence_indexed_fields(self):
"""Does a GET request to /ws/index/fields.
List in JSON the index fields within the occurrence store
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/index/fields"
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_endemic_species_list(self,
options=dict()):
"""Does a GET request to /ws/explore/endemic/species.
List endemic species within an area
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
facets -- string -- The field on which to based the
species list. This can be taxon_concept_lsid or
species_guid
fq -- string -- Filters to be applied to the original
query. These are additional params of the form
fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://biocache.ala.org.au/ws/index/fields for all the
fields that a queryable.
q -- string -- The initial query. q=: will query
anything, q=macropus will do a free text search for
macropus, q=kingdom:Fungi will search for records with
a kingdom of Fungi. For a listing of the fields that
can be queried in a q=INDEXEDFIELD:VALUE fashion, see
/index/fields. This will restrict the records that are
considered in then region. For example this could
allow people to restrict the service to endemic
birds.
wkt -- string -- The Well Known Text Area in which to
provide the endemic species.
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/explore/endemic/species"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"facets": options.get('facets', None),
"fq": options.get('fq', None),
"q": options.get('q', None),
"wkt": options.get('wkt', None) if options.get('wkt', None) is not None else "POLYGON((160 -60,160 -25,180 -25,180 -60,160 -60))"
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_occurrence_facet_search(self,
options=dict()):
"""Does a GET request to /ws/occurrence/facets.
Use this service to retrieve counts for facets e.g. the number of taxa
matching a query. Note: fq is ignore for this web service. If
required, include any fq query into the q param with an AND clause.
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
facets -- string -- Comma separated list of the fields to
create facets on e.g. facets=basis_of_record.
dir -- string -- Supports "asc" or "desc"
flimit -- int -- Maximum number of facet values to return
foffset -- int -- Facet offset, to enable paging
fprefix -- string -- Limits facets to values that start
with the supplied value
fsort -- string -- Method in which to sort the facets
either "count" or "index"
lat -- double -- The decimal latitude to limit records to.
Use with lon and radius to specify a "search" circle
lon -- double -- The decimal latitude to limit records to.
Use with lon and radius to specify a "search" circle
lookup -- bool -- Only suitable for facets that are
returning taxon GUIDs (e.g.species_guid) If set to
true this will try to perform a taxon lookup against
the guid and will return additional taxon information
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
radius -- double -- The radius in which to limit records
(relative to the lat, lon point). Use with lat and lon
to specify a "search" circle.
sort -- string -- The indexed field to sort by
start_index -- int -- Record offset, to enable paging
wkt -- string -- The polygon area in which to limit
records.
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/occurrence/facets"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"facets": options.get('facets', None),
"dir": options.get('dir', None),
"flimit": options.get('flimit', None),
"foffset": options.get('foffset', None),
"fprefix": options.get('fprefix', None),
"fsort": options.get('fsort', None),
"lat": options.get('lat', None) if options.get('lat', None) is not None else -41.290817,
"lon": options.get('lon', None) if options.get('lon', None) is not None else 174.753377,
"lookup": options.get('lookup', None),
"q": options.get('q', None),
"radius": options.get('radius', None) if options.get('radius', None) is not None else 20,
"sort": options.get('sort', None),
"startIndex": options.get('start_index', None),
"wkt": options.get('wkt', None) if options.get('wkt', None) is not None else "POLYGON((160 -60,160 -25,180 -25,180 -60,160 -60))"
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_occurrence_facet_download(self,
options=dict()):
"""Does a GET request to /ws/occurrences/facets/download.
CSV download of a facet. In addition to the parameters listed, range
based faceting is supported by using the SOLR parameters. The facets,
q and fq values support the stored & indexed fields
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
facets -- string -- eg. species_guid
fq -- list of string -- additional filters. eg.
fq=state_conservation:Endangered
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
Returns:
binary: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/occurrences/facets/download"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"facets": options.get('facets', None),
"fq": options.get('fq', None),
"q": options.get('q', None)
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def create_occurrence_query_cache(self,
options=dict()):
"""Does a POST request to /ws/webportal/params.
Add query details to a cache to reduce the size of the query params
that are being passed around. This is particularly useful if you
requests are too large for a GET. Returns a text identification for
the query that has been cached. This identification can be used as
part of the value for a search q. ie q=qid:
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
fq -- string -- Filters to be applied to the original
query. These are additional params of the form
fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://biocache.ala.org.au/ws/index/fields for all the
fields that a queryable.
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
wkt -- string -- The polygon area in which to limit
records.
Returns:
string: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/webportal/params"
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0"
}
# Prepare parameters
parameters = {
"fq": options.get('fq', None),
"q": options.get('q', None),
"wkt": options.get('wkt', None)
}
# Prepare and invoke the API call request to fetch the response
response = unirest.post(query_url, headers=headers, params=parameters)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def retrieve_geojson_cluster_for_group(self,
options=dict()):
"""Does a GET request to /ws/geojson/radius-points.
Supports the additional parameters pageSize, start, sort, dir - to
allow paging through the results
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
dir -- string -- dir
fq -- list of string -- The filter query
group -- string -- Species group
lat -- double -- The latitude to limit the query by (must
be used with lon and radius)
lon -- double -- The longitude to limit the query by (must
be used with lat and radius)
page_size -- int -- Number of records to return
q -- string -- The query which defaults to : when not
supplied
radius -- string -- The radius in km to limit the search
to. must be used with lat and lon.
sort -- string -- sort
start -- int -- Record offset, to enable paging
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/geojson/radius-points"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"dir": options.get('dir', None),
"fq": options.get('fq', None),
"group": options.get('group', None),
"lat": options.get('lat', None) if options.get('lat', None) is not None else -41.290817,
"lon": options.get('lon', None) if options.get('lon', None) is not None else 174.753377,
"pageSize": options.get('page_size', None),
"q": options.get('q', None),
"radius": options.get('radius', None) if options.get('radius', None) is not None else "20",
"sort": options.get('sort', None),
"start": options.get('start', None)
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_download_list_of_species_in_group(self,
options=dict()):
"""Does a GET request to /ws/explore/group/{group}/download.
Retrieve all species groups and counts. The first count is total
number of occurrence, the second is the number of distinct species
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
group -- string -- group
fq -- list of string -- The filter query
lat -- double -- The latitude to limit the query by (must
be used with lon and radius)
lon -- double -- The longitude to limit the query by (must
be used with lat and radius)
q -- string -- The query which defaults to : when not
supplied
radius -- int -- The radius in km of the circle to limit
to (must be used with lat and lon)
Returns:
binary: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/explore/group/{group}/download"
# Process optional template parameters
query_builder = APIHelper.append_url_with_template_parameters(query_builder, {
"group": options.get('group', None)
})
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"fq": options.get('fq', None),
"lat": options.get('lat', None) if options.get('lat', None) is not None else -41.290817,
"lon": options.get('lon', None) if options.get('lon', None) is not None else 174.753377,
"q": options.get('q', None),
"radius": options.get('radius', None) if options.get('radius', None) is not None else 20
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_occurrence_download(self,
options=dict()):
"""Does a GET request to /ws/occurrences/index/download.
Occurrence download. Downloads of the following formats are supported:
CSV SHAPE The output format is determined based on the fileType
param. The download will return a ZIP file that contains the data in
the requested format and a Readme and citataion.csv. Please be aware
that a shape file download will be large. Each of the fields is
included as a feature. It is advised to select a subset of information
to be included.
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
reason_type_id -- int -- A reason code for the download.
See reasons for valid values.
email -- string -- The email address of the user
performing the download.
esc -- string -- The Escape character to use for a CSV
file. This will default to " in order to produce an
Excel compliant CSV file.
extra -- string -- a CSV list of fields in include in
addition to the "fields". This is useful if you would
like to make use of the default fields and include
extra fields.
fields -- string -- A CSV list of fields to include in the
download. This can be an index field name OR a Darwin
Core Field name. There is a default list that is
included if no value is supplied.
file -- string -- The name of the file to produce. This
will default to data.
file_type -- string -- The file format for the download.
Either csv or shp. When no value is supplied csv is
assumed.
fq -- list of string -- Filters to be applied to the
original query. These are additional params of the
form fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://biocache.ala.org.au/ws/index/fields for all the
fields that a queryable.
lat -- double -- The decimal latitude to limit records to.
Use with lon and radius to specify a "search" circle
lon -- double -- The decimal latitude to limit records to.
Use with lon and radius to specify a "search" circle
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
qa -- string -- A CSV list of record issues to include in
the download. See assertions for possible values to
include. When no value is supplied all the record
issues are included. To include NO record issues set
this value to none.
radius -- double -- The radius in which to limit records
(relative to the lat, lon point). Use with lat and lon
to specify a "search" circle.
reason -- string -- A user supplied description of the
reason for the download
sep -- string -- The separator character to use for a CSV
file. This will default to , .
source_type_id -- OccurrenceDownloadSourceTypeIdTypeEnum
-- A source type code for the download. This indicates
which system requested the download. See sources for
valid values.
wkt -- string -- The polygon area in which to limit
records.
Returns:
binary: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/occurrences/index/download"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"reasonTypeId": options.get('reason_type_id', None),
"email": options.get('email', None),
"esc": options.get('esc', None),
"extra": options.get('extra', None),
"fields": options.get('fields', None),
"file": options.get('file', None),
"fileType": options.get('file_type', None),
"fq": options.get('fq', None),
"lat": options.get('lat', None) if options.get('lat', None) is not None else -41.290817,
"lon": options.get('lon', None) if options.get('lon', None) is not None else 174.753377,
"q": options.get('q', None),
"qa": options.get('qa', None),
"radius": options.get('radius', None) if options.get('radius', None) is not None else 20,
"reason": options.get('reason', None),
"sep": options.get('sep', None),
"sourceTypeId": options.get('source_type_id', None).to_string() if options.get('source_type_id', None) is not None else None,
"wkt": options.get('wkt', None) if options.get('wkt', None) is not None else "POLYGON((160 -60,160 -25,180 -25,180 -60,160 -60))"
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_occurrence_search(self,
options=dict()):
"""Does a GET request to /ws/occurrences/search.
JSON occurrence search. In addition to the parameters listed, range
based faceting is supported by using the SOLR parameters.
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
dir -- string -- Supports "asc" or "desc"
facet -- string -- Supported values are "off" or "on". By
default, its "on". This is worth switching off if
facetting is not required, to reduce the JSON being
sent.
facets -- string -- Comma separated list of the fields to
create facets on e.g. facets=basis_of_record.
flimit -- int -- Maximum number of facet values to return
foffset -- int -- Facet offset, to enable paging
fprefix -- string -- Limits facets to values that start
with the supplied value
fq -- list of string -- Filters to be applied to the
original query. These are additional params of the
form fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://biocache.ala.org.au/ws/index/fields for all the
fields that a queryable.
fsort -- string -- Method in which to sort the facets
either "count" or "index"
lat -- double -- The decimal latitude to limit records to.
Use with lon and radius to specify a "search" circle
lon -- double -- The decimal latitude to limit records to.
Use with lon and radius to specify a "search" circle
page_size -- int -- Number of records to return
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
radius -- double -- The radius in which to limit records
(relative to the lat, lon point). Use with lat and lon
to specify a "search" circle.
sort -- string -- The indexed field to sort by
start_index -- int -- Record offset, to enable paging
wkt -- string -- The polygon area in which to limit
records.
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/occurrences/search"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"dir": options.get('dir', None),
"facet": options.get('facet', None) if options.get('facet', None) is not None else "on",
"facets": options.get('facets', None),
"flimit": options.get('flimit', None),
"foffset": options.get('foffset', None),
"fprefix": options.get('fprefix', None),
"fq": options.get('fq', None),
"fsort": options.get('fsort', None),
"lat": options.get('lat', None) if options.get('lat', None) is not None else -41.290817,
"lon": options.get('lon', None) if options.get('lon', None) is not None else 174.753377,
"pageSize": options.get('page_size', None),
"q": options.get('q', None),
"radius": options.get('radius', None) if options.get('radius', None) is not None else 20,
"sort": options.get('sort', None),
"startIndex": options.get('start_index', None),
"wkt": options.get('wkt', None) if options.get('wkt', None) is not None else "POLYGON((160 -60,160 -25,180 -25,180 -60,160 -60))"
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_wms_get_map(self, options=dict()):
"""Does a GET request to /ws/ogc/wms/reflect.
WMS services for point occurrence data
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
dir -- int -- Supports "asc" or "desc"
env -- string -- Additional parameters. e.g.
ENV=color%3Acd3844%3Bsize%3A3%3Bopacity%3A0.8.
color - hex RGB values. e.g. colour:cd3844. size -
radius of points in pixels. opacity - opacity
value 0 - 1. sel - fq parameter applied to
CQL_FILTER. Matching occurrences will be highlighted
on the map in a Red circle. uncertainty - presence
of the uncertainty parameter draws uncertainty circles
to a fixed maximum of 30km. colormode - facet
colouring type. -1 (default) use color value.
grid map as density grid. Grid cells drawn are not
restricted to within any query WKT parameters.
facetname colour as categories in a facet.
facetname,cutpoints colour as range in a facet using
the supplied comma separated cutpoints. 4 to 10 values
are required. Include minimum and maximum. Minimum and
maximum values do not need to be accurate. e.g.
colormode:year,1800,1900,1950,1970,1990,2010
facet -- string -- Supported values are "off" or "on".
By default, its "on". This is worth switching off if
facetting is not required, to reduce the JSON being
sent.
facets -- string -- Comma separated list of the fields
to create facets on e.g. facets=basis_of_record.
flimit -- int -- Maximum number of facet values to
return
foffset -- int -- Facet offset, to enable paging
fprefix -- int -- Limits facets to values that start
with the supplied value
fq -- list of string -- Filters to be applied to the
original query. These are additional params of the
form fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://biocache.ala.org.au/ws/index/fields for all the
fields that a queryable.
fsort -- int -- Method in which to sort the facets
either "count" or "index"
lat -- double -- The decimal latitude to limit records
to. Use with lon and radius to specify a "search"
circle
lon -- double -- The decimal latitude to limit records
to. Use with lon and radius to specify a "search"
circle
page_size -- int -- Number of records to return
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
radius -- double -- The radius in which to limit records
(relative to the lat, lon point). Use with lat and lon
to specify a "search" circle.
sort -- int -- The indexed field to sort by
start_index -- int -- Record offset, to enable paging
wkt -- string -- The polygon area in which to limit
records. For information on Well known text
Returns:
binary: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/ogc/wms/reflect"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(
query_builder,
{
"dir": options.get("dir", None),
"ENV": options.get("env", None),
"facet": options.get("facet", None),
"facets": options.get("facets", None),
"flimit": options.get("flimit", None),
"foffset": options.get("foffset", None),
"fprefix": options.get("fprefix", None),
"fq": options.get("fq", None),
"fsort": options.get("fsort", None),
"lat": options.get("lat", None) if options.get("lat", None) is not None else -41.290817,
"lon": options.get("lon", None) if options.get("lon", None) is not None else 174.753377,
"pageSize": options.get("page_size", None),
"q": options.get("q", None),
"radius": options.get("radius", None) if options.get("radius", None) is not None else 20,
"sort": options.get("sort", None),
"startIndex": options.get("start_index", None),
"wkt": options.get("wkt", None)
if options.get("wkt", None) is not None
else "POLYGON((160 -60,160 -25,180 -25,180 -60,160 -60))",
},
)
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {"user-agent": "APIMATIC 2.0"}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_generate_static_map(self, options=dict()):
"""Does a GET request to /ws/mapping/wms/image.
Generate a static image with various formatting options.
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
extents -- string -- minx,miny,maxx,maxy
160.0,-60.0,180.0,-25.0
baselayer -- string -- Base layer to use from
http://spatial.ala.org.au/geoserver
baselayer_prefix -- string -- Default "ALA:"
dpi -- string -- Dots per inch. Default is 300.
file_name -- string -- File name to use
format -- string -- Default 'jpg'
fq -- string -- Filters to be applied to the original
query. These are additional params of the form
fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://biocache.ala.org.au/ws/index/fields for all the
fields that a queryable.
outline -- string -- Point outline. Default is false
outline_colour -- string -- Default #000000
pcolour -- string -- Point colour in hex. Default is
FF0000
popacity -- string -- Point opacity. Default is 0.8
pradiusmm -- string -- Species point radius in mm,
integer
pradiuspx -- string -- Species point radius in pixels,
integer. Only pradiuspx or pradiusmm need be supplied.
If both supplied, pradiuspx takes precendence.
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
scale -- string -- Include a scale. DefaultValue =
"off".
widthmm -- string -- Image width in mm
Returns:
binary: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/mapping/wms/image"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(
query_builder,
{
"extents": options.get("extents", None),
"baselayer": options.get("baselayer", None),
"baselayerPrefix": options.get("baselayer_prefix", None)
if options.get("baselayer_prefix", None) is not None
else "ALA",
"dpi": options.get("dpi", None) if options.get("dpi", None) is not None else "300",
"fileName": options.get("file_name", None),
"format": options.get("format", None) if options.get("format", None) is not None else "jpg",
"fq": options.get("fq", None),
"outline": options.get("outline", None) if options.get("outline", None) is not None else "false",
"outlineColour": options.get("outline_colour", None)
if options.get("outline_colour", None) is not None
else "0x000000",
"pcolour": options.get("pcolour", None) if options.get("pcolour", None) is not None else "FF0000",
"popacity": options.get("popacity", None) if options.get("popacity", None) is not None else "0.8",
"pradiusmm": options.get("pradiusmm", None),
"pradiuspx": options.get("pradiuspx", None),
"q": options.get("q", None),
"scale": options.get("scale", None) if options.get("scale", None) is not None else "off",
"widthmm": options.get("widthmm", None),
},
)
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {"user-agent": "APIMATIC 2.0"}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_scatterplot_image(self,
options=dict()):
"""Does a GET request to /ws/scatterplot.
Return an image for occurrences and two environmental layers as a
scatterplot.
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
x -- string -- Environmental layer for the X dimension
of the scatterplot. See fields at
http://biocache.ala.org.au/ws/index/fields with
dataType=double.
y -- string -- Environmental layer for the Y dimension
of the scatterplot. See fields at
http://biocache.ala.org.au/ws/index/fields with
dataType=double.
fq -- list of string -- Filters to be applied to the
original query. These are additional params of the
form fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://bie.ala.org.au/ws/admin/indexFields for all the
fields that a queryable.
height -- int -- Height of the returned image in pixels.
The default value is 256.
pointcolour -- string -- Colour of the occurrence
points. The default value is 0000FF (blue).
pointradius -- string -- Size of occurrence points. The
default value is 3.
width -- int -- Widith of the returned image in pixels.
The default value is 256.
Returns:
binary: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/scatterplot"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"q": options.get('q', None),
"x": options.get('x', None),
"y": options.get('y', None),
"fq": options.get('fq', None),
"height": options.get('height', None),
"pointcolour": options.get('pointcolour', None),
"pointradius": options.get('pointradius', None),
"width": options.get('width', None)
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body
def get_scatterplot_query(self,
options=dict()):
"""Does a GET request to /ws/scatterplot/point.json.
Returns x and y axis co-ordinates corresponding to image pixel points
(origin top left) for two pointspointx1 pointx2 pointy1 pointy2
http://biocache.ala.org.au/ws/scatterplot/point.json?q=Macropus%20Agili
s&x=el874&y=el871&height=512&width=512&pointx1=200&pointy1=200&pointx2=
500&pointy2=0
Args:
options (dict, optional): Key-value pairs for any of the
parameters to this API Endpoint. All parameters to the
endpoint are supplied through the dictionary with their names
being the key and their desired values being the value. A list
of parameters that can be used are::
fq -- list of string -- Filters to be applied to the
original query. These are additional params of the
form fq=INDEXEDFIELD:VALUE e.g. fq=kingdom:Fungi. See
http://bie.ala.org.au/ws/admin/indexFields for all the
fields that a queryable.
height -- int -- Height of the returned image in pixels.
The default value is 256.
pointx_1 -- int -- X coordinate for the first
scatterplot image pixel. Origin is the top left
corner.
pointx_2 -- int -- X coordinate for the second
scatterplot image pixel. Origin is the top left
corner.
pointy_1 -- int -- Y coordinate for the first
scatterplot image pixel. Origin is the top left
corner.
pointy_2 -- int -- Y coordinate for the second
scatterplot image pixel. Origin is the top left
corner.
q -- string -- Query of the form field:value e.g.
q=genus:Macropus or a free text search e.g.
q=Macropus
width -- int -- Widith of the returned image in pixels.
The default value is 256.
x -- string -- Environmental layer for the X dimension
of the scatterplot. See fields at
http://biocache.ala.org.au/ws/index/fields with
dataType=double.
y -- string -- Environmental layer for the Y dimension
of the scatterplot. See fields at
http://biocache.ala.org.au/ws/index/fields with
dataType=double.
Returns:
mixed: Response from the API.
Raises:
APIException: When an error occurs while fetching the data from
the remote API. This exception includes the HTTP Response
code, an error message, and the HTTP body that was received in
the request.
"""
# The base uri for api requests
query_builder = Configuration.BASE_URI
# Prepare query string for API call
query_builder += "/ws/scatterplot/point.json"
# Process optional query parameters
query_builder = APIHelper.append_url_with_query_parameters(query_builder, {
"fq": options.get('fq', None),
"height": options.get('height', None),
"pointx1": options.get('pointx_1', None),
"pointx2": options.get('pointx_2', None),
"pointy1": options.get('pointy_1', None),
"pointy2": options.get('pointy_2', None),
"q": options.get('q', None),
"width": options.get('width', None),
"x": options.get('x', None),
"y": options.get('y', None)
})
# Validate and preprocess url
query_url = APIHelper.clean_url(query_builder)
# Prepare headers
headers = {
"user-agent": "APIMATIC 2.0",
"accept": "application/json"
}
# Prepare and invoke the API call request to fetch the response
response = unirest.get(query_url, headers=headers)
# Error handling using HTTP status codes
if response.code < 200 or response.code > 206: # 200 = HTTP OK
raise APIException("HTTP Response Not OK", response.code, response.body)
return response.body