def withdrawal(self, asset, orderstr=None, orderfile=None):
req = {
'address': '',
'amount': 0,
'asset_name': asset,
'user_order_id': '',
'memo': 'memo'
}
orders = {}
order_id_prefix = time.strftime('%Y%m%d%H%M%S', time.localtime())
if orderfile and orderfile != "":
try:
file = open(orderfile, "rb")
orders.update(json.load(file))
except Exception as e:
click.echo(e)
elif orderstr and orderstr != "":
try:
orders.update(json.loads(orderstr))
except Exception as e:
click.echo(e)
if len(orders) == 0:
util.error('withdrawal failed, there are no order')
return
index = 0
for k in orders:
req['user_order_id'] = ('%s-%03d' % (order_id_prefix, index))
index += 1
req['address'] = k
req['amount'] = orders[k]
util.result('withdraw_result:%s' % (self.withdrawl_oneorder(req)))
def getbalance(self, coins):
if isinstance(coins, str):
coins = coins.split(',')
pageindex = 1
totalpage = 1
rowscount = 20
req = {
'asset_names': coins,
'is_async': 0,
'page_index': 1,
'max_disp_lines': 100,
'total_lines': 0
}
while (pageindex - 1) != totalpage:
req['page_index'] = pageindex
req['max_disp_lines'] = rowscount
res = self.httpcall(req, 'get_balance')
if res['err'] != 0:
print('get balacne faild, message:', res['errmsg'])
return res
value = res['value']
data = value['data']
for v in data:
util.result(
('coin:%s, frozen_value:%.6f, avalavailable_value:%.6f' %
(v['asset_name'], v['frozen_amount'],
v['available_amount'])))
pageindex += 1
totalpage = int((value['total_lines'] + rowscount - 1) / rowscount)
def deposite():
param = params['deposite']
param["params"][1] = round(random.uniform(0, 0.01), 4)
index = random.randint(0, len(addresses) - 1)
address = addresses[index]
param['params'][0] = address
util.info('deposite to address(%s) index=(%d)' % (address, index))
util.result(('txid : %s' % (do_requrest(param))), color='blue')
def listbilldaily(self, assets, offsetday):
if isinstance(assets, str): assets = assets.split(',')
if not isinstance(offsetday, int): offsetday = int(offsetday)
if offsetday < 1: offsetday = 1
now = datetime.datetime.now()
end_date = int(now.strftime('%Y%m%d'))
start_date = int(
(now - datetime.timedelta(days=offsetday - 1)).strftime('%Y%m%d'))
req = {
'is_async': 0,
'page_index': 1,
'max_period': end_date,
'min_period': start_date,
'max_disp_lines': 100,
'total_lines': 0
}
for asset in assets:
pageindex = 1
totalpage = 1
rowscount = 20
req['asset_name'] = asset
while (pageindex - 1) != totalpage:
req['page_index'] = pageindex
req['max_disp_lines'] = rowscount
res = self.httpcall(req, 'transaction_bill_daily')
if res['err'] != 0:
print('list (%s)addresses faild, message:%s' %
(assets, res['errmsg']))
return res
value = res['value']
data = value['data']
for v in data:
util.result((
'date:%s, asset:%s, pre_balance:%f, last_balance:%f...'
% (v['period'], v['asset_name'], v['pre_balance'],
v['last_balance'])))
pageindex += 1
totalpage = int(
(value['total_lines'] + rowscount - 1) / rowscount)
util.result('----------------------------------------')
def show_results(self):
util.right(self.log_path, "relative error:")
if abs(self.relative_error) < TOLERANCE:
util.result(self.log_path, "OK")
else:
util.result(self.log_path, "%0e" % self.relative_error)
util.right(self.log_path, "mass change:")
if self.initcond == "delta" or self.initcond == "smooth":
if abs(self.mass_change) < TOLERANCE:
util.result(self.log_path, "OK")
else:
util.result(self.log_path, "%0e" % self.mass_change)
else:
util.result(self.log_path, "--")
def withdraw():
global client
message = time.strftime('%Y%m%d%H%M%S', time.localtime())
req = {
'address': random_withdrawal_address(),
'amount': round(random.uniform(0.1, 0.2), 3),
'asset_name': 'BTC',
'user_order_id': message,
'memo': message
}
resp = client.withdrawl_oneorder(req)
util.result('withdraw ok: orderid:%s, address:%s, value:%f' %
(resp['order_id'], resp['address'], req['amount']))
def listcoins(self):
res = self.httpcall({}, 'support_assets')
if res['err'] != 0:
print('list supported coins faild, message:', res['errmsg'])
return res
value = res['value']['data']
if value[0] == '0x': value = value[1:]
length = len(value)
colums = 15
for index in range(0, int((length + colums - 1) / colums)):
message = value[index * colums]
for i in range(index * colums + 1, min((index + 1) * colums,
length)):
message += (',%s' % value[i])
util.result(message)
def newaddress(self, coin, count):
if not isinstance(count, int):
count = int(count)
begintime = time.time()
for i in range(1, count + 1):
res = self.httpcall({'asset_name': coin}, 'new_address')
if res['err'] != 0:
print('get new address, message:', res['errmsg'])
return res
util.result('coin:%s, index:%d, address:%s' %
(coin, i, res['value']['data']))
endtime = time.time()
diff = endtime - begintime
util.warn('total time = %d(s), count=%d, average time = %.2f(s)' %
(diff, count, diff / count))
def run(self, commands, iterations, initial_sample=None):
errors = []
samples = []
if initial_sample:
samples.append(initial_sample)
for i in reversed(range(iterations)):
self.setup_files["input.deck"] = util.decks.input_deck(solver=self.solver,
num_cells_x=32*2**i, num_cells_y=32*2**i, t_final=0.33, init_cond="smooth")
util.bullet(self.log_path, "dx / %d" % 2**i, indent=2)
with util.ResetFile(self.current_path, self.initial_path):
super(ConvergenceTest, self).run(commands)
samples.append(self.parser(self.current_path))
if len(samples) > 1:
errors.append(samples[-1] - samples[0])
if len(errors) > 1:
util.result(self.log_path,
"%f" % math.log(abs(errors[-1]) / abs(errors[-2]), 2))
else:
util.result(self.log_path, "")
return samples
def listaddresses(self, assets):
if isinstance(assets, str):
assets = assets.split(',')
pageindex = 1
totalpage = 1
rowscount = 50
req = {
'asset_names': assets,
'is_async': 0,
'page_index': 1,
'max_disp_lines': 100,
'total_lines': 0
}
while (pageindex - 1) != totalpage:
req['page_index'] = pageindex
req['max_disp_lines'] = rowscount
res = self.httpcall(req, 'query_address')
if res['err'] != 0:
print('list (%s)addresses faild, message:%s' %
(assets, res['errmsg']))
return res
value = res['value']
data = value['data']
for v in data:
util.result(
('asset:%s, address:%s' % (v['asset_name'], v['address'])))
total = value['total_lines']
util.warn('totalcount=%d, pageindex = %d, length=%d' %
(total, pageindex, len(data)))
pageindex += 1
totalpage = int((total + rowscount - 1) / rowscount)
def blockheight(self, coins, repeats=1):
if not isinstance(repeats, int): repeats = int(repeats)
if isinstance(coins, str):
coins = coins.split(',')
begintime = time.time()
for i in range(0, repeats):
res = self.httpcall({'asset_names': coins}, 'block_height')
if res['err'] != 0:
print('get blockheight faild, message:', res['errmsg'])
return res
value = res['value']['data']
for v in value:
util.result('(%s, %d)' % (v['asset_name'], v['block_height']))
endtime = time.time()
diff = endtime - begintime
util.warn(
'blockheight totaltime=%d(s), repeats=%d, averagetime=%.2f(s)' %
(diff, repeats, diff / repeats))
kwrds[key] = value
else:
args.append(arg)
return (args, kwrds)
if __name__ == '__main__':
if False and len(sys.argv) < 2:
util.error('require an environment, \'test\' or \'release\'')
exit(0)
while True:
try:
inputs = input(util.colortitle('Enter your input > '))
argv = inputs.split(' ')
args, kwrds = parse_args(argv, ['-', '--'])
method = args.pop(0)
if method in ['q', 'quit', 'exit']:
util.result('─=≡Σ(((つ•̀ω•́)つ')
util.result('─=≡Σ(((つ•̀ω•́)つ good bye!')
break
if method == 'sayhello':
sayhallo(*args, **kwrds)
# else:
# client.Call(method, args, kwrds)
except Exception as e:
util.error('error:%s' % e)
def analyze(list_users):
RW = result()
RWRW = result()
unweighted_total_playcount = 0
unweighted_total_playlists = 0
unweighted_total_age = 0
unweighted_total_id = 0
unweighted_total_friends = 0
weighted_total_playcount = 0
weighted_total_playlists = 0
weighted_total_age = 0
weighted_total_id = 0
weighted_total_friends = 0
total_weight = 0
for user in list_users:
if user.age == '' or int(user.friends)==0:
num_total_users -= 1
continue
unweighted_total_playcount += int(user.playcount)
unweighted_total_playlists += int(user.playlists)
unweighted_total_age += int(user.age)
unweighted_total_id += int(user.id)
unweighted_total_friends += int(user.friends)
weight = 1/float(user.friends)
weighted_total_playcount += int(user.playcount) * weight
weighted_total_playlists += int(user.playlists) * weight
weighted_total_age += int(user.age) * weight
weighted_total_id += int(user.id) * weight
weighted_total_friends += int(user.friends) * weight
total_weight += weight
num_total_users = len(list_users)
RW.samplesize = num_total_users
RWRW.samplesize = num_total_users
RW.playcount = float(unweighted_total_playcount) / float(num_total_users)
RW.playlists = float(unweighted_total_playlists) / float(num_total_users)
RW.age = float(unweighted_total_age) / float(num_total_users)
RW.id = float(unweighted_total_id) / float(num_total_users)
RW.friends = float(unweighted_total_friends) / float(num_total_users)
RWRW.playcount = float(weighted_total_playcount) / total_weight
RWRW.playlists = float(weighted_total_playlists) / total_weight
RWRW.age = float(weighted_total_age) / total_weight
RWRW.id = float(weighted_total_id) / total_weight
RWRW.friends = float(weighted_total_friends) / total_weight
print ""
print "Results for sample size of {}".format(num_total_users)
print "{0:20s} {1:^15s} {2:^15s}".format("", "RW", "RWRW")
print "{0:20s} {1:<15f} {2:<15f}".format( "average playcount", RW.playcount, RWRW.playcount)
print "{0:20s} {1:<15f} {2:<15f}".format( "average playlists", RW.playlists, RWRW.playlists)
print "{0:20s} {1:<15f} {2:<15f}".format( "average age", RW.age, RWRW.age)
print "{0:20s} {1:<15f} {2:<15f}".format( "average id", RW.id, RWRW.id)
print "{0:20s} {1:<15f} {2:<15f}".format( "average friends", RW.friends, RWRW.friends)
print ""
return RW, RWRW
def blockheight():
util.result(('blockheight:%s' % (do_requrest(params['blockcount']))),
color='white',
attrs=['dark', 'concealed'])
def mineblock():
util.result(('blockid : %s' % (do_requrest(params['mineblock'])[0])))
def gettx(txid):
param = params['gettx']
param['params'][0] = txid
util.result('tx:%s' % (do_requrest(param)))
(mean_train, std_train, data_train_norm,
data_test_norm) = util.standardized_data(data_train_un, data_test_un)
# MSE
binary_model = MSE_binary()
mse = OneVsRestClassifier(binary_model)
# nonnormalized:
(mean_un, std_un) = util.doCrossOnClf(5, data_train_un, label_train, mse)
print(mean_un, std_un)
# normalized data:
(mean_norm, std_norm) = util.doCrossOnClf(5, data_train_norm, label_train, mse)
print(mean_norm, std_norm)
# basic feature selection:
(set, mean, std) = util.doCrossOnFeature(5, data_train_norm, label_train, mse)
print(set, mean, std)
#PCA feature selection(use normalized data):
(ratio, pca_train, pca_test) = util.doPCA(4, data_train_norm, data_test_norm)
(mean_pca, std_pca) = util.doCrossOnClf(5, pca_train, label_train, mse)
print(mean_pca, std_pca)
print(ratio)
#LDA feature selection(use normalized data):
(lda_train, lda_test) = util.doLDA(3, data_train_norm, label_train,
data_test_norm)
(mean_lda, std_lda) = util.doCrossOnClf(5, lda_train, label_train, mse)
print(mean_lda, std_lda)
(train_acc, train_matrix, test_acc,
test_matrix) = util.result(mse, lda_train, label_train, lda_test, label_test)
print(train_acc)
print(train_matrix)
print(test_acc)
print(test_matrix)
(label_test, data_test_un) = util.csv_to_X_and_labels(
"/Users/mac-pro/Desktop/20SPRING/559/Assignment/location/D_Test1.csv")
(mean_train, std_train, data_train_norm,
data_test_norm) = util.standardized_data(data_train_un, data_test_un)
# basic for SVC
lsvc = SVC(C=1.0, gamma=0.1, kernel='rbf', probability=True)
# unnormalized:
(mean_un, std_un) = util.doCrossOnClf(5, data_train_un, label_train, lsvc)
print(mean_un, std_un)
# normalized:
(mean_norm, std_norm) = util.doCrossOnClf(5, data_train_norm, label_train,
lsvc)
print(mean_norm, std_norm)
(train_acc, train_matrix, test_acc,
test_matrix) = util.result(lsvc, data_train_norm, label_train, data_test_norm,
label_test)
print(train_acc)
print(train_matrix)
print(test_acc)
print(test_matrix)
# basic feature selection:
(set, mean, std) = util.doCrossOnFeature(5, data_train_norm, label_train, lsvc)
print(set, mean, std)
# PCA feature selection(use normalized data):
(ratio, pca_train, pca_test) = util.doPCA(4, data_train_norm, data_test_norm)
(mean_pca, std_pca) = util.doCrossOnClf(5, pca_train, label_train, lsvc)
print(mean_pca, std_pca)
print(ratio)
# LDA feature selection(use normaliezd data):
(lda_train, lda_test) = util.doLDA(3, data_train_norm, label_train,
data_test_norm)
def help(self):
for k, v in self.switch.items():
util.result('>>>>> %s, useage:\n%s' % (k, v['h']))
# baseline model
gnb = GaussianNB()
# unnormalized:
list = [
0,
1,
2,
3,
4,
6,
]
(mean_un, std_un) = util.doCrossOnClf(5, data_train_un[:, list], label_train,
gnb)
print(mean_un, std_un)
(train_acc, train_matrix, test_acc,
test_matrix) = util.result(gnb, data_train_un, label_train, data_test_un,
label_test)
print(train_acc)
print(train_matrix)
print(test_acc)
print(test_matrix)
# normalized:
(mean_norm, std_norm) = util.doCrossOnClf(5, data_train_norm, label_train, gnb)
print(mean_norm, std_norm)
# basic feature selection:
(set, mean, std) = util.doCrossOnFeature(5, data_train_un, label_train, gnb)
print(set, mean, std)
#PCA feature selection(use normalized data):
# try different C in doPCA(): C = 2,3,4,5,6,7
(ratio, pca_train, pca_test) = util.doPCA(4, data_train_norm, data_test_norm)
(mean_pca, std_pca) = util.doCrossOnClf(5, pca_train, label_train, gnb)
print(mean_pca, std_pca)
"memo": "string",
"user_order_id": "string"
}
]'''
def parsjson_test(jsonstring):
elements = json.loads(jsonstring)
return elements
if __name__ == '__main__':
order_id_prefix = time.strftime('%Y%m%d%H%M%S',time.localtime())
print(order_id_prefix)
eles = parsjson_test(jsonstring)
eles.append(parsjson_test(jsonstring))
util.result(eles)
exit(0)
show_level(10, 20, 'thankdyou', name='Your name', level=20)
print('-------------------------------------')
# args = ('zl', 'very good boy')
# kwrds = {'name':'zl', 'level':'very good boy'}
# showlevel_(*args, **kwrds)
showlevel_(*(), **{'name':'zl', 'level':'very good boy'})
print('-------------------------------------')
saysomething()
print('-------------------------------------')
"/Users/mac-pro/Desktop/20SPRING/559/Assignment/location/D_Test1.csv")
(mean_train, std_train, data_train_norm,
data_test_norm) = util.standardized_data(data_train_un, data_test_un)
pct = Perceptron(tol=1e-3, random_state=0)
# unnormalized:
(mean_un, std_un) = util.doCrossOnClf(5, data_train_un, label_train, pct)
print(mean_un, std_un)
# normalized:
(mean_norm, std_norm) = util.doCrossOnClf(5, data_train_norm, label_train, pct)
print(mean_norm, std_norm)
# basic feature selection:
(set, mean, std) = util.doCrossOnFeature(5, data_train_norm, label_train, pct)
print(set, mean, std)
#PCA feature selection(use normalized data):
(ratio, pca_train, pca_test) = util.doPCA(7, data_train_norm, data_test_norm)
(mean_pca, std_pca) = util.doCrossOnClf(5, pca_train, label_train, pct)
print(mean_pca, std_pca)
print(ratio)
(train_acc, train_matrix, test_acc,
test_matrix) = util.result(pct, pca_train, label_train, pca_test, label_test)
print(train_acc)
print(train_matrix)
print(test_acc)
print(test_matrix)
#LDA feature selection(use normalized data)
(lda_train, lda_test) = util.doLDA(2, data_train_norm, label_train,
data_test_norm)
(mean_lda, std_lda) = util.doCrossOnClf(5, lda_train, label_train, pct)
print(mean_lda, std_lda)
# run the game until there's a winner or tie
while True:
# figure out who's turn it is
player = util.turn(board)
if player == human:
print()
print(
"Your turn...give the coordinates of the space you'd like to play in. X is shown on top and Y is shown on the side."
)
while True:
# Make sure human cooperates
x_cord = util.get_human_action("X")
y_cord = util.get_human_action("Y")
# Making sure that result function doesn't return None because the spot is filled
potential_board = util.result(board, (y_cord, x_cord))
if potential_board != None:
board = potential_board
break
util.print_board(board)
elif player == machine:
print()
print("The computer is thinking.")
time.sleep(3)
# Computer figures out move
action = util.minimax(board, machine)
# you don't have to check to make sure the board is using an empty space here because the actions() takes care of that
board[action[0]][action[1]] = machine
util.print_board(board)
else:
# game over
