def detect_face(filepath): #传入图片文件
http_url = "https://api-cn.faceplusplus.com/facepp/v3/detect"
files = {"image_file": open(filepath, "rb")}
data = {"api_key": key, "api_secret": secret, "return_gesture": "1"}
#starttime = datetime.datetime.now()
response = requests.post(http_url, data=data, files=files)
#endtime = datetime.datetime.now()
#print((endtime - starttime).seconds)
req_con = response.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def get_count_stars_followers(user):
global MUST_HAVE
result = {"s": 0, "f": 0}
answer_f = requests.get(MUST_HAVE + f"/users/{user}") # for followers
answer_st = requests.get(MUST_HAVE + f"/users/{user}/repos") # for stars
if answer_f.status_code != 200 or answer_st.status_code != 200:
err = answer_f.status_code if answer_f.status_code != 200 else answer_st.status_code
print(f"Program got an error {err}.\nPlease, repeat later.")
sys.exit(1)
info = JSONDecoder().decode(answer_f.text)
result["f"] = info["followers"]
info = JSONDecoder().decode(answer_st.text)
for note in info:
result["s"] += note["stargazers_count"]
def count_scope(stat):
scope = stat["s"] * 3 + stat["f"] * 7
workers_stat[user] = scope
count_scope(result)
def decode_stacked(document, pos=0, decoder=JSONDecoder()):
while True:
match = NOT_WHITESPACE.search(document, pos)
if not match:
return
pos = match.start()
try:
obj, pos = decoder.raw_decode(document, pos)
except JSONDecodeError:
raise Exception("Can't parse")
yield obj
def faceset_getdetail(faceset_token):
url = 'https://api-cn.faceplusplus.com/facepp/v3/faceset/getdetail'
params = {
'api_key': key,
'api_secret': secret,
'faceset_token': faceset_token,
}
r = requests.post(url, data=params)
req_con = r.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def __init__(self,
*,
hyperparams: Hyperparams,
random_seed: int = 0,
volumes: typing.Dict[str, str] = None) -> None:
super().__init__(hyperparams=hyperparams,
random_seed=random_seed,
volumes=volumes)
self._decoder = JSONDecoder()
self._params = {}
self._volumes = volumes
def __init__(self, **kwargs):
body = kwargs.get('body') # type: Any
signer = kwargs.get('signer') # type: AttestationSigningKey
if body:
if signer:
token = self._create_secured_jwt(body, signer)
else:
token = self._create_unsecured_jwt(body)
else:
token = kwargs.pop('token')
self._token = token
self._body_type = kwargs.get('body_type') #type: Type
token_parts = token.split('.')
if len(token_parts) != 3:
raise ValueError("Malformed JSON Web Token")
self.header_bytes = Base64Url.decode(token_parts[0])
self.body_bytes = Base64Url.decode(token_parts[1])
self.signature_bytes = Base64Url.decode(token_parts[2])
self._body = JSONDecoder().decode(self.body_bytes.decode('ascii'))
self._header = JSONDecoder().decode(self.header_bytes.decode('ascii'))
def __init__(self,
func: Callable,
*,
decoder: JSONDecoder = None,
encoder: JSONEncoder = None,
encoding='utf-8') -> None:
self._func = func # Wrapped function: __call__(**kwargs) -> <output_type>
self._decoder = decoder or JSONDecoder(
) # JSON decoder: decode(str) -> dict.
self._encoder = encoder or JSONEncoder(
) # JSON encoder: encode(<output_type>) -> str.
self._encoding = encoding # Pretty much has to be UTF-8.
def decode(self, data):
"""
decode the data to python from json
"""
if data:
decoder = JSONDecoder()
thunker = JSONThunker()
data = decoder.decode(data)
unthunked = thunker.unthunk(data)
return unthunked
else:
return {}
def decode_obj(self, line, pos=0, decoder=JSONDecoder()):
no_white_space_regex = re.compile(r'[^\s]')
while True:
match = no_white_space_regex.search(line, pos)
if not match:
return
pos = match.start()
try:
obj, pos = decoder.raw_decode(line, pos)
except JSONDecodeError as err:
print("Oops! Something went wrong. Error : {}".format(err))
yield obj
def get_points():
path = os.path.join("data.txt")
if not os.path.exists(path):
return None
input_file = open('data.txt')
json_array = json.load(input_file)
points = []
for item in json_array:
point = JSONDecoder(object_hook=get_point_from_json).decode(
json.dumps(item))
points.append(point)
return points
def get_face_set(): # 获取所有 FaceSet id
url = 'https://api-cn.faceplusplus.com/facepp/v3/faceset/getfacesets'
params = {
'api_key': key,
'api_secret': secret,
}
r = requests.post(url, data=params)
req_con = r.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def set_face(outer_id): # 创建一个人脸的集合 FaceSet，用于存储人脸标识 face_token
url = 'https://api-cn.faceplusplus.com/facepp/v3/faceset/create'
params = {
'api_key': key,
'api_secret': secret,
'outer_id': outer_id
}
r = requests.post(url, data=params)
req_con = r.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def json_to_object(cls, string: str) -> 'Atom':
"""
:param string: str
:return: Atom
"""
target, stream = Atom('', '', ''), JSONDecoder().decode(string)
for prop in target.__dict__.keys():
if prop in stream:
setattr(target, prop, stream[prop])
return target
def extract_json_objects(text, decoder=JSONDecoder()):
pos = 0
while True:
match = text.find('{', pos)
if match == -1:
break
try:
result, index = decoder.raw_decode(text[match:])
yield result
pos = match + index
except ValueError:
pos = match + 1
def decodeStacked(data, pos=0, decoder=JSONDecoder()):
while True:
try:
obj, pos = decoder.raw_decode(data, pos)
if len(data) == pos:
yield obj
return
except Exception as error:
print(
'An error occured while decoding incoming data from bluetooth: ',
str(error))
yield obj
def json_parse(fileobj, decoder=JSONDecoder(), buffersize=2048):
buf = ''
for chunk in iter(partial(fileobj.read, buffersize), ''):
buf += chunk
while buf:
try:
result, index = decoder.raw_decode(buf)
yield result
buf = buf[index:]
except ValueError:
# Not enough data to decode, read more
break
def github_callback(request):
code = request.GET['code']
uid = request.session.get('uid', defautl=None)
if uid is not None:
p = Profile.objects.get(pk=uid)
token_url = "https://github.com/login/oauth/access_token?client_id=%s&client_secret=%s&code=%s" % (
GITHUB_KEY, GITHUB_SECRET, code)
info = JSONDecoder().decode(urllib2.urlopen(token_url, "").read())
uinfo_url = "https://api.github.com/user?access_token=%s" % (
info['access_token'])
uinfo = JSONDecoder().decode(urllib2.urlopen(uinfo_url).read())
info['id'] = uinfo['id']
account_name = uinfo['name']
d = DataSource.objects.create(source_name="github",
auth_info=JSONEncoder().encode(info),
account_name=account_name,
owner=p)
sync_source(d)
return redirect('/datasources')
else:
return redirect('/login')
def decode_stacked(document, pos=0, decoder=JSONDecoder()):
while True:
match = NOT_WHITESPACE.search(document, pos)
if not match:
return
pos = match.start()
try:
obj, pos = decoder.raw_decode(document, pos)
except JSONDecodeError:
print("ERROR")
yield obj
def __init__(self, trexObj , zmq_port):
super(ZmqMonitorSession, self).__init__()
self.stoprequest = threading.Event()
# self.terminateFlag = False
self.first_dump = True
self.zmq_port = zmq_port
self.zmq_publisher = "tcp://localhost:{port}".format( port = self.zmq_port )
# self.context = zmq.Context()
# self.socket = self.context.socket(zmq.SUB)
self.trexObj = trexObj
self.expect_trex = self.trexObj.expect_trex # used to signal if T-Rex is expected to run and if data should be considered
self.decoder = JSONDecoder()
logger.info("ZMQ monitor initialization finished")
def parse_jsonlines(document, pos=0, decoder=JSONDecoder()):
while True:
match = NOT_WHITESPACE.search(document, pos)
if not match:
return
pos = match.start()
try:
obj, pos = decoder.raw_decode(document, pos)
except JSONDecodeError:
# do something sensible if there's some error
raise
yield obj
def myRequest_get(http_url, params, save_file=""):
params["app_id"] = APP_ID
params["app_key"] = APP_KEY
response = requests.get(http_url, params=params)
print(response)
req_con = response.content.decode('utf-8')
try:
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
save(save_file, req_dict)
return req_dict
except:
return {}
def face_search(image_file1, faceset_token):
url = 'https://api-cn.faceplusplus.com/facepp/v3/search'
files = {"image_file": open(image_file1, "rb")}
params = {
"api_key": key,
"api_secret": secret,
"faceset_token": "338bf95e3268d1a3c802f03a3f78fff1"
}
r = requests.post(url, files=files, params=params)
req_con = r.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def load(self):
try:
settings = codecs.open(self.path, "r", "utf8").read()
except IOError:
return False
try:
self.values = JSONDecoder().decode(settings)
except ValueError:
return False
return True
def iss_regions_from_str(self, s):
if not s:
return
data = JSONDecoder().decode(s)
for (indices, regions) in data:
if not indices:
continue # should not get empty tuple
# is_type should already be set
is_type = self.project.get_value('is_type', args=[indices[0]])
self.iss_add_regions_1(regions,
is_type=is_type,
indices=indices,
autoselect=False)
def sync_douban_collections(did, index, new_latest):
d = DataSource.objects.get(pk=did)
info = JSONDecoder().decode(d.auth_info)
consumer = oauth.Consumer(key=DOUBAN_KEY, secret=DOUBAN_SECRET)
token = oauth.Token(key=info['oauth_token'],
secret=info['oauth_token_secret'])
client = oauth.Client(consumer, token)
url = "http://api.douban.com/people/%s/collection?start-index=%s&max-results=50&alt=json" % (
info['douban_user_id'], index)
resp, content = client.request(url, "GET")
collections_info = JSONDecoder().decode(content)
if collections_info['entry']:
if (index == 1):
new_latest = collections_info['entry'][0]['id']['$t']
for collect in collections_info['entry']:
if (info.has_key('latest_collection')
and collect['id']['$t'] == info['latest_collection']):
info['latest_collection'] = new_latest
d.auth_info = JSONEncoder().encode(info)
d.save(force_update=True)
sync_douban_collections.apply_async(args=[did, 1, None],
countdown=84600)
break
new_paw = Paw.objects.create(source=d, \
type="douban collection", \
content=collect['title']['$t'], \
create_time=datetime.strptime(collect['updated']['$t'][:-6], "%Y-%m-%dT%H:%M:%S"))
if not (info.has_key('latest_collection')
and collect['id']['$t'] == info['latest_collection']):
sync_douban_collections.apply_async(
args=[did, index + 50, new_latest], countdown=60)
else:
if new_latest is not None:
info['latest_collection'] = new_latest
d.auth_info = JSONEncoder().encode(info)
d.save(force_update=True)
sync_douban_collections.apply_async(args=[did, 1, None],
countdown=84600)
def get(self, params):
try:
raw_result = requests.get(self.vk_api + self.method, params=params)
result = JSONDecoder().decode(raw_result.text)
if 'response' in result.keys():
return result['response']
else:
print(result['error']['error_msg'])
except requests.exceptions.ConnectionError as err:
raise 'Connection error' + err
except JSONDecodeError:
print('Can\'t decode, return empty string')
return ''
def addface(faceset, facetokens):
url = 'https://api-cn.faceplusplus.com/facepp/v3/faceset/addface'
params = {
'api_key': key,
'api_secret': secret,
'faceset_token': faceset,
'face_tokens': facetokens
}
r = requests.post(url, params=params)
req_con = r.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def face_search(image_file1, faceset_token):
url = 'https://api-cn.faceplusplus.com/facepp/v3/search'
files = {"image_file": open(image_file1, "rb")}
params = {
'api_key': key,
'api_secret': secret,
'faceset_token': faceset_token
}
r = requests.post(url, files=files, params=params)
req_con = r.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def delete_faceset(faceset_token, check_empty):
url = 'https://api-cn.faceplusplus.com/facepp/v3/faceset/delete'
params = {
'api_key': key,
'api_secret': secret,
'faceset_token': faceset_token,
'check_empty': check_empty
}
r = requests.post(url, params=params)
req_con = r.content.decode('utf-8')
req_dict = JSONDecoder().decode(req_con)
print(req_dict)
return req_dict
def parse_json(text: str, decoder=JSONDecoder()) -> str:
pos = 0
while True:
match = text.find('{', pos)
if match == -1:
break
try:
result, index = decoder.raw_decode(text[match:])
yield result
pos = match + index
except ValueError:
pos = match + 1
