def organization_list_for_user(client=client.Client(), permission=''):
"""
Return the list of organizations that the user is a member of.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param permission: the permission the user has against the returned organizations
(optional, default: ``edit_group``)
:type permission: string
:returns: the names of organizations the user is authorized to do specific permission
:rtype: list of strings
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='organization_list_for_user', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def dashboard_new_activities_count(client=client.Client()):
"""
Return the number of new activities in the user's dashboard.
Return the number of new activities in the authorized user's dashboard
activity stream.
Activities from the user herself are not counted by this function even
though they appear in the dashboard (users don't want to be notified about
things they did themselves).
:rtype: int
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='dashboard_new_activities_count', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def related_show(client=client.Client(), id=''):
"""
Return a single related item.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id of the related item to show
:type id: string
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='related_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def dashboard_new_activities_count(client=client.Client()):
"""
Return the number of new activities in the user's dashboard.
Return the number of new activities in the authorized user's dashboard
activity stream.
Activities from the user herself are not counted by this function even
though they appear in the dashboard (users don't want to be notified about
things they did themselves).
:rtype: int
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='dashboard_new_activities_count', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def user_list(client=client.Client(), q='', order_by=''):
"""
Return a list of the site's user accounts.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param q: restrict the users returned to those whose names contain a string
(optional)
:type q: string
:param order_by: which field to sort the list by (optional, default:
``'name'``)
:type order_by: string
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='user_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def tag_show(client=client.Client(), id=''):
"""
Return the details of a tag and all its datasets.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the name or id of the tag
:type id: string
:returns: the details of the tag, including a list of all of the tag's
datasets and their details
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='tag_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def package_autocomplete(client=client.Client(), q=""):
"""
Return a list of datasets (packages) that match a string.
Datasets with names or titles that contain the query string will be
returned.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param q: the string to search for
:type q: string
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action="package_autocomplete", data=args)
if not resp["success"]:
raise exceptions.CKANError(resp.error)
return resp
def package_relationships_list(client=client.Client(), id="", id2="", rel=""):
"""
Return a dataset (package)'s relationships.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the package
:type id: string
:param id2:
:type id2:
:param rel:
:type rel:
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action="package_relationships_list", data=args)
if not resp["success"]:
raise exceptions.CKANError(resp.error)
return resp
def group_package_show(client=client.Client(), id="", limit=""):
"""
Return the datasets (packages) of a group.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the group
:type id: string
:param limit: the maximum number of datasets to return (optional)
:type limit: int
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action="group_package_show", data=args)
if not resp["success"]:
raise exceptions.CKANError(resp.error)
return resp
def group_package_show(client=client.Client(), id='', limit=''):
"""
Return the datasets (packages) of a group.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the group
:type id: string
:param limit: the maximum number of datasets to return (optional)
:type limit: int
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='group_package_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def package_autocomplete(client=client.Client(), q=''):
"""
Return a list of datasets (packages) that match a string.
Datasets with names or titles that contain the query string will be
returned.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param q: the string to search for
:type q: string
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='package_autocomplete', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def package_relationships_list(client=client.Client(), id='', id2='', rel=''):
"""
Return a dataset (package)'s relationships.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the package
:type id: string
:param id2:
:type id2:
:param rel:
:type rel:
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='package_relationships_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def resource_show(client=client.Client(), id=''):
"""
Return the metadata of a resource.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id of the resource
:type id: string
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='resource_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def tag_show(client=client.Client(), id=''):
"""
Return the details of a tag and all its datasets.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the name or id of the tag
:type id: string
:returns: the details of the tag, including a list of all of the tag's
datasets and their details
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='tag_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def user_show(client=client.Client(), id='', user_obj=''):
"""
Return a user account.
Either the ``id`` or the ``user_obj`` parameter must be given.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the user (optional)
:type id: string
:param user_obj: the user dictionary of the user (optional)
:type user_obj: user dictionary
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='user_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def organization_list_for_user(client=client.Client(), permission=''):
"""
Return the list of organizations that the user is a member of.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param permission: the permission the user has against the returned organizations
(optional, default: ``edit_group``)
:type permission: string
:returns: the names of organizations the user is authorized to do specific permission
:rtype: list of strings
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='organization_list_for_user', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def roles_show(client=client.Client(), domain_object='', user=''):
"""
Return the roles of all users and authorization groups for an object.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param domain_object: a package or group name or id
to filter the results by
:type domain_object: string
:param user: a user name or id
:type user: string
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='roles_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def organization_activity_list_html(client=client.Client(), id=''):
"""
Return a organization's activity stream as HTML.
The activity stream is rendered as a snippet of HTML meant to be included
in an HTML page, i.e. it doesn't have any HTML header or footer.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the organization
:type id: string
:rtype: string
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='organization_activity_list_html', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def organization_activity_list(client=client.Client(), id=''):
"""
Return a organization's activity stream.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the organization
:type id: string
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='organization_activity_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def organization_activity_list_html(client=client.Client(), id=''):
"""
Return a organization's activity stream as HTML.
The activity stream is rendered as a snippet of HTML meant to be included
in an HTML page, i.e. it doesn't have any HTML header or footer.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the organization
:type id: string
:rtype: string
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='organization_activity_list_html', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def recently_changed_packages_activity_list(client=client.Client(), offset='', limit=''):
"""
Return the activity stream of all recently added or changed packages.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param offset: where to start getting activity items from
(optional, default: 0)
:type offset: int
:param limit: the maximum number of activities to return
(optional, default: 31, the default value is configurable via the
ckan.activity_list_limit setting)
:type limit: int
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='recently_changed_packages_activity_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def group_list_authz(client=client.Client(), available_only=''):
"""
Return the list of groups that the user is authorized to edit.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param available_only: remove the existing groups in the package
(optional, default: ``False``)
:type available_only: boolean
:returns: the names of groups that the user is authorized to edit
:rtype: list of strings
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='group_list_authz', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def user_autocomplete(client=client.Client(), q='', limit=''):
"""
Return a list of user names that contain a string.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param q: the string to search for
:type q: string
:param limit: the maximum number of user names to return (optional,
default: 20)
:type limit: int
:rtype: a list of user dictionaries each with keys ``'name'``,
``'fullname'``, and ``'id'``
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='user_autocomplete', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def revision_list(client=client.Client()):
"""
Return a list of the IDs of the site's revisions.
:rtype: list of strings
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='revision_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def tag_search(client=client.Client(),
query='',
vocabulary_id='',
fields='',
limit='',
offset=''):
"""
Return a list of tags whose names contain a given string.
By default only free tags (tags that don't belong to any vocabulary) are
searched. If the ``vocabulary_id`` argument is given then only tags
belonging to that vocabulary will be searched instead.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param query: the string(s) to search for
:type query: string or list of strings
:param vocabulary_id: the id or name of the tag vocabulary to search in
(optional)
:type vocabulary_id: string
:param fields: deprecated
:type fields: dictionary
:param limit: the maximum number of tags to return
:type limit: int
:param offset: when ``limit`` is given, the offset to start returning tags
from
:type offset: int
:returns: A dictionary with the following keys:
``'count'``
The number of tags in the result.
``'results'``
The list of tags whose names contain the given string, a list of
dictionaries.
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='tag_search', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def tag_search(client=client.Client(), query='', vocabulary_id='', fields='', limit='', offset=''):
"""
Return a list of tags whose names contain a given string.
By default only free tags (tags that don't belong to any vocabulary) are
searched. If the ``vocabulary_id`` argument is given then only tags
belonging to that vocabulary will be searched instead.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param query: the string(s) to search for
:type query: string or list of strings
:param vocabulary_id: the id or name of the tag vocabulary to search in
(optional)
:type vocabulary_id: string
:param fields: deprecated
:type fields: dictionary
:param limit: the maximum number of tags to return
:type limit: int
:param offset: when ``limit`` is given, the offset to start returning tags
from
:type offset: int
:returns: A dictionary with the following keys:
``'count'``
The number of tags in the result.
``'results'``
The list of tags whose names contain the given string, a list of
dictionaries.
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='tag_search', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def organization_list(client=client.Client(),
order_by='',
sort='',
organizations='',
all_fields=''):
"""
Return a list of the names of the site's organizations.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param order_by: the field to sort the list by, must be ``'name'`` or
``'packages'`` (optional, default: ``'name'``) Deprecated use sort.
:type order_by: string
:param sort: sorting of the search results. Optional. Default:
"name asc" string of field name and sort-order. The allowed fields are
'name' and 'packages'
:type sort: string
:param organizations: a list of names of the groups to return, if given only
groups whose names are in this list will be returned (optional)
:type organizations: list of strings
:param all_fields: return full group dictionaries instead of just names
(optional, default: ``False``)
:type all_fields: boolean
:rtype: list of strings
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='organization_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def related_list(client=client.Client(), id='', dataset='', type_filter='', sort='', featured=''):
"""
Return a dataset's related items.
Either the ``id`` or the ``dataset`` parameter must be given.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: id or name of the dataset (optional)
:type id: string
:param dataset: dataset dictionary of the dataset (optional)
:type dataset: dictionary
:param type_filter: the type of related item to show (optional,
default: None, show all items)
:type type_filter: string
:param sort: the order to sort the related items in, possible values are
'view_count_asc', 'view_count_desc', 'created_asc' or 'created_desc'
(optional)
:type sort: string
:param featured: whether or not to restrict the results to only featured
related items (optional, default: False)
:type featured: bool
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='related_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def related_list(client=client.Client(), id="", dataset="", type_filter="", sort="", featured=""):
"""
Return a dataset's related items.
Either the ``id`` or the ``dataset`` parameter must be given.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: id or name of the dataset (optional)
:type id: string
:param dataset: dataset dictionary of the dataset (optional)
:type dataset: dictionary
:param type_filter: the type of related item to show (optional,
default: None, show all items)
:type type_filter: string
:param sort: the order to sort the related items in, possible values are
'view_count_asc', 'view_count_desc', 'created_asc' or 'created_desc'
(optional)
:type sort: string
:param featured: whether or not to restrict the results to only featured
related items (optional, default: False)
:type featured: bool
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action="related_list", data=args)
if not resp["success"]:
raise exceptions.CKANError(resp.error)
return resp
def tag_list(client=client.Client(), query='', vocabulary_id='',
all_fields=''):
"""
Return a list of the site's tags.
By default only free tags (tags that don't belong to a vocabulary) are
returned. If the ``vocabulary_id`` argument is given then only tags
belonging to that vocabulary will be returned instead.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param query: a tag name query to search for, if given only tags whose
names contain this string will be returned (optional)
:type query: string
:param vocabulary_id: the id or name of a vocabulary, if give only tags
that belong to this vocabulary will be returned (optional)
:type vocabulary_id: string
:param all_fields: return full tag dictionaries instead of just names
(optional, default: ``False``)
:type all_fields: boolean
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='tag_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def group_list(client=client.Client(), order_by='', sort='', groups='', all_fields=''):
"""
Return a list of the names of the site's groups.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param order_by: the field to sort the list by, must be ``'name'`` or
``'packages'`` (optional, default: ``'name'``) Deprecated use sort.
:type order_by: string
:param sort: sorting of the search results. Optional. Default:
"name asc" string of field name and sort-order. The allowed fields are
'name' and 'packages'
:type sort: string
:param groups: a list of names of the groups to return, if given only
groups whose names are in this list will be returned (optional)
:type groups: list of strings
:param all_fields: return full group dictionaries instead of just names
(optional, default: ``False``)
:type all_fields: boolean
:rtype: list of strings
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='group_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def dashboard_activity_list(client=client.Client(), offset='', limit=''):
"""
Return the authorized user's dashboard activity stream.
Unlike the activity dictionaries returned by other ``*_activity_list``
actions, these activity dictionaries have an extra boolean value with key
``is_new`` that tells you whether the activity happened since the user last
viewed her dashboard (``'is_new': True``) or not (``'is_new': False``).
The user's own activities are always marked ``'is_new': False``.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param offset: where to start getting activity items from
(optional, default: 0)
:type offset: int
:param limit: the maximum number of activities to return
(optional, default: 31, the default value is configurable via the
``ckan.activity_list_limit`` setting)
:rtype: list of activity dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='dashboard_activity_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def recently_changed_packages_activity_list_html(
client=client.Client(), offset='', limit=''):
"""
Return the activity stream of all recently changed packages as HTML.
The activity stream includes all recently added or changed packages. It is
rendered as a snippet of HTML meant to be included in an HTML page, i.e. it
doesn't have any HTML header or footer.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param offset: where to start getting activity items from
(optional, default: 0)
:type offset: int
:param limit: the maximum number of activities to return
(optional, default: 31, the default value is configurable via the
ckan.activity_list_limit setting)
:type limit: int
:rtype: string
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(
action='recently_changed_packages_activity_list_html', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def tag_list(client=client.Client(), query='', vocabulary_id='', all_fields=''):
"""
Return a list of the site's tags.
By default only free tags (tags that don't belong to a vocabulary) are
returned. If the ``vocabulary_id`` argument is given then only tags
belonging to that vocabulary will be returned instead.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param query: a tag name query to search for, if given only tags whose
names contain this string will be returned (optional)
:type query: string
:param vocabulary_id: the id or name of a vocabulary, if give only tags
that belong to this vocabulary will be returned (optional)
:type vocabulary_id: string
:param all_fields: return full tag dictionaries instead of just names
(optional, default: ``False``)
:type all_fields: boolean
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='tag_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def dashboard_activity_list(client=client.Client(), offset='', limit=''):
"""
Return the authorized user's dashboard activity stream.
Unlike the activity dictionaries returned by other ``*_activity_list``
actions, these activity dictionaries have an extra boolean value with key
``is_new`` that tells you whether the activity happened since the user last
viewed her dashboard (``'is_new': True``) or not (``'is_new': False``).
The user's own activities are always marked ``'is_new': False``.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param offset: where to start getting activity items from
(optional, default: 0)
:type offset: int
:param limit: the maximum number of activities to return
(optional, default: 31, the default value is configurable via the
``ckan.activity_list_limit`` setting)
:rtype: list of activity dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='dashboard_activity_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def user_activity_list_html(client=client.Client(), id='', offset='', limit=''):
"""
Return a user's public activity stream as HTML.
The activity stream is rendered as a snippet of HTML meant to be included
in an HTML page, i.e. it doesn't have any HTML header or footer.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: The id or name of the user.
:type id: string
:param offset: where to start getting activity items from
(optional, default: 0)
:type offset: int
:param limit: the maximum number of activities to return
(optional, default: 31, the default value is configurable via the
ckan.activity_list_limit setting)
:type limit: int
:rtype: string
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='user_activity_list_html', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def user_activity_list(client=client.Client(), id='', offset='', limit=''):
"""
Return a user's public activity stream.
You must be authorized to view the user's profile.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the user
:type id: string
:param offset: where to start getting activity items from
(optional, default: 0)
:type offset: int
:param limit: the maximum number of activities to return
(optional, default: 31, the default value is configurable via the
ckan.activity_list_limit setting)
:type limit: int
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='user_activity_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def user_activity_list(client=client.Client(), id='', offset='', limit=''):
"""
Return a user's public activity stream.
You must be authorized to view the user's profile.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the user
:type id: string
:param offset: where to start getting activity items from
(optional, default: 0)
:type offset: int
:param limit: the maximum number of activities to return
(optional, default: 31, the default value is configurable via the
ckan.activity_list_limit setting)
:type limit: int
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='user_activity_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def task_status_show(
client=client.Client(), id='', entity_id='', task_type='', key=''):
"""
Return a task status.
Either the ``id`` parameter *or* the ``entity_id``, ``task_type`` *and*
``key`` parameters must be given.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id of the task status (optional)
:type id: string
:param entity_id: the entity_id of the task status (optional)
:type entity_id: string
:param task_type: the task_type of the task status (optional)
:type tast_type: string
:param key: the key of the task status (optional)
:type key: string
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='task_status_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def task_status_show(client=client.Client(), id='', entity_id='', task_type='', key=''):
"""
Return a task status.
Either the ``id`` parameter *or* the ``entity_id``, ``task_type`` *and*
``key`` parameters must be given.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id of the task status (optional)
:type id: string
:param entity_id: the entity_id of the task status (optional)
:type entity_id: string
:param task_type: the task_type of the task status (optional)
:type tast_type: string
:param key: the key of the task status (optional)
:type key: string
:rtype: dictionary
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='task_status_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def member_list(client=client.Client(), id='', object_type='', capacity=''):
"""
Return the members of a group.
The user must have permission to 'get' the group.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param id: the id or name of the group
:type id: string
:param object_type: restrict the members returned to those of a given type,
e.g. ``'user'`` or ``'package'`` (optional, default: ``None``)
:type object_type: string
:param capacity: restrict the members returned to those with a given
capacity, e.g. ``'member'``, ``'editor'``, ``'admin'``, ``'public'``,
``'private'`` (optional, default: ``None``)
:type capacity: string
:rtype: list of (id, type, capacity) tuples
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='member_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def term_translation_show(client=client.Client(), terms='', lang_codes=''):
"""
Return the translations for the given term(s) and language(s).
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param terms: the terms to search for translations of, e.g. ``'Russian'``,
``'romantic novel'``
:type terms: list of strings
:param lang_codes: the language codes of the languages to search for
translations into, e.g. ``'en'``, ``'de'`` (optional, default is to
search for translations into any language)
:type lang_codes: list of language code strings
:rtype: a list of term translation dictionaries each with keys ``'term'``
(the term searched for, in the source language), ``'term_translation'``
(the translation of the term into the target language) and
``'lang_code'`` (the language code of the target language)
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='term_translation_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def current_package_list_with_resources(
client=client.Client(), limit='', page=''):
"""
Return a list of the site's datasets (packages) and their resources.
The list is sorted most-recently-modified first.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param limit: if given, the list of datasets will be broken into pages of
at most ``limit`` datasets per page and only one page will be returned
at a time (optional)
:type limit: int
:param page: when ``limit`` is given, which page to return
:type page: int
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='current_package_list_with_resources',
data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def status_show(client=client.Client()):
"""
Return a dictionary with information about the site's configuration
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
.
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='status_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def status_show(client=client.Client()):
"""
Return a dictionary with information about the site's configuration
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
.
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='status_show', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def member_roles_list(client=client.Client()):
"""
<TODO: DESCRIPTION>
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
<TODO: PARAMETERS>
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='member_roles_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def package_list(client=client.Client()):
"""
Return a list of the names of the site's datasets (packages).
:rtype: list of strings
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:returns: A list of names of the packages.
:return: [str]
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='package_list', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def package_list(client=client.Client()):
"""
Return a list of the names of the site's datasets (packages).
:rtype: list of strings
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:returns: A list of names of the packages.
:return: [str]
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action="package_list", data=args)
if not resp["success"]:
raise exceptions.CKANError(resp.error)
return resp
def current_package_list_with_resources(client=client.Client(), limit="", page=""):
"""
Return a list of the site's datasets (packages) and their resources.
The list is sorted most-recently-modified first.
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param limit: if given, the list of datasets will be broken into pages of
at most ``limit`` datasets per page and only one page will be returned
at a time (optional)
:type limit: int
:param page: when ``limit`` is given, which page to return
:type page: int
:rtype: list of dictionaries
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action="current_package_list_with_resources", data=args)
if not resp["success"]:
raise exceptions.CKANError(resp.error)
return resp
def resource_search(client=client.Client(), query='', fields='', order_by='', offset='', limit=''):
"""
Searches for resources satisfying a given search criteria.
It returns a dictionary with 2 fields: ``count`` and ``results``. The
``count`` field contains the total number of Resources found without the
limit or query parameters having an effect. The ``results`` field is a
list of dictized Resource objects.
The 'query' parameter is a required field. It is a string of the form
``{field}:{term}`` or a list of strings, each of the same form. Within
each string, ``{field}`` is a field or extra field on the Resource domain
object.
If ``{field}`` is ``"hash"``, then an attempt is made to match the
`{term}` as a *prefix* of the ``Resource.hash`` field.
If ``{field}`` is an extra field, then an attempt is made to match against
the extra fields stored against the Resource.
Note: The search is limited to search against extra fields declared in
the config setting ``ckan.extra_resource_fields``.
Note: Due to a Resource's extra fields being stored as a json blob, the
match is made against the json string representation. As such, false
positives may occur:
If the search criteria is: ::
query = "field1:term1"
Then a json blob with the string representation of: ::
{"field1": "foo", "field2": "term1"}
will match the search criteria! This is a known short-coming of this
approach.
All matches are made ignoring case; and apart from the ``"hash"`` field,
a term matches if it is a substring of the field's value.
Finally, when specifying more than one search criteria, the criteria are
AND-ed together.
The ``order`` parameter is used to control the ordering of the results.
Currently only ordering one field is available, and in ascending order
only.
The ``fields`` parameter is deprecated as it is not compatible with calling
this action with a GET request to the action API.
The context may contain a flag, `search_query`, which if True will make
this action behave as if being used by the internal search api. ie - the
results will not be dictized, and SearchErrors are thrown for bad search
queries (rather than ValidationErrors).
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param query: The search criteria. See above for description.
:type query: string or list of strings of the form "{field}:{term1}"
:param fields: Deprecated
:type fields: dict of fields to search terms.
:param order_by: A field on the Resource model that orders the results.
:type order_by: string
:param offset: Apply an offset to the query.
:type offset: int
:param limit: Apply a limit to the query.
:type limit: int
:returns: A dictionary with a ``count`` field, and a ``results`` field.
:rtype: dict
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='resource_search', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp
def package_search(client=client.Client(),
q='',
fq='',
rows='',
sort='',
start='',
qf='',
facet='',
facet_mincount='',
facet_limit='',
facet_field='',
count='',
results='',
facets='',
search_facets=''):
"""
Searches for packages satisfying a given search criteria.
This action accepts solr search query parameters (details below), and
returns a dictionary of results, including dictized datasets that match
the search criteria, a search count and also facet information.
**Solr Parameters:**
For more in depth treatment of each paramter, please read the `Solr
Documentation <http://wiki.apache.org/solr/CommonQueryParameters>`_.
This action accepts a *subset* of solr's search query parameters:
:param client: the CKAN Client.
Default: an instance of libckan.model.client.Client
:type client: libckan.model.client.Client
:param q: the solr query. Optional. Default: `"*:*"`
:type q: string
:param fq: any filter queries to apply. Note: `+site_id:{ckan_site_id}`
is added to this string prior to the query being executed.
:type fq: string
:param rows: the number of matching rows to return.
:type rows: int
:param sort: sorting of the search results. Optional. Default:
"score desc, name asc". As per the solr documentation, this is a
comma-separated string of field names and sort-orderings.
:type sort: string
:param start: the offset in the complete result for where the set of
returned datasets should begin.
:type start: int
:param qf: the dismax query fields to search within, including boosts. See
the `Solr Dismax Documentation
<http://wiki.apache.org/solr/DisMaxQParserPlugin#qf_.28Query_Fields.29>`_
for further details.
:type qf: string
:param facet: whether to enable faceted results. Default: "true".
:type facet: string
:param facet.mincount: the minimum counts for facet fields should be
included in the results.
:type facet.mincount: int
:param facet.limit: the maximum number of constraint counts that should be
returned for the facet fields. A negative value means unlimited
:type facet.limit: int
:param facet.field: the fields to facet upon. Default empty. If empty,
then the returned facet information is empty.
:type facet.field: list of strings
:returns: the dictionary returned by the CKAN API,
with the keys "help","result", and "success".
"results" is a list of packages (dict).
:return: dict
**Results:**
The result of this action is a dict with the following keys:
:rtype: A dictionary with the following keys
:param count: the number of results found. Note, this is the total number
of results found, not the total number of results returned (which is
affected by limit and row parameters used in the input).
:type count: int
:param results: ordered list of datasets matching the query, where the
ordering defined by the sort parameter used in the query.
:type results: list of dictized datasets.
:param facets: DEPRECATED. Aggregated information about facet counts.
:type facets: DEPRECATED dict
:param search_facets: aggregated information about facet counts. The outer
dict is keyed by the facet field name (as used in the search query).
Each entry of the outer dict is itself a dict, with a "title" key, and
an "items" key. The "items" key's value is a list of dicts, each with
"count", "display_name" and "name" entries. The display_name is a
form of the name that can be used in titles.
:type search_facets: nested dict of dicts.
An example result: ::
{'count': 2,
'results': [ { <snip> }, { <snip> }],
'search_facets': {u'tags': {'items': [{'count': 1,
'display_name': u'tolstoy',
'name': u'tolstoy'},
{'count': 2,
'display_name': u'russian',
'name': u'russian'}
]
}
}
}
**Limitations:**
The full solr query language is not exposed, including.
fl
The parameter that controls which fields are returned in the solr
query cannot be changed. CKAN always returns the matched datasets as
dictionary objects.
Raises: :class:`libckan.model.exceptions.CKANError`:
An error occurred accessing CKAN API
"""
args = client.sanitize_params(locals())
resp = client.request(action='package_search', data=args)
if not resp['success']:
raise exceptions.CKANError(resp.error)
return resp