def update_batch(**path_data):
request_data = load_request_data(definition.request_schema)
response_data = definition.func(
**merge_data(path_data, request_data))
return dump_response_data(definition.response_schema,
response_data,
operation.value.default_code)
def make_json_error(error):
"""
Handle errors by logging and
"""
message = extract_error_message(error)
status_code = extract_status_code(error)
context = extract_context(error)
retryable = extract_retryable(error)
headers = extract_headers(error)
# Flask will not log user exception (fortunately), but will log an error
# for exceptions that escape out of the application entirely (e.g. if the
# error handler raises an error)
error_logger.debug("Handling {} error: {}".format(
status_code,
message,
))
# Serialize into JSON response
response_data = {
"code": status_code,
"context": context,
"message": message,
"retryable": retryable,
}
# Don't pass in the error schema because it will suppress any extra fields
return dump_response_data(None, response_data, status_code, headers)
def make_json_error(error):
"""
Handle errors by logging and
"""
message = extract_error_message(error)
status_code = extract_status_code(error)
context = extract_context(error)
retryable = extract_retryable(error)
headers = extract_headers(error)
# Flask will not log user exception (fortunately), but will log an error
# for exceptions that escape out of the application entirely (e.g. if the
# error handler raises an error)
error_logger.debug("Handling {} error: {}".format(
status_code,
message,
))
# Serialize into JSON response
response_data = {
"code": status_code,
"context": context,
"message": message,
"retryable": retryable,
}
# Don't pass in the error schema because it will suppress any extra fields
return dump_response_data(None, response_data, status_code, headers)
def create(**path_data):
request_data = load_request_data(definition.request_schema)
response_data = require_response_data(
definition.func(**merge_data(path_data, request_data)))
return dump_response_data(definition.response_schema,
response_data,
Operation.CreateFor.value.default_code)
def create_collection(**path_data):
request_data = load_request_data(definition.request_schema)
# NB: if we don't filter the request body through an explicit page schema,
# we will leak other request arguments into the pagination query strings
page = self.page_cls.from_query_string(self.page_schema(),
request_data)
result = definition.func(**merge_data(
path_data,
merge_data(
request_data,
page.to_dict(func=identity),
),
))
response_data, headers = page.to_paginated_list(
result, ns, Operation.CreateCollection)
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(
definition.response_formats)
return dump_response_data(
paginated_list_schema,
response_data,
headers=headers,
response_format=response_format,
)
def update(**path_data):
# NB: using partial here means that marshmallow will not validate required fields
request_data = load_request_data(definition.request_schema,
partial=True)
response_data = require_response_data(
definition.func(**merge_data(path_data, request_data)))
return dump_response_data(definition.response_schema,
response_data)
def replace(**path_data):
request_data = load_request_data(definition.request_schema)
# Replace/put should create a resource if not already present, but we do not
# enforce these semantics at the HTTP layer. If `func` returns falsey, we
# will raise a 404.
response_data = require_response_data(
definition.func(**merge_data(path_data, request_data)))
return dump_response_data(definition.response_schema,
response_data)
def foo_command():
"""
My doc string
"""
request_data = load_request_data(request_schema)
response_data = dict(
result=True,
value=request_data["value"],
)
return dump_response_data(response_schema, response_data, Operation.Command.value.default_code)
def foo_query():
"""
My doc string
"""
request_data = load_query_string_data(request_schema)
response_data = dict(
result=True,
value=request_data["value"],
)
return dump_response_data(response_schema, response_data, Operation.Query.value.default_code)
def retrieve(**path_data):
headers = dict()
request_data = load_query_string_data(request_schema)
response_data = require_response_data(definition.func(**merge_data(path_data, request_data)))
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
definition.response_schema,
response_data,
headers=headers,
response_format=response_format,
)
def search(**path_data):
page = self.page_cls.from_query_string(definition.request_schema)
result = definition.func(**merge_data(path_data, page.to_dict(func=identity)))
response_data, headers = page.to_paginated_list(result, ns, Operation.Search)
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
paginated_list_schema,
response_data,
headers=headers,
response_format=response_format,
)
def update_batch(**path_data):
headers = dict()
request_data = load_request_data(definition.request_schema)
response_data = definition.func(**merge_data(path_data, request_data))
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
definition.response_schema,
response_data,
status_code=operation.value.default_code,
headers=headers,
response_format=response_format,
)
def create(**path_data):
request_data = load_request_data(definition.request_schema)
response_data = definition.func(**merge_data(path_data, request_data))
headers = encode_id_header(response_data)
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
definition.response_schema,
response_data,
status_code=Operation.Create.value.default_code,
headers=headers,
response_format=response_format,
)
def delete(**path_data):
headers = dict()
request_data = load_query_string_data(request_schema)
response_data = require_response_data(definition.func(**merge_data(path_data, request_data)))
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
"",
None,
status_code=Operation.Delete.value.default_code,
headers=headers,
response_format=response_format,
)
def update(**path_data):
headers = dict()
# NB: using partial here means that marshmallow will not validate required fields
request_data = load_request_data(definition.request_schema, partial=True)
response_data = require_response_data(definition.func(**merge_data(path_data, request_data)))
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
definition.response_schema,
response_data,
headers=headers,
response_format=response_format,
)
def count(**path_data):
request_data = load_query_string_data(definition.request_schema)
response_data = dict()
count = definition.func(**merge_data(path_data, request_data))
headers = encode_count_header(count)
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
None,
None,
headers=headers,
response_format=response_format,
)
def delete(**path_data):
headers = dict()
response_data = dict()
require_response_data(definition.func(**path_data))
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(
definition.response_formats)
return dump_response_data(
"",
None,
status_code=Operation.DeleteFor.value.default_code,
headers=headers,
response_format=response_format,
)
def replace(**path_data):
headers = dict()
request_data = load_request_data(definition.request_schema)
# Replace/put should create a resource if not already present, but we do not
# enforce these semantics at the HTTP layer. If `func` returns falsey, we
# will raise a 404.
response_data = require_response_data(definition.func(**merge_data(path_data, request_data)))
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
definition.response_schema,
response_data,
headers=headers,
response_format=response_format,
)
def search(**path_data):
request_data = load_query_string_data(definition.request_schema)
page = Page.from_query_string(request_data)
items, count, context = definition.func(
**merge_data(path_data, request_data))
response_data = self.paginated_list_class(
ns=ns,
page=page,
items=items,
count=count,
schema=definition.response_schema,
operation=Operation.SearchFor,
**context)
return dump_response_data(paginated_list_schema, response_data)
def upload(**path_data):
merged_data = merge_data(request.args.to_dict(), request.form.to_dict())
request_data = load_query_string_data(request_schema, merged_data)
if not request.files:
raise BadRequest("No files were uploaded")
uploads = [
temporary_upload(name, fileobj)
for name, fileobj
in request.files.items()
if not self.exclude_func(name, fileobj)
]
with nested(*uploads) as files:
response_data = definition.func(files, **merge_data(path_data, request_data))
if response_data is None:
return "", 204
return dump_response_data(response_schema, response_data, operation.value.default_code)
def upload(**path_data):
request_data = load_query_string_data(request_schema)
if not request.files:
raise BadRequest("No files were uploaded")
uploads = [
temporary_upload(name, fileobj)
for name, fileobj in request.files.items()
if not self.exclude_func(name, fileobj)
]
with nested(*uploads) as files:
response_data = definition.func(
files, **merge_data(path_data, request_data))
if response_data is None:
return "", 204
return dump_response_data(response_schema, response_data,
operation.value.default_code)
def search(**path_data):
request_data = load_query_string_data(definition.request_schema)
page = self.page_cls.from_query_string(request_data)
return_value = definition.func(
**merge_data(path_data, request_data))
if len(return_value) == 3:
items, count, context = return_value
else:
context = {}
items, count = return_value
response_data = PaginatedList(ns=ns,
page=page,
items=items,
count=count,
schema=definition.response_schema,
operation=Operation.Search,
**context)
return dump_response_data(paginated_list_schema, response_data)
def handle(self, error):
"""
Generates a response that follows connexion's error format i.e.,
"status": http status code,
"title": Short description,
"detail": "detail message",
"type": "An absolute URI that identifies the problem type.
When dereferenced, it SHOULD provide human-readable documentation for the problem type"
Note: Heavily inspired by the microcosm_flask.errors module just needed a different format
"""
status = extract_status_code(error)
title = self.extract_title(error)
detail = extract_error_message(error)
type_name = "about:blank"
# To make sure that we have some stack trace for 500+ errors
if status >= 500:
self.logger.exception(error)
self.logger.debug(
"Handling error {} with status {}, title {}, detail {}, type_name {}"
.format(
error,
status,
title,
detail,
type_name,
))
response_data = {
"status": status,
"title": title,
"detail": detail,
"type": type_name,
}
return dump_response_data(None, response_data, status)
def create_collection(**path_data):
request_data = load_request_data(definition.request_schema)
page = self.page_cls.from_query_string(self.page_schema(), {})
result = definition.func(**merge_data(
path_data,
merge_data(
request_data,
page.to_dict(func=identity),
),
))
response_data, headers = page.to_paginated_list(
result, ns, Operation.CreateCollection)
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(
definition.response_formats)
return dump_response_data(
paginated_list_schema,
response_data,
headers=headers,
response_format=response_format,
)
def create_collection(**path_data):
request_data = load_request_data(definition.request_schema)
# NB: if we don't filter the request body through an explicit page schema,
# we will leak other request arguments into the pagination query strings
page = self.page_cls.from_query_string(self.page_schema(), request_data)
result = definition.func(**merge_data(
path_data,
merge_data(
request_data,
page.to_dict(func=identity),
),
))
response_data, headers = page.to_paginated_list(result, ns, Operation.CreateCollection)
definition.header_func(headers, response_data)
response_format = self.negotiate_response_content(definition.response_formats)
return dump_response_data(
paginated_list_schema,
response_data,
headers=headers,
response_format=response_format,
)
def count(**path_data):
request_data = load_query_string_data(definition.request_schema)
count = definition.func(**merge_data(path_data, request_data))
headers = encode_count_header(count)
return dump_response_data(None, None, headers=headers)
def retrieve(**path_data):
request_data = load_query_string_data(request_schema)
response_data = require_response_data(
definition.func(**merge_data(path_data, request_data)))
return dump_response_data(definition.response_schema,
response_data)
def retrieve():
logger_tree = build_logger_tree()
return dump_response_data(response_schema, logger_tree)
def retrieve(**path_data):
response_data = require_response_data(definition.func(**path_data))
return dump_response_data(definition.response_schema,
response_data)
