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')