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