def getDatastreamDissemination(self, pid, dsID, asOfDateTime=None, stream=False,
head=False, rqst_headers={}):
"""Get a single datastream on a Fedora object; optionally, get the version
as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
:param stream: return a streaming response (default: False); use
is recommended for large datastreams
:param head: return a HEAD request instead of GET (default: False)
:param rqst_headers: request headers to be passed through to Fedora,
such as http range requests
:rtype: :class:`requests.models.Response`
"""
# /objects/{pid}/datastreams/{dsID}/content ? [asOfDateTime] [download]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
url = 'objects/%(pid)s/datastreams/%(dsid)s/content' % \
{'pid': pid, 'dsid': dsID}
if head:
reqmethod = self.head
else:
reqmethod = self.get
return reqmethod(url, params=http_args, stream=stream, headers=rqst_headers)
def getDatastream(self,
pid,
dsID,
asOfDateTime=None,
validateChecksum=False):
"""Get information about a single datastream on a Fedora object; optionally,
get information for the version of the datastream as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# /objects/{pid}/datastreams/{dsID} ? [asOfDateTime] [format] [validateChecksum]
http_args = {}
if validateChecksum:
# fedora only responds to lower-case validateChecksum option
http_args['validateChecksum'] = str(validateChecksum).lower()
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
uri = 'objects/%s/datastreams/%s' % (pid, dsID)
if http_args:
uri += '?' + _safe_urlencode(http_args)
return self.read(uri)
def getDatastreamDissemination(self,
pid,
dsID,
asOfDateTime=None,
return_http_response=False):
"""Get a single datastream on a Fedora object; optionally, get the version
as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
:param return_http_response: optional parameter; if True, the
actual :class:`httlib.HttpResponse` instance generated by
the request will be returned, instead of just the contents
(e.g., if you want to deal with large datastreams in
chunks). Defaults to False.
"""
# TODO: Note that this loads the entire datastream content into
# memory as a Python string. This will suck for very large
# datastreams. Eventually we need to either modify this function or
# else add another to return self.open(), allowing users to stream
# the result in a with block.
# /objects/{pid}/datastreams/{dsID}/content ? [asOfDateTime] [download]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
url = 'objects/%s/datastreams/%s/content?%s' % (
pid, dsID, _safe_urlencode(http_args))
return self.read(url, return_http_response=return_http_response)
def getDatastreamDissemination(self, pid, dsID, asOfDateTime=None, return_http_response=False):
"""Get a single datastream on a Fedora object; optionally, get the version
as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
:param return_http_response: optional parameter; if True, the
actual :class:`httlib.HttpResponse` instance generated by
the request will be returned, instead of just the contents
(e.g., if you want to deal with large datastreams in
chunks). Defaults to False.
"""
# TODO: Note that this loads the entire datastream content into
# memory as a Python string. This will suck for very large
# datastreams. Eventually we need to either modify this function or
# else add another to return self.open(), allowing users to stream
# the result in a with block.
# /objects/{pid}/datastreams/{dsID}/content ? [asOfDateTime] [download]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
url = 'objects/%s/datastreams/%s/content?%s' % (pid, dsID, _safe_urlencode(http_args))
return self.read(url, return_http_response=return_http_response)
def getDatastream(self,
pid,
dsID,
asOfDateTime=None,
validateChecksum=False):
"""Get information about a single datastream on a Fedora object; optionally,
get information for the version of the datastream as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
:param validateChecksum: boolean; if True, request Fedora to recalculate
and verify the stored checksum against actual data
:rtype: :class:`requests.models.Response`
"""
# /objects/{pid}/datastreams/{dsID} ? [asOfDateTime] [format] [validateChecksum]
http_args = {}
if validateChecksum:
# fedora only responds to lower-case validateChecksum option
http_args['validateChecksum'] = str(validateChecksum).lower()
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
uri = 'objects/%(pid)s/datastreams/%(dsid)s' % {
'pid': pid,
'dsid': dsID
}
return self.get(uri, params=http_args)
def getDatastreamDissemination(self,
pid,
dsID,
asOfDateTime=None,
stream=False):
"""Get a single datastream on a Fedora object; optionally, get the version
as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# TODO: Note that this loads the entire datastream content into
# memory as a Python string. This will suck for very large
# datastreams. Eventually we need to either modify this function or
# else add another to return self.open(), allowing users to stream
# the result in a with block.
# /objects/{pid}/datastreams/{dsID}/content ? [asOfDateTime] [download]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
url = 'objects/%(pid)s/datastreams/%(dsid)s/content' % \
{'pid': pid, 'dsid': dsID}
return self.get(url, params=http_args, stream=stream)
def test_purgeDatastream(self):
# add a datastream that can be purged
(added, dsprofile), ds = self._add_text_datastream()
# grab datastream creation date from addDatastream result to test purge result
dsprofile_node = etree.fromstring(dsprofile)
created = dsprofile_node.xpath("string(m:dsCreateDate)", namespaces={"m": FEDORA_MANAGE_NS})
# purgeDatastream gives us back the time in a different format:
expect_created = created
if expect_created.endswith("Z"): # it does
# strip of the Z and any final zeros
expect_created = expect_created.rstrip("Z0")
# strip the decimal if it got that far
expect_created = expect_created.rstrip(".")
# and put back the Z
expect_created += "Z"
r = self.rest_api.purgeDatastream(self.pid, ds["id"], logMessage="purging text datastream")
purged = r.status_code == requests.codes.ok
times = r.text
self.assertTrue(purged)
self.assert_(
expect_created in times,
"datastream creation date should be returned in list of purged datastreams - expected %s, got %s"
% (expect_created, times),
)
# log message in audit trail
r = self.rest_api.getObjectXML(self.pid)
self.assert_("purging text datastream" in r.text)
# datastream no longer listed
r = self.rest_api.listDatastreams(self.pid)
self.assert_('<datastream dsid="%s"' % ds["id"] not in r.text)
# NOTE: Fedora bug - attempting to purge a non-existent datastream returns 204?
# purged = self.rest_api.purgeDatastream(self.pid, "BOGUS",
# logMessage="test purging non-existent datastream")
# self.assertFalse(purged)
self.assertRaises(
RequestFailed,
self.rest_api.purgeDatastream,
"bogus:pid",
"BOGUS",
logMessage="test purging non-existent datastream from non-existent object",
)
# also test purging specific versions of a datastream ?
# attempt to purge a version that doesn't exist
(added, dsprofile), ds = self._add_text_datastream()
tomorrow = datetime.now(tzutc()) + timedelta(1)
r = self.rest_api.purgeDatastream(
self.pid, ds["id"], startDT=datetime_to_fedoratime(tomorrow), logMessage="purging text datastream"
)
success = r.status_code == requests.codes.ok
times = r.text
# no errors, no versions purged
self.assertTrue(success)
self.assertEqual("[]", times)
def test_purgeDatastream(self):
# add a datastream that can be purged
(added, dsprofile), ds = self._add_text_datastream()
# grab datastream creation date from addDatastream result to test purge result
dsprofile_node = etree.fromstring(dsprofile)
created = dsprofile_node.xpath('string(m:dsCreateDate)',
namespaces={'m': FEDORA_MANAGE_NS})
# purgeDatastream gives us back the time in a different format:
expect_created = created
if expect_created.endswith('Z'): # it does
# strip of the Z and any final zeros
expect_created = expect_created.rstrip('Z0')
# strip the decimal if it got that far
expect_created = expect_created.rstrip('.')
# and put back the Z
expect_created += 'Z'
purged, times = self.rest_api.purgeDatastream(
self.pid, ds['id'], logMessage="purging text datastream")
self.assertTrue(purged)
self.assert_(expect_created in times,
'datastream creation date should be returned in list of purged datastreams - expected %s, got %s' % \
(expect_created, times))
# log message in audit trail
xml, url = self.rest_api.getObjectXML(self.pid)
self.assert_('purging text datastream' in xml)
# datastream no longer listed
dslist, url = self.rest_api.listDatastreams(self.pid)
self.assert_('<datastream dsid="%s"' % ds['id'] not in dslist)
# NOTE: Fedora bug - attempting to purge a non-existent datastream returns 204?
# purged = self.rest_api.purgeDatastream(self.pid, "BOGUS",
# logMessage="test purging non-existent datastream")
# self.assertFalse(purged)
self.assertRaises(
RequestFailed,
self.rest_api.purgeDatastream,
"bogus:pid",
"BOGUS",
logMessage=
"test purging non-existent datastream from non-existent object")
# also test purging specific versions of a datastream ?
# attempt to purge a version that doesn't exist
(added, dsprofile), ds = self._add_text_datastream()
tomorrow = datetime.now(tzutc()) + timedelta(1)
success, times = self.rest_api.purgeDatastream(
self.pid,
ds['id'],
startDT=datetime_to_fedoratime(tomorrow),
logMessage="purging text datastream")
# no errors, no versions purged
self.assertTrue(success)
self.assertEqual('[]', times)
def getObjectProfile(self, pid, asOfDateTime=None):
"""Get top-level information aboug a single Fedora object; optionally,
retrieve information as of a particular date-time.
:param pid: object pid
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# /objects/{pid} ? [format] [asOfDateTime]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
url = 'objects/%(pid)s' % {'pid': pid}
return self.get(url, params=http_args)
def getObjectProfile(self, pid, asOfDateTime=None):
"""Get top-level information aboug a single Fedora object; optionally,
retrieve information as of a particular date-time.
:param pid: object pid
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# /objects/{pid} ? [format] [asOfDateTime]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
url = 'objects/%s?%s' % (pid, _safe_urlencode(http_args))
return self.read(url)
def getObjectProfile(self, pid, asOfDateTime=None):
"""Get top-level information aboug a single Fedora object; optionally,
retrieve information as of a particular date-time.
:param pid: object pid
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
:rtype: :class:`requests.models.Response`
"""
# /objects/{pid} ? [format] [asOfDateTime]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
url = 'objects/%(pid)s' % {'pid': pid}
return self.get(url, params=http_args)
def getDatastream(self, pid, dsID, asOfDateTime=None, validateChecksum=False):
"""Get information about a single datastream on a Fedora object; optionally,
get information for the version of the datastream as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# /objects/{pid}/datastreams/{dsID} ? [asOfDateTime] [format] [validateChecksum]
http_args = {}
if validateChecksum:
# fedora only responds to lower-case validateChecksum option
http_args['validateChecksum'] = str(validateChecksum).lower()
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
http_args.update(self.format_xml)
uri = 'objects/%(pid)s/datastreams/%(dsid)s' % {'pid': pid, 'dsid': dsID}
return self.get(uri, params=http_args)
def getDatastreamDissemination(self, pid, dsID, asOfDateTime=None, stream=False):
"""Get a single datastream on a Fedora object; optionally, get the version
as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
"""
# TODO: Note that this loads the entire datastream content into
# memory as a Python string. This will suck for very large
# datastreams. Eventually we need to either modify this function or
# else add another to return self.open(), allowing users to stream
# the result in a with block.
# /objects/{pid}/datastreams/{dsID}/content ? [asOfDateTime] [download]
http_args = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
url = 'objects/%(pid)s/datastreams/%(dsid)s/content' % \
{'pid': pid, 'dsid': dsID}
return self.get(url, params=http_args, stream=stream)
def getDatastreamDissemination(self,
pid,
dsID,
asOfDateTime=None,
stream=False,
head=False,
rqst_headers=None):
"""Get a single datastream on a Fedora object; optionally, get the version
as of a particular date time.
:param pid: object pid
:param dsID: datastream id
:param asOfDateTime: optional datetime; ``must`` be a non-naive datetime
so it can be converted to a date-time format Fedora can understand
:param stream: return a streaming response (default: False); use
is recommended for large datastreams
:param head: return a HEAD request instead of GET (default: False)
:param rqst_headers: request headers to be passed through to Fedora,
such as http range requests
:rtype: :class:`requests.models.Response`
"""
# /objects/{pid}/datastreams/{dsID}/content ? [asOfDateTime] [download]
http_args = {}
if rqst_headers is None:
rqst_headers = {}
if asOfDateTime:
http_args['asOfDateTime'] = datetime_to_fedoratime(asOfDateTime)
url = 'objects/%(pid)s/datastreams/%(dsid)s/content' % \
{'pid': pid, 'dsid': dsID}
if head:
reqmethod = self.head
else:
reqmethod = self.get
return reqmethod(url,
params=http_args,
stream=stream,
headers=rqst_headers)
def to_xml(self, dt):
return datetime_to_fedoratime(dt)
def to_xml(self, dt):
return datetime_to_fedoratime(dt)