def parse(cls, compoundIdStr):
"""
Parses the specified compoundId string and returns an instance
of this CompoundId class.
:raises: An ObjectWithIdNotFoundException if parsing fails. This is
because this method is a client-facing method, and if a malformed
identifier (under our internal rules) is provided, the response should
be that the identifier does not exist.
"""
if not isinstance(compoundIdStr, basestring):
raise exceptions.BadIdentifierException(compoundIdStr)
try:
deobfuscated = cls.deobfuscate(compoundIdStr)
except TypeError:
# When a string that cannot be converted to base64 is passed
# as an argument, b64decode raises a TypeError. We must treat
# this as an ID not found error.
raise exceptions.ObjectWithIdNotFoundException(compoundIdStr)
try:
splits = deobfuscated.split(cls.separator)
except UnicodeDecodeError:
# Sometimes base64 decoding succeeds but we're left with
# unicode gibberish. This is also and IdNotFound.
raise exceptions.ObjectWithIdNotFoundException(compoundIdStr)
if len(splits) != len(cls.fields):
raise exceptions.ObjectWithIdNotFoundException(compoundIdStr)
return cls(None, *splits)
def parse(cls, compoundIdStr):
"""
Parses the specified compoundId string and returns an instance
of this CompoundId class.
:raises: An ObjectWithIdNotFoundException if parsing fails. This is
because this method is a client-facing method, and if a malformed
identifier (under our internal rules) is provided, the response should
be that the identifier does not exist.
"""
if not isinstance(compoundIdStr, basestring):
raise exceptions.BadIdentifierException(compoundIdStr)
try:
deobfuscated = cls.deobfuscate(compoundIdStr)
except TypeError:
# When a string that cannot be converted to base64 is passed
# as an argument, b64decode raises a TypeError. We must treat
# this as an ID not found error.
raise exceptions.ObjectWithIdNotFoundException(compoundIdStr)
try:
encodedSplits = cls.split(deobfuscated)
splits = [cls.decode(split) for split in encodedSplits]
except (UnicodeDecodeError, ValueError):
# Sometimes base64 decoding succeeds but we're left with
# unicode gibberish. This is also and IdNotFound.
raise exceptions.ObjectWithIdNotFoundException(compoundIdStr)
# pull the differentiator out of the splits before instantiating
# the class, if the differentiator exists
fieldsLength = len(cls.fields)
if cls.differentiator is not None:
differentiatorIndex = cls.fields.index(
cls.differentiatorFieldName)
if differentiatorIndex < len(splits):
del splits[differentiatorIndex]
else:
raise exceptions.ObjectWithIdNotFoundException(
compoundIdStr)
fieldsLength -= 1
if len(splits) != fieldsLength:
raise exceptions.ObjectWithIdNotFoundException(compoundIdStr)
return cls(None, *splits)
def runGetRequest(self, idMap, id_):
"""
Runs a get request by indexing into the provided idMap and
returning a json string of that object
"""
try:
obj = idMap[id_]
except KeyError:
raise exceptions.ObjectWithIdNotFoundException(id_)
protocolElement = obj.toProtocolElement()
jsonString = protocolElement.toJsonString()
return jsonString
def getFeature(self, compoundId):
"""
Returns a protocol.Feature object corresponding to a compoundId
:param compoundId: a datamodel.FeatureCompoundId object
:return: a Feature object.
:raises: exceptions.ObjectWithIdNotFoundException if invalid
compoundId is provided.
"""
featureId = long(compoundId.featureId)
with self._db as dataSource:
featureReturned = dataSource.getFeatureById(featureId)
if featureReturned is None:
raise exceptions.ObjectWithIdNotFoundException(compoundId)
else:
gaFeature = self._gaFeatureForFeatureDbRecord(featureReturned)
return gaFeature
def listReferenceBases(self, id_, requestArgs):
# parse arguments
try:
reference = self._referenceIdMap[id_]
except KeyError:
raise exceptions.ObjectWithIdNotFoundException(id_)
start = 0
end = datamodel.PysamDatamodelMixin.fastaMax
if 'start' in requestArgs:
startString = requestArgs['start']
try:
start = int(startString)
except ValueError:
raise exceptions.BadRequestIntegerException(
'start', startString)
if 'end' in requestArgs:
endString = requestArgs['end']
try:
end = int(endString)
except ValueError:
raise exceptions.BadRequestIntegerException(
'end', endString)
if 'pageToken' in requestArgs:
pageTokenStr = requestArgs['pageToken']
start = _parsePageToken(pageTokenStr, 1)[0]
chunkSize = self._maxResponseLength
# get reference bases
gbEnd = min(start + chunkSize, end)
sequence = reference.getBases(start, gbEnd)
# determine nextPageToken
if len(sequence) == chunkSize:
nextPageToken = start + chunkSize
elif len(sequence) > chunkSize:
raise exceptions.ServerError() # should never happen
else:
nextPageToken = None
# build response
response = protocol.ListReferenceBasesResponse()
response.offset = start
response.sequence = sequence
response.nextPageToken = nextPageToken
return response.toJsonString()
def getFeature(self, compoundId):
"""
Fetches a simulated feature by ID.
:param compoundId: any non-null string
:return: A simulated feature with id set to the same value as the
passed-in compoundId.
":raises: exceptions.ObjectWithIdNotFoundException if None is passed
in for the compoundId.
"""
if compoundId is None:
raise exceptions.ObjectWithIdNotFoundException(compoundId)
randomNumberGenerator = random.Random()
randomNumberGenerator.seed(self._randomSeed)
feature = self._generateSimulatedFeature(randomNumberGenerator)
feature.id = str(compoundId)
feature.parent_id = "" # TODO: Test with nonempty parentIDs?
return feature
