def _api_convert_output(status_code, return_value, response=None):
if not response:
response = Response()
response.status_code = status_code
""" Convert the output to what the client asks """
content_type = flask.request.environ.get('CONTENT_TYPE', 'text/json')
if "text/json" in content_type:
response.content_type = 'text/json; charset=utf-8'
response.response = [json.dumps(return_value)]
return response
if "text/html" in content_type:
response.content_type = 'text/html; charset=utf-8'
dump = yaml.dump(return_value)
response.response = ["<pre>" + dump + "</pre>"]
return response
if "text/yaml" in content_type or \
"text/x-yaml" in content_type or \
"application/yaml" in content_type or \
"application/x-yaml" in content_type:
response.content_type = 'text/yaml; charset=utf-8'
response.response = [yaml.dump(return_value)]
return response
response.content_type = 'text/json; charset=utf-8'
response.response = [json.dumps(return_value)]
return response
def make_response(data, output='json'):
resp = Response()
if output == 'json':
resp.data = json.dumps(data, indent=2)
resp.content_type = 'application/json; charset="UTF-8"'
elif output == 'yaml':
resp.data = yaml.safe_dump(data, default_flow_style=False, indent=2)
resp.content_type = 'application/yaml; charset="UTF-8"'
return resp
def buildResponse(self, intStatus, dictResponse=None, dictHeaders=None):
'''
*Author: Iago Rocha*
Create a Flask Response object with custom headers
- Param 0: int | status code of response object
- Param 1: dict | a dict that will be cast to a json string
- Param 2: dict | dict within header and value. Ex.: {'IA-Cidada-API-Version' : '1.0.0'}
- Return: object | a Flask Response object
'''
# create a response object
objResponse = Response()
# set a response json
objResponse.response = json.dumps(dictResponse, sort_keys=False)
# config content type
objResponse.content_type = 'application/json'
# set headers response
objResponse.headers['IA-Cidada-API-Version'] = '1.0.0'
# verify if headers is a dict instance
if isinstance(dictHeaders, dict):
# loop to add headers
for strKey, strValue in dictHeaders.iteritems():
# add header and value to response object
objResponse.headers[strKey] = strValue
# set status return
objResponse.status = str(intStatus)
# return a Response object
return objResponse
def post_message_to_entity(entity, request):
res = Response()
res.content_type = 'application/json'
res.status_code = 200
res.data = 'SUCCESS'
error_msg = 'Please send user, message and owner either in query parameters or as json payload.'
if request.is_json:
payload = request.get_json()
user = payload.get('user', None)
if user and payload.get('message', None):
db_id = add_to_db(payload, ADDING_TO_REDIS_QUEUE, entity)
executor.submit(publish_to_redis, payload, db_id, entity)
res.data = str(db_id)
else:
res.data = error_msg
res.status_code = 404
else:
user = request.args.get('user', None)
message = request.args.get('message', None)
if user and message:
payload = {
'user': user,
'message': message,
}
db_id = add_to_db(payload, ADDING_TO_REDIS_QUEUE, entity)
executor.submit(publish_to_redis, payload, db_id, entity)
#publish_to_redis(payload,db_id,entity)
res.data = str(db_id)
else:
res.data = error_msg
res.status_code = 404
return res
def stat1():
pub_year = request.args.get('pub_year', None)
pub_month = request.args.get('pub_month', None)
labels = []
data = []
if pub_year or pub_month:
conn = sqlite3.connect('stat.sqlite')
cursor = conn.cursor()
if pub_month:
sql = 'SELECT pub_day, count FROM stat1 WHERE pub_month="{}"'.format(
pub_month)
elif pub_year:
sql = 'SELECT pub_month, SUM(count) FROM stat1 WHERE pub_year="{}" GROUP BY pub_month'.format(
pub_year)
for row in cursor.execute(sql):
label, count = row
labels.append(label)
data.append(count)
cursor.close()
conn.close()
result = {'labels': labels, 'data': data}
response = Response()
response.data = json.dumps(result)
response.content_type = 'application/json'
response.headers['Access-Control-Allow-Origin'] = '*'
return response
def inner(*args, **kwargs):
response = Response()
response.content_type = 'application/json'
try:
result = f(*args, **kwargs)
result = {
'status': SUCCESS,
'data': result,
}
response.status_code = 200
except APINotFoundException as e:
result = {
'status': FAIL,
'message': str(e)
}
response.status_code = 404
except APIFailureException as e:
result = {
'status': FAIL,
'message': str(e),
}
response.status_code = 500
except HTTPException:
raise # This causes issues
except Exception as e:
result = {
'status': ERROR,
'message': str(e),
}
response.status_code = 500
response.data = json.dumps(result)
return response
def get(self):
self.reqparse.add_argument('page', type=int, default=1)
self.reqparse.add_argument('count',
type=int,
default=100,
choices=[25, 50, 100])
self.reqparse.add_argument('numInstances', type=int, default=None)
self.reqparse.add_argument('fileFormat',
type=str,
default='json',
choices=['json', 'xlsx'])
args = self.reqparse.parse_args()
query = {'limit': 99999, 'page': 1, 'properties': {}}
total, elbs = ELB.search(**query)
elbs = [x.to_json() for x in elbs]
elb_count = len(elbs)
output = {'message': None, 'elbCount': total, 'elbs': elbs}
response = Response(response=b64encode(
bytes(json.dumps(output, indent=4, cls=InquisitorJSONEncoder),
'utf-8')))
response.content_type = 'application/octet-stream'
response.status_code = HTTP.OK
return response
def generate_offers_xls():
import urlparse, StringIO
from modules.catalog.models import Offer
from xlwt import Workbook
wb = Workbook()
ws = wb.add_sheet('Offers')
url_root = request.url_root
for line, offer in enumerate(Offer.objects()):
ws.write(line, 0, offer.name)
ws.write(
line, 1,
urlparse.urljoin(url_root,
url_for('site.dispatcher', path=offer.path)))
output = StringIO.StringIO()
wb.save(output)
response = Response()
response.status_code = 200
response.data = output.getvalue()
response.content_type = u'application/vnd.ms-excel'
response.headers["Content-Disposition"] = "attachment; filename=offers.xls"
return response
def handle_error(error):
logging.error('An exception has occured: %s', str(error))
response = Response()
response.data = json.dumps({'error': str(error)})
response.content_type = 'application/json'
response.status_code = 400
return response
def driveQuery(self, context) -> Any:
self._checkDriveHeaders(context)
query: str = context.args().get("q", "")
fields = self.parseFields(context.args().get('fields', 'id'))
if mimeTypeQueryPattern.match(query):
ret = []
mimeType = query[len("mimeType='"):-1]
for item in self.items.values():
if item.get('mimeType', '') == mimeType:
ret.append(self.filter_fields(item, fields))
return {'files': ret}
elif parentsQueryPattern.match(query):
ret = []
parent = query[1:-len("' in parents")]
if parent not in self.items:
return HTTP_404_NOT_FOUND
if parent in self.lostPermission:
resp = Response()
resp.status_code = HTTP_403_FORBIDDEN
resp.content_type = "application/json"
resp.set_data(
'{"error": {"errors": [{"reason": "forbidden"}]}}')
return resp
for item in self.items.values():
if parent in item.get('parents', []):
ret.append(self.filter_fields(item, fields))
return {'files': ret}
elif len(query) == 0:
ret = []
for item in self.items.values():
ret.append(self.filter_fields(item, fields))
return {'files': ret}
else:
return HTTP_400_BAD_REQUEST
def random_bytes(n):
"""Returns n random bytes generated with given seed
---
tags:
- Dynamic data
parameters:
- in: path
name: n
type: int
produces:
- application/octet-stream
responses:
200:
description: Bytes.
"""
if n <= 0 or n > (100 * 1024):
response = Response(headers={
"ETag": "range%d" % n,
"Accept-Ranges": "bytes"
})
response.status_code = 404
response.data = "number of bytes must be in the range (0, 102400]"
return response
params = CaseInsensitiveDict(request.args.items())
if "seed" in params:
random.seed(int(params["seed"]))
response = make_response()
# Note: can't just use os.urandom here because it ignores the seed
response.data = bytearray(random.randint(0, 255) for i in range(n))
response.content_type = "application/octet-stream"
return response
def handle_exception(e):
"""Return JSON instead of HTML for errors"""
if (isinstance(e, HTTPException)):
# start with the correct headers and status code from the error
response = e.get_response()
# replace the body with JSON
response.data = json.dumps({
"code": e.code,
"name": e.name,
"description": e.description,
})
response.content_type = "application/json"
else:
traceback.print_exc()
# start with empty response object
response = Response(status=500)
# add a JSON body
response.data = json.dumps({
"code": 500,
"name": 'Internal Server Error',
"description": 'Something Went Wrong',
})
response.content_type = "application/json"
return response
def request_finished_handler(self, sender, response: Response, **extra):
if 200 >= response.status_code < 300 and response.content_type == 'application/json':
data = response.get_data(as_text=True)
jwe = JWE(data, alg='A256KW', enc='A256CBC-HS512', cty='application/json')
encrypted = jwe.encrypt(self._keys, kid=self._keys[0].kid)
response.content_type = 'application/jose'
response.data = encrypted
def phone():
current_app.logger.info(str(request.form.to_dict()))
response = Response()
response.data= 'OK'
response.content_type="text/plain; charset=utf-8"
return response, 200
def stat2():
kota = request.args.get('kota', None)
pub_year = request.args.get('pub_year', None)
pub_month = request.args.get('pub_month', None)
labels = []
data = []
if pub_year or pub_month:
conn = sqlite3.connect('stat.sqlite')
cursor = conn.cursor()
if pub_month:
sql = 'SELECT pub_day, new_case, recovered, death FROM stat2 WHERE pub_month="{}" AND kota="{}"'.format(
pub_month, kota)
elif pub_year:
sql = 'SELECT pub_month, SUM(new_case), SUM(recovered), SUM(death) FROM stat2 WHERE pub_year="{}" AND kota="{}" GROUP BY pub_month'.format(
pub_year, kota)
for row in cursor.execute(sql):
label, new_case, recovered, death = row
labels.append(label)
data.append({
'new_case': new_case,
'recovered': recovered,
'death': death
})
cursor.close()
conn.close()
result = {'labels': labels, 'data': data}
response = Response()
response.data = json.dumps(result)
response.content_type = 'application/json'
# response.headers['Access-Control-Allow-Origin'] = '*'
return response
def build_file_response(file: typing.Union[Image, Video]):
response = Response(file.content)
response.headers[
'Content-Disposition'] = f'attachment; filename={file.filename}'
response.content_type = file.mimetype
return response
def exception_handler(exc):
"""Return JSON instead of HTML for HTTP errors."""
# start with the correct headers and status code from the error
status = 500
message = "Unhandled exception occured."
data = {
"message": message,
"debug_message": str(exc),
"code": None,
}
if isinstance(exc, HTTPException):
status = exc.code
message = exc.name
data = {
"code": None,
"message": exc.name,
"debug_message": exc.description,
}
if isinstance(exc, HttpException):
data = exc.marshal()
status = exc.status
if status >= 500:
logger.exception(message)
response = Response(status=status)
response.data = json.dumps(data)
response.content_type = "application/json"
return response
def stat2_pie():
kota = request.args.get('kota', None)
pub_year = request.args.get('pub_year', None)
pub_month = request.args.get('pub_month', None)
labels = ['New Case, Recovered, Death']
data = {}
if pub_year or pub_month:
conn = sqlite3.connect('stat.sqlite')
cursor = conn.cursor()
if pub_month:
sql = 'SELECT SUM(new_case), SUM(recovered), SUM(death) FROM stat2 WHERE pub_month="{}" AND kota="{}"'.format(
pub_month, kota)
elif pub_year:
sql = 'SELECT SUM(new_case), SUM(recovered), SUM(death) FROM stat2 WHERE pub_year="{}" AND kota="{}"'.format(
pub_year, kota)
cursor.execute(sql)
row = cursor.fetchone()
print(row)
new_case, recovered, death = row
data = {'new_case': new_case, 'recovered': recovered, 'death': death}
cursor.close()
conn.close()
result = {'labels': labels, 'data': data}
response = Response()
response.data = json.dumps(result)
response.content_type = 'application/json'
# response.headers['Access-Control-Allow-Origin'] = '*'
return response
def export_csv():
survey = request.args.get('survey')
yesterday = date.today() - timedelta(days=1)
start = yesterday.strftime('%Y-%m-%d 00:00:00')
start_dt = datetime.strptime(start,
'%Y-%m-%d %H:%M:%S').replace(tzinfo=server_tz)
end = yesterday.strftime('%Y-%m-%d 23:59:59')
end_dt = datetime.strptime(end,
'%Y-%m-%d %H:%M:%S').replace(tzinfo=server_tz)
summary = database.survey_admin.generate_summary(survey_name=survey,
start=start_dt,
end=end_dt)
summary_rows = [[survey.encode('utf-8')], [yesterday.strftime('%d-%m-%Y')],
[], ['New users', 'Active users', 'Points', 'Prompts'],
[
summary['new_users'], summary['active_users'],
summary['num_points'], summary['num_prompts']
]]
filestream = io.BytesIO()
filestream.write(codecs.BOM_UTF8)
writer = csv.writer(filestream)
writer.writerows(summary_rows)
csv_data = filestream.getvalue().strip('\r\n')
csv_fn = '{survey}-{date}.csv'.format(survey=survey.encode('utf-8'),
date=yesterday)
headers = {
'Content-disposition': 'attachment; filename={fn}'.format(fn=csv_fn)
}
response = Response(csv_data, mimetype='text/csv', headers=headers)
response.content_type = 'text/csv'
return response
def factquery():
current_app.logger.info(str(request.form.to_dict()))
response = Response()
response.data= 'OK'
response.content_type="text/plain; charset=utf-8"
time.sleep( 20)
return response, 200
def respond(data, code):
output = request.args.get('output', default='json')
response = Response(status=code)
if output == 'pretty':
response.content_type = 'text/plain; charset=utf-8'
response.data = json.dumps(data,
ensure_ascii=False,
indent=4,
separators=(',', ': '),
cls=APIJSONEncoder)
else:
response.content_type = 'application/json; charset=utf-8'
response.data = json.dumps(data,
ensure_ascii=False,
cls=APIJSONEncoder)
return response
def generateResponse(status="200 OK",
content_type="application/json",
cache_control="no-cache",
message=""):
response = Response()
response.status = status
response.content_type = content_type
# response.cache_control = cache_control
response.response = message
return response
def catch_http_exception(e):
response = Response()
response.data = json.dumps({
'status': 'failure',
'message': e.description,
'code': e.code
})
response.content_type = 'application/json'
return response, e.code
def catch_exception(e):
response = Response()
response.data = json.dumps({
'status': 'failure',
'message': str(e),
'code': 500
})
response.content_type = 'application/json'
return response, 500
def get_imp(optimal_ct, xmin, ymin, xmax, ymax):
"""
The client doesn't know which imp to use. It can call this function.
"""
env = Envelope(*map(float, [xmin, ymin, xmax, ymax]), srid=3857)
imp = map_bbox_imp(env, optimal_ct, DATASET)
imp = dumps({"imp": imp})
res = Response(imp)
res.content_type = 'application/x-javascript'
return res
def handle_schema_validation_error(error_messages):
field_error_msgs = []
for k in error_messages:
print(k + ", " + str(error_messages[k]))
field_error_msgs.append({k: error_messages[k]})
r = Response()
r.status_code = 400
r.content_type = 'application/json'
r.data = json.dumps(generate_response_wrapper(None, field_error_msgs=field_error_msgs))
return r
def view_file(uuid):
try:
file = File.get(File.uuid == uuid)
except File.DoesNotExist:
return abort(404)
if not file.encrypted:
print(request.headers.get('if-none-match'), file.hash,
request.headers.get('if-none-match') == file.hash)
if request.headers.get('if-none-match') == f'"{file.hash}"':
resp = Response('')
resp.status_code = 304
resp.set_etag(file.hash, False)
resp.cache_control.max_age = 5
resp.cache_control.public = True
return resp
resp = Response(file.content)
resp.content_type = file.mimetype
resp.headers.set('Content-Disposition',
'attachment',
filename=file.filename)
resp.cache_control.max_age = 5
resp.cache_control.public = True
resp.set_etag(file.hash, False)
return resp
else:
if request.method == 'GET':
return render_template('unlock-file.html', file=file), 401
elif request.method == 'POST':
try:
content = file.decrypt(request.form['password'])
except ValueError:
return render_template('unlock-file.html',
file=file,
error=True)
resp = Response(content)
resp.content_type = file.mimetype
resp.headers.set('Content-Disposition',
'attachment',
filename=file.filename)
# not setting cache-control or etag because this is in response to a POST
return resp
def generate_png(story_id):
story = Story.query.get_or_404(story_id)
res = Response()
g = Digraph(story.name)
for step in story.steps:
if step.final:
g.node('step_%d' % step.id, label=step.name, color="lightblue2", style="filled")
else:
g.node('step_%d' % step.id, label=step.name)
if step.first_choice_step_id:
g.edge('step_%d' % step.id, 'step_%d' % step.first_choice_step_id, label = step.first_choice)
if step.second_choice_step_id:
g.edge('step_%d' % step.id, 'step_%d' % step.second_choice_step_id, label = step.second_choice)
if str(request.url_rule).endswith('dot'):
res.content_type = "text/plain"
res.data = g.source
elif str(request.url_rule).endswith('png'):
g.format = 'png'
res.content_type = 'image/png'
res.data = g.pipe()
return res
def response(message):
"""! Wrapper for HTTP responses.
@param message The content of the successful (200) HTTP response.
@return Flask HTTP response object with content of message from the
argument and status code 200.
"""
res = Response(json.dumps(message))
res.status_code = 200
res.content_type = "application/json"
return res
def __metrics(self):
start_time = time.time()
@after_this_request
def to_do_after_this_request(response):
record_log(request, response, logger=self.__http_logger)
self.__record_metrics(start_time, request, response)
return response
resp = Response()
try:
resp.status_code = HTTPStatus.OK
resp.content_type = CONTENT_TYPE_LATEST
resp.data = generate_latest(self.__metrics_registry)
except Exception as ex:
resp.status_code = HTTPStatus.INTERNAL_SERVER_ERROR
resp.content_type = 'text/plain; charset="UTF-8"'
resp.data = '{0}\n{1}'.format(resp.status_code.phrase, resp.status_code.description)
self.__logger.error(ex)
return resp
def search():
print "data:", request.data
data = json.loads(request.data)
images = []
for color in data["colors"]:
for image_name in image_index.search(color[0], color[1], color[2], data.get("count", 10)):
images.append("/static/data/i/product/100/0/%s" % image_name)
response = Response(json.dumps({"images":images}))
response.content_type = "application/json"
return response
def __root(self):
start_time = time.time()
@after_this_request
def to_do_after_this_request(response):
record_log(request, response, logger=self.__http_logger)
self.__record_metrics(start_time, request, response)
return response
resp = Response()
try:
resp.status_code = HTTPStatus.OK
resp.content_type = 'text/plain; charset="UTF-8"'
resp.data = NAME + ' ' + VERSION + ' is running.\n'
except Exception as ex:
resp.status_code = HTTPStatus.INTERNAL_SERVER_ERROR
resp.content_type = 'text/plain; charset="UTF-8"'
resp.data = '{0}\n{1}'.format(resp.status_code.phrase, resp.status_code.description)
self.__logger.error(ex)
return resp
def api_task(task_id=0):
response = Response()
response.content_type = 'application/json;charset=UTF-8'
if request.method == 'DELETE':
Task.delete(id_=task_id)
response.response = json.dumps({'error': False, 'deleted': True, 'id_': task_id})
elif request.method == 'GET':
response.response = json.dumps(
Task.list(column=request.args.get('column', 'A'))
)
else:
task = Task(request.data)
task.save()
json_response = dict()
json_response['error'] = False
json_response['data'] = task.to_dict
response.response = json.dumps(json_response)
return response
def display_history_png(instance_id):
instance = InstanceStory.query.get_or_404(instance_id)
if not is_obj_of_current_user(instance):
return abort(403)
histories = instance.history.order_by(HistoryInstance.timestamp.asc()).all()
res = Response()
g = Digraph(instance.story.name)
step_ids = []
for history in histories:
if history.from_step_id and not history.from_step_id in step_ids:
step_ids.append(history.from_step_id)
if history.to_step_id and not history.to_step_id in step_ids:
step_ids.append(history.to_step_id)
steps_tmp = Step.query.filter(Step.id.in_(step_ids))
steps = {}
for step in steps_tmp:
steps[step.id] = step
for history in histories:
if history.from_step_id and not history.from_step_id in steps:
step = Step.query.get(history.from_step_id)
steps[history.from_step_id] = step
if history.to_step_id and not history.to_step_id in steps:
step = Step.query.get(history.to_step_id)
steps[history.to_step_id] = step
for step_id in steps:
step = steps[step_id]
if step.final:
g.node('step_%d' % step.id, label=step.name, color="lightblue2", style="filled")
else:
g.node('step_%d' % step.id, label=step.name)
index = 1
for history in histories:
if history.from_step_id:
g.edge('step_%d' % history.from_step_id, 'step_%d' % history.to_step_id, label = "%d. %s" % (index, history.choice_text))
index += 1
g.format = 'png'
res.content_type = "image/png"
res.data = g.pipe()
return res
def do(self, action, options=None):
"""
This method executes the defined action in the given event.
:param action:
:param options: Contains the flask parameters g, request, response
and the handler_def configuration
:type options: dict
:return:
"""
g = options.get("g")
request = options.get("request")
handler_def = options.get("handler_def")
handler_options = handler_def.get("options", {})
if action == ACTION_TYPE.FORWARD:
server_def = handler_options.get("privacyIDEA")
pi_server = get_privacyideaserver(server_def)
# the new url is the configured server url and the original path
url = pi_server.config.url + request.path
# We use the original method
method = request.method
tls = pi_server.config.tls
# We also transfer the original payload
data = request.all_data
if handler_options.get("forward_client_ip"):
data["client"] = g.client_ip
if handler_options.get("realm"):
data["realm"] = handler_options.get("realm")
if handler_options.get("resolver"):
data["resolver"] = handler_options.get("resolver")
log.info(u"Sending {0} request to {1!r}".format(method, url))
requestor = None
params = None
headers = {}
# We need to pass an authorization header if we forward administrative requests
if handler_options.get("forward_authorization_token"):
auth_token = request.headers.get('PI-Authorization')
if not auth_token:
auth_token = request.headers.get('Authorization')
headers["PI-Authorization"] = auth_token
if method.upper() == "GET":
params = data
data = None
requestor = requests.get
elif method.upper() == "POST":
requestor = requests.post
elif method.upper() == "DELETE":
requestor = requests.delete
if requestor:
r = requestor(url, params=params, data=data,
headers=headers, verify=tls)
# convert requests Response to werkzeug Response
response_dict = json.loads(r.text)
if "detail" in response_dict:
if response_dict.get("detail") is None:
# In case of exceptions we may not have a detail
response_dict["detail"] = {"origin": url}
else:
response_dict.get("detail")["origin"] = url
# We will modify the response!
# We can not use flask.jsonify(response_dict) here, since we
# would work outside of application context!
options["response"] = Response()
options["response"].status_code = r.status_code
options["response"].content_type = "application/json"
options["response"].data = json.dumps(response_dict)
else:
log.warning(u"Unsupported method: {0!r}".format(method))
return True
def index(url):
redata = {}
format_request_headers = {}
unfilter_headers = {}
for i in request.headers:
format_request_headers[str(i[0]).lower()] = i[1]
status_code = format_request_headers.get('x-vs-ctrl-status-code', 200)
content_type = format_request_headers.get('content-type')
content_random = format_request_headers.get('x-vs-ctrl-body-content-israndom', 'false')
length = format_request_headers.get('x-vs-ctrl-body-content-length', '-1')
interval = format_request_headers.get('x-vs-ctrl-response-interval', '-1')
isclean = format_request_headers.get('x-vs-ctrl-header-isclean', 'false')
redata = str(request.get_data())
try:
if length[-1] == 'k':
length = int(length[:-1]) * 1024
elif length[-1] == 'm':
length = int(length[:-1]) * 1024 * 1024
else:
length = int(length)
except ValueError:
length = -1
try:
interval = int(interval)
except ValueError:
interval = -1
if content_random == "true":
if length >= 0:
redata = make_random_str(length)
else:
redata = make_random_str(128)
content_type = "text/plain; charset=utf8"
resp = Response(redata)
if length >= 0:
if length <= len(redata):
resp.headers['Content-Length'] = length
elif 0 < len(redata) < length:
i = length / len(redata)
j = length % len(redata)
resp.data = redata * i + redata[:j]
else:
resp.headers['Content-Length'] = 0
if isclean != "true":
for i in format_request_headers:
if 'x-vs-ctrl-' not in i and i not in FILTER_HEADERS:
resp.headers[i] = format_request_headers[i]
try:
resp.status_code = int(status_code)
except ValueError:
resp.status = status_code + " unknow"
resp.content_type = content_type
if interval >= 0:
time.sleep(interval)
return resp
