def dark_enhance_aksk(_ak, _sk, image, brightness=0.9):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/vision/dark-enhance' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "brightness": brightness}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/vision/dark-enhance"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
status_code, resp = utils.request_aksk(sig, kreq, _url)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def image_content_batch_aksk(_ak, _sk, urls, categories=None, threshold=None):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/image/batch' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
_data = {
"urls": urls,
"categories": categories,
"threshold": threshold,
}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/moderation/image/batch"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
status_code, resp = utils.request_aksk(sig, kreq, _url)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def super_resolution_aksk(_ak, _sk, image, scale=3, model="ESPCN"):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/vision/super-resolution' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "scale": scale, "model": model}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/vision/super-resolution"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
status_code, resp = utils.request_aksk(sig, kreq, _url)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def recapture_detect_aksk(_ak, _sk, image, url, threshold=0.95, scene=None):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/image/recapture-detect' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {
"image": image,
"url": url,
"threshold": threshold,
"scene": scene,
}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/image/recapture-detect"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
status_code, resp = utils.request_aksk(sig, kreq, _url)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def celebrity_recognition_aksk(_ak, _sk, image, url, threshold=4.8):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/image/celebrity-recognition' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {
"image": image,
"url": url,
"threshold": threshold,
}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/image/celebrity-recognition"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
status_code, resp = utils.request_aksk(sig, kreq, _url)
if sys.version_info.major < 3:
return resp.decode('unicode-escape').encode('utf-8')
else:
return resp.decode('unicode_escape')
def distortion_correct_aksk(_ak, _sk, image, url, correction=True):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/image/distortion-correct' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "url": url, "correction": correction}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/moderation/image/distortion-correct"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
status_code, resp = utils.request_aksk(sig, kreq, _url)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def recapture_detect_aksk(_ak, _sk, image, url, threshold=0.95, scene=None):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/image/recapture-detect' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
if image != '':
image = image.decode('utf-8')
_data = {
"image": image,
"url": url,
"threshold": threshold,
"scene": scene,
}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/image/recapture-detect"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
resp = None
status_code = None
try:
sig.Sign(kreq)
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
_context = ssl._create_unverified_context()
req = urllib.request.Request(url=_url,
data=kreq.body,
headers=kreq.headers)
r = urllib.request.urlopen(req, context=_context)
#
# We use HTTPError and URLError，because urllib2 can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('utf-8')
def moderation_text_aksk(
_ak,
_sk,
text,
type='content',
categories=["ad", "politics", "p**n", "abuse", "contraband", "flood"]):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/text' % endpoint
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
_data = {"categories": categories, "items": [{"text": text, "type": type}]}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = "/v1.0/moderation/text"
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
resp = None
status_code = None
try:
sig.Sign(kreq)
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
_context = ssl._create_unverified_context()
req = urllib.request.Request(url=_url,
data=kreq.body,
headers=kreq.headers)
r = urllib.request.urlopen(req, context=_context)
#
# We use HTTPError and URLError，because urllib2 can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('unicode_escape')
def moderation_video_aksk(_ak,
_sk,
url,
frame_interval=5,
categories=['politics', 'terrorism']):
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
status, r = _moderation_video_aksk(endpoint, sig, url, frame_interval,
categories)
if status != 200:
return r
submit_result = json.loads(r)
job_id = submit_result['result'].get('job_id', '')
#print "Process job id is :", job_id
time.sleep(1.0)
retry_times = 0
try:
while True:
status, r = _get_result_aksk(endpoint, sig, job_id)
if status != 200:
if retry_times < _RETRY_TIMES:
retry_times += 1
time.sleep(2.0)
continue
else:
return r
rec_result = json.loads(r)
process_status = rec_result["result"].get('status')
if process_status == 'failed':
return r
elif process_status == 'finish':
return r
#
# process_status == 0 || process_status == 1
#
else:
time.sleep(2.0)
continue
except Exception:
return ''
def asr_bgm(token, url):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/bgm/recognition' % endpoint
_data = {
"url": url,
}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp.decode('unicode-escape').encode('utf-8')
else:
return resp.decode('unicode_escape')
def request_moderation_url(token, inner_path, image_str=None, url=None):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://' + endpoint + inner_path
if sys.version_info.major >= 3:
if image_str != '':
image_str = image_str.decode("utf-8")
_data = {"image": image_str, "url": url}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def dark_enhance(token, image, brightness=0.9):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/vision/dark-enhance' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "brightness": brightness}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def super_resolution(token, image, scale=3, model="ESPCN"):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/vision/super-resolution' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "scale": scale, "model": model}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def distortion_correct(token, image, url, correction=True):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/image/distortion-correct' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "url": url, "correction": correction}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def image_content_batch(token, urls, categories=None, threshold=None):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/image/batch' % endpoint
_data = {
"urls": urls,
"categories": categories,
"threshold": threshold,
}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def image_defog(token, image, gamama=1.5):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/vision/defog' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "gamma": gamama}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def celebrity_recognition(token, image, url, threshold=4.8):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/image/celebrity-recognition' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {"image": image, "url": url, "threshold": threshold}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp.decode('unicode-escape').encode('utf-8')
else:
return resp.decode('unicode_escape')
def image_tagging(token, image, url, languzge, limit=-1, threshold=0.0):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/image/tagging' % endpoint
if image != '':
image = image.decode("utf-8")
_data = {
"image": image,
"url": url,
"language": languzge,
"limit": limit,
"threshold": threshold
}
_headers = {
"Content-Type": "application/json",
"X-Auth-Token": token
}
data = json.dumps(_data).encode("utf-8")
kreq = urllib.request.Request(_url, data, _headers)
resp = None
status_code = None
try:
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
_context = ssl._create_unverified_context()
r = urllib.request.urlopen(kreq, context=_context)
#
# We use HTTPError and URLError，because urllib can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('utf-8')
def request_moderation_url_aksk(sig, inner_path, image_str=None, url=None):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s' % (endpoint + inner_path)
if image_str != '':
image_str = image_str.decode('utf-8')
_data = {"image": image_str, "url": url}
kreq = signer.HttpRequest()
kreq.scheme = "https"
kreq.host = endpoint
kreq.uri = inner_path
kreq.method = "POST"
kreq.headers = {"Content-Type": "application/json"}
kreq.body = json.dumps(_data)
resp = None
status_code = None
try:
sig.Sign(kreq)
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
_context = ssl._create_unverified_context()
req = urllib.request.Request(url=_url,
data=kreq.body,
headers=kreq.headers)
r = urllib.request.urlopen(req, context=_context)
#
# We use HTTPError and URLError，because urllib can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('utf-8')
def video_tagging_aksk(_ak,
_sk,
url,
frame_interval=5,
language='zh',
threshold=60.0):
sig = signer.Signer()
sig.AppKey = _ak
sig.AppSecret = _sk
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
status, r = _video_tagging_aksk(endpoint, sig, url, frame_interval,
language, threshold)
if status != 200:
return r
submit_result = json.loads(r)
job_id = submit_result['result'].get('job_id', '')
#print("Process job id is :", job_id)
time.sleep(1.0)
try:
while True:
status, r = _get_result_aksk(endpoint, sig, job_id)
if status != 200:
return r
rec_result = json.loads(r)
process_status = rec_result["result"].get('status')
if process_status == 'failed':
return r
elif process_status == 'finish':
return r
#
# process_status == 0 || process_status == 1
#
else:
time.sleep(2.0)
continue
except Exception:
return ''
def image_batch_jobs(token,
urls,
categories=['politics', 'terrorism', 'p**n']):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
status, r = _image_batch_jobs(endpoint, token, urls, categories)
if status != 200:
return r
submit_result = json.loads(r)
job_id = submit_result['result'].get('job_id', '')
# print "Process job id is :", job_id
time.sleep(1.0)
retry_times = 0
try:
while True:
status, r = _get_result(endpoint, token, job_id)
if status != 200:
if retry_times < _RETRY_TIMES:
retry_times += 1
time.sleep(2.0)
continue
else:
return r
rec_result = json.loads(r)
process_status = rec_result["result"].get('status')
if process_status == 'failed':
return r
elif process_status == 'finish':
return r
#
# process_status == 0 || process_status == 1
#
else:
time.sleep(2.0)
continue
except Exception:
return ''
def clarity_detect(token, image, url, threshold=0.8):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/image/clarity-detect' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {
"image": image,
"url": url,
"threshold": threshold
}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def moderation_image(token, image, url, categories=None, threshold=None):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/image' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {
"image": image,
"url": url,
"categories": categories,
"threshold": threshold,
}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def recapture_detect(token, image, url, threshold=0.95, scene=None):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/image/recapture-detect' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {
"image": image,
"url": url,
"threshold": threshold,
"scene": scene,
}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp
else:
return resp.decode('utf-8')
def moderation_text(
token,
text,
type='content',
categories=["ad", "politics", "p**n", "abuse", "contraband", "flood"]):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/text' % endpoint
_data = {"categories": categories, "items": [{"text": text, "type": type}]}
_headers = {"Content-Type": "application/json", "X-Auth-Token": token}
data = json.dumps(_data).encode("utf-8")
kreq = urllib.request.Request(_url, data, _headers)
resp = None
status_code = None
try:
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
_context = ssl._create_unverified_context()
r = urllib.request.urlopen(kreq, context=_context)
#
# We use HTTPError and URLError，because urllib2 can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('unicode_escape')
def image_tagging(token, image, url, languzge, limit=-1, threshold=0.0):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/image/tagging' % endpoint
if sys.version_info.major >= 3:
if image != '':
image = image.decode("utf-8")
_data = {
"image": image,
"url": url,
"language": languzge,
"limit": limit,
"threshold": threshold
}
status_code, resp = utils.request_token(_url, _data, token)
if sys.version_info.major < 3:
return resp.decode('unicode-escape').encode('utf-8')
else:
return resp.decode('unicode_escape')
def moderation_image_batch(token, urls, categories=None, threshold=None):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
_url = 'https://%s/v1.0/moderation/image/batch' % endpoint
_data = {
"urls": urls,
"categories": categories,
"threshold": threshold,
}
_headers = {"Content-Type": "application/json", "X-Auth-Token": token}
data = json.dumps(_data).encode("utf-8")
kreq = urllib.request.Request(_url, data, _headers)
resp = None
status_code = None
try:
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
_context = ssl._create_unverified_context()
r = urllib.request.urlopen(kreq, context=_context)
#
# We use HTTPError and URLError，because urllib can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('utf-8')
def asr_bgm(token, url):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/bgm/recognition' % endpoint
_data = {
"url": url,
}
_headers = {"Content-Type": "application/json", "X-Auth-Token": token}
data = bytes(json.dumps(_data), 'utf8')
kreq = urllib.request.Request(_url, data, _headers)
resp = None
status_code = None
try:
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
r = urllib.request.urlopen(kreq)
#
# We use HTTPError and URLError，because urllib2 can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('unicode_escape')
def moderation_video(token,
url,
frame_interval=5,
categories=['politics', 'terrorism']):
endpoint = utils.get_endpoint(ais.AisService.MODERATION_SERVICE)
status, r = _moderation_video(endpoint, token, url, frame_interval,
categories)
if status != 200:
return r
submit_result = json.loads(r)
job_id = submit_result['result'].get('job_id', '')
#print("Process job id is :", job_id)
time.sleep(1.0)
try:
while True:
status, r = _get_result(endpoint, token, job_id)
if status != 200:
return r
rec_result = json.loads(r)
process_status = rec_result["result"].get('status')
if process_status == 'failed':
return r
elif process_status == 'finish':
return r
#
# process_status == 0 || process_status == 1
#
else:
time.sleep(2.0)
continue
except Exception:
return ''
def super_resolution(token, image, scale=3, model="ESPCN"):
endpoint = utils.get_endpoint(ais.AisService.IMAGE_SERVICE)
_url = 'https://%s/v1.0/vision/super-resolution' % endpoint
_data = {"image": image.decode("utf-8"), "scale": scale, "model": model}
_headers = {"Content-Type": "application/json", "X-Auth-Token": token}
data = json.dumps(_data).encode("utf-8")
kreq = urllib.request.Request(_url, data, _headers)
resp = None
status_code = None
try:
#
# Here we use the unvertified-ssl-context, Because in FunctionStage
# the client CA-validation have some problem, so we must do this.
#
_context = ssl._create_unverified_context()
r = urllib.request.urlopen(kreq, context=_context)
#
# We use HTTPError and URLError，because urllib2 can't process the 4XX &
# 500 error in the single urlopen function.
#
# If you use a modern, high-level designed HTTP client lib, Yeah, I mean requests,
# there is no this problem.
#
except HTTPError as e:
resp = e.read()
status_code = e.code
except URLError as e:
resp = e.read()
status_code = e.code
else:
status_code = r.code
resp = r.read()
return resp.decode('utf-8')
