def create_search(self, query_expression):
# validate credential and create search_id. No query submission -- Sync call
#
respObj = Response()
respObj.code = "401"
respObj.error_type = ""
respObj.status_code = 401
if (self.get_accessToken()):
self.query = query_expression
response = self.build_searchId()
if (response != None):
respObj.code = "200"
respObj.error_type = ""
respObj.status_code = 200
content = '{"search_id": "' + \
str(response) + \
'", "data": {"message": "Search id generated."}}'
respObj._content = bytes(content, 'utf-8')
else:
respObj.code = "404"
respObj.error_type = "Not found"
respObj.status_code = 404
respObj.message = "Could not generate search id."
else:
respObj.error_type = "Unauthorized: Access token could not be generated."
respObj.message = "Unauthorized: Access token could not be generated."
#
return ResponseWrapper(respObj)
def create_search(self, query_expression):
respObj = Response()
respObj.code = "401"
respObj.error_type = ""
respObj.status_code = 401
# print("query="+query_expression)
if (self.client.access_token):
self.query = query_expression
response = self.build_searchId()
if (response != None):
respObj.code = "200"
respObj.error_type = ""
respObj.status_code = 200
content = '{"search_id": "' + \
str(response) + \
'", "data": {"message": "Search id generated."}}'
respObj._content = bytes(content, 'utf-8')
else:
respObj.code = "404"
respObj.error_type = "Not found"
respObj.status_code = 404
respObj.message = "Could not generate search id."
else:
respObj.error_type = "Unauthorized: Access token could not be generated."
respObj.message = "Unauthorized: Access token could not be generated."
#
return ResponseWrapper(respObj)
def ping(self):
respObj = Response()
if (self.getToken()):
respObj.code = "200"
respObj.error_type = ""
respObj.status_code = 200
content = '{"status":"OK", "data": {"message": "Service is up."}}'
respObj._content = bytes(content, 'utf-8')
else:
respObj.code = "503"
respObj.error_type = "Service Unavailable"
respObj.status_code = 503
content = '{"status":"Failed", "data": {"message": "Service is down."}}'
respObj._content = bytes(content, 'utf-8')
# return
return ResponseWrapper(respObj)
async def acall(self, summary, **kwargs):
if self.is_expired():
self.refresh_token()
method = self.functions[summary]["method"]
path = self.__url + self.functions[summary]["path"]
url = path.format(**kwargs)
params = kwargs.get("params", {})
payload = kwargs.get("payload", {})
limit = kwargs.get("limit", 100)
if limit == 100:
async with aiohttp.ClientSession(
headers=self.session.headers) as session:
async with session.request(method,
url=url,
json=payload,
params=params) as resp:
ret_resp = Response()
ret_resp.status_code = resp.status
ret_resp.error_type = resp.reason
ret_resp._content = await resp.read()
return ret_resp
tasks = []
for i in range(0, limit, 100):
new_params = params.copy()
new_kwargs = kwargs.copy()
new_params["limit"] = 100
new_params["offset"] = i
del new_kwargs["params"]
new_kwargs["limit"] = 100
tasks.append(self.acall(summary, params=new_params, **new_kwargs))
resps = await asyncio.gather(*tasks)
resps_json = [resp.json() for resp in resps]
results = []
for resp in resps_json:
if "results" in resp:
# print(f"There are {len(resp['results'])} results in this response")
results.extend(resp["results"])
# print(len(results))
if "paging" in resps_json[-1]:
resp["paging"] = resps_json[-1]["paging"]
if len(results) > limit:
resp = {"results": results[:limit]}
params["offset"] = limit
resp["paging"] = {
"nextPage": f"{url}?{urllib.parse.urlencode(params)}"
}
else:
resp["results"] = results
ret_resp = Response()
ret_resp.status_code = 200
ret_resp._content = json.dumps(resp).encode("utf-8")
ret_resp.url = url
return ret_resp
def get_projects_response(self, project_data):
the_response = Response()
the_response.code = "expired"
the_response.error_type = "expired"
the_response.status_code = 200
the_response._content = project_data.encode()
return the_response
def test_error_status_code_throw_apiresponseexception():
test_response = Response()
test_response.code = "expired"
test_response.error_type = "expired"
test_response.status_code = 400
with pytest.raises(ApiRequestException):
parse_response(test_response)
def __create_fake_responses(code):
"""Create fake response to test."""
from requests.models import Response
response = Response()
response.code = "blah"
response.error_type = "blah"
response.status_code = code
return response
def client(self):
the_response = Response()
the_response.code = "expired"
the_response.error_type = "expired"
the_response.status_code = 200
with patch('datagym.client.Client._request', return_value=the_response):
from datagym import Client
return Client("38641a09-cdf1-448e-bbc6-8e49109f7b63")
def ping_box(self):
# Subroto -- Guardium does not have ping facility
# We test if we can get the access token if we can then success = true
#
respObj = Response()
if (self.fetch_accessToken()):
respObj.code = "200"
respObj.error_type = ""
respObj.status_code = 200
content = '{"status":"OK", "data": {"message": "Service is up."}}'
respObj._content = bytes(content, 'utf-8')
else:
respObj.code = "503"
respObj.error_type = "Service Unavailable"
respObj.status_code = 503
content = '{"status":"Failed", "data": {"message": "Service is down."}}'
respObj._content = bytes(content, 'utf-8')
# return
return ResponseWrapper(respObj)
def make_response(data):
header, content = data.split(b"\r\n\r\n", 1)
response = Response()
response._content, _ = content.rsplit(b'\r\n', 1)
status, headers = header.split(b'\r\n', 1)
_, code, reason = status.split()
response.code = reason
response.error_type = reason
response.status_code = int(code)
return response
def createResponse(self, resp, newContent):
pp = pprint.PrettyPrinter(indent=1)
respObj = Response()
if (resp.code == 200):
respObj.code = "200"
respObj.status_code = 200
content = json.dumps(newContent) #put new content in response
respObj._content = bytes(content, 'utf-8')
elif (resp.code == 400):
respObj.code = "400"
respObj.error_type = "Bad Request"
respObj.status_code = 400
respObj.message = "Could not generate response."
elif (resp.code == 500):
respObj.code = "500"
respObj.error_type = "Internal Server Error"
respObj.status_code = 400
respObj.message = "An internal server error occured. "
return ResponseWrapper(respObj)
def get_status(self, search_id):
# It is a synchronous connector.
# return {"code": 200, "status": "COMPLETED"}
respObj = Response()
respObj.code = "200"
respObj.error_type = ""
respObj.status_code = 200
content = '{"search_id": "' + search_id + \
'", "progress":"Completed", "status":"COMPLETED", "data": {"message":"Completed for the search id provided."}}'
respObj._content = bytes(content, 'utf-8')
return ResponseWrapper(respObj)
def get_status(self, search_id):
# Subroto we do not need to send anything to Guardium
# We create response object and send "COMPLETED"
# Note: we may have an issue with this simplistic approach
respObj = Response()
if (self.fetch_accessToken()):
respObj.code = "200"
respObj.error_type = ""
respObj.status_code = 200
content = '{"search_id": "' + search_id + \
'", "progress":"Completed", "status":"COMPLETED", "data": {"message":"Completed for the search id provided."}}'
respObj._content = bytes(content, 'utf-8')
else:
respObj.code = "503"
respObj.error_type = "Service Unavailable"
respObj.status_code = 503
content = '{"status":"Failed", "data": {"message": "Could obtain status: Authentication issue / service unavailable."}}'
respObj._content = bytes(content, 'utf-8')
#
return ResponseWrapper(respObj)
def download_page(pURL, max_retry=3, attempt=0):
try:
r = requests.get(pURL)
return r
except requests.ConnectionError:
logging.warning("Connection Error for URL: {}".format(pURL))
response = Response()
response.code = "Connection Error"
response.error_type = "Connection"
response.status_code = 451
response._content = b'{"error":"Connection Error"}'
return response
except requests.Timeout:
if attempt < max_retry:
download_page(pURL, max_retry, attemp + 1)
else:
logging.warning("Connection Timeout for URL: {}".format(pURL))
response = Response()
response.code = "Timeout"
response.error_type = "Connection"
response.status_code = 400
response._content = b'{"error":"Timeout"}'
return response
except requests.TooManyRedirects:
logging.warning("Too Many Redirects for URL: {}".format(pURL))
response = Response()
response.code = "Too many redirects"
response.error_type = "Redirects"
response.status_code = 309
response._content = b'{"error":"Too many redirects"}'
return response
except requests.RequestException as e:
logging.warning("Generic Request Exception for URL: {}".format(pURL))
response = Response()
response.code = "Unknown error"
response.error_type = "Generic"
response.status_code = 450
response._content = b'{"error":"Unknown error"}'
return response
async def acall(self, summary, **kwargs):
if self.is_expired():
self.refresh_token()
method = self.functions[summary]['method']
path = self.__url + self.functions[summary]['path']
url = path.format(**kwargs)
params = kwargs.get('params', {})
payload = kwargs.get('payload', {})
limit = kwargs.get('limit', 100)
if limit == 100:
async with aiohttp.ClientSession(headers=self.session.headers) as session:
async with session.request(method, url=url, json=payload, params=params) as resp:
ret_resp = Response()
ret_resp.status_code = resp.status
ret_resp.error_type = resp.reason
ret_resp._content = await resp.read()
return ret_resp
tasks = []
for i in range(0,limit,100):
new_params = params.copy()
new_params['limit'] = 100
new_params['offset'] = i
tasks.append(self.acall(summary, params=new_params))
resps = await asyncio.gather(*tasks)
resps_json = [resp.json() for resp in resps]
results = []
for resp in resps_json:
if 'results' in resp:
#print(f"There are {len(resp['results'])} results in this response")
results.extend(resp['results'])
#print(len(results))
if len(results) > limit:
resp = {'results':results[:limit]}
params['offset'] = limit
resp['paging'] = {'nextPage': f'{url}?{urllib.parse.urlencode(params)}'}
else:
resp = {'results':results}
ret_resp = Response()
ret_resp.status_code = 200
ret_resp._content = json.dumps(resp).encode('utf-8')
return ret_resp
def test_result_fail(self):
# generate intended response object
expected_response = Response()
expected_response.code = "expired"
expected_response.error_type = "expired"
expected_response.status_code = 400
expected_response._content = b'{ "error" : "Can not connect to API" }'
objectified_response = ApiResult(expected_response)
# check values of objects are equal
self.assertEqual(ApiCall().get_result("").error_message,
objectified_response.error_message)
self.assertEqual(ApiCall().get_result("").result,
objectified_response.result)
self.assertEqual(ApiCall().get_result("").is_success,
objectified_response.is_success)
from requests.models import Response resp = Response() resp.code = "expired" resp.error_type = "expired" resp.status_code = 200 resp._content = b'["Under-Review","IGO-Complete","Passed","Failed","Resequence-Pool","Repool-Sample","Recapture-Sample","New-Library-Needed","Required-Additional-Reads"]'
def create_dummy_response(response_code=None, error=None):
dummy_response = Response()
dummy_response.status_code = response_code
dummy_response.error_type = error
return dummy_response
