def post(self, uri, payload=None, etag=None,
content_type="application/json", accept="application/json"):
headers = {'content-type': content_type,
'accept': accept}
if etag is not None:
headers['if-match'] = etag
self.logger.debug("POST {0}...".format(uri))
self.payload_logger.debug("Headers:")
self.payload_logger.debug(json.dumps(headers, indent=2))
if payload != None:
self.payload_logger.debug("Payload:")
if content_type == 'application/json':
self.payload_logger.debug(json.dumps(payload, indent=2))
else:
self.payload_logger.debug(payload)
if payload is None:
self.response = requests.post(uri, auth=self.auth, headers=headers)
else:
if content_type == "application/json":
self.response = requests.post(uri, json=payload,
auth=self.auth, headers=headers)
else:
self.response = requests.post(uri, data=payload,
auth=self.auth, headers=headers)
return self._response()
def deferred_add_user_to_album(album_url, user_id, response_url=None):
response = {
'attachments': build_my_list_attachment(),
'replace_original': False,
'response_type': 'ephemeral',
'text': 'Added album to your list.',
}
try:
album = albums_model.get_album_details_by_url(album_url)
if album:
albums_model.add_user_to_album(album.album_id, user_id)
else:
deferred_consume.delay(
album_url,
bandcamp.scrape_bandcamp_album_ids_from_url_forced,
list_model.add_to_list,
response_url=response_url,
)
deferred_add_user_to_album.delay(album_url, user_id, response_url=response_url)
return
flask.current_app.cache.delete(f'u-{user_id}')
except DatabaseError as e:
response['text'] = 'Failed to add album to your list.'
print(f'[db]: failed to add user to album')
print(f'[db]: {e}')
else:
print(f'[db]: added user to album')
if response_url:
requests.post(response_url, data=json.dumps(response))
def process_action(request, server_id):
if not request.POST:
return HttpResponseNotAllowed(['POST'])
action = request.POST['action']
process_name = request.POST['process']
server = Server.objects.get(id=server_id)
process = server.process_set.get(name=process_name)
ip_address = server.address
time_out = 15
try:
# would only work for this server
# subprocess.call(["monit", action, process_name])
monit_url = 'http://%s:%s@%s:%s/%s' % (monit_user, monit_password, ip_address, monit_port, process_name)
requests.post(monit_url, {'action': action}, timeout=time_out)
action_labels = {'start': 'starting...', 'stop': 'stopping...', 'restart': 'restarting...', 'unmonitor': 'disable monitoring...', 'monitor': 'enable monitoring...'}
if action in action_labels:
process.status = action_labels.get(action)
if action == 'unmonitor':
process.monitor = 0
elif action == 'monitor':
process.monitor = 2
process.save()
return redirect(reverse('monitcollector.views.process', kwargs={'server_id': server.id, 'process_name': process_name}))
except:
return render(request, 'monitcollector/error.html', {'time_out': time_out, 'monit_user': monit_user, 'ip_address': ip_address, 'monit_port': monit_port, 'process_name': process_name})
def worker(self):
if not ENDPOINT:
return
while True:
datapack = {'sensors': {}}
for sensor in Sensor.get_all():
data = {}
for variant in sensor.get_variants():
data[variant] = sensor.value(variant)
datapack['sensors'][sensor.id] = data
gevent.sleep(3)
url = ENDPOINT % ajenti.config.tree.installation_id
if not self.get_key():
continue
try:
requests.post(url, data={
'data': json.dumps(datapack),
'key': self.get_key()
})
self.last_report = datetime.now()
self.last_error = None
except Exception, e:
self.last_error = e
def test_api_fire_event_with_invalid_json(self):
"""Test if the API allows us to fire an event."""
test_value = []
def listener(event):
"""Helper method that will verify our event got called."""
test_value.append(1)
hass.bus.listen_once("test_event_bad_data", listener)
req = requests.post(
_url(const.URL_API_EVENTS_EVENT.format("test_event_bad_data")),
data=json.dumps('not an object'),
headers=HA_HEADERS)
hass.pool.block_till_done()
self.assertEqual(400, req.status_code)
self.assertEqual(0, len(test_value))
# Try now with valid but unusable JSON
req = requests.post(
_url(const.URL_API_EVENTS_EVENT.format("test_event_bad_data")),
data=json.dumps([1, 2, 3]),
headers=HA_HEADERS)
hass.pool.block_till_done()
self.assertEqual(400, req.status_code)
self.assertEqual(0, len(test_value))
def setup_oauth(self):
# Request token
oauth = OAuth1(CONSUMER_KEY, client_secret=CONSUMER_SECRET)
r = requests.post(url=REQUEST_TOKEN_URL, auth=oauth)
credentials = parse_qs(r.content)
resource_owner_key = credentials.get('oauth_token')[0]
resource_owner_secret = credentials.get('oauth_token_secret')[0]
# Authorize
authorize_url = AUTHORIZE_URL + resource_owner_key
print 'Please go here and authorize: ' + authorize_url
verifier = raw_input('Please input the verifier: ')
oauth = OAuth1(CONSUMER_KEY,
client_secret=CONSUMER_SECRET,
resource_owner_key=resource_owner_key,
resource_owner_secret=resource_owner_secret,
verifier=verifier)
# Finally, Obtain the Access Token
r = requests.post(url=ACCESS_TOKEN_URL, auth=oauth)
credentials = parse_qs(r.content)
token = credentials.get('oauth_token')[0]
secret = credentials.get('oauth_token_secret')[0]
return token, secret
def test_Anrufer_sperren_in_web():
u = inte_testutils.TestUtil()
u.unblock_callerid(TelephoneNumber('0790000003'))
assert not u.is_blocked_callerid(TelephoneNumber('0790000003'))
requests.post('http://localhost/block_caller', data={'telephone_number': '0790000003'})
assert u.is_blocked_callerid(TelephoneNumber('0790000003'))
def get_access_keys():
#Request Token
app_oauth = OAuth1(keys.CONSUMER_KEY, client_secret = keys.CONSUMER_SECRET)
authorize_data = requests.post(url = REQUEST_TOKEN_URL, auth = app_oauth)
authorize_credentials = parse_qs(authorize_data.content);
authorize_key = authorize_credentials.get('oauth_token')[0]
authorize_secret = authorize_credentials.get('oauth_token_secret')[0]
#Authorize Token
authorization_url = AUTHORIZE_BASE_URL + authorize_key
print 'Authorize this application at: ' + authorization_url
verify_pin = raw_input('Enter your verification pin: ')
#Obtain Access Token
access_token = OAuth1(keys.CONSUMER_KEY,
client_secret = keys.CONSUMER_SECRET,
resource_owner_key = authorize_key,
resource_owner_secret = authorize_secret,
verifier = verify_pin)
access_data = requests.post(url = ACCESS_TOKEN_URL, auth = access_token)
print access_data
#Need to add error code handling
if access_data.status_code == 200:
access_credentials = parse_qs(access_data.content)
access_token = access_credentials.get('oauth_token')[0]
access_secret = access_credentials.get('oauth_token_secret')[0]
print 'Add the following to plat/apikeys/twitter_keys.py:'
print "ACCESS_KEY = '" + access_token + "'"
print "ACCESS_SECRET = '" + access_secret + "'"
exit()
else:
print 'Some sort of error'
exit()
def merge_kitchens_improved(self, from_kitchen, to_kitchen, resolved_conflicts=None):
"""
merges kitchens
'/v2/kitchen/merge/<string:kitchenname>/<string:kitchenname>', methods=['POST']
:param resolved_conflicts:
:param self: DKCloudAPI
:param from_kitchen: string
:param to_kitchen: string
:rtype: dict
"""
rc = DKReturnCode()
if from_kitchen is None or isinstance(from_kitchen, basestring) is False:
rc.set(rc.DK_FAIL, 'issue with from kitchen')
return rc
if to_kitchen is None or isinstance(to_kitchen, basestring) is False:
rc.set(rc.DK_FAIL, 'issue with to kitchen')
return rc
url = '%s/v2/kitchen/merge/%s/%s' % (self.get_url_for_direct_rest_call(), from_kitchen, to_kitchen)
try:
if resolved_conflicts is not None and len(resolved_conflicts) > 0:
data = dict()
data['resolved_conflicts'] = resolved_conflicts
response = requests.post(url, data=json.dumps(data), headers=self._get_common_headers())
else:
response = requests.post(url, headers=self._get_common_headers())
rdict = self._get_json(response)
except (RequestException, ValueError, TypeError), c:
rc.set("merge_kitchens: exception: %s" % str(c))
return rc
def test_06_create_transaction_1(self):
# Create transaction
params = {'value': 1100}
r = requests.post(''.join((URL + ('user', '/', self.user, '/', 'transaction', '/'))),
headers=HEADERS,
data=json.dumps(params))
now = datetime.datetime.utcnow()
self.assertEqual(201, r.status_code)
self.assertEqual('application/json', r.headers['Content-Type'])
result = json.loads(r.text)
self.assertTrue({'id', 'user', 'create_date', 'value'}.issubset(result), msg=str(result))
self.assertEqual(self.user, str(result['user']))
self.assertEqual(1100, result['value'])
# TODO This assumes Z timezone a.k.a. UTC. Should be handled and parsed properly
create_date = datetime.datetime.strptime(result['create_date'], '%Y-%m-%dT%H:%M:%S.%fZ')
self.assertGreater(20, (now - create_date).total_seconds())
params = {'value': 1201}
r = requests.post(''.join((URL + ('user', '/', self.user, '/', 'transaction', '/'))),
headers=HEADERS,
data=json.dumps(params))
now = datetime.datetime.utcnow()
self.assertEqual(201, r.status_code)
self.assertEqual('application/json', r.headers['Content-Type'])
result = json.loads(r.text)
self.assertTrue({'id', 'user', 'create_date', 'value'}.issubset(result), msg=str(result))
self.assertEqual(self.user, str(result['user']))
self.assertEqual(1201, result['value'])
# TODO This assumes Z timezone a.k.a. UTC. Should be handled and parsed properly
create_date = datetime.datetime.strptime(result['create_date'], '%Y-%m-%dT%H:%M:%S.%fZ')
self.assertGreater(20, (now - create_date).total_seconds())
self.assert_user(self.user, (1100, 1201))
def csv_upload(self, filename, operation):
# create the request url for init.
rest_url_pre = 'https://' + self.iba_host + '/wapi/v' + self.iba_wapi_version
try:
init_url = rest_url_pre + '/fileop?_function=uploadinit'
# send request to the server to establish the object, with token and url.
r = requests.post(url=init_url, auth=(self.iba_user, self.iba_password), verify=self.iba_verify_ssl)
r_json = r.json()
# need to do escaping or we will have issues when it's sent to the requests.post
token = r_json['token'].encode('unicode-escape')
req_url = r_json['url']
files = {'file': (filename, open(filename, 'rb')) }
file_r = requests.post(url=req_url, auth=(self.iba_user, self.iba_password), verify=self.iba_verify_ssl, files=files)
# Use the token to tell the server to process the file as a csv_import
csv_url = rest_url_pre + '/fileop?_function=csv_import'
payload = '{ "token": "' + token + '", "operation": "' + operation + '" }'
requests.post(url=csv_url, auth=(self.iba_user, self.iba_password), verify=self.iba_verify_ssl, data=payload)
except ValueError:
raise Exception(r)
except Exception:
raise
def _authenticate(self, response=None, headers=None):
if self._authn_type is None:
return headers
url = "%s://%s:%s%s" % (self._authn_protocol, self._authn_server, self._authn_port,
self._authn_url)
new_headers = headers or {}
try:
if self._ksinsecure:
response = requests.post(url, data=self._authn_body,
headers=self._DEFAULT_AUTHN_HEADERS, verify=False)
elif not self._ksinsecure and self._use_ks_certs:
response = requests.post(url, data=self._authn_body,
headers=self._DEFAULT_AUTHN_HEADERS, verify=self._kscertbundle)
else:
response = requests.post(url, data=self._authn_body,
headers=self._DEFAULT_AUTHN_HEADERS)
except Exception as e:
errmsg = 'Unable to connect to keystone for authentication. '
errmsg += 'Exception %s' %(e)
raise RuntimeError(errmsg)
if (response.status_code == 200) or (response.status_code == 201):
# plan is to re-issue original request with new token
if 'v2' in self._authn_url:
authn_content = json.loads(response.text)
self._auth_token = authn_content['access']['token']['id']
else:
self._auth_token = response.headers['x-subject-token']
new_headers['X-AUTH-TOKEN'] = self._auth_token
return new_headers
else:
raise RuntimeError('Authentication Failure')
def post_to_slack(self, file_name, file_content, bot_callback=None, title=None):
slack = getSecrets('slack')
data = {
'token' : slack['api_token'],
'title' : "i deepdreamed..." if title is None else title,
'channels' : slack['channel_id']
}
try:
r = requests.post("https://slack.com/api/files.upload", data=data, files={ 'file' : file_content})
res = json.loads(r.content)
if not res['ok']:
return False
if bot_callback is not None:
r = requests.post(slack['webhook_url'], data={'payload' : json.dumps({ 'text' : bot_callback })})
print r.content
return True
except Exception as e:
print e, type(e)
return False
def bale_CRITs_indicator(base_url, data, indicator_que):
""" One thread of adding indicators to CRITs"""
while not indicator_que.empty():
indicator = indicator_que.get()
if indicator[1] == 'IPv4':
# using the IP API
url = base_url + 'ips/'
data['add_indicator'] = "true"
data['ip'] = indicator[0]
data['ip_type'] = 'Address - ipv4-addr'
data['reference'] = indicator[3]
# getting the source automatically:
source = re.findall(r'\/\/(.*?)\/', data['reference'])
if source:
data['source'] = source[0]
res = requests.post(url, data=data, verify=False)
if not res.status_code in [201, 200, 400]:
logger.info("Issues with adding: %s" % data['ip'])
elif indicator[1] == "FQDN":
# using the Domain API
url = base_url + 'domains/'
data['add_indicator'] = "true"
data['domain'] = indicator[0]
data['reference'] = indicator[3]
# getting the source automatically:
source = re.findall(r'\/\/(.*?)\/', data['reference'])
if source:
data['source'] = source[0]
res = requests.post(url, data=data, verify=False)
if not res.status_code in [201, 200, 400]:
logger.info("Issues with adding: %s" % data['domain'])
else:
logger.info("don't yet know what to do with: %s[%s]" % (indicator[1], indicator[0]))
def upload(self, path):
"""
Uploads a file to the current folder. Takes a file location as an
argument, either relative or absolute. If a file of the same name is
already in the current folder, a new version is uploaded.
Returns True if file upload is successful, False otherwise.
"""
parent_id = self.current_folder.get('id')
item_id = None
filename = path.split('/')[-1]
for entry in self.current_folder.get('item_collection').get('entries'):
if (entry.get('name') == filename and entry.get('type') == 'file'):
item_id = entry.get('id')
break
if (item_id == None):
f = requests.post('https://upload.box.com/api/2.0/files/content',
headers = { 'Authorization': 'Bearer ' + self.token },
data = { 'filename': filename, 'parent_id':parent_id },
files = { filename: open(path, 'rb')})
else:
f = requests.post('https://upload.box.com/api/2.0/files/' +
item_id + '/content', headers = { 'Authorization': 'Bearer ' +
self.token }, data = { 'filename': filename }, files = {
filename: open(path, 'rb')})
if (f.status_code == 409):
print "File upload caused a conflict"
return False
elif (f.status_code != 201):
print "Problem uploading the file"
return False
else:
print "File uploaded"
return True
def addtrade(request):
"""
API interface: Request handler for adding a new trade to :model:`hw1.Trades`.
Required parameters:
1. First name of the trader
2. Last name of the trader
3. Company the trader belongs to
"""
date_time=time.strftime('%Y-%m-%d %H:%M:%S')
product=request.POST.get('product', False)
month=request.POST.get('month', False)
year=request.POST.get('year', False)
lots=request.POST.get('lots', False)
price=request.POST.get('price', False)
sign=''
if request.POST.get('sign', False) == 'Buy':
sign=1
else:
sign=-1
trader= Clients.objects.get(id=request.POST.get('trader', False))
side = request.POST.get('sign', False).lower();
type = request.POST.get('type', False)
post_data = {'type': type, 'side': side, 'symbol': product, 'price': price, 'lots' : lots}
new = Trades(status = 0, time = date_time, product_code = product, month_code = month, year = year, lots = lots, price = price, buy_or_sell = sign, trader = trader)
id = Trades.objects.latest('id')
post_data = {'id': id, 'type': type, 'side': side, 'symbol': product, 'price': price, 'lots' : lots}
requests.post('localhost:8080/fix/process-order', data=post_data)
new.save()
return HttpResponseRedirect('/hw1/?success=true')
def getTrackIDs(performer):
r = requests.post('http://muzis.ru/api/search.api', data = {'q_performer':performer})
artId = json.loads(r.text)["performers"][0]["id"]
r = requests.post('http://muzis.ru/api/get_songs_by_performer.api', data = {'performer_id':artId,'type':'3'})
listOfSongs = json.loads(r.text)['songs']
#a = [x["file_mp3"] for x in listOfSongs]
return(listOfSongs[:5])
def worker(worker_info, password, remote):
global ALIVE
payload = {
'worker_info': worker_info,
'password': password,
}
try:
req = requests.post(remote + '/api/request_version', data=json.dumps(payload), headers={'Content-type': 'application/json'}, timeout=HTTP_TIMEOUT)
req = json.loads(req.text)
if 'version' not in req:
print 'Incorrect username/password'
time.sleep(5)
sys.exit(1)
if req['version'] > WORKER_VERSION:
print 'Updating worker version to %d' % (req['version'])
#update()
req = requests.post(remote + '/api/request_task', data=json.dumps(payload), headers={'Content-type': 'application/json'}, timeout=HTTP_TIMEOUT)
req = json.loads(req.text)
except:
sys.stderr.write('Exception accessing host:\n')
traceback.print_exc()
time.sleep(10)
return
if 'error' in req:
raise Exception('Error from remote: %s' % (req['error']))
# No tasks ready for us yet, just wait...
if 'task_waiting' in req:
print 'No tasks available at this time, waiting...'
time.sleep(10)
return
success = True
run, task_id = req['run'], req['task_id']
try:
run_games(worker_info, password, remote, run, task_id)
except:
sys.stderr.write('\nException running games:\n')
traceback.print_exc()
success = False
finally:
payload = {
'username': worker_info['username'],
'password': password,
'run_id': str(run['_id']),
'task_id': task_id
}
try:
requests.post(remote + '/api/failed_task', data=json.dumps(payload), headers={'Content-type': 'application/json'}, timeout=HTTP_TIMEOUT)
except:
pass
sys.stderr.write('Task exited\n')
return success
def db_write(db_uri, measurement, value, timestamp):
try:
payload = "%s value=%s %d" % (measurement, value, timestamp)
requests.post(db_uri, data=payload)
except requests.exceptions.ConnectionError:
sys.stderr.write("error: Connection to local influxdb failed\n")
sys.exit(5)
def send_message(data=None):
"""function for sending sms.
validates if user is valid > sends message > redirects to source path
Assumes URL of the form /smsapi?number=12341234&message=message&source=/url
"""
number = request.args.get('number')
message = request.args.get('message')
source = request.args.get('source', '/')
anonymous = request.args.get('anonymous')
if message is not None:
if len(message) > 141:
abort(400)
if number is None:
abort(400)
if(anonymous==None):
logMessage(number,message)
if Production:
requests.post(os.environ['BLOWERIO_URL'] + '/messages', data={'to': '+' + number, 'message': message})
else:
app.logger.info(str({'to': '+' + number, 'message': message}))
return redirect("."+source)
def main():
url = "http://localhost:4000/jsonrpc"
headers = {'content-type': 'application/json'}
# Example echo method
payload = {
"method": "echo",
"params": ["echome!"],
"jsonrpc": "2.0",
"id": 0,
}
response = requests.post(
url, data=json.dumps(payload), headers=headers).json()
assert response["result"] == "echome!"
assert response["jsonrpc"] == "2.0"
assert response["id"] == 0
# Example add method
payload = {
"method": "add",
"params": [1, 2],
"jsonrpc": "2.0",
"id": 1,
}
response = requests.post(
url, data=json.dumps(payload), headers=headers).json()
assert response["result"] == 3
assert response["jsonrpc"] == "2.0"
assert response["id"] == 1
# Example foobar method
payload = {
"method": "foobar",
"params": {"foo": "json", "bar": "-rpc"},
"jsonrpc": "2.0",
"id": 3,
}
response = requests.post(
url, data=json.dumps(payload), headers=headers).json()
assert response["result"] == "json-rpc"
assert response["jsonrpc"] == "2.0"
assert response["id"] == 3
# Example exception
payload = {
"method": "add",
"params": [0],
"jsonrpc": "2.0",
"id": 4,
}
response = requests.post(
url, data=json.dumps(payload), headers=headers).json()
assert response["error"]["message"] == "Invalid params"
assert response["error"]["code"] == -32602
assert response["jsonrpc"] == "2.0"
assert response["id"] == 4
def send_data(self, eventdata, spooledevent=False):
# only send if there is data to be sent
success = None
if eventdata:
tries = 0
r = None
# If at first you don't succeed, try again. And again, and again, and again, and again.
# Server must return 200 OK or we will assume the delivery failed.
# while tries <= 5:
try:
headers = {'User-Agent': self.useragent,
'Content-Type': 'application/json'}
url = self.send_to
if self.key:
r = requests.post(url, headers=headers, data=json.dumps(eventdata),
verify=self.verify, cert=(self.cert, self.key))
elif url.startswith('https'):
r = requests.post(url, headers=headers, data=json.dumps(eventdata), verify=self.verify)
else:
r = requests.post(url, headers=headers, data=json.dumps(eventdata))
success = r.status_code
if not r.status_code == 200:
if not spooledevent:
spooler.spool_data(json.dumps(eventdata))
errorstr = "Warning: server unable to accept events. Spooling events to file."
print >> sys.stderr, errorstr
else:
self.write_last_event(eventdata)
except ConnectionError as e:
if not spooledevent:
spooler.spool_data(json.dumps(eventdata))
errorstr = "Warning: could not reach {}.".format(self.send_to)
print >> sys.stderr, errorstr
return success
def test_diff(self):
r = requests.post(self.url("/test_diff?edit"), data={
"body": "# test diff\n\n"
})
self.assertGreaterEqual(r.status_code, 200)
self.assertLess(r.status_code, 300)
r = requests.post(self.url("/test_diff?edit"), data={
"body": "# test diff\n\nadd an newline here \n"
})
self.assertGreaterEqual(r.status_code, 200)
self.assertLess(r.status_code, 300)
r = requests.get(self.url("/test_diff?history"))
self.assertRegexpMatches(r.text, r'<a href="\?version=[0-9a-f]{40}">')
version_re = re.compile(r'<a href="\?version=([0-9a-f]{40})">')
versions = version_re.findall(r.text)
self.assertEqual(len(versions), 2)
r = requests.get(self.url("/test_diff?diff=%s,%s" % (versions[0], versions[1])))
self.assertGreaterEqual(r.status_code, 200)
self.assertLess(r.status_code, 300)
self.assertIn(r'Diff for file from %s to %s' % (versions[0], versions[1]), r.text)
r = requests.get(self.url("/test_diff?diff=%s,%s" % (versions[0][:13], versions[1][:13])))
self.assertGreaterEqual(r.status_code, 200)
self.assertLess(r.status_code, 300)
self.assertIn(r'Diff for file from %s to %s' % (versions[0][:13], versions[1][:13]), r.text)
r = requests.get(self.url("/test_diff?diff=%syyyy,xxxx%s" % (versions[0][:13], versions[1][:13])))
self.assertGreaterEqual(r.status_code, 400)
self.assertLess(r.status_code, 500)
def send_mail(self, request):
fn = self.cleaned_data['firstname']
ln = self.cleaned_data['lastname']
subj = self.cleaned_data['subject']
fr = self.cleaned_data['email']
msg = self.cleaned_data['message']
try:
requests.post(
"https://api.mailgun.net/v2/neumerance.mailgun.org/messages",
auth= ("api", "key-85jxyi84br32xu0cizfihmmbbxv576j5"),
data={
"from":fr,
"to": ["*****@*****.**",],
"subject": subj,
"text": msg
}
)
messages.info(request,
"Thank you for sending me your feedback, I will get back to you as soon as possible.",
extra_tags="success"
)
except:
messages.info(request,
"Unable to send your message at this time, Please try again later.",
extra_tags="error"
)
def test_save_option(self):
data = {"Title": "title", "Toc": "false", "HeadingNumber": "i.a.a.i"}
# dir does not exists
r = requests.post(self.url("test") + "/test_dir_not_exists?option", data=json.dumps(data))
self.assertEqual(r.status_code, 400)
self.assertEqual(json.loads(r.content), {"code": 1})
# missing Title field
r = requests.post(self.url("test.md") + "?option", data=json.dumps({"Toc": "false", "HeadingNumber": "i.a.a.i"}))
self.assertEqual(r.status_code, 400)
self.assertEqual(json.loads(r.content), {"code": 1})
# Toc show be either `true` or `false`
r = requests.post(self.url("test.md") + "?option", data=json.dumps({"Title": "test", "Toc": "falsexxx", "HeadingNumber": "i.a.a.i"}))
self.assertEqual(r.status_code, 400)
self.assertEqual(json.loads(r.content), {"code": 1})
# HeadingNumber format shoule be `i.a.a.i`
r = requests.post(self.url("test.md") + "?option", data=json.dumps({"Title": "test", "Toc": "false", "HeadingNumber": "i.a.a.iiii"}))
self.assertEqual(r.status_code, 400)
self.assertEqual(json.loads(r.content), {"code": 1})
# succeeded
r = requests.post(self.url("test1xxx") + "?option", data=json.dumps({"Title": "test", "Toc": "false", "HeadingNumber": "i.a.a.i"}))
self.assertEqual(r.status_code, 200)
self.assertEqual(r.headers["Content-Type"], "application/json")
self.assertEqual(json.loads(r.content), {"code": 0})
self.assertEqual(json.loads(open(self.cwd + "/test1xxx.md.option.json", "r").read()), {"Title": "test", "Toc": "false", "HeadingNumber": "i.a.a.i", "Theme": "", "Host": ""})
def verify_signature(engine, signature, remote, payload, concurrency):
if concurrency > 1:
busy_process = subprocess.Popen([engine], stdin=subprocess.PIPE, stdout=subprocess.PIPE)
busy_process.stdin.write('setoption name Threads value %d\n' % (concurrency-1))
busy_process.stdin.write('go infinite\n')
try:
bench_sig = ''
print 'Verifying signature of %s ...' % (os.path.basename(engine))
with open(os.devnull, 'wb') as f:
p = subprocess.Popen([engine, 'bench'], stderr=subprocess.PIPE, stdout=f, universal_newlines=True)
for line in iter(p.stderr.readline,''):
if 'Nodes searched' in line:
bench_sig = line.split(': ')[1].strip()
if 'Nodes/second' in line:
bench_nps = float(line.split(': ')[1].strip())
p.wait()
if p.returncode != 0:
raise Exception('Bench exited with non-zero code %d' % (p.returncode))
if int(bench_sig) != int(signature):
requests.post(remote + '/api/stop_run', data=json.dumps(payload))
raise Exception('Wrong bench in %s Expected: %s Got: %s' % (engine, signature, bench_sig))
finally:
if concurrency > 1:
busy_process.stdin.write('quit\n')
busy_process.kill()
return bench_nps
def analyze(result_directory=None, upload=False, compute_cheapest=0, compute_average_per_day=False, compute_average_per_trip_length=False, compute_average_per_days_in_advance=False):
data, meta_data = read_results(result_directory)
result = []
result.append("Leaving from %s going to %s" % (meta_data['from'], meta_data['to']))
result.append("Size of date range: %s (days)" % meta_data['window_size'])
result.append("Minimum trip length: %s (days)" % meta_data['min_trip'])
result.append("Maximum trip length: %s (days)" % meta_data['max_trip'])
if compute_cheapest:
result.extend(get_cheapest(data, compute_cheapest))
if compute_average_per_day:
result.extend(get_average_per_day(data))
if compute_average_per_trip_length:
result.extend(get_average_per_trip_length(data))
if compute_average_per_days_in_advance:
result.extend(get_average_per_days_in_advance(data))
if upload:
upload_url = settings.DEBUG_UPLOAD_URL if settings.DEBUG else settings.UPLOAD_URL
requests.post(upload_url, data={'content': json.dumps(result)})
print "\n".join(result)
def test_file_dir_with_same_name(self):
text = u"file a content"
r = requests.post(self.url("a?edit"), data={
"body": text
})
self.assertIn(text, r.text)
self.assertIn("strapdown.min.js", r.text)
text2 = "does not matter"
r = requests.post(self.url("a/b?edit"), data={
"body": text2
})
self.assertIn(text2, r.text)
self.assertIn("strapdown.min.js", r.text)
# should be the file
r = requests.get(self.url("a"))
self.assertIn(text, r.text)
self.assertGreaterEqual(r.status_code, 200)
self.assertLess(r.status_code, 300)
# should be the directory
r = requests.get(self.url("a/"))
self.assertNotIn(text, r.text)
self.assertGreaterEqual(r.status_code, 200)
self.assertLess(r.status_code, 300)
self.assertIn('Directory Listing', r.text)
self.assertIn('b.md', r.text)
# should be file b
r = requests.get(self.url("a/b"))
self.assertIn(text2, r.text)
self.assertGreaterEqual(r.status_code, 200)
self.assertLess(r.status_code, 300)
def setUp(self):
"""
# Create a db
"""
headers = {'Content-Type': 'application/json; charset=utf-8'}
db_data = {'name': 'testDB'}
response = requests.post(__db_url__, json=db_data, headers=headers)
if response.status_code == 201:
self.assertEqual(response.status_code, 201)
else:
self.assertEqual(response.status_code, 404)
# Create a server
response = requests.get(__db_url__)
value = response.json()
if value:
db_length = len(value['databases'])
last_db_id = value['databases'][db_length-1]['id']
url = 'http://%s:8000/api/1.0/databases/%u/servers/' % \
(__host_or_ip__,last_db_id)
data = {'description': 'test', 'hostname': __host_or_ip__, 'name': 'test'}
response = requests.post(url, json=data, headers=headers)
if response.status_code == 201:
self.assertEqual(response.status_code, 201)
else:
self.assertEqual(response.status_code, 404)
else:
print "The database list is empty"
def postfile(host, port, user, auth_token, db, table, filename, lines, version):
"""
post data reading from file to server
"""
if not os.path.isfile(filename):
click.echo('[ERROR] Filename not exist')
return
headers = {'X-USERNAME':user, 'X-AUTH-TOKEN':auth_token}
url = "http://%s:%s/%s/%s/%s" % (host, port, version, db, table)
total_lines = wc['-l', filename]().split()[0]
over_lines = 0
post_data = []
for data in open(filename):
js = json.loads(data)
js['tags']= js['tags'][0] if len(js['tags']) else ''
post_data.append(js)
if len(post_data) == lines:
over_lines = over_lines + lines
r = requests.post(url, data=json.dumps(post_data), headers=headers)
if r.status_code != 200:
click.echo("Invalid response from server")
return
click.echo('Post %s/%s lines data to ingestion Server' % (over_lines, total_lines))
post_data = []
if len(post_data) > 0:
over_lines = over_lines + len(post_data)
requests.post(url, data=json.dumps(post_data), headers=headers)
click.echo('Post %s/%s lines data to ingestion Server' % (over_lines,total_lines))
click.echo("All data post to ingestion server")
def yandex_speech(input_link: str, bucket: str, aws_secret_access_key: str,
aws_access_key_id: str, API_key: str) -> str:
"""
:param input_link: path to the wav-file
:param bucket: name of bucket at Yandex.Cloud
:param aws_secret_access_key: secret code of the access key
:param aws_access_key_id: ID of the access key
:param API_key: ID of the API_key
:return:
"""
# загрузка в облако
session = boto3.session.Session(region_name="ru-central1", aws_secret_access_key=aws_secret_access_key,
aws_access_key_id=aws_access_key_id)
s3 = session.client(service_name='s3', endpoint_url='https://storage.yandexcloud.net/')
s3.upload_file(input_link, bucket, 'obj.wav')
file_link = 'https://storage.yandexcloud.net/' + bucket + '/obj.wav'
POST = "https://transcribe.api.cloud.yandex.net/speech/stt/v2/longRunningRecognize"
body = {
"config": {
"specification": {
"languageCode": "ru-RU",
"model": "general:rc",
"audioEncoding": "LINEAR16_PCM",
"sampleRateHertz": 8000,
"audioChannelCount": 1
}
},
"audio": {
"uri": file_link
}
}
header = {'Authorization': 'Api-Key {}'.format(API_key)}
# Отправить запрос на распознавание.
req = requests.post(POST, headers=header, json=body)
data = req.json()
id_ = data['id']
GET = "https://operation.api.cloud.yandex.net/operations/" + str(id_)
# Запрашивать на сервере статус операции, пока распознавание не будет завершено.
wait = 0
while wait <= 60:
time.sleep(1)
wait += 1
req = requests.get(GET, headers=header).json()
if req['done']:
break
# удаление объекта в облаке
for_deletion = [{'Key': 'obj.wav'}]
s3.delete_objects(Bucket=bucket, Delete={'Objects': for_deletion})
# Текст результатов распознавания.
output_text = ''
if req['done']:
for chunk in req['response']['chunks']:
c = chunk['alternatives'][0]['text']
output_text += ' ' + c
else:
raise TimeoutError('no response from YSK')
return output_text
def post(self, location='/%s/1' % default_index, **kwargs):
return requests.post(self.url + location, headers=http_api_headers, auth=self.auth, **kwargs)
def create_project(self, name, description):
url = "%s%s" % (self.endpoint, "/projects.json")
data = {"project": {"name": name, "description": description}}
data = json.dumps(data)
r = post(url, data=data, headers=self.headers, verify=False)
return r
def send_mess(chat, text):
params = {'chat_id': chat, 'text': text}
response = requests.post(url + 'sendMessage', data=params)
return response
def sync(multi, identity):
"""
Upload records to each registered server.
Each user, bid, offer, etc. (i.e. anything except actual payments) is
stored as document across a public database that is maintained across
a network of paid servers. This command pushes the documents you have
created to the servers from which you have purchased hosting.
"""
(log, user, key, urls) = init(multi, identity)
click.echo("User: "******"No buckets registered. Run 'rein request' to continue.")
return
create_placements(rein.engine)
upload = []
nonce = {}
for url in urls:
nonce[url] = get_new_nonce(rein, url)
if nonce[url] is None:
continue
check = get_user_documents(rein)
if len(check) == 0:
click.echo("Nothing to do.")
for doc in check:
if len(doc.contents) > 8192:
click.echo('Document is too big. 8192 bytes should be enough for anyone.')
log.error("Document oversized %s" % doc.doc_hash)
else:
placements = get_placements(rein, url, doc.id)
if len(placements) == 0:
upload.append([doc, url])
else:
for plc in placements:
if get_remote_document_hash(rein, plc) != doc.doc_hash:
upload.append([doc, url])
failed = []
succeeded = 0
for doc, url in upload:
placements = get_placements(rein, url, doc.id)
if len(placements) == 0:
remote_key = ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits)
for _ in range(32))
plc = Placement(doc.id, url, remote_key, False, rein.testnet)
rein.session.add(plc)
rein.session.commit()
else:
plc = placements[0]
for p in placements[1:]:
rein.session.delete(p)
rein.session.commit()
if len(doc.contents) > 8192:
log.error("Document oversized %s" % doc.doc_hash)
click.echo('Document is too big. 8192 bytes should be enough for anyone.')
elif nonce[url] is None:
continue
else:
message = plc.remote_key + doc.contents + user.daddr + nonce[url]
message = message.decode('utf8')
message = message.encode('ascii')
signature = sign(user.dkey, message)
data = {"key": plc.remote_key,
"value": doc.contents,
"nonce": nonce[url],
"signature": signature,
"signature_address": user.daddr,
"owner": user.maddr,
"testnet": rein.testnet}
body = json.dumps(data)
headers = {'Content-Type': 'application/json'}
answer = requests.post(url='{0}put'.format(url), headers=headers, data=body)
res = answer.json()
if 'result' not in res or res['result'] != 'success':
log.error('upload failed doc=%s plc=%s url=%s' % (doc.id, plc.id, url))
failed.append(doc)
else:
plc.verified += 1
rein.session.commit()
log.info('upload succeeded doc=%s plc=%s url=%s' % (doc.id, plc.id, url))
click.echo('uploaded %s' % doc.doc_hash)
succeeded += 1
for url in urls:
if nonce[url] is None:
continue
sel_url = url + 'nonce?address={0}&clear={1}'
answer = requests.get(url=sel_url.format(user.maddr, nonce[url]))
log.info('nonce cleared for %s' % (url))
click.echo('%s docs checked on %s servers, %s uploads done.' % (len(check), len(urls), str(succeeded)))
def APiCaller(parameters={}):
response = requests.post(API_url, json=parameters)
#[{"eventTime": "2017-04-09T18:42:11Z", "userIdentity_userName": "******"}, {"eventTime": "2017-04-09T22:27:58Z", "userIdentity_userName": "******"}
return ast.literal_eval(response.json())
def send_ptm_data_to_ems (target_Data) :
response_json = {}
with open("config.json") as f:
tmp_config_json = json.loads(f.read())
target = tmp_config_json[target_Data]
ems_url = tmp_config_json["EMS Server URL"] + target['url']
# print(ems_url)
if target_Data == "device":
try:
target['rq_param_send_time'] = datetime.fromtimestamp(int(str(time.time())[0:10])).strftime('%Y%m%d%H%M%S')
res = requests.post(ems_url, headers=headers, data=json.dumps(target))
# print('\n status_code : ' + str(res.status_code))
response_json = res.json()
# prnt(response_json)
# device에 대한 정보 받아와서 보여주
return response_json #response_json
except:
print("Device 기록에 실패했습니다.")
elif target_Data == "regist" :
try:
target['rq_param_parameter'] = eid
res = requests.post(ems_url, headers=headers, data=json.dumps(target))
# print('\n status_code : ' + str(res.status_code))
response_json = res.json()
# prnt(response_json)
# device에 대한 정보 받아와서 보여주
return response_json#response_json
except:
print("Device 등록에 실패했습니다.")
elif target_Data == "params" :
try:
res = requests.post(ems_url, headers=headers, data=json.dumps(target))
# print('\n status_code : ' + str(res.status_code))
response_json = res.json()
prnt(response_json)
# prnt(response_json)
# device에 대한 정보 받아와서 보여주
return response_json
# res = requests.post(ems_url, headers=headers, data=json.dumps(target))
#print('\n status_code : ' + str(res.status_code))
#prnt(res.json())
#response_json = res.json()
# stateOfcharge = stateParams['rs_stateParameter'][0]['stateOfcharge'] 응답 받고 수신값
# genRatio = stateParams['rs_stateParameter'][0]['genRatio']
# lossRatio = stateParams['rs_stateParameter'][0]['lossRatio']
# print('\n SoC : ' + str(stateOfcharge))
# print('\n genRatio : ' + str(genRatio))
# print('\n lossRatio : ' + str(lossRatio))
#return print(target)#response_json
except:
print("EMS Data loading에 실패했습니다.")
elif target_Data == "contractMsg" :
try:
target['rq_param_parameter']['dep2_rq_param_id'] = deal_info_completed["deal_id"]
target['rq_param_parameter']['dep2_rq_param_seller'] = deal_info_completed["seller_eid"]
target['rq_param_parameter']['dep2_rq_param_buyer'] = deal_info_completed["buyer_eid"]
target['rq_param_parameter']['dep2_rq_param_price'] = deal_info_completed["price"]
target['rq_param_parameter']['dep2_rq_param_quantity'] = deal_info_completed["kwh"]
target['rq_param_parameter']['dep2_rq_param_tr_st_time'] = datetime.fromtimestamp(int(deal_info_completed["txTimestamp"][0:10]) + tmp_config_json["start_delay"]).strftime('%Y%m%d%H%M%S')
#complete 되고 tmp_config_json["start_delay"] = 300초 만큼 딜레이 후 전력 거래 시#
target['rq_param_parameter']['dep2_rq_param_tr_ed_time'] = ""
target['rq_param_time'] = datetime.fromtimestamp(int(str(time.time())[0:10])).strftime('%Y%m%d%H%M%S')
res = requests.post(ems_url, headers=headers, data=json.dumps(target))
# print('\n status_code : ' + str(res.status_code))
response_json = res.json()
# prnt(response_json)
# device에 대한 정보 받아와서 보여주
return response_json
#res = requests.post(ems_url, headers=headers, data=json.dumps(target))
#print('\n status_code : ' + str(res.status_code))
#prnt(res.json())
#response_json = res.json()
# return print(target)#response_json
except:
print("Contract Msg 전송에 실패했습니다.")
def _make_post(self, endpoint, body):
url = self.base_endpoint + endpoint
return requests.post(url, json=body,
headers=self._get_headers()).json()
landmark_analyze_url = vision_base_url + "models/landmarks/analyze"
# Set image_url to the URL of an image that you want to analyze.
#image_url = "https://upload.wikimedia.org/wikipedia/commons/f/f6/" + \
# "Bunker_Hill_Monument_2005.jpg"
#image_url = "https://upload.wikimedia.org/wikipedia/ja/thumb/3/3e/MtFuji_FujiCity.jpg/320px-MtFuji_FujiCity.jpg"
#image_url = "https://i.ytimg.com/vi/Fs1W5WrGTjE/hqdefault.jpg"
image_url = "https://clicktraveltips.com/wp-content/uploads/2013/04/Golden-Gate-Bridge.jpg"
image_url = "https://cdntct.com/tct/pic/china-tour-pic/beijing/tiananmen-04.jpg"
#image_url = "https://cache-graphicslib.viator.com/graphicslib/thumbs360x240/7845/SITours/%E3%82%A8%E3%83%83%E3%83%95%E3%82%A7%E3%83%AB%E5%A1%94%E3%81%B8%E3%81%AE%E5%84%AA%E5%85%88%E5%85%A5%E5%A0%B4%E3%83%81%E3%82%B1%E3%83%83%E3%83%88%EF%BC%88%E3%83%9B%E3%82%B9%E3%83%88%E4%BB%98%E3%81%8D%EF%BC%89-in-paris-299567.jpg"
headers = {'Ocp-Apim-Subscription-Key': subscription_key}
params = {'model': 'landmarks'}
data = {'url': image_url}
response = requests.post(landmark_analyze_url,
headers=headers,
params=params,
json=data)
response.raise_for_status()
# The 'analysis' object contains various fields that describe the image. The
# most relevant landmark for the image is obtained from the 'result' property.
analysis = response.json()
assert analysis["result"]["landmarks"] is not []
print(json.dumps(analysis, indent=4))
landmark_name = ''
if (analysis["result"]["landmarks"]):
landmark_name = analysis["result"]["landmarks"][0]["name"].capitalize()
# Display the image and overlay it with the landmark name.
image = Image.open(BytesIO(requests.get(image_url).content))
import numpy as np
from collections import OrderedDict
import time
import traceback
import logging
import pdb
rtData={
"client_id":"curl",
"username":os.environ["KEYCLOAK_USER"],
"password":os.environ["KEYCLOAK_PWD"],
"grant_type":"password",
"scope":"openid offline_access"
}
refreshData=requests.post("https://login.akvo.org/auth/realms/akvo/protocol/openid-connect/token",rtData).json();
def getAccessToken():
acData={
"client_id":"curl",
"refresh_token":refreshData["refresh_token"],
"grant_type":"refresh_token"
}
accessData = requests.post("https://login.akvo.org/auth/realms/akvo/protocol/openid-connect/token",acData).json()
return accessData["access_token"]
def getResponse(url):
# print(url)
header={
"Authorization":"Bearer "+ getAccessToken() ,
def test7_vote(self) :
tester = app.test_client(self)
response = requests.post("http://0.0.0.0:8080/poll/cast/vote",data = json.dumps({"Account":"0xdc2875d889Bbb48bF7097dC12191E88C1C8Cfc23","CandidateId":0}))
self.assertEqual(response.status_code,200)
check_id = resp.content
print(check_id)
#string_input = resp.json()
string_input = resp.json()
final_str = (string_input['test_input']['text'])
string_input = final_str
count = 0
for i in string_input:
if i =='.':
count +=1
data1 = {
"test_session": 13,
"output": { "sentenceCount": count },
"challenge": 3
}
data2 = json.dumps(data1)
#print(data2)
headers = {'Content-type':'application/json', 'Accept':'application/json'}
url = "https://code-riddler.herokuapp.com/api/v1/testsessionchallenges/output/"
check = requests.post(url,data = data2 ,auth = (username,password),headers =headers)
#print(check.status_code)
print(check.content)
from hashlib import sha1
import email.utils
import hmac
import requests
secret = "xxxx-xxxx-xxx-xxx-xxxx" # replace with secret from email
username = "******" # replace with username from email
url = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxx' # replace with url from email
dt = email.utils.formatdate(usegmt="true")
stringToSign = 'date: ' + dt
encodedSignature = hmac.new(secret, stringToSign,
sha1).digest().encode("base64").rstrip('\n')
hmacAuth = 'hmac username="******",algorithm="hmac-sha1",headers="date",signature="' + encodedSignature + '"'
headers = {'date': dt, 'Authorization': hmacAuth}
data = {"companyId": 386}
endpoint = url + "marketplace/v1/pricing/global"
r = requests.post(endpoint, json=data, headers=headers)
print(r.text)
def test1_addCandididates(self) :
tester = app.test_client(self)
response = requests.post("http://0.0.0.0:8080/poll/add/candidate",data = json.dumps({"Account":"0xdc2875d889Bbb48bF7097dC12191E88C1C8Cfc23","CandidateName":"Kevin Kingsly"}))
self.assertEqual(response.status_code,200)
def test_post_formdata(pub_data):
data = {'userName':'******'}
h = {'token':pub_data['token']}
r = requests.post('http://qa.yansl.com:8084/user/lock',data=data,headers=h)
print(r.text)
def test6_getinfo(self) :
tester = app.test_client(self)
response = requests.post("http://0.0.0.0:8080/poll/get/information",data = json.dumps({"Account":"0xdc2875d889Bbb48bF7097dC12191E88C1C8Cfc23"}))
self.assertEqual(response.status_code,200)
print("data : ",response.json(),flush=True)
# 텍스트 템플릿 형식 만들기
template = {
"object_type": "text",
"text": text,
"link": {
"web_url": weather_url,
"mobile_web_url": weather_url
},
"button_title": "날씨 상세보기"
}
# JSON 형식 -> 문자열 변환
payload = {"template_object": json.dumps(template)}
# 카카오톡 보내기
res = requests.post(kakaotalk_template_url, data=payload, headers=kheaders)
if res.json().get('result_code') == 0:
print('메시지를 성공적으로 보냈습니다.')
else:
print('메시지를 성공적으로 보내지 못했습니다. 오류메시지 : ' + str(res.json()))
# 리스트 템플릿 형식 만들기
contents = []
template = {
"object_type":
"list",
"header_title":
"현재 날씨에 따른 옷 추천",
"header_link": {
"web_url": weather_url,
def test_post_upload_file(pub_data):
data = {'file':open('aa.xls','rb')}
h = {'token':pub_data['token']}
r = requests.post('http://qa.yansl.com:8084/product/uploaprodRepertory',files=data,headers=h)
print(r.text)
auth=base64_string,
origin=config['api_base_url'])
for header, value in headers.iteritems():
if header and value:
request_headers += '\r\n{header}: {value}'.format(
header=header, value=value)
# make request
response = None
verify = False
timeout = 60
if method == 'GET':
response = requests.get(
url, auth=auth, headers=headers, verify=verify, timeout=timeout)
elif method == 'POST':
response = requests.post(
url, auth=auth, headers=headers, data=payload, verify=verify, timeout=timeout)
elif method == 'PUT':
response = requests.put(
url, auth=auth, headers=headers, data=payload, verify=verify, timeout=timeout)
elif method == 'DELETE':
response = requests.delete(
url, auth=auth, headers=headers, verify=verify, timeout=timeout)
else:
response = requests.options(
url, auth=auth, headers=headers, verify=verify, timeout=timeout)
headers = collections.OrderedDict(sorted(response.headers.items()))
code_description = requests.status_codes._codes[response.status_code][0]
code_description = code_description.replace('_', ' ').title()
http_version = str(response.raw.version)
if len(http_version) > 1:
def test_post_json():
data = {'pwd':'abc123','userName':'******'}
r = requests.post('http://qa.yansl.com:8084/login',json=data)
print(r.text)
def update_parcel_department_effectivefirefighting_rollup(fd_id):
"""
Update for one department for the effective fire fighting force
"""
stationlist = FireStation.objects.filter(department_id=fd_id)
dept = FireDepartment.objects.filter(id=fd_id)
staffingtotal = "1" # assume staffing minimum of 1 for now
if dept[0].geom is None:
print "No geometry for the department " + dept[0].name
else:
print "Calculating Response times and staffing for: " + dept[0].name + ' at ' + time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
try:
# Use Headquarters geometry if there is no Statffing assets
if len(stationlist) < 1:
drivetimeurl = 'http://gis.iaff.org/arcgis/rest/services/Production/PeopleCountOct2012/GPServer/PeopleCountOct2012/execute?f=json&Facilities={"features":[{"geometry":{"x":' + str(dept[0].headquarters_geom.x) + ',"spatialReference":{"wkid":4326},"y":' + str(dept[0].headquarters_geom.y) + '}}],"geometryType":"esriGeometryPoint"}&env:outSR=4326&text_input=' + staffingtotal + '&returnZ=false&returnM=false'
getdrivetime = requests.get(drivetimeurl)
else:
drivetimegeom = []
staffingtotal = ""
for fireStation in stationlist:
# staffing
assetlist = Staffing.objects.filter(firestation_id=fireStation.id)
stationstafftotal = 0
for staff in assetlist:
stationstafftotal = stationstafftotal + staff.personnel
# geometry
stationasset = {}
stationasset["spatialReference"] = {"wkid": 4326}
stationasset["y"] = round(fireStation.geom.y, 5)
stationasset["x"] = round(fireStation.geom.x, 5)
stationgeom = {}
stationgeom["geometry"] = stationasset
drivetimegeom.append(stationgeom)
staffingtotal = staffingtotal + str(stationstafftotal) + ','
drivepostdata = {}
drivepostdata['f'] = 'pjson'
drivepostdata['returnZ'] = False
drivepostdata['returnM'] = False
drivepostdata['env:outSR'] = 4326
drivepostdata['text_input'] = staffingtotal[:-1]
drivepostfeatures = {}
drivepostfeatures['features'] = drivetimegeom
drivepostfeatures['geometryType'] = "esriGeometryPoint"
drivepostdata['Facilities'] = json.dumps(drivepostfeatures)
# need to run async so it doesn't time out
# getdrivetime = requests.post("http://gis.iaff.org/arcgis/rest/services/Production/PeopleCountOct2012/GPServer/PeopleCountOct2012/execute", data=drivepostdata)
getdrivetime = requests.post("http://gis.iaff.org/arcgis/rest/services/Production/PeopleCount2017_V2/GPServer/PeopleCount2017/submitJob", data=drivepostdata)
get_async_efff_service_status(json.loads(getdrivetime.content)['jobId'], dept[0])
except KeyError:
print 'Drive Time Failed for ' + dept[0].name
except IntegrityError:
print 'Drive Time Failed for ' + dept[0].name
except:
print 'Drive Time Failed for ' + dept[0].name
def request_action(self, phone, header, cookie):
# 解析cookie里面snsInfo数据
try:
cookie_dic = json.loads(cookie.split(';')[3].split('=')[1])
except:
return
sleep_time = 0
blind_url = 'https://h5.ele.me/restapi/v1/weixin/' + cookie_dic[
'openid'] + '/phone'
lucky_url = 'https://h5.ele.me/restapi/marketing/promotion/weixin/' + cookie_dic[
'openid']
blind_data = {
'sign': cookie_dic['eleme_key'],
'method': 'phone',
'phone': str(phone),
}
avater = cookie_dic['avatar']
user_name = phone[:3] + '*' * 4 + phone[7:9]
sleep(0.1)
request_data = {
'device_id': self.query['device_id'],
'group_sn': self.query['sn'],
'hardware_id': self.query['hardware_id'],
'method': 'phone',
'phone': str(phone),
'platform': self.query['platform'],
'refer_user_id': self.query['refer_user_id'],
'sign': cookie_dic['eleme_key'],
'track_id': self.query['track_id'],
'unionid': 'f**k',
'theme_id': self.query['theme_id'],
'weixin_avatar': avater,
'weixin_username': user_name,
}
# 两个不同请求分开放
try:
get_post_result = requests.post(lucky_url,
data=json.dumps(request_data),
headers=header).text
sleep(sleep_time)
except:
get_post_result = False
self.output_json({
"errorCode": "10002",
"msg": "Parameter error",
"other": "post"
})
try:
# sleep(3)
get_put_result = requests.put(blind_url,
data=json.dumps(blind_data),
headers=header).text
soup_1 = BeautifulSoup(get_put_result, 'lxml')
soup = BeautifulSoup(get_post_result, 'lxml').p.get_text()
soup_string = json.loads(str(soup))
try_times = last_times = big_number = 0
promotion_records = soup_string['promotion_records']
for i in range(len(promotion_records)):
if promotion_records[i]['is_lucky'] or int(
promotion_records[i]['amount']) >= 4:
last_times += 1
big_number = float(promotion_records[i]['amount'])
else:
try_times += 1
return {
'small_package': try_times,
'big_package': last_times,
'big_number': big_number
}
except:
self.output_json({"errorCode": "10006", "msg": "Bad request"})
self.error += 1
self.begin(1)
import requests
cred = {
'email':'*****@*****.**',
'password':'******'
}
login = '******'
api = 'http://192.168.100.105:5000/users'
res = requests.post(login,json=cred)
token = res.json().get('token')
print(token)
if token:
headers = {'Authorization':f'Bearer{token}'}
print(headers)
res = requests.get(api,headers=headers)
print("bien")
else:
print ("mal")
#!/usr/bin/python3
import requests
import json
print('\n 1. Login in Odoo and get access tokens:')
r = requests.post(
'http://localhost:8069/api/auth/get_tokens',
headers={'Content-Type': 'text/html; charset=utf-8'},
data=json.dumps({
'username': '******',
'password': '******',
}),
# verify = False # for TLS/SSL connection
)
print(r.text)
access_token = r.json()['access_token']
print('\n 2. res.partner - Read all (with filters in URL):')
r = requests.get(
"http://localhost:8069/api/res.partner?filters=[('name','like','ompany'),('id','!=',50)]",
headers={
'Content-Type': 'text/html; charset=utf-8',
'Access-Token': access_token
},
# verify = False # for TLS/SSL connection
)
print(r.text)
def relay_call(name, data):
return requests.post("http://{}/{}".format(relay_address, name),
headers={"content-type" : "application/json"},
data=json.dumps(data))
#!/usr/bin/python
from requests.packages.urllib3.exceptions import InsecureRequestWarning
import requests as r
import json
r.packages.urllib3.disable_warnings(InsecureRequestWarning)
username = "******"
port = '8081'
base_url = 'https://' + username + '.code.engineering.nyu.edu:' + port + '/'
login_payload = {"username" : "john", "password" : "1234"}
r1 = r.post(base_url + 'user/login', verify=False, json=login_payload)
print "Response from login: "******"Session_id cookie: " + r1.cookies["session_id"]
r2 = r.post(base_url + 'user/logout', verify=False, cookies=r1.cookies)
print "Response from logout: " + r2.content
# Получение всех работ
print(requests.get('http://127.0.0.1:8080/api/jobs').json())
# Корректное получение одной работы
print(requests.get('http://127.0.0.1:8080/api/jobs/1').json())
# Ошибочный запрос на получение одной работы — неверный id
print(requests.get('http://127.0.0.1:8080/api/jobs/999').json())
# Ошибочный запрос на получение одной работы — строка
print(requests.get('http://127.0.0.1:8080/api/jobs/test').json())
# Верный запрос
print(
requests.post('http://127.0.0.1:8080/api/jobs',
json={
'id': 99,
'job': '1',
'team_leader': 1,
'work_size': 1,
'collaborators': '1',
'is_finished': False
}).json())
# Не передан параметр is_finished
print(
requests.post('http://127.0.0.1:8080/api/jobs',
json={
'id': 7,
'job': '1',
'team_leader': 1,
'work_size': 1,
'collaborators': '1'
}).json())
# Работа с существующим id
def severity(num_cars):
max_cars = 96
max_weight = 96*6000 # 96 * 3 tons with 30% buffer
print("max weight: " + str(max_weight))
avg_car_weight = 4500 # 2 tons is avg weight of cars
# severity values (ratio from weight of cars)
# TODO: modify this to use max cars value
sev_1 = 0 # 0
sev_2 = int(max_weight/5)
sev_3 = sev_2 + int(max_weight/5)
sev_4 = sev_3 + int(max_weight/5)
sev_5 = sev_4 + int(max_weight/5)
print("sev_1: %s sev_2: %s sev_3: %s sev_4: %s sev_5: %s max_weight: %s" % (sev_1, sev_2, sev_3, sev_4, sev_5, max_weight))
# key: # of cars, value: the severity value
# severities = {sev_1: 1, sev_2: 2, sev_3: 3, sev_4: 4, sev_5: 5}
# extent - constant depending on bridge age
# TODO: need to figure out a way to quantify age as a key for determining what age is
# A, B, C, D, or E
age = 2
extent = {0: "A", 1: "B", 2: "C", 3: "D", 4: "E"}
# first key value for tuple for querying in ECS table
# constant for one bridge
bridge_extent = extent[age]
# STEP 1: retrieve ECS VALUE
# TODO: modify the severity values based on the weight of cars passing through each point
cars_at_points = num_cars
weight_of_cars = cars_at_points*avg_car_weight
print("weight of cars: " + str(weight_of_cars))
severity_val = 1
if weight_of_cars >= sev_1 and weight_of_cars < sev_2:
severity_val = 1
elif weight_of_cars >= sev_2 and weight_of_cars < sev_3:
severity_val = 2
elif weight_of_cars >= sev_3 and weight_of_cars < sev_4:
severity_val = 3
elif weight_of_cars >= sev_4 and weight_of_cars < sev_5:
severity_val = 4
# elif weight_of_cars >= sev_5:
# severity_val = 5
elif (weight_of_cars >= sev_5 and weight_of_cars < max_weight) or weight_of_cars > max_weight:
severity_val = 5
print("severity_val: " + str(severity_val))
A_severity = severity_val
B_severity = severity_val
C_severity = severity_val
print("severities: " + str(A_severity))
A_ECS = ECS_table[(bridge_extent, A_severity)] # (C, 2) = 2.1
B_ECS = ECS_table[(bridge_extent, B_severity)] # (C, 3) = 3.2
C_ECS = ECS_table[(bridge_extent, C_severity)] # (C, 4) = 4.1
# print()
# print("STEP 1")
# print("A_ECS: " + str(A_ECS))
# print("B_ECS: " + str(B_ECS))
# print("C_ECS: " + str(C_ECS))
# print()
# STEP 2: retrieve EIF VALUE
# B - most important (very high)
# A, C - least important (low)
# very high = 2, high = 1.5, medium = 1.2, low = 1.0
A_EIF = 1.0
B_EIF = 2.0
C_EIF = 1.0
# print("STEP 2")
# print("A_EIF: very low")
# print("B_EIF: very high")
# print("C_EIF: very low")
# print()
# STEP 3: ECF calculation
# ECF for high = 0.3 - [(pointB_ECS - 1)*(0.3/4)]
B_ECF = 0.3 - (B_ECS - 1)*(0.3/4)
# ECF for low = 1.2 - [(pointA,C_ECS - 1)*(1.2/4)]
A_ECF = 0.3 - (A_ECS - 1)*(1.2/4)
C_ECF = 0.3 - (C_ECS - 1)*(1.2/4)
# print("STEP 3")
# print("A_ECF: " + str(A_ECF))
# print("B_ECF: " + str(B_ECF))
# print("C_ECF: " + str(C_ECF))
# print()
# STEP 4: ECI calculation
# ECI = ECS - ECF
A_ECI = A_ECS - A_ECF
B_ECI = B_ECS - B_ECF
C_ECI = C_ECS - C_ECF
# print("STEP 4")
# print("A_ECI: " + str(A_ECI))
# print("B_ECI: " + str(B_ECI))
# print("C_ECI: " + str(C_ECI))
# print()
# STEP 5: BCS calculation
# for N = 3 bridge elements (summation)
BCS_top = (A_ECI*A_EIF) + (B_ECI*B_EIF) + (C_ECI*C_EIF)
BCS_bot = A_EIF + B_EIF + C_EIF
BCS = BCS_top/BCS_bot
# print("STEP 5")
# print("BCS: " + str(BCS))
# print()
# STEP 6: BCI calculation
print("100 - " + str((2 * (pow(BCS, 2) + (6.5 * BCS) - 7.5))))
BCI = 100 - (2 * (pow(BCS, 2) + (6.5 * BCS) - 7.5))
# print("STEP 5")
print("BCI: " + str(BCI))
print()
url = "https://smart-city-266807.appspot.com/bci"
data = {"id": "0", "bci": BCI, "latitude": 33.714445, "longitude": -117.921869}
r = requests.post(url = url, json = data)
# print(r.content)
# Because we are rebuilding in sandbox the pools are always called VM-MIRROR
#POOL=PROJ["POOL"]
POOL="VM-MIRROR"
# Get replication target ID, this needs to be already setup in the BUI
url = 'https://'+HOST+':215/api/storage/v1/replication/targets'
response = requests.get(url, headers={'Authorization': 'Basic cm9vdDpHMGRfNGM3Xw=='},verify=False)
nodeRef = json.loads(response.text)
# We assume only one target, which should always be the case in our environment
TARGET = nodeRef['targets'][0]['label']
# Create the projects and LUNS
data = { 'name':PROJECT }
headers = {'Authorization': 'Basic cm9vdDpHMGRfNGM3Xw==', 'Content-Type': 'application/json'}
url = 'https://'+HOST+':215/api/storage/v1/pools/'+POOL+'/projects'
response = requests.post(url,headers=headers,data=json.dumps(data),verify=False)
print 'Created '+PROJECT+' on '+POOL, response
if response.status_code != 201:
print json.dumps (response.json(), sort_keys=True, indent=4, separators=(',', ': '))
# Create LUNS while we are here
data = {
'name':LUN,
'volsize':500*1024*1024
}
url = 'https://'+HOST+':215/api/storage/v1/pools/'+POOL+'/projects/'+PROJECT+'/luns'
response = requests.post(url,headers=headers,data=json.dumps(data),verify=False)
#print json.loads(response.text)
print 'Created '+LUN+' in project '+PROJECT, response
if response.status_code != 201:
print json.dumps (response.json(), sort_keys=True, indent=4, separators=(',', ': '))
"塞浦路斯", "尼泊尔", "巴拉圭", "布基纳法索", "乌拉圭", "塞拉利昂", "安道尔", "尼加拉瓜", "格鲁吉亚",
"埃塞俄比亚", "约旦", "乍得", "钻石号邮轮", "中非共和国", "圣马力诺", "马达加斯加", "马耳他", "刚果（布）",
"牙买加", "坦桑尼亚", "巴勒斯坦", "多哥", "佛得角", "卢旺达", "毛里求斯", "越南", "黑山", "毛里塔尼亚",
"乌干达", "斯威士兰", "利比里亚", "也门", "莫桑比克", "贝宁", "缅甸", "蒙古", "文莱", "圭亚那", "津巴布韦",
"柬埔寨", "叙利亚", "特立尼达和多巴哥", "马拉维", "巴哈马", "利比亚", "摩纳哥", "巴巴多斯", "科摩罗",
"列支敦士登公国", "安哥拉", "布隆迪", "厄立特里亚", "马提尼克岛", "博茨瓦纳", "不丹", "冈比亚", "安提瓜和巴布达",
"东帝汶", "格林纳达", "纳米比亚", "老挝", "斐济", "伯利兹", "圣文森特和格林纳丁斯", "圣卢西亚", "多米尼克",
"圣基茨和尼维斯", "梵蒂冈", "苏里南", "塞舌尔", "巴布亚新几内亚", "莱索托"
]
print("本程序用于拟合所选国家感染人数和预测未来数据")
for i in range(len(country_list)):
print(str(i) + "." + country_list[i])
print("请选择所想展示的国家（输入数字即可）：")
n = int(input())
param = {"country": country_list[n]}
res = requests.post(query_url, param)
d = json.loads(res.content.decode())
data = pd.DataFrame(d['data'])
xs = pd.DataFrame(d['data']).date
for i in range(len(xs)):
xs[i] = "2020-" + xs[i][0] + xs[i][1] + '-' + xs[i][3] + xs[i][4]
xs = [datetime.strptime(d, '%Y-%m-%d').date() for d in xs]
data.insert(0, 'riqi', xs)
#data.to_csv("tzzs_data.csv")
x = np.arange(1, len(xs) + 1, 1)
y = np.array(data.confirm_add)
z1 = np.polyfit(x, y, 3) #用n次多项式拟合
p1 = np.poly1d(z1)
print(p1) #在屏幕上打印拟合多项式
yvals = p1(x)
