def update(self, trans, history_id, id, payload, **kwd):
"""
update( self, trans, history_id, id, payload, **kwd )
* PUT /api/histories/{history_id}/contents/{id}
updates the values for the history content item with the given ``id``
:type history_id: str
:param history_id: encoded id string of the items's History
:type id: str
:param id: the encoded id of the history item to update
:type payload: dict
:param payload: a dictionary containing any or all the
fields in :func:`galaxy.model.HistoryDatasetAssociation.to_dict`
and/or the following:
* annotation: an annotation for the HDA
:rtype: dict
:returns: an error object if an error occurred or a dictionary containing
any values that were different from the original and, therefore, updated
"""
serialization_params = parse_serialization_params(**kwd)
contents_type = self.__get_contents_type(kwd)
return self.service.update(
trans, history_id, id, payload, serialization_params, contents_type
)
def show(self, trans, id, history_id, **kwd):
"""
GET /api/histories/{history_id}/contents/{id}
GET /api/histories/{history_id}/contents/{type}/{id}
return detailed information about an HDA or HDCA within a history
.. note:: Anonymous users are allowed to get their current history contents
:type id: str
:param id: the encoded id of the HDA or HDCA to return
:type type: str
:param id: 'dataset' or 'dataset_collection'
:type history_id: str
:param history_id: encoded id string of the HDA's or HDCA's History
:type view: str
:param view: if fetching a dataset collection - the view style of
the dataset collection to produce.
'collection' returns no element information, 'element'
returns detailed element information for all datasets,
'element-reference' returns a minimal set of information
about datasets (for instance id, type, and state but not
metadata, peek, info, or name). The default is 'element'.
:type fuzzy_count: int
:param fuzzy_count: this value can be used to broadly restrict the magnitude
of the number of elements returned via the API for large
collections. The number of actual elements returned may
be "a bit" more than this number or "a lot" less - varying
on the depth of nesting, balance of nesting at each level,
and size of target collection. The consumer of this API should
not expect a stable number or pre-calculable number of
elements to be produced given this parameter - the only
promise is that this API will not respond with an order
of magnitude more elements estimated with this value.
The UI uses this parameter to fetch a "balanced" concept of
the "start" of large collections at every depth of the
collection.
:rtype: dict
:returns: dictionary containing detailed HDA or HDCA information
"""
serialization_params = parse_serialization_params(**kwd)
contents_type = self.__get_contents_type(kwd)
fuzzy_count = kwd.get("fuzzy_count", None)
if fuzzy_count:
fuzzy_count = int(fuzzy_count)
return self.service.show(trans, id, serialization_params, contents_type, fuzzy_count)
def update_batch(self, trans, history_id, payload, **kwd):
"""
PUT /api/histories/{history_id}/contents
:type history_id: str
:param history_id: encoded id string of the history containing supplied items
:type id: str
:param id: the encoded id of the history to update
:type payload: dict
:param payload: a dictionary containing any or all the
:rtype: dict
:returns: an error object if an error occurred or a dictionary containing
any values that were different from the original and, therefore, updated
"""
serialization_params = parse_serialization_params(**kwd)
update_payload = UpdateHistoryContentsBatchPayload.parse_obj(payload)
return self.service.update_batch(trans, history_id, update_payload, serialization_params)
def contents_near(self, trans, history_id, direction, hid, limit, **kwd):
"""
Returns the following data:
a) item counts:
- total matches-up: hid < {hid}
- total matches-down: hid > {hid}
- total matches: total matches-up + total matches-down + 1 (+1 for hid == {hid})
- displayed matches-up: hid <= {hid} (hid == {hid} is included)
- displayed matches-down: hid > {hid}
- displayed matches: displayed matches-up + displayed matches-down
b) {limit} history items:
- if direction == before: hid <= {hid}
- if direction == after: hid > {hid}
- if direction == near: "near" {hid}, so that |before| <= limit // 2, |after| <= limit // 2 + 1.
Intended purpose: supports scroller functionality.
GET /api/histories/{history_id}/contents/{direction:near|before|after}/{hid}/{limit}
"""
serialization_params = parse_serialization_params(default_view='betawebclient', **kwd)
since_str = kwd.pop('since', None)
if since_str:
since = dateutil.parser.isoparse(since_str)
else:
since = None
filter_params = parse_content_filter_params(kwd)
hid = int(hid)
limit = int(limit)
result = self.service.contents_near(
trans, history_id, serialization_params, filter_params, direction, hid, limit, since,
)
if result is None:
trans.response.status = 204
return
# Put stats in http headers
trans.response.headers.update(result.stats.to_headers())
return result.contents
def delete(self, trans, history_id, id, purge=False, recursive=False, **kwd):
"""
DELETE /api/histories/{history_id}/contents/{id}
DELETE /api/histories/{history_id}/contents/{type}s/{id}
delete the history content with the given ``id`` and specified type (defaults to dataset)
.. note:: Currently does not stop any active jobs for which this dataset is an output.
:type id: str
:param id: the encoded id of the history to delete
:type recursive: bool
:param recursive: if True, and deleted an HDCA also delete containing HDAs
:type purge: bool
:param purge: if True, purge the target HDA or child HDAs of the target HDCA
:type kwd: dict
:param kwd: (optional) dictionary structure containing:
* payload: a dictionary itself containing:
* purge: if True, purge the HDA
* recursive: if True, see above.
.. note:: that payload optionally can be placed in the query string of the request.
This allows clients that strip the request body to still purge the dataset.
:rtype: dict
:returns: an error object if an error occurred or a dictionary containing:
* id: the encoded id of the history,
* deleted: if the history content was marked as deleted,
* purged: if the history content was purged
"""
serialization_params = parse_serialization_params(**kwd)
contents_type = self.__get_contents_type(kwd)
purge = util.string_as_bool(purge)
recursive = util.string_as_bool(recursive)
if kwd.get('payload', None):
# payload takes priority
purge = util.string_as_bool(kwd['payload'].get('purge', purge))
recursive = util.string_as_bool(kwd['payload'].get('recursive', recursive))
delete_payload = DeleteHistoryContentPayload(purge=purge, recursive=recursive)
return self.service.delete(trans, id, serialization_params, contents_type, delete_payload)
def index(self, trans, history_id, **kwd):
"""
GET /api/histories/{history_id}/contents
return a list of HDA data for the history with the given ``id``
.. note:: Anonymous users are allowed to get their current history contents
If Ids is not given, index returns a list of *summary* objects for
every HDA associated with the given `history_id`.
If ids is given, index returns a *more complete* json object for each
HDA in the ids list.
:type history_id: str
:param history_id: encoded id string of the HDA's History
:type ids: str
:param ids: (optional) a comma separated list of encoded `HDA` ids
:param types: (optional) kinds of contents to index (currently just
dataset, but dataset_collection will be added shortly).
:type types: str
:rtype: list
:returns: dictionaries containing summary or detailed HDA information
"""
index_params = parse_index_query_params(**kwd)
legacy_params = parse_legacy_index_query_params(**kwd)
# Sometimes the `v=dev` version is called with `details` or `dataset_details`
index_params.dataset_details = index_params.dataset_details or legacy_params.dataset_details
serialization_params = parse_serialization_params(**kwd)
filter_parameters = FilterQueryParams(**kwd)
return self.service.index(
trans, history_id,
index_params,
legacy_params,
serialization_params, filter_parameters
)
