def describe_response(
status: typing.Union[int, HTTPStatus],
description: str = "",
*,
content: typing.Union[typing.Type[BaseModel], type, dict] = None,
headers: dict = None,
links: dict = None,
) -> typing.Callable[[T], T]:
"""
describe a response in HTTP view function
https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.0.md#responseObject
"""
status = int(status)
if not description:
description = HTTPStatus(status).description
def decorator(func: T) -> T:
if not hasattr(func, "__responses__"):
responses: typing.Dict[int, typing.Dict[str, typing.Any]] = {}
setattr(func, "__responses__", responses)
else:
responses = getattr(func, "__responses__")
if (content is None or isinstance(content, dict)
or (not isinstance(content, GenericType) and isclass(content)
and issubclass(content, BaseModel))):
real_content = content
else:
real_content = create_model(
f"ParsingModel[{display_as_type(content)}]",
__root__=(content, ...))
responses[status] = {
"description": description,
"content": real_content,
"headers": headers,
"links": links,
} | F(lambda d: {k: v
for k, v in d.items() if v})
return func
return decorator
def get(self):
http_status = 200
try:
http_status = int(request.args.get('http_status', 200))
except Exception:
pass
try:
desc = HTTPStatus(http_status).name
except Exception as e:
desc = str(e)
r = make_response('', http_status)
r.headers['X-HTTPStatus-Code'] = http_status
r.headers['X-HTTPStatus-Text'] = desc
return r
def serialize(self):
rv = dict(self.payload or ())
if self.status_code:
rv['status_code'] = str(self.status_code)
rv['reply'] = HTTPStatus(self.status_code).phrase
if self.message:
rv['message'] = self.message
if hasattr(self, 'chain'):
rv['chain'] = self.chain
if hasattr(self, 'error'):
rv['error'] = self.error
rv['error_message'] = self.error_msg
rv['traceback'] = self.traceback
rv['timestamp'] = self.timestamp.strftime('%Y/%m/%d %H:%M:%S')
return rv
def Rendeles():
try:
rendeles = request.args.get('rendeles')
except:
return HTTPStatus(400).description
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = "127.0.0.1"
port = 3223
s.connect((host, port))
s.send(rendeles.encode('ascii'))
data = s.recv(1024)
s.close()
return Response(str(data.decode('ascii')),
status=200,
mimetype='http/text')
def test_verificationoption_without_phone_number(self,
request_code_by_pds_mock,
_):
""" Test that verificationoption template is rendered properly
without sms"""
headers = {'Content-type': 'application/json', 'cookie': None}
with self.client as c:
with c.session_transaction() as session:
session["email"] = common.USER_DETAILS.get("email")
request_code_by_pds_mock.return_value = constants.OTP_REQUEST_SUCCESS
result = self.client.post('/verificationoption',
data=json.dumps(common.USER_DETAILS),
headers=headers)
assert HTTPStatus(result.status_code) == HTTPStatus.FOUND
assert "enteryourcode" in result.headers['Location']
async def send(data):
if data["type"] == "http.response.start":
protocol = "HTTP/1.1"
status = HTTPStatus(data["status"])
status_line = f"{protocol} {status.value} {status.phrase}"
headers = [status_line]
for header in data["headers"]:
key, value = header[0].decode(), header[1].decode()
headers.append(f"{key}: {value}")
headers.append("")
writer.writelines([f"{line}\r\n".encode() for line in headers])
await writer.drain()
elif data["type"] == "http.response.body":
writer.writelines([data["body"], "\r\n".encode()])
await writer.drain()
else:
raise Exception("Not implemented")
def dump_wrapper(*args, **kwargs):
response = func(*args, **kwargs)
if response is None:
if model is not None:
raise ValueError(
"Response cannot not be None with HTTP status %d" %
code)
return flask.Response(status=code)
elif isinstance(response, flask.Response) or model is None:
return response
elif isinstance(response, tuple):
response, _code = response
else:
_code = code
if HTTPStatus(_code) is code:
response = model.dump(response).data
return response, _code
def test_verificationoption_without_phone_number(self, _):
""" Test that verificationoption template is rendered properly
without sms"""
headers = {'Content-type': 'application/json', 'cookie': None}
with self.client as c:
with c.session_transaction() as session:
session["email"] = common.USER_DETAILS.get("email")
result = self.client.post('/verificationoption',
data=json.dumps(common.USER_DETAILS),
headers=headers)
assert HTTPStatus(result.status_code) == HTTPStatus.OK
assert common.USER_DETAILS['sms'] not in str(result.data)
assert 'wrong_value_with_randomxxxx' not in str(result.data)
assert common.USER_DETAILS['email'] in str(result.data)
assert 'phone number has' not in str(result.data)
assert 'email address has' in str(result.data)
def test_given_invalid_submission_payload_response_with_error(self):
test_session_id = "test.session.id"
auth_response = AuthResponse(status=HTTPStatus(200))
auth_response.session_id = test_session_id
self.mock_auth.login = MagicMock(return_value=auth_response)
biostudies = BioStudies("url", "username", "password")
expected_error_message = "Submission validation errors."
biostudies.api.create_submission = MagicMock(
side_effect=RestErrorException(expected_error_message,
HTTPStatus.BAD_REQUEST))
with self.assertRaises(RestErrorException) as context:
biostudies.send_submission(
TestBioStudiesService.__create_submission())
self.assertEqual(HTTPStatus.BAD_REQUEST, context.exception.status_code)
self.assertEqual(expected_error_message, context.exception.message)
def test_given_valid_submission_payload_response_with_accession(self):
test_session_id = "test.session.id"
auth_response = AuthResponse(status=HTTPStatus(200))
auth_response.session_id = test_session_id
self.mock_auth.login = MagicMock(return_value=auth_response)
bst_accession_id = 'bst123'
response = ResponseObject()
response.json = {'accno': bst_accession_id}
biostudies = BioStudies("url", "username", "password")
biostudies.api.create_submission = MagicMock(return_value=response)
accession_from_response = biostudies.send_submission(
TestBioStudiesService.__create_submission())
self.assertEqual(bst_accession_id, accession_from_response)
def on_web_request_end(self,
app: AppT,
request: web.Request,
response: Optional[web.Response],
state: Dict,
*,
view: web.View = None) -> None:
"""Web server finished working on request."""
status_code = HTTPStatus(response.status if response else 500)
time_start = state['time_start']
time_end = self.time()
latency_end = time_end - time_start
state.update(
time_end=time_end,
latency_end=latency_end,
status_code=status_code,
)
deque_pushpopmax(self.http_response_latency, latency_end,
self.max_avg_history)
self.http_response_codes[status_code] += 1
def on_web_request_end(self,
app: AppT,
request: web.Request,
response: Optional[web.Response],
state: Dict,
*,
view: web.View = None) -> None:
"""Web server finished working on request."""
status_code = HTTPStatus(
response.status if response is not None else 500)
time_start = state["time_start"]
time_end = self.time()
latency_end = time_end - time_start
state.update(
time_end=time_end,
latency_end=latency_end,
status_code=status_code,
)
self.http_response_latency.append(latency_end)
self.http_response_codes[status_code] += 1
def _request(self,
method: str,
url: str,
fields: Optional[Mapping[str, str]] = None,
headers: Mapping[str, str] = None,
body: Union[bytes, str, None] = None):
headers = headers if headers else {}
if method in ('PATCH', 'POST', 'PUT'):
headers = {
**self.base_headers, 'Content-Type': self.API_CONTENT_TYPE,
**headers
}
body = body.encode(self.API_BODY_ENCODING) if isinstance(
body, str) else body
else:
headers = {**self.base_headers, **headers}
response = self.http.request(method,
self._resolve_url(url),
fields=fields,
headers=headers,
body=body)
content_type = ContentType.from_response(response)
if content_type.is_json():
content = json.loads(
response.data.decode(
content_type.charset(
default=self.API_BODY_ENCODING).lower()))
else:
content = response.data.decode(
content_type.charset(default=self.API_BODY_ENCODING).lower())
self._logger.debug(
'GitHub API request: %s <%s>\nGitHub API response (status: %s; content type: %s):\n%s',
method, url, HTTPStatus(response.status), content_type, content)
if response.status >= 400:
raise GitHubClientError(response.status, response.reason, content)
return content
def test_flash_errors(self, flash_mock, choice_option_mock, _, **kwargs):
""" Test errors are flashed when setpreference not validated """
form_mock = MagicMock()
form_mock.validate_on_submit.return_value = False
form_mock.radio.data = "Yes"
form_mock.errors = ['sample_fot_tests']
choice_option_mock.return_value = form_mock
flash_mock.return_value = "_"
mock = kwargs['mock']
mock.get(self.app.config['PREFERENCE_RESULT_URL'],
text=get_preference_results_callback_inactive)
mock.post(self.app.config['SET_PREFERENCE_URL'], text="{}")
result = self.client.post('/setyourpreference')
assert HTTPStatus(result.status_code) == HTTPStatus.OK
flash_mock.assert_called()
def _write_response(self, bolt_resp: BoltResponse, resp: Response):
resp.body = bolt_resp.body
status = HTTPStatus(bolt_resp.status)
resp.status = str(f"{status.value} {status.phrase}")
resp.set_headers(bolt_resp.first_headers_without_set_cookie())
for cookie in bolt_resp.cookies():
for name, c in cookie.items():
expire_value = c.get("expires")
expire = (datetime.strptime(expire_value,
"%a, %d %b %Y %H:%M:%S %Z")
if expire_value else None)
resp.set_cookie(
name=name,
value=c.value,
expires=expire,
max_age=c.get("max-age"),
domain=c.get("domain"),
path=c.get("path"),
secure=True,
http_only=True,
)
async def http_dog(self, ctx: commands.Context, code: int) -> None:
"""Sends an embed with an image of a dog, portraying the status code."""
embed = discord.Embed(title=f'**Status: {code}**')
url = HTTP_DOG_URL.format(code=code)
try:
HTTPStatus(code)
async with self.bot.http_session.get(url, allow_redirects=False) as response:
if response.status != 302:
embed.set_image(url=url)
else:
raise NotImplementedError
except ValueError:
embed.set_footer(text='Inputted status code does not exist.')
except NotImplementedError:
embed.set_footer(text='Inputted status code is not implemented by httpstatusdogs.com yet.')
finally:
await ctx.send(embed=embed)
async def _do_req(self, path: str, *, method: str = 'GET',
data: Optional[Any] = None):
"""
Performs a request against the instance eureka server.
:param path: URL Path, the hostname is prepended automatically
:param method: request method (put/post/patch/get/etc)
:param data: Optional data to be sent with the request, must
already be encoded appropriately.
:return: optional[dict[str, any]]
"""
url = self._eureka_url + path
logger.debug('Performing %s on %s with payload: %s', method, path,
data)
async with self._session.request(method, url, data=data) as resp:
if 400 <= resp.status < 600:
# noinspection PyArgumentList
raise EurekaException(HTTPStatus(resp.status),
await resp.text())
logger.debug('Result: %s', resp.status)
return await resp.json()
def _get_error_message(response: Response) -> str:
error_message = 'Unknown error'
try:
error_json = response.json()
if 'errors' in error_json:
if isinstance(error_json['errors'], list):
err = error_json['errors'][0]
error_message = err.get('message')
elif 'error' in error_json:
error_message = error_json['error']
elif 'message' in error_json:
error_message = error_json['message']
elif 'errorMessage' in error_json:
error_message = error_json['errorMessage']
elif response.status_code == 401:
error_message = 'Unauthorized: Access is denied due to invalid credentials'
else:
error_message = HTTPStatus(response.status_code).phrase
return error_message
except:
return response.text or error_message
def _json_exception(status: int, exception: web.HTTPException,
url: URL) -> str:
"""Convert an HTTP exception into a problem detailed JSON object.
The problem details are in accordance with RFC 7807.
(https://tools.ietf.org/html/rfc7807)
:param status: Status code of the HTTP exception
:param exception: Exception content
:param url: Request URL that caused the exception
:returns: Problem detail JSON object as a string
"""
body = json.dumps({
"type": "about:blank",
# Replace type value above with an URL to
# a custom error document when one exists
"title": HTTPStatus(status).phrase,
"detail": exception.reason,
"instance": url.path, # optional
})
return body
def _do_req(self,
path: str,
*,
method: str = 'GET',
data: Optional[Dict] = None):
"""
Performs a request against the instance eureka server.
:param path: URL Path, the hostname is prepended automatically
:param method: request method (put/post/patch/get/etc)
:param data: Optional data to be sent with the request, must
already be encoded appropriately.
:return: optional[dict[str, any]]
"""
url = self._eureka_url + path
logger.debug('Performing %s on %s with payload: %s', method, path,
data)
resp = requests.request(method, url, json=data or {})
if 400 <= resp.status_code < 600:
raise EurekaException(HTTPStatus(resp.status_code), resp.text)
logger.debug('Result status: %s', resp.status_code)
return resp.text
def name_of(cls, value):
"""
>>> FeedResponseStatus.name_of(200)
'OK'
>>> FeedResponseStatus.name_of(-200)
'RSSANT_CONNECTION_ERROR'
>>> FeedResponseStatus.name_of(-999)
'RSSANT_E999'
"""
if value > 0:
try:
return HTTPStatus(value).name
except ValueError:
# eg: http://huanggua.sinaapp.com/
# ValueError: 600 is not a valid HTTPStatus
return f'HTTP_{value}'
else:
try:
return 'RSSANT_' + FeedResponseStatus(value).name
except ValueError:
return f'RSSANT_E{abs(value)}'
def handle_new_case_triage_etl(data: Dict[str, Any],
_: ContextType) -> Tuple[str, HTTPStatus]:
"""This function is triggered when a file is dropped in the
`{project_id}-case-triage-data` bucket. If the file matches `etl_*.csv`,
then it makes a request to import the CSV to Cloud SQL.
"""
project_id = os.environ.get(GCP_PROJECT_ID_KEY)
if not project_id:
logging.error(
"No project id set for call to update auth0 users, returning.")
return "", HTTPStatus.BAD_REQUEST
filename = data["name"]
if not filename.startswith("etl_") or not filename.endswith(".csv"):
logging.info("Ignoring file %s", filename)
return "", HTTPStatus.OK
import_url = _APP_ENGINE_IMPORT_CASE_TRIAGE_ETL_CSV_TO_SQL_URL.format(
project_id, filename)
import_response = make_iap_request(import_url, IAP_CLIENT_ID[project_id])
return "", HTTPStatus(import_response.status_code)
async def get_file(self, url: str, filename: str,
session: aiohttp.ClientSession) -> None:
"""Download a single file.
Parameters
----------
url: str, required
URL path to file.
filename: str, required
Local filename used to write downloaded file. This will save the file
to self.output_directory/filename
session: aiohttp.ClientSession, required
Session object used for retrieval.
Returns
-------
None
"""
# Retrieve a single file
async with session.get(url, ssl=self.ssl_context,
timeout=900) as response:
# Warn if unable to locate file
if response.status != HTTPStatus.OK:
status = HTTPStatus(response.status_code)
message = (f"HTTP Status: {status.value}" +
f" - {status.phrase}" +
f" - {status.description}\n" + f"{response.url}")
warnings.warn(message, RuntimeWarning)
return
# Construct output file path
output_file = self.output_directory / filename
# Stream download
async with aiofiles.open(output_file, 'wb') as fo:
while True:
chunk = await response.content.read(1024)
if not chunk:
break
await fo.write(chunk)
def process_openweathermap(params, cfg) -> Response:
"""
Process one of api.openweathermap.org method call as specified in {cfg} dict + passing {params} in request.
Return actual status line, specified headers and content 'as is' from provider
"""
headers = json.loads(cfg.get('request_headers',
'{}')) # '{"Connection": "close"}'
# openweather supports head, get and post http methods, let's use get one
with requests.get(
url=cfg['request_url_path'],
params=params,
headers=headers,
timeout=float(
cfg.get('request_time_out', 0)
) # https://docs.python-requests.org/en/master/user/quickstart/#timeouts
) as response:
logging.debug('request url %s headers: %s', response.request.url,
response.request.headers)
response_status = status_line(HTTPStatus(response.status_code))
response_headers_list_relay = [
header.strip().title()
for header in cfg.get('response_headers_list_relay', '').split(',')
]
response_headers = dict((k, v) for k, v in response.headers.items()
if k in response_headers_list_relay)
response_content = response.content
response_headers['Server'] = response_headers.get(
'Server', APP_SERVER_NAME)
response_headers['Date'] = response_headers.get(
'Date', gmtime_string())
response_headers['Content-Type'] = response_headers.get(
'Content-Type',
response.headers.get(
'Content-Type',
f'application/json; charset={APP_ENC_HTML_DEFAULT}'))
response_headers['Content-Length'] = response_headers.get(
'Content-Length', str(len(response_content)))
response_headers['Connection'] = response_headers.get(
'Connection', 'close')
return Response(response_status, response_headers, response_content)
def my_orders(request):
headers = {
'Authorization': f'Token {settings.ORDER_SERVICE_AUTHTOKEN}',
'Content-type': 'application/json'
}
get_order_endpoint = f'/api/customer/{request.user.id}/orders/get/'
service_url = f'{settings.ORDER_SERVICE_BASEURL}{get_order_endpoint}'
response = requests.get(service_url, headers=headers)
if HTTPStatus(response.status_code) is HTTPStatus.OK:
request_data = json.loads(response.text)
print('request data')
from pprint import pprint
pprint(request_data)
context = {'orders': request_data}
else:
messages.add_message(
request, messages.ERROR,
('Unfortunately we could not receive your orders.',
' Try again later.'))
context = {"orders": []}
return render(request, 'main/my-orders.html', context)
def on_click(self):
self.statusBar().showMessage('Connecting to Elastic Server')
result = kibana_api.authenticate(self.useredit.text(), self.passedit.text(), self.ipedit.text())
if not isinstance(result, str):
if result != HTTPStatus.OK.value:
error = HTTPStatus(result)
self.statusBar().showMessage("Error " + str(error.value) + ', ' + error.phrase)
return
else:
QMessageBox().critical(self, "Error", result, QMessageBox.Ok)
return
self.statusBar().showMessage('Connected')
# Write yml file
self.write_yaml()
# sleep(0.5)
self.board = ManageBoard()
self.close()
def test_render_set_preferences_again_when_active(self, choice_option_mock,
_, **kwargs):
""" Test rerender setpreference when active """
form_mock = MagicMock()
form_mock.validate_on_submit.return_value = False
choice_option_mock.return_value = form_mock
with self.client as c:
with c.session_transaction() as session:
session['pds_opted_out'] = 'active'
headers = {
'Content-type': 'application/json',
'cookie': common.SESSION_ID
}
result = self.client.post('/setyourpreference', headers=headers)
assert HTTPStatus(result.status_code) == HTTPStatus.OK
assert form_mock.radio.data == 'No'
def test_your_details_review_post_fail(self, _, __, **kwargs):
""" Test your_details_review page re rendered when post to PDS_SEARCH_URL unsuccessful"""
common.registerExceptionHandlers(self.app)
mock = kwargs['mock']
adapter = mock.post(
self.app.config['PDS_SEARCH_URL'], text=common.pds_search_callback)
headers = {'Content-type': 'application/json',
'cookie': common.SESSION_ID}
# headers={'Content-type': 'application/json', 'cookie': None}
with self.client as c:
with c.session_transaction() as session:
session["first_name"] = "error"
result = self.client.post('/yourdetailsreview',
data=json.dumps(common.USER_DETAILS),
headers=headers)
assert HTTPStatus(result.status_code) == HTTPStatus.FOUND
assert '/genericerror' in result.headers['Location']
assert mock.called_once is True
def test_render_set_preferences_again_when_get_preference_empty(
self, choice_option_mock, _):
""" Test rerender setpreference when empty preference """
form_mock = MagicMock()
form_mock.validate_on_submit.return_value = False
choice_option_mock.return_value = form_mock
with self.client as c:
with c.session_transaction() as session:
session['pds_opted_out'] = constants.GET_PREFERENCE_EMPTY
headers = {
'Content-type': 'application/json',
'cookie': common.SESSION_ID
}
result = self.client.post('/setyourpreference', headers=headers)
assert HTTPStatus(result.status_code) == HTTPStatus.OK
assert form_mock.radio.data not in ('Yes', 'No')
def problems_middleware(request, handler):
try:
response = yield from handler(request)
except ProblemException as exc:
response = problem(status=exc.status,
detail=exc.detail,
title=exc.title,
type=exc.type,
instance=exc.instance,
headers=exc.headers,
ext=exc.ext)
except (werkzeug_HTTPException, _HttpNotFoundError) as exc:
response = problem(status=exc.code,
title=exc.name,
detail=exc.description)
except web.HTTPError as exc:
if exc.text == "{}: {}".format(exc.status, exc.reason):
detail = HTTPStatus(exc.status).description
else:
detail = exc.text
response = problem(status=exc.status, title=exc.reason, detail=detail)
except (
web.HTTPException, # eg raised HTTPRedirection or HTTPSuccessful
asyncio.CancelledError, # skipped in default web_protocol
):
# leave this to default handling in aiohttp.web_protocol.RequestHandler.start()
raise
except asyncio.TimeoutError as exc:
# overrides 504 from aiohttp.web_protocol.RequestHandler.start()
logger.debug('Request handler timed out.', exc_info=exc)
response = _generic_problem(HTTPStatus.GATEWAY_TIMEOUT, exc)
except Exception as exc:
# overrides 500 from aiohttp.web_protocol.RequestHandler.start()
logger.exception('Error handling request', exc_info=exc)
response = _generic_problem(HTTPStatus.INTERNAL_SERVER_ERROR, exc)
if isinstance(response, ConnexionResponse):
response = yield from AioHttpApi.get_response(response)
return response
