def discover():
request_data = load_query_string_data(ValidateSwaggerSchema())
swagger = build_swagger(self.graph, ns,
self.find_matching_endpoints(ns),
**request_data)
g.hide_body = True
return make_response(swagger)
def test_page_from_query_string():
graph = create_object_graph(name="example", testing=True)
with graph.flask.test_request_context():
qs = load_query_string_data(PageSchema())
page = Page.from_query_string(qs)
assert_that(page.offset, is_(equal_to(0)))
assert_that(page.limit, is_(equal_to(20)))
def from_query_string(cls, schema, qs=None):
"""
Extract a page from the current query string.
:param qs: a query string dictionary (`request.args` will be used if omitted)
"""
dct = load_query_string_data(schema, qs)
return cls.from_dict(dct)
def from_query_string(cls, schema, qs=None):
"""
Extract a page from the current query string.
:param qs: a query string dictionary (`request.args` will be used if omitted)
"""
dct = load_query_string_data(schema, qs)
return cls.from_dict(dct)
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 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):
# request_schema is optional for Alias
request_data = (load_query_string_data(definition.request_schema)
if definition.request_schema else dict())
resource = definition.func(**merge_data(path_data, request_data))
kwargs = dict()
identifier = "{}_id".format(name_for(ns.subject))
kwargs[identifier] = resource.id
url = ns.url_for(Operation.Retrieve, **kwargs)
return redirect(url)
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 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()
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 discover():
# accept pagination limit from request
page = Page.from_query_string(load_query_string_data(page_schema))
page.offset = 0
response_data = dict(_links=Links({
"self":
Link.for_(Operation.Discover, ns, qs=page.to_tuples()),
"search": [
link for link in iter_links(
self.find_matching_endpoints(ns), page)
],
}).to_dict())
return make_response(response_data)
def retrieve(**path_data):
# request_schema is optional for Alias
request_data = (
load_query_string_data(definition.request_schema)
if definition.request_schema
else dict()
)
resource = definition.func(**merge_data(path_data, request_data))
kwargs = dict()
identifier = "{}_id".format(name_for(ns.subject))
kwargs[identifier] = resource.id
url = ns.url_for(Operation.Retrieve, **kwargs)
return redirect(url)
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 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 current_health():
query_params = load_query_string_data(RetrieveHealthSchema())
response_data = self.health.to_dict(**query_params)
status_code = 200 if response_data["ok"] else 503
return make_response(response_data, status_code=status_code)
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)
