def dispatch_request(self, *args, **kwargs): # Taken from flask #noinspection PyUnresolvedReferences meth = getattr(self, request.method.lower(), None) if meth is None and request.method == 'HEAD': meth = getattr(self, 'get', None) assert meth is not None, 'Unimplemented method %r' % request.method for decorator in self.method_decorators: meth = decorator(meth) resp = meth(*args, **kwargs) if isinstance(resp, ResponseBase): # There may be a better way to test return resp representations = self.representations or {} #noinspection PyUnresolvedReferences mediatype = request.accept_mimetypes.best_match(representations, default=None) if mediatype in representations: data, code, headers = unpack(resp) resp = representations[mediatype](data, code, headers) resp.headers['Content-Type'] = mediatype return resp elif request.content_type in representations: mediatype = request.content_type data, code, headers = unpack(resp) resp = representations[mediatype](data, code, headers) resp.headers['Content-Type'] = mediatype return resp return resp
def wrapper(*args, **kwargs): resp = f(*args, **kwargs) if isinstance(resp, tuple): data, code, headers = unpack(resp) return self.field.format(data), code, headers return self.field.format(resp)
def wrapper(*args, **kwargs): objects = f(*args, **kwargs) if objects[1] != 200: return objects if isinstance(objects, tuple): data, code, header = unpack(objects) else: data = objects if isinstance(data, dict) or isinstance(data, OrderedDict): data = self.prepare_objetcs(data) kwargs = self.prepare_kwargs(kwargs, data) kwargs["templated"] = True for link in self.links: kwargs["rel"] = link data["links"].append( create_external_link("v1.{}".format(link), **kwargs)) for link, uri in self.links_uri.items(): kwargs["rel"] = link if uri is not None: kwargs["uri"] = uri data["links"].append( create_external_link("v1.{}".format(link), **kwargs)) if isinstance(objects, tuple): return data, code, header else: return data
def wrapper(*args, **kwargs): resp = f(*args, **kwargs) if isinstance(resp, tuple): data, code, headers = unpack(resp) return marshal(data, self.fields, self.envelope), code, headers else: return marshal(resp, self.fields, self.envelope)
def access(self, func, price, *args, **kwargs): if self.channel_manager.node_online() is False: return "Ethereum node is not responding", 502 if self.channel_manager.get_eth_balance() < config.PROXY_BALANCE_LIMIT: return "Channel manager ETH balance is below limit", 502 try: data = RequestData(request.headers, request.cookies) except ValueError as e: return str(e), 409 accepts_html = r'text/html' in request.headers.get('Accept', '') if callable(price): price = price(request.path) # payment required paywall, headers = self.paywall_check(price, data) if paywall and accepts_html is True: reply_data = func.__self__.get_paywall(request.path) return self.reply_webui(reply_data, headers) elif paywall: return self.reply_payment_required(price, reply_data='', headers=headers, gen_ui=accepts_html) # all ok, return actual content resp = func(request.path, *args, **kwargs) if isinstance(resp, Response): return resp else: data, code, resource_headers = unpack(resp) resource_headers.update(headers) return make_response(str(data), code, resource_headers)
def wrapper(*args, **kwargs): if hasattr(request, '__skip_marshalling'): return f(*args, **kwargs) fields_to_include = self._get_fields_to_include() if self._is_include_parameter_in_request(): # only pushing "_include" into kwargs when the request # contained this parameter, to keep things cleaner (identical # behavior for passing "_include" which contains all fields) kwargs['_include'] = fields_to_include.keys() response = f(*args, **kwargs) if isinstance(response, ListResponse): wrapped_items = self.wrap_with_response_object(response.items) response.items = marshal(wrapped_items, fields_to_include) return marshal(response, ListResponse.resource_fields) # SQLAlchemy returns a class that subtypes tuple, but acts # differently (it's taken care of in `wrap_with_response_object`) if isinstance(response, tuple) and \ not isinstance(response, sql_alchemy_collection): data, code, headers = unpack(response) data = self.wrap_with_response_object(data) return marshal(data, fields_to_include), code, headers else: response = self.wrap_with_response_object(response) return marshal(response, fields_to_include)
def dispatch_request(self, *args, **kwargs): """Overridden to support list and create method names, and improved decorator handling for methods """ method = self._get_method_for_request() try: resp = method(*args, **kwargs) except Exception: if apm.is_initialized: apm.capture_exception() resp = ({ 'message': 'Server Error' }, HTTPStatus.INTERNAL_SERVER_ERROR, {}) traceback.print_exc() if isinstance(resp, Response): return resp representations = self.representations or OrderedDict() mediatype = request.accept_mimetypes.best_match(representations, default=None) if mediatype in representations: data, code, headers = unpack(resp) resp = representations[mediatype](data, code, headers) resp.headers['Content-Type'] = mediatype return resp return resp
def wrapper(*args, **kwargs): objects = f(*args, **kwargs) if isinstance(objects, tuple): data, code, header = unpack(objects) else: data = objects if self.resource.region: collection = { "notes": { "type": "notes", "del": ["value"] }, "exceptions": { "type": "exceptions", "del": ["date", "except_type"] } } # Add notes exceptions for col in collection: if not col in data or not isinstance(data[col], list): data[col] = [] res = [] note = self.complete(data, collection[col]) [res.append(item) for item in note if not item in res] data[col].extend(res) if isinstance(objects, tuple): return data, code, header else: return data
def dispatch_request(self, *args, **kwargs): # Taken from flask # noinspection PyUnresolvedReferences action = kwargs.get('action') if action: del kwargs['action'] meth = partial(self._route, request.method.lower(), action) for decorator in self.method_decorators: meth = decorator(meth) resp = meth(*args, **kwargs) if isinstance(resp, ResponseBase): # There may be a better way to test return resp representations = self.representations or OrderedDict() # noinspection PyUnresolvedReferences mediatype = request.accept_mimetypes.best_match(representations, default=None) if mediatype in representations: data, code, headers = unpack(resp) resp = representations[mediatype](data, code, headers) resp.headers['Content-Type'] = mediatype return resp return resp
def wrapper(*args, **kwargs): response, status, h = unpack(f(*args, **kwargs)) if status == 200 and self.attribute in response: instance = i_manager.instances.get(self.resource.region) resource_args = self.resource.parsers["get"].parse_args() show_bss_stands = 'bss_stands' in resource_args.get('add_poi_infos') show_car_park = 'car_park' in resource_args.get('add_poi_infos') if show_bss_stands and instance and instance.bss_provider: _handle( response, bss_provider_manager, self.attribute, self.logger, 'Error while handling BSS realtime availability', ) if show_car_park and instance and instance.car_park_provider: _handle( response, car_park_provider_manager, self.attribute, self.logger, 'Error while handling car park realtime availability', ) return response, status, h
def dispatch_request(self, *args, **kwargs): # Taken from flask #noinspection PyUnresolvedReferences meth = getattr(self, request.method.lower(), None) if meth is None and request.method == 'HEAD': meth = getattr(self, 'get', None) assert meth is not None, 'Unimplemented method %r' % request.method if isinstance(self.method_decorators, Mapping): decorators = self.method_decorators.get(request.method.lower(), []) else: decorators = self.method_decorators for decorator in decorators: meth = decorator(meth) resp = meth(*args, **kwargs) if isinstance(resp, ResponseBase): # There may be a better way to test return resp representations = self.representations or OrderedDict() #noinspection PyUnresolvedReferences mediatype = request.accept_mimetypes.best_match(representations, default=None) if mediatype in representations: data, code, headers = unpack(resp) resp = representations[mediatype](data, code, headers) resp.headers['Content-Type'] = mediatype return resp return resp
def wrapper(*args, **kwargs): resp = f(*args, **kwargs) if isinstance(resp, tuple): data, code, headers = unpack(resp) return self.schema.dump(data, many=self.many).data, code, headers else: return self.schema.dump(resp, many=self.many).data
def wrapper(*args, **kwargs): resp = resource(*args, **kwargs) if isinstance(resp, ResponseBase): # There may be a better way to test return resp data, code, headers = unpack(resp) return self.make_response(data, code, headers=headers)
def inner_wrapper(self, *args, **kwargs): resp = fn(self, *args, **kwargs) if isinstance(resp, tuple): data, code, headers = unpack(resp) return schema.dump(data)[0], code, headers else: return schema.dump(resp)[0]
def wrapper(*args, **kwargs): resp = func(*args, **kwargs) if isinstance(resp, tuple): query, code, headers = unpack(resp) data = self.make_pagination(query) return marshal(data, self.fields, self.envelope), code, headers else: data = self.make_pagination(resp) return marshal(data, self.fields, self.envelope)
def wrapper(*args, **kwargs): objects = f(*args, **kwargs) if objects[1] != 200: return objects if isinstance(objects, tuple): data, code, header = unpack(objects) else: data = objects pagination = data.get('pagination', None) endpoint = request.endpoint kwargs.update(request.args) if pagination and endpoint and "region" in kwargs: if ( "start_page" in pagination and "items_on_page" in pagination and "items_per_page" in pagination and "total_result" in pagination ): if "links" not in data: data["links"] = [] start_page = int(pagination["start_page"]) items_per_page = int(pagination["items_per_page"]) items_on_page = int(pagination["items_on_page"]) total_result = int(pagination["total_result"]) kwargs["_external"] = True if start_page > 0: kwargs["start_page"] = start_page - 1 data["links"].append( {"href": url_for(endpoint, **kwargs), "type": "previous", "templated": False} ) nb_next_page = items_per_page * start_page nb_next_page += items_on_page if total_result > nb_next_page: kwargs["start_page"] = start_page + 1 data["links"].append( {"href": url_for(endpoint, **kwargs), "type": "next", "templated": False} ) if items_per_page == 0 or total_result == 0: kwargs["start_page"] = 0 else: nb_last_page = total_result - 1 nb_last_page = int(nb_last_page / items_per_page) kwargs["start_page"] = nb_last_page data["links"].append( {"href": url_for(endpoint, **kwargs), "type": "last", "templated": False} ) del kwargs["start_page"] data["links"].append( {"href": url_for(endpoint, **kwargs), "type": "first", "templated": False} ) if isinstance(objects, tuple): return data, code, header else: return data
def wrapper(*args, **kwargs): resp = resource(*args, **kwargs) if isinstance(resp, ResponseBase): # There may be a better way to test return resp output, code, headers = unpack(resp) if isinstance(output, Output): data = output.show() else: data = output return self.make_response(data, code, headers=headers)
def wrapper(*args, **kwargs): resp = f(*args, **kwargs) if isinstance(resp, tuple): data, code, headers = unpack(resp) if data is None: return self._get_none(), code, headers return marshal(data, self.fields, self.envelope), code, headers else: if resp is None: return self._get_none() return marshal(resp, self.fields, self.envelope)
def wrapper(*args, **kwargs): objects = f(*args, **kwargs) if isinstance(objects, tuple): data, code, header = unpack(objects) else: data = objects if self.resource.region: # Add notes and exceptions data.update(self.get_links(data)) if isinstance(objects, tuple): return data, code, header else: return data
def access(self, resource, method, *args, **kwargs): if self.channel_manager.node_online() is False: return "Ethereum node is not responding", 502 if self.channel_manager.get_eth_balance() < config.PROXY_BALANCE_LIMIT: return "Channel manager ETH balance is below limit", 502 try: data = RequestData(request.headers, request.cookies) except ValueError as e: return str(e), 409 accepts_html = ( 'text/html' in request.accept_mimetypes and request.accept_mimetypes.best != '*/*' ) headers = {} price = resource.price() # payment required if price > 0: paywall, headers = self.paywall_check(price, data) if paywall and accepts_html is True: reply_data = resource.get_paywall(request.path) return self.reply_webui(reply_data, headers) elif paywall: return make_response('', 402, headers) # all ok, return actual content resp = method(request.path, *args, **kwargs) # merge headers, resource headers take precedence headers_lower = {key.lower(): value for key, value in headers.items()} lower_to_case = {key.lower(): key for key in headers} if isinstance(resp, Response): resource_headers = (key for key, value in resp.headers) else: data, code, resource_headers = unpack(resp) for key in resource_headers: key_lower = key.lower() if key_lower in headers_lower: headers.pop(lower_to_case[key_lower]) if isinstance(resp, Response): resp.headers.extend(headers) return resp else: headers.update(resource_headers) return make_response(str(data), code, resource_headers)
def access(self, resource, method, *args, **kwargs): if self.channel_manager.node_online() is False: return "Ethereum node is not responding", 502 if self.channel_manager.get_eth_balance() < constants.PROXY_BALANCE_LIMIT: return "Channel manager ETH balance is below limit", 502 try: data = RequestData(request.headers, request.cookies) except ValueError as e: return str(e), 409 accepts_html = ( 'text/html' in request.accept_mimetypes and request.accept_mimetypes.best != '*/*' ) headers = {} price = resource.price() # payment required if price > 0: paywall, headers = self.paywall_check(price, data) if paywall and accepts_html is True: reply_data = resource.get_paywall(request.path) return self.reply_webui(reply_data, headers) elif paywall: return make_response('', 402, headers) # all ok, return actual content resp = method(request.path, *args, **kwargs) # merge headers, resource headers take precedence headers_lower = {key.lower(): value for key, value in headers.items()} lower_to_case = {key.lower(): key for key in headers} if isinstance(resp, Response): resource_headers = (key for key, value in resp.headers) else: data, code, resource_headers = unpack(resp) for key in resource_headers: key_lower = key.lower() if key_lower in headers_lower: headers.pop(lower_to_case[key_lower]) if isinstance(resp, Response): resp.headers.extend(headers) return resp else: headers.update(resource_headers) return make_response(str(data), code, resource_headers)
def wrapper(*args, **kwargs): response = f(*args, **kwargs) if isinstance(response, tuple): data, code, header = unpack(response) if code != 200: return data, code, header else: data = response if (isinstance(data, dict) or isinstance(data, OrderedDict)) and "links" in data: for link in data['links']: link['href'] = link['href'].replace("%7B", "{").replace("%7D", "}").replace("%3B", ";") if isinstance(response, tuple): return data, code, header else: return data
def wrapper(*args, **kwargs): resp = f(*args, **kwargs) if (self.fields): if isinstance(resp, tuple): data, code, headers = unpack(resp) marshal_data = marshal(data, self.fields, self.envelope), code, headers else: marshal_data = marshal(resp, self.fields, self.envelope) else: marshal_data = resp return { 'success': True, 'data': marshal_data, }
def wrapper(*args, **kwargs): resp = view(*args, **kwargs) if isinstance(resp, current_app.response_class): return resp endpoint = request.endpoint.partition('.')[-1] method = request.method if method == 'HEAD': method = 'GET' try: resp_filter = filters[(endpoint, method)] except KeyError: LOG.error( '"(%(endpoint)s, %(method)s)" is not defined in the response ' 'filters.', { "endpoint": endpoint, "method": method }) abort(500) headers = None status = None if isinstance(resp, tuple): resp, status, headers = unpack(resp) try: schemas = resp_filter[status] except KeyError: LOG.error( 'The status code %(status)d is not defined in the response ' 'filter "(%(endpoint)s, %(method)s)".', { "status": status, "endpoint": endpoint, "method": method }) abort(500) resp, errors = normalize(schemas['schema'], resp) if schemas['headers']: headers, header_errors = normalize( {'properties': schemas['headers']}, headers) errors.extend(header_errors) if errors: abort(500, message='Expectation Failed', errors=errors) return resp, status, headers
def wrapper(*args, **kwargs): resp = view(*args, **kwargs) if isinstance(resp, current_app.response_class): return resp endpoint = request.endpoint.partition(".")[-1] method = request.method if method == "HEAD": method = "GET" filter = filters.get((endpoint, method), None) if not filter: return resp headers = None status = None if isinstance(resp, tuple): resp, status, headers = unpack(resp) if len(filter) == 1: if six.PY3: status = list(filter.keys())[0] else: status = filter.keys()[0] schemas = filter.get(status) if not schemas: # return resp, status, headers abort(500, message="`%d` is not a defined status code." % status) resp, errors = normalize(schemas["schema"], resp, resolver=resolver) if schemas["headers"]: headers, header_errors = normalize( {"properties": schemas["headers"]}, headers, resolver=resolver) errors.extend(header_errors) if errors: abort(500, message="Expectation Failed", errors=errors) return current_app.response_class( json.dumps(resp, cls=JSONEncoder) + "\n", status=status, headers=headers, mimetype="application/json", )
def wrapper(*args, **kwargs): resp = view(*args, **kwargs) if isinstance(resp, current_app.response_class): return resp endpoint = request.endpoint.partition('.')[-1] method = request.method if method == 'HEAD': method = 'GET' filter = filters.get((endpoint, method), None) if not filter: return resp headers = None status = None if isinstance(resp, tuple): resp, status, headers = unpack(resp) if len(filter) == 1: if six.PY3: status = list(filter.keys())[0] else: status = filter.keys()[0] schemas = filter.get(status) if not schemas: # return resp, status, headers abort(500, message='`%d` is not a defined status code.' % status) resp, errors = normalize(schemas['schema'], resp, resolver=resolver) if schemas['headers']: headers, header_errors = normalize( {'properties': schemas['headers']}, headers, resolver=resolver) errors.extend(header_errors) if errors: abort(500, message='Expectation Failed', errors=errors) return current_app.response_class( json.dumps(resp, cls=JSONEncoder) + '\n', status=status, headers=headers, mimetype='application/json' )
def wrapper(*args, **kwargs): resp = view(*args, **kwargs) if isinstance(resp, current_app.response_class): return resp endpoint = request.endpoint.partition('.')[-1] method = request.method if method == 'HEAD': method = 'GET' filter = filters.get((endpoint, method), None) if not filter: return resp headers = None status = None if isinstance(resp, tuple): resp, status, headers = unpack(resp) if len(filter) == 1: if six.PY3: status = list(filter.keys())[0] else: status = filter.keys()[0] schemas = filter.get(status) if not schemas: # return resp, status, headers abort(500, message='`%d` is not a defined status code.' % status) resp, errors = normalize(schemas['schema'], resp) if schemas['headers']: headers, header_errors = normalize( {'properties': schemas['headers']}, headers) errors.extend(header_errors) if errors: abort(500, message='Expectation Failed', errors=errors) return current_app.response_class(json.dumps(resp, cls=JSONEncoder) + '\n', status=status, headers=headers, mimetype='application/json')
def wrapper(*args, **kwargs): objects = f(*args, **kwargs) if objects[1] != 200: return objects if isinstance(objects, tuple): data, code, header = unpack(objects) else: data = objects self.get_objets(data) data = self.prepare_objetcs(objects, True) kwargs = self.prepare_kwargs(kwargs, data) if 'region' not in kwargs and 'lon' not in kwargs: # we don't know how to put links on this object, there is no coverage, we don't add links return objects uri_id = None if "id" in kwargs and "collection" in kwargs and kwargs[ "collection"] in data: uri_id = kwargs["id"] for obj in self.data: kwargs["collection"] = resource_type_to_collection.get( obj, obj) if kwargs["collection"] in collections_to_resource_type: if not uri_id: kwargs["id"] = "{" + obj + ".id}" endpoint = "v1." + kwargs["collection"] + ".id" collection = kwargs["collection"] to_pass = { k: v for k, v in kwargs.items() if k != "collection" } to_pass["_type"] = obj to_pass["templated"] = True to_pass["rel"] = collection data["links"].append( create_external_link(url=endpoint, **to_pass)) if isinstance(objects, tuple): return data, code, header else: return data
def dispatch_request(self, *args, **kwargs): """Overridden to support list and create method names, and improved decorator handling for methods """ method = self._get_method_for_request() resp = method(*args, **kwargs) if isinstance(resp, Response): return resp representations = self.representations or OrderedDict() mediatype = request.accept_mimetypes.best_match(representations, default=None) if mediatype in representations: data, code, headers = unpack(resp) resp = representations[mediatype](data, code, headers) resp.headers['Content-Type'] = mediatype return resp return resp
def wrapper(*args, **kwargs): objects = f(*args, **kwargs) if objects[1] != 200: return objects if isinstance(objects, tuple): data, code, header = unpack(objects) else: data = objects if isinstance(data, dict) or isinstance(data, OrderedDict): data = self.prepare_objetcs(objects, True) kwargs = self.prepare_kwargs(kwargs, data) kwargs["templated"] = True for collection in self.collections: kwargs["rel"] = collection data["links"].append( create_external_link("v1.{c}.collection".format(c=collection), **kwargs) ) if isinstance(objects, tuple): return data, code, header else: return data
def wrapper(*args, **kwargs): if hasattr(request, '__skip_marshalling'): return f(*args, **kwargs) fields_to_include = self._get_fields_to_include() if self._is_include_parameter_in_request(): # only pushing "_include" into kwargs when the request # contained this parameter, to keep things cleaner (identical # behavior for passing "_include" which contains all fields) kwargs['_include'] = fields_to_include.keys() response = f(*args, **kwargs) def wrap_list_items(response): wrapped_items = self.wrap_with_response_object(response.items) response.items = marshal(wrapped_items, fields_to_include) return response if isinstance(response, ListResponse): return marshal(wrap_list_items(response), ListResponse.resource_fields) # SQLAlchemy returns a class that subtypes tuple, but acts # differently (it's taken care of in `wrap_with_response_object`) if isinstance(response, tuple) and \ not isinstance(response, sql_alchemy_collection): data, code, headers = unpack(response) if isinstance(data, ListResponse): data = wrap_list_items(data) return (marshal(data, ListResponse.resource_fields), code, headers) else: data = self.wrap_with_response_object(data) return marshal(data, fields_to_include), code, headers else: response = self.wrap_with_response_object(response) return marshal(response, fields_to_include)
def dispatch_request(self, *args, **kwargs): # Taken from flask meth = getattr(self, request.method.lower(), None) if meth is None and request.method == 'HEAD': meth = getattr(self, 'get', None) assert meth is not None, 'Unimplemented method %r' % request.method for decorator in self.method_decorators: meth = decorator(meth) try: increment(total_requests) except Exception as exc: pass # this is where actual method starts resp = meth(*args, **kwargs) # this is where actual method ends if isinstance(resp, ResponseBase): # There may be a better way to test return resp representations = self.representations or OrderedDict() mediatype = request.accept_mimetypes.best_match(representations, default=None) if mediatype in representations: data, code, headers = unpack(resp) resp = representations[mediatype](data, code, headers) resp.headers['Content-Type'] = mediatype return resp return resp
def test_unpack(): yield check_unpack, ("hey", 200, {}), unpack("hey") yield check_unpack, (("hey",), 200, {}), unpack(("hey",)) yield check_unpack, ("hey", 201, {}), unpack(("hey", 201)) yield check_unpack, ("hey", 201, "foo"), unpack(("hey", 201, "foo")) yield check_unpack, (["hey", 201], 200, {}), unpack(["hey", 201])
def wrapper(*args, **kwargs): resp = original_fun(*args, **kwargs) if isinstance(resp, Response): # There may be a better way to test return resp data, code, headers = unpack(resp) return flask_restful.make_response(data, code, headers=headers)
def _extend_tuple_response_headers(response, extra_headers): data, code, headers = unpack(response) headers.update(extra_headers) return data, code, headers
def wrapper(*args, **kwargs): response = f(*args, **kwargs) if isinstance(response, tuple): data, code, header = unpack(response) else: data = response if 'links' not in data: return response collection = None kwargs["_external"] = True templated = True for key in data: if key == 'disruptions' and collection is not None: # disruption is a special case since it can be present in all responses continue if key in collections_to_resource_type: collection = key if key in resource_type_to_collection: collection = resource_type_to_collection[key] if collection is None: return response kwargs["uri"] = collection + '/' if "id" in kwargs: kwargs["uri"] += kwargs["id"] del kwargs["id"] templated = False else: kwargs["uri"] += '{' + collection + ".id}" if (collection in [ 'stop_areas', 'stop_points', 'lines', 'routes', 'addresses' ] and "region" in kwargs): for api in [ 'route_schedules', 'stop_schedules', 'arrivals', 'departures', "places_nearby" ]: data['links'].append({ "href": url_for("v1." + api, **kwargs), "rel": api, "type": api, "templated": templated }) if collection in ['stop_areas', 'stop_points', 'addresses']: data['links'].append({ "href": url_for("v1.journeys", **kwargs), "rel": "journeys", "type": "journey", "templated": templated, }) # for lines we add the link to the calendars if 'region' in kwargs: if collection == 'lines': data['links'].append({ "href": url_for("v1.calendars", **kwargs), "rel": "calendars", "type": "calendar", "templated": templated, }) if collection in ['stop_areas', 'lines', 'networks']: data['links'].append({ "href": url_for("v1.traffic_reports", **kwargs), "rel": "disruptions", "type": "disruption", "templated": templated, }) if isinstance(response, tuple): return data, code, header else: return data
def test_unpack(): yield check_unpack, ("hey", 200, {}), unpack("hey") yield check_unpack, (("hey", ), 200, {}), unpack(("hey", )) yield check_unpack, ("hey", 201, {}), unpack(("hey", 201)) yield check_unpack, ("hey", 201, "foo"), unpack(("hey", 201, "foo")) yield check_unpack, (["hey", 201], 200, {}), unpack(["hey", 201])
def wrapped(self, *args, **kwargs): (data, code, headers) = unpack(func(self, *args, **kwargs)) headers["Deprecation"] = "true" return (data, code, headers)