def indexConversation(transcript, person_id, title):
topics = getTopicsFromConversation(transcript)
doc = { "content": transcript, "title": title, "reference": str(time.time()),
"topics": topics, "date": time.strftime("%m/%d/%y"), "person_id": str(person_id) }
print doc
result = index.addDoc(doc, async=True).json()
return result
def cancel(self, task_id):
task = self._get_object(task_id)
if task:
task.cancel(log=log)
return json({'success':True, 'message':'Cancel is ok.'})
else:
return json({'success':False, 'message':'Task %r can not be found.' % task_id})
async def add_ip(request, ipport):
try:
for protocol in ProxyProvider.PROTOCOLS:
proxy_provider.add_ip(protocol, ipport)
return json({"result": "done"})
except:
logger.exception("WTF in add_ip")
return json({"result": None})
def test_withdraw(self, case):
'''提现用例类'''
global result
#替换测试数据
member_id = getattr(CaseVar, 'member_id', "")
token = getattr(CaseVar, 'token', "")
# 替换测试数据
case['data'] = handler.replace_data(case['data'])
case['headers'] = handler.replace_data(case['headers'])
data = json.loads(case['data'])
headers = json.loads(case['headers'])
excepted = json.loads(case['expected'])
#提现前余额与提现流水记录
before_amount = self.db.query(
"select leave_amount from member where id={}".format(member_id))
before_count = self.db.query(
"select count(1) as cn from financelog where pay_member_id={};".
format(member_id))
mylog.info("正在测试第{}个用例，测试数据是：{}".format(case['case_id'], case))
mylog.info('用例期望结果是：{}'.format(excepted))
#发送请求
res = doRequests(url=MiddleHandler().host + case['url'],
method=case['method'],
headers=headers,
json=data).json()
mylog.info('用例实际结果是：{}'.format(res))
#检查点
try:
for k, v in excepted.items():
self.assertEqual(v, res[k])
after_amount = self.db.query(
"select leave_amount from member where id={}".format(
member_id))
after_count = self.db.query(
"select count(1) as cn from financelog where pay_member_id={};"
.format(member_id))
if res['code'] == 0:
#提现成功后，判断余额是否正确并存在流水记录
self.assertEqual(
before_amount['leave_amount'] -
Decimal(str(data['amount'])), after_amount['leave_amount'])
self.assertEqual(str(before_count['cn'] + 1),
str(after_count['cn']))
result = '通过'
else:
#提现异常后，判断余额是否正确
self.assertEqual(before_amount['leave_amount'],
after_amount['leave_amount'])
result = '通过'
except AssertionError as e:
mylog.error('异常信息{}'.format(e))
result = '不通过'
raise e
finally:
mylog.info('用例{}:测试{}，正在回写测试结果...'.format(case['case_id'], result))
MiddleHandler.execl.write(MiddleHandler.file_name, 'withdraw',
case['case_id'] + 1, 9, result)
mylog.info('回写测试结果成功!')
def process(self, job):
web.header('Content-Type', 'text/json')
job = str(uuid(job))
status, _ = get_job_status(job)
if status == 'awaiting':
return json(dict(status = status, **db.queue_position(job)))
else:
return json(dict(status = status))
def v2_runner_on_failed(self, result, ignore_errors=False):
### change payload
payload = {'host_name': result._host.name,
'task_name': result.task_name,
'task_output_message' : result._result['msg']
}
requests.post(self.callback_url),data=payload).json()
pass
def addCardToIndex(information):
cards = getCard(information["name"])
doc = {
"content": str(information),
"title": information["name"],
"reference": information["name"]
}
result = cardIndex.addDoc(doc, async=True).json()
return result
def submit_task():
task, errors = task_schema.load(requests.form)
if errors:
return json({'errors': errors}), 400
db.session.add(Task(**task))
db.session.commit()
calculate_hash_some_hash.delay(task['id'])
return json({'id': task['id']}), 201
def reset(self, task_id):
"""
Reset task status to initialization status
"""
task = self._get_object(task_id)
if task:
task.reset(log=log)
return json({'success':True, 'message':'Reset is ok.'})
else:
return json({'success':False, 'message':'Task %r can not be found.' % task_id})
def __init__(self):
json()
base64.b64encode(hmac.new(tob(key), msg).digest())):
return pickle.loads(base64.b64decode(msg))
def StudentLogin(request):
if request.method == "GET":
return HttpResponse("Yoo. You GET me. :P")
else :
user = authenticate(username=request.POST['email'], password=request.POST['password'])
if user is not None:
if hasattr(user, 'student'):
login(request, user)
return HttpResponse(json(user))
return HttpResponse(json(('message',"You are not allowed here")))
return HttpResponse(json(('message',"Wrong username or password")))
def indexConversation(transcript, person_id, title):
topics = getTopicsFromConversation(transcript)
doc = {
"content": transcript,
"title": title,
"reference": str(time.time()),
"topics": topics,
"date": time.strftime("%m/%d/%y"),
"person_id": str(person_id)
}
print doc
result = index.addDoc(doc, async=True).json()
return result
def check_task():
task = None
if 'id' in requests.args:
task = Task.query.filter_by(id=requests.args['id']).first()
if not task:
return json({'status': 'not found'}), 404
responce = {'status': task.status}
if task.status == StatusType.DONE:
responce['url'] = task.url
responce['md5'] = task.md5
return json(**responce)
async def _post(self, request):
data = request.json
token = data['token']
msg = data['msg']
user = self.chat_ids[token]
actions = data.get('actions', [])
reply_token = random_key(12)
progress = data.get('progress', None)
edit = data.get('edit', None)
text = msg
if isinstance(progress, float) and 0 <= progress <= 1:
blacks = int(progress * 10)
whites = 10 - blacks
text += "\n"
for i in range(blacks):
text += BLACK
for i in range(whites):
text += WHITE
if actions:
reply_markup = InlineKeyboardMarkup([[
InlineKeyboardButton(s, callback_data=reply_token + "/" + s)
for s in actions
]])
else:
reply_markup = None
if isinstance(edit, int):
message = self.bot.edit_message_text(text=text,
chat_id=user,
message_id=edit,
parse_mode=ParseMode.MARKDOWN,
reply_markup=reply_markup)
else:
message = self.bot.send_message(text=text,
chat_id=user,
parse_mode=ParseMode.MARKDOWN,
reply_markup=reply_markup)
if not actions:
return json(dict(msg=msg, id=message.message_id))
while not reply_token in self.callbacks:
await asyncio.sleep(1)
response = self.callbacks.pop(reply_token)
return json(dict(msg=msg, response=response, id=message.message_id))
async def auth_token(req, *arg, **kwargs):
try:
value = req.headers.get(token)
if value and TOKEN == value:
r = await func(req, *arg, **kwargs)
return json({'retcode': 0, 'stdout': r})
else:
return json({
'retcode': 1,
'stderr': 'status{}'.format(403)
})
except Exception as e:
log('error', str(e))
return json({'retcode': 1, 'stderr': str(e)})
async def test(request):
self.generateEvent(self)
resp = make_response(json({'event': 'received'}), 200)
resp.set_cookie('simon', 'cookie')
# http://flask.pocoo.org/docs/1.0/api/#incoming-request-data
# response.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)¶
return resp
def addToKnownList(request):
english = request.POST['word']
word = Word.objects.get(spell=english)
word.known = True
word.error = False
word.save()
return HttpResponse(json({'success': True}))
def test(self, username, cookies):
print('正在测试cookies', '用户名', username)
try:
cookies = json(cookies)
except TypeError:
print('cookies不合法', username)
self.cookies_db.delete(username)
print('删除cookies', username)
return
try:
test_url = TEST_URL_MAP[self.website]
response = requests.get(test_url,
cookies=cookies,
timeout=5,
allow_redirects=False)
if response.status_code == 200:
print('cookies有效', username)
print('部分测试结果', response.text[0:50])
else:
print(response.status_code, response.headers)
print('cookies失效', username)
self.cookies_db.delete(username)
print('删除cookies', username)
except ConnectionError as e:
print('发生异常', e.args)
def processFile(file):
counter = 0
locations = 0
totalSize = 0
now = time.time()
for line in file:
counter += 1
totalSize += len(line)
line = line.decode('utf-8')
if counter % 100 == 0:
e = time.time() - now
print("Rows processed:", counter, counter / e, e,
totalSize / 1024 / 1024 / e)
json = convert(line)
if not json: continue
try:
obj = extract(json())
except:
obj = None
if not obj: continue
locations += 1
#print(line)
yield obj
print("Total:", counter, "\t with locations: ", locations)
def list_file():
path = os.getcwd() + "/file_diem"
list_of_files = {}
for filename in os.listdir(path):
list_of_files[filename] = filename
return json(list_of_files)
def convert(shp):
# Translate the path for this Docker Container's Volume context
# shp = shp.replace('/mnt/queries/', '/FuelModels/queries/')
shp = '/FuelModels/queries/' + shp
geoj = shp.replace('.shp', '.json')
if Path(geoj).is_file():
contents = open(geoj, 'r')
return json.loads(contents.read())
if not Path(shp).is_file():
raise FileNotFoundError("File not found.")
else:
with fiona.open(shp, 'r') as source:
original = Proj(source.crs)
destination = Proj(init='EPSG:4326')
with fiona.open(geoj,
'w',
driver='GeoJSON',
crs=fiona.crs.from_epsg(4326),
schema=source.schema.copy()) as sink:
for feat in source:
# sink.write(feat)
out_linear_ring = []
for point in feat['geometry']['coordinates'][0]:
long, lat = point
x, y = transform(original, destination, long, lat)
out_linear_ring.append((x, y))
feat['geometry']['coordinates'] = [out_linear_ring]
sink.write(feat)
# Remove the default WGS84 crs to avoid GeoJSON import error on UI
return json(geoj)
async def submit_contract(request):
code = request.json.get('code')
name = request.json.get('name')
if code is None or name is None:
return json({'error': 'malformed payload'}, status=500)
violations = client.lint(code)
if violations is None:
client.submit(code, name=name)
else:
return json({'violations': violations}, status=500)
return json({'success': True}, status=200)
def login():
data = request.get_data()
data = json.loads(data)
username = data['username']
password = data['password']
return json({"login": (username, password)})
def check(req):
username,password,user_md5 = (req.GET['username'],req.GET['password'],req.GET['user_md5'])
user = authenticate(username=username,password=password)
usercode = hashlib.md5(user_md5).hexdigest().upper()
if user:
return HttpResponse(json.dumps({'username':username,'usercode':usercode}))
return HttpResponse(json({'username':''}))
def __init__(self, response, exception=None):
"""用响应包和异常信息初始化ResponseInfo类"""
self.__response = response
self.exception = exception
if response is None:
self.status_code = -1
self.text_body = None
self.req_id = None
self.x_log = None
self.error = str(exception)
else:
self.status_code = response.code
self.text_body = response.body
self.req_id = response.headers.get('X-Reqid')
self.x_log = response.headers.get('X-Log')
if self.status_code >= 400:
try:
ret = json(response.body) if response.body != '' else None
except Exception,e:
ret = None
if ret is None or ret['error'] is None:
self.error = 'unknown'
else:
self.error = ret['error']
if self.req_id is None and self.status_code == 200:
self.error = 'server is not qiniu'
async def predict(request, model_name):
if request.method == 'POST':
receive_time = utils.now()
logging.info(f'Received request for model: {model_name}')
typ = request.json['type']
# use a general decoder to handle different types
# data = utils.decode_image(request.json['data']) if typ == 'image' else request.json['data']
data = request.json['data']
sch.record_request(model_name)
res, typ, handel_time = await processor.send_query(
model_name, receive_time, data)
if (typ > 3):
scheduler.Scheduler.failed_rate = scheduler.Scheduler.failed_rate * 0.999 + 0.001
elif (handel_time > UPPER_LATENCY_BOUND):
scheduler.Scheduler.failed_rate = scheduler.Scheduler.failed_rate * 0.999 + 0.001
else:
scheduler.Scheduler.failed_rate = scheduler.Scheduler.failed_rate * 0.999
if sch.failed_rate > SLA_BOUND:
sch.launch_standby('c5.xlarge', 1, model_name)
scheduler.Scheduler.failed_rate = 0.0
logging.info(
f'Model: {model_name}; typ: {typ}; handel_time: {handel_time}; failed_rate: {scheduler.Scheduler.failed_rate}'
)
return json({'res': res, 'latency': handel_time})
def add():
request_data = request.get_json()
if (validBookObject(request_data)):
data = request.form.to_dict(flat=True)
print("requested data")
print(request_data)
book = get_model().create(request_data)
print('book id')
print(json(book['_id']))
# First parameter is a response body, second parameter is the status code, third is the content type header that will be sent
response = Response('', 201, mimetype='application/json')
# response.headers['Location'] = '/books/' + str(book['_id'])
return response
else:
invalidBookObjectErrorMsg = {
'error':
'Invalid book object passed in request',
'helpString':
"Data passed in similiar to this {'author': 'Tarantino','title': 'Pulp Fiction','genre': 'Drama', 'read': true}"
}
# invalidBookObjectErrorMsg is a dictionary and we need conver to json
response = Response(json.dumps(invalidBookObjectErrorMsg),
status=400,
mimetype='application/json')
return response
def test_district():
"Test district pages such as /us/nm-02."
nm_02 = html('/us/nm-02')
ok_re(nm_02, r'69,598 sq\. mi\.') # the district's area
ok_re(nm_02, 'href=".*/us/nm"')
# JSON
(district,) = json('/us/nm-02')
# I hope these are right. I just copied them from the current
# output --- this is a problem with doing unit tests after the
# fact. I omitted floating-point numbers (poverty_pct,
# center_lat, center_lng) and the outline.
ok_items(district, dict(
almanac = 'http://nationaljournal.com/pubs/almanac/2008/people/nm/rep_nm02.htm',
area_sqmi = 69598,
cook_index = 'R+6',
est_population = 625204,
est_population_year = 2005,
median_income = 29269,
name = 'NM-02',
state = 'http://watchdog.net/us/nm#it',
_type = 'District',
uri = 'http://watchdog.net/us/nm-02#it',
wikipedia = "http://en.wikipedia.org/wiki/New_Mexico's_2nd_congressional_district",
zoom_level = 6,
voting = True,
))
async def sql_qa(request):
qargs = request.get_args(keep_blank_values=True)
question = unquote(qargs.get("q", ""))
table_idx = qargs.get("table_idx", "")
if not question or not table_idx:
return json({}, headers=cros_headers)
try:
table_idx = int(table_idx)
table_id = table_ids[table_idx]
except:
table_id = table_idx
q = {"question": question, "table_id": table_id}
# import pdb; pdb.set_trace()
try:
results = infer([q], tables)
except Exception as e:
print(e.with_traceback())
results = []
# results = [{"sql": "test", "sels": ["col1", "col2", "col3"], "data": [["0.23", "2019年", "安徽省滁州市"]]}]
if not results:
results = {}
else:
results = results[0]
return response.json(
{
"sql": results["sql"],
"sel": results["sel"],
"data": results["data"]
},
headers=cros_headers)
def GetCertList(self, get):
try:
vpath = '/www/server/panel/vhost/ssl'
if not os.path.exists(vpath): public.ExecShell("mkdir -p " + vpath)
data = []
for d in os.listdir(vpath):
mpath = vpath + '/' + d + '/info.json'
if not os.path.exists(mpath): continue
tmp = public.readFile(mpath)
if not tmp: continue
tmp1 = json.loads(tmp)
data.append(tmp1)
if not data:
lets_file = '/www/server/panel/config/letsencrypt.json'
tmp = public.readFile(ltes_file)
if not tmp:
return []
tmp = json(tmp)
for i in tmp['orders']:
data.append({
"domains": tmp['orders'][i]['domains'],
"notAfter": tmp['orders'][i]['cert_timeout'],
"save_path": tmp['orders'][i]['save_path']
})
except:
return []
class TestAudit(unittest.TestCase):
myexcel = DoExcel.DoExcel(contents.case_file, 'audit')
cases = myexcel.get_cases()
@classmethod
def setUpClass(cls):
cls.http_request = HttpRequest()
cls.config = config.ReadConfig()
@data(*cases)
def test_audit(self, case):
case.data = eval(replace(case.data))
expected = str(case.expected)
res = self.http_request.http_request(case.method, case.url, case.data).json()['code']
print(case.title)
print(case.data)
try:
self.assertEqual(res, expected)
except AssertionError as e:
self.myexcel.write_result(case.case_id + 1, res, 'FAIL')
raise e
else:
self.myexcel.write_result(case.case_id + 1, res, 'PASS')
def mine():
# We run the proof of work algorithm to get the next proof...
last_block = blockchain.last_block
proof = blockchain.proof_of_work(last_block)
# We must receive a reward for finding the proof.
# The sender is "0" to signify that this node has mined a new coin.
blockchain.new_transaction(
sender="0",
recipient=node_identifier,
amount=1,
)
# Forge the new Block by adding it to the chain
previous_hash = blockchain.hash(last_block)
block = blockchain.new_block(proof, previous_hash)
response = {
'message': "New Block Forged",
'index': block['index'],
'transactions': block['transactions'],
'proof': block['proof'],
'previous_hash': block['previous_hash'],
}
return json(response), 200
def generate_secret():
origin = flask.request.headers.get('origin')
if origin is None or origin in allowed_origins:
resp = flask.Response(json(new_secret()))
resp.headers['Access-Control-Allow-Origin'] = origin
return resp
return ''
def get_list_book(request):
status = 200
books = Book.objects.all()
data = {
'items': 'elements sample',
'elements': [1, 2, 3, 4],
'person': {
'name': 'joel',
'age': 21
},
'el': [
{
'title': 'sample1',
'date': '2201'
},
{
'title': 'sample2',
'date': '1998'
}
],
'ha': json(books)
}
return Response(data, status=status)
def predict_prophet(x, y, n):
print('prophet预测算法')
futureday = n
print(x)
print(y)
print(n)
df = pd.DataFrame()
df['ds'] = [
'2020-01-01', '2020-01-02', '2020-01-03', '2020-01-04', '2020-01-05',
'2020-01-06', '2020-01-07', '2020-01-08'
]
df['y'] = [100, 200, 300, 400, 500, 600, 700, 800]
# Y = np.array(y)[:-futureday]
# print(newdf)
# 设置置信区间
model = Prophet(interval_width=0.95)
train_data = (df.loc[:, :, ])
model.fit(train_data)
# 数据预测，periods表示预测点数，freq表示预测频率
future = model.make_future_dataframe(periods=futureday, freq='D') # 预测未来
forecast = model.predict(future)
print(forecast['trend'])
return json(forecast['trend'])
async def get(self, get_request):
try:
print("Hey nice to have you here")
# print(some_random_param)
return json(self.response({'status': "Success"}))
except Exception:
return self.return_unexpected_error()
def settings_js(context):
'''Returns a safe json dictionary of the vars in settings.SETTINGS_JS'''
ret = {}
from django.conf import settings
for var_name in settings.SETTINGS_JS:
ret[var_name] = getattr(settings, var_name, None)
return json(ret)
def stream(self, until=False):
begin = perf_counter()
self.send({"msg_id": 259, "token": self.__token, "param": "none_force"})
while True:
if until and (until < perf_counter() - begin):
break
sleep(REST)
return json(self.__control.recv(512).decode("utf-8"))
def return_events_guardian (request):
if request.method != 'GET':
return json('not a GET request')
person = get_person_from_request(request)
if not person:
return logout_view(request)
players = Player.objects.all()
children = []
for player in players:
if not player.guardians:
continue
for guardian in player.guardians.all():
if person.username == guardian.username:
children.append(player)
event_players = []
for child in children:
event_players += Event_Player.objects.filter(player=child).exclude(answer=5)
now = datetime.datetime.now()
event_list = []
for event_player in event_players:
event_datetime = event_player.event.meetup_datetime.replace(tzinfo=None)
delta = now - event_datetime
if delta.days > 7 or now > event_datetime:
continue
event_data = {
'id': event_player.event.id,
'title' : event_player.event.title,
'date':datetimeformat(event_player.event.start_datetime)['date'],
'startTime':datetimeformat(event_player.event.start_datetime)['time'],
'meetupTime': datetimeformat(event_player.event.meetup_datetime)['time'],
'nrOfAttendees': return_nr_ofAttendees_local(event_player.event.id),
'nfOfNotAttendees': return_nr_of_notAttendees_local(event_player.event.id),
'dateTime': datetimeformat(event_player.event.start_datetime),
'sent': is_sent(event_player.event),
'urlHash': event_player.url_hash,
'playerName': event_player.player.person.first_name + ' ' + event_player.player.person.last_name,
'playerAnswerInt': event_player.answer,
'playerAnswer': answer_to_string(event_player.answer),
}
event_list.append(event_data)
sorted_events_list = sorted(event_list, key=lambda item:item['dateTime'])
json_data = json.dumps(sorted_events_list)
return HttpResponse(json_data, content_type="application/json")
def build_from_apis_data(cls, **kw):
for p in ['t_tank_id']:
assert p in kw, '*{}* - required parameter missing.'.format(p)
params = {'files': {}}
t_summary = {}
if kw.get('luna_id'):
try:
l_test_id=kw.get('luna_id')).json().pop()
t_summary.update(kw)
if t_summary.get('jira_task'):
t_summary['issue'] = t_summary['jira_task'].lower()
try:
cfg_str = cls.tank_c.get_generator_cfg(fqdn=t_summary['tank_fqdn'],
t_test_id=t_summary.get('t_tank_id'))
except TankClientError as e:
raise ValueError('Tank API call failed: {}'.format(e))
assert cfg_str, 'Can\'t fetch load.cfg from tank.'
params['generator_cfg'] = cls.parse_generator_cfg(cfg_str,
plain_cfg=True)
def postcomment(request, cid):
if not request.user.is_authenticated():
return json({'status': 'error', 'error': ['LOGIN', 'User not logged in']}, status=403)
if request.method != 'POST':
return json({'status': 'error', 'error': ['NOTPOST', 'Not a POST request']}, status=405)
if cid == 'new':
url = filterurl(request.POST.get('url'))
if not url:
return json({'status': 'error', 'error': ['NOURL', 'No URL given']}, status=400)
conv = Conversation(founder=request.user, page=url)
conv.save()
else:
conv = get_object_or_404(Conversation, id=int(cid))
text = request.POST['content']
com = Comment(conversation=conv, user=request.user, text=text)
com.save()
if cid == 'new':
conv.clean_topic() #Awful hack
conv.save()
return json({'status': 'ok', 'cid': conv.id})
def return_user_instance_or_anonymous(thing):
if type(thing) == type(dict()):
user_dict = thing
user_instance = convert_user_dict_to_user_instance(user_dict)
elif type(thing) == type(json()):
user_dict = json.loads(thing)
user_instance = convert_user_dict_to_user_instance(user_dict)
elif type(thing) == type(models.User()):
user_instance = thing
if isinstance(user_instance, models.User):
return user_instance
else:
return AnonymousUserMixin()
def _do_get_tasks(self, job):
"""
获取执行详细信息
"""
from uliweb import json
Task = functions.get_model('async_tasks')
tasks = []
def get_obj(t):
from uliweb.utils.timesince import timesince
status_text = Task.status.get_display_value(t.status)
d = {'id':t.task_id,
'label':t.title,
'title':'<br/>'.join([
'任务 ID :{}'.format(t.task_id),
'开始时间:{}'.format(t.started_time),
'结束时间:{}'.format(t.finished_time),
'执行状态:{}'.format(status_text),
'执行命令:{}'.format(t.command_name),
'执行参数:{!r}'.format(t.command_info.get('parameters', ''))
]),
'depend_tasks':t.depend_tasks,
'parent_task':t._parent_task_,
'status':t.status,
'children_count':t.children_count,
'status_text':status_text,
'started_time':t.started_time,
'finished_time':t.finished_time,
}
if t.status == 'E':
d['label'] += u'({}/{})'.format(t.retry_times, timesince(t.startup_time))
elif t.status == '1': #成功
d['label'] += u'(用时:{}s)'.format((t.finished_time-t.started_time).seconds)
return d
def iter_objs(job):
for t in job.tasks.all():
tasks.append(get_obj(t))
iter_objs(t)
tasks.append(get_obj(job))
iter_objs(job)
return json({'tasks':tasks})
def return_events_player (request):
if request.method != 'GET':
return json('not a GET request')
person = get_person_from_request(request)
if not person:
return logout_view(request)
player_list = Player.objects.filter(person=person)
event_players = []
for player in player_list:
event_players += Event_Player.objects.filter(player=player).exclude(answer=5)
player_events = []
now = datetime.datetime.now()
for event_player in event_players:
event_datetime = event_player.event.meetup_datetime.replace(tzinfo=None)
delta = now - event_datetime
if delta.days > 7 or now > event_datetime:
continue
event_player_data = {
'id': event_player.event.id,
'title' : event_player.event.title,
'date':datetimeformat(event_player.event.start_datetime)['date'],
'startTime':datetimeformat(event_player.event.start_datetime)['time'],
'meetupTime': datetimeformat(event_player.event.meetup_datetime)['time'],
'nrOfAttendees': return_nr_ofAttendees_local(event_player.event.id),
'nfOfNotAttendees': return_nr_of_notAttendees_local(event_player.event.id),
'dateTime': datetimeformat(event_player.event.start_datetime),
'sent': is_sent(event_player.event),
'answerInt': event_player.answer,
'answer': answer_to_string(event_player.answer),
}
player_events.append(event_player_data)
player_events = sorted(player_events, key=lambda item:item['dateTime'])
json_data = json.dumps(player_events)
return HttpResponse(json_data, content_type="application/json")
def tojson(range):
delimiter = get_delimiter(range[0])
reader = csv.reader(range, delimiter=delimiter)
result = []
result.append("[")
header = ""
key = ""
for i, row in enumerate(reader):
if i == 0:
header = row
key = row[0].strip()
continue
result.append(" {" + json(header, row) + "},")
result[len(result) - 1] = result[len(result) - 1].strip(",")
result.append("]")
return result
def cancel_purchase():
pending_transaction = models.PendingTransaction.query.filter(
models.PendingTransaction.barcode ==
flask.request.json['barcode'])
# Check if this barcode actually exists
if pending_transaction.count() < 1:
return json({ 'error': 'Unknown barcode.' })
else:
pending_transaction = pending_transaction.first()
vendor = models.Vendor.query.filter(models.Vendor.id ==
pending_transaction.company)
data['secret'] = vendor.secret
data['barcode'] = flask.request.json['barcode']
url = vendor.agent_url + '/cancel'
headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
r = requests.post(url, data=json.dumps(data), headers=headers)
def export_gzipNexSON():
'Exports the otus and trees in the study specified by the argument as gzipped JSON NeXML'
studyid = request.args(0)
if (db.study(studyid) is None):
raise HTTP(404)
else:
from gluon.serializers import json
import cStringIO
stream = cStringIO.StringIO()
jsondict = nexson.nexmlStudy(studyid,db)
jsonText = json(jsondict)
zipfilename = "study%s.json.gz" % studyid
gzfile = gzip.GzipFile(filename=zipfilename, mode="wb", fileobj=stream)
gzfile.write(jsonText)
gzfile.write("\n")
gzfile.close()
response.headers['Content-Type'] = "application/gzip"
response.headers['Content-Disposition'] = "attachment;filename=%s"%zipfilename
return stream.getvalue()
return
def validate(request):
if request.method == 'GET':
return HttpResponse(json.dumps({'ret':False,'msg':'只支持POST请求'}))
else:
post = request.POST
if post['type'] == 'mobile':
mobile = post['mobile']
users = User.objects.filter(mobile = mobile)
if users.count()<=0:
return HttpResponse(json.dumps({'ret':True,'msg':'正确的手机号'}))
else:
return HttpResponse(json.dumps({'ret':False,'msg':'已注册的手机号'}))
elif post['type'] == 'verifycode':
mobile,code= post['mobile'],post['code']
pattern = '^[0-9]{6}$'
if not re.match(pattern,code):
return HttpResponse(json.dumps({'ret':False, 'msg':'验证码为六位数字'}))
codes = VerifyCode.objects.filter(mobile=mobile,code=code,flag=0)
if codes.count()<=0:
return HttpResponse(json.dumps({'ret':False,'msg':'错误的验证码'}))
else:
time_delta = datetime.datetime.now()-codes[0].created
if time_delta>datetime.timedelta(minutes=5):
return HttpResponse(json.dumps({'ret':False,'msg':'过期的验证码'}))
else:
return HttpResponse(json.dumps({'ret':True, 'msg':'正确的验证码'}))
elif post['type'] == 'password':
mobile,pwd = post['mobile'], post['password']
users = User.objects.filter(mobile=mobile)
if users.count()<=0:
return HttpResponse(json({'ret':True,'msg':'错误的手机号'}))
else:
user = users[0]
if user.check_password(pwd):
return HttpResponse(json.dumps({'ret':True,'msg':'原密码'}))
else:
return HttpResponse(json.dumps({'ret':False,'msg':'非原密码'}))
else:
return HttpResponse(json.dumps({'ret':False,'msg':'不正确的验证类型'}))
def polling_check_scan():
pending_transaction = models.PendingTransaction.query.filter(
models.PendingTransaction.barcode ==
flask.request.json['barcode'])
# Check if this barcode actually exists
if pending_transaction.count() < 1:
return json({ 'error': 'Unknown barcode.' })
else:
pending_transaction = pending_transaction.first()
if pending_transaction.status != 0:
company_name = models.Vendor.query.filter(models.Vendor.id ==
pending_transaction.company).first().name
else:
company_name = None
return json.dumps({
'status': pending_transaction.status,
'amount': pending_transaction.amount,
'company': company_name
})
def on_status(self, status):
tags = []
for hashtag in status.entities['hashtags']:
tags.append(hashtag['text'])
tweet = json(status);
collection.insert({'tweet':tweet})
self.counter += 1
if self.counter < 20000000:
with open(self.fname, 'a') as f:
json.dump(str(tweet), f)
f.write(os.linesep)
else:
self.fname = self.fprefix + '.' + time.strftime('%Y%m%d-%H%M%S') + '.json'
with open(self.fname, 'a') as f:
json.dump(str(tweet), f)
f.write(os.linesep)
self.counter = 0
return True
def test_find():
"Test /us/."
headers = {'Accept': 'text/html'}
ok(webapp.app.request('/', headers=headers).status[:3], '200')
# A ZIP code within a single congressional district.
resp = webapp.app.request('/us/?zip=94070', headers=headers)
ok(resp.status[:3], '303')
ok(resp.headers.get('Location'), 'http://0.0.0.0:8080/us/ca-12')
# A ZIP code in Indiana that crosses three districts.
in_zip = html('/us/?zip=46131')
ok_re(in_zip, '/us/in-04')
ok_re(in_zip, 'Stephen Buyer') # rep for IN-04 at the moment
ok_re(in_zip, '/us/in-05')
ok_re(in_zip, '/us/in-06')
assert '/us/in-07' not in in_zip, in_zip
# Test for LEFT OUTER JOIN: district row with no corresponding politician row.
ok_re(html('/us/?zip=70072'), '/us/la-01') # no rep at the moment
# Test for /us/ listing of all the districts and reps.
# Takes 9-12 seconds on my machine, I think because it's
# retrieving the district outline data from MySQL. Takes nearly
# 1s on watchdog.net.
reqtime, resp = time_thunk(lambda: webapp.app.request('/us/',
headers=headers))
print "took %.3f sec to get /us/" % reqtime
ok(resp.status[:3], '200')
ok_re(resp.data, '/us/in-04')
ok_re(resp.data, 'Stephen Buyer')
ok_re(resp.data, '/us/la-01') # LEFT OUTER JOIN test
assert '(Rep. )' not in resp.data
# JSON of /us/ --- very minimal test
index = json('/us/index')
ok(len(index), len(list(webapp.db.select('district'))))
def get_sentiment(self, message):
text = TextBlob(message)
response = {'polarity': text.polarity, 'subjectivity': text.subjectivity}
return json(response)
__author__ = 'Faz'
import key
import requests
import json
"""
API GET CALLS:
http://api.steampowered.com/<interface name>/<method name>/v<version>/?key=<api key>&format=<format>.
<format>:
json (DEFAULT) - The output will be returned in the JSON format
xml - Output is returned as an XML document
vdf - Output is returned as a VDF file.
My Profile:
http://steamcommunity.com/id/thisisfaz/
my steamid : 76561198066178099, 76561198066178099
USEFUL:
http://store.steampowered.com/api/appdetails/?appids=730
"""
# Global Variables
BASE_URL = 'https://api.steampowered.com/'
API_KEY = key.API_PRIVATE_KEY
INTERFACE_DICT = {'user_stats' : 'ISteamUser',
'app_stats' : 'ISteamUserStats',
'news_stats' : 'ISteamNews',}
def json(self):
data = dict()
data["type"] = self.typ
return json(data)
def addCardToIndex(information):
cards = getCard(information["name"])
doc = { "content": str(information), "title": information["name"], "reference": information["name"] }
result = cardIndex.addDoc(doc, async=True).json()
return result
return self.__url_json
if __name__ == '__main__':
client = pysvn.Client()
ur = URL('http://sourceforge.net/directory/language:cpp')
#n_projetos_desejados = raw_input('Quantos projetos deseja fazer o download?')
n_projetos_desejados = 1
n_paginas = ur.extrai_n_paginas()
n_paginas = n_paginas + 1
page = 1
i = 0
while (i < n_projetos_desejados and page < n_paginas + 1):
j = 0
url = 'http://sourceforge.net/directory/language:cpp/?page='+ str(page)
projetos = URL(url)
nome_projetos = projetos.extrai_nome_projetos()
while j < len(nome_projetos) and i < n_projetos_desejados:
svn = SVN(json(nome_projetos[j]).getUrl()).extrair_end_svn()
if (svn != None):
print 'Baixando o projeto: ' + nome_projetos[j]
print 'Endereço SVN: ' + svn
client.checkout(svn,'./projects/' + nome_projetos[j])
i = i + 1
j = j + 1
page = page + 1
import json
from elasticsearch import Elasticsearch
es = Elasticsearch()
# by default we connect to localhost:9200
# from elasticsearch import E1
# create an index in elasticsearch, ignore status code 400 (index already exists)
es.indices.create(index='my-index', ignore=400)
{u'acknowledged': True}
resp = E1.search(index="mynewcontacts", body={"query": {"match_all": {}}})
response = json.dumps(resp)
data = json(load)
#print data["hits"]["hits"][0]["_source"]["email"]
for row in data['hits']['hits']:
print row["hits"]["hits"][0]["_source"]["email"]
return "OK"
PUT my_index/my_type/1
{
"text": "Geo-point as an object",
"location": {
"lat": 41.12,
"lon": -71.34
}
}
def speakers(self):
from person import data
return json(data)
