def main(): rpc = RPC() response = rpc.get_accounts() accounts = response["result"]["subaddress_accounts"] print("\nTotal accounts:", len(accounts), "\n") print_accounts(accounts)
def applyRules(self): if self.status != "RUNNING": # In goal state (SUCCEEDED or FAILED); deactivate. self.pool.deactivate(self) elif self.container == None: # Rule 1: No container allocated; request container. if not self.container_requested: self.eventQueue.append(("CONTAINER_REQ", (self, None))) self.container_requested = True elif self.cleanup_rpc != None: # Cleanup requested (attempt killed); ensure cleanup occurs. if self.cleanup_rpc.status == "complete": if self.cleanup_rpc.reply == "failed": # Rule 2: Cleanup RPC failed; retry. self.cleanup_rpc = RPC( self.container, None, ("CONTAINER_REMOTE_CLEANUP", self.work)) self.rpcManager.send(self.cleanup_rpc) else: # Rule 3: Cleanup RPC completed; release container, goal reached. self.eventQueue.append( ("CONTAINER_DEALLOCATE", (self, self.container))) self.status = "FAILED" elif self.launch_rpc == None: # Rule 4: Attempt not launched; launch. self.launch_rpc = RPC(self.container, None, ("LAUNCH", self.work)) self.rpcManager.send(self.launch_rpc) self.time = time.time() elif self.launch_rpc.status != "complete": # Placeholder for state with nothing to do (Attempt running). pass elif self.launch_rpc.reply == "failed": # Rule 5: Attempt failed; report container failure, goal reached. self.eventQueue.append( ("CONTAINER_FAILED", (self, self.container))) self.status = "FAILED" elif self.commit_rpc == None: # Rule 6: Attempt complete but not committed; request commit. self.commit_rpc = RPC(self.container, None, ("COMMIT", self.work)) self.rpcManager.send(self.commit_rpc) elif self.commit_rpc.status != "complete": # Placeholder for state with nothing to do (Attempt committing). pass elif self.commit_rpc.reply == "failed": # Rule 7: Commit failed; report container failure, goal reached. self.eventQueue.append( ("CONTAINER_FAILED", (self, self.container))) self.status = "FAILED" else: # Rule 8: Commit succeeded; release container, goal reached. self.status = "SUCCEEDED" self.eventQueue.append( ("CONTAINER_DEALLOCATE", (self, self.container)))
def query_bitcoin(): if not core_enabled: body = json.dumps({"result": "error", "message": "Bitcoin Core not enabled for this server"}) return (body, 200, {'Content-length': len(body), 'Content-type': 'application/json', } ) rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) # to begin, get hash, block height, and time for latest, then n-blocks-ago, or for a block hash owner = request.args.get('owner') string = request.args.get('query') sales = db.session.query(Sale).filter(Sale.owner == owner).count() res = [] out = {} if sales == 0: body = json.dumps({"result": "error", "message": "Account required to make queries"}) return (body, 200, {'Content-length': len(body), 'Content-type': 'application/json', } ) elif string == 'getbydepth': depth = request.args.get('depth') res = rpc.get('getblockcount') if 'output' in res and 'result' in res['output']: height = res['output']['result'] - int(depth) elif string == 'getbyheight': height = request.args.get('height') elif string == 'getbyhash': res = rpc.get('getblockheader', [request.args.get('hash')]) height = res['output']['result']['height'] res = rpc.get('getblockhash', [int(height)]) out['height'] = height if 'output' in res and 'result' in res['output']: out['hash'] = res['output']['result'] res = rpc.get('getblockheader', [str(out['hash'])]) out['time'] = res['output']['result']['time'] out['height'] = height body = json.dumps(out) else: body = json.dumps({"result": "error", "message": "Invalid depth or RPC error"}) return (body, 200, {'Content-length': len(body), 'Content-type': 'application/json', } )
def get_by_depth(depth): rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) res = rpc.get('getblockcount') if 'output' in res and 'result' in res['output']: height = res['output']['result'] - int(depth) else: return None res = rpc.get('getblockhash', [height]) out = {} if 'output' in res and 'result' in res['output']: out['hash'] = res['output']['result'] res = rpc.get('getblockheader', [out['hash']]) out['time'] = res['output']['result']['time'] out['height'] = height return out
def __init__(self, library_path, assembly_path, enable_debug=False): self.is_windows = "win" in sys.platform print(library_path) self.module = Module(library_path) state = State(self) self.rpc = RPC(state) # Prepare delegates self.on_message = on_message_delegate(RPC.on_message) self.on_exit = on_exit_delegate(Bridge.on_exit) self._imp_common() self._imp_proxy() pluginDir = os.path.dirname( os.path.abspath( sys.modules['__main__'].__file__ ) ) # Initialize AppDomain and call initialize from the plugin self.plugin_handle = self.module.clrInit( assembly_path, pluginDir, self.on_message, self.on_exit, enable_debug )
def __init__(self, library_path, assembly, enable_debug=False): self.is_windows = "win" in sys.platform self.module = Module(library_path) #print("Init State: %s" % extra_vars) #state = State(**extra_vars) state = State(self) self.rpc = RPC(state) # Prepare delegates self.on_message = on_message_delegate(RPC.on_message) self.on_exit = on_exit_delegate(Bridge._on_exit) self._imp_common() # Initialize MonoHost on Unix if not self.is_windows: self._imp_monohost() self.module.setMainMethodName(str(assembly.entry)) self.module.clrInit(assembly.path, self.on_message, self.on_exit) # Call initialize from the plugin self.module.Initialize(self.on_message, self.on_exit, enable_debug)
def DigitalGlobe2Grid_main(aNameFile, targetSyst, altiMin, altiMax, nbLayers): inputSyst = "+proj=longlat +datum=WGS84 " #input syst proj4 refineCoef = "" binaire = True stepPixel = 100. stepCarto = 50. # Reading Inverse RPC, computing Direct RPC and setting up RPC object aRPC = RPC() aRPC.ReadRPB(aNameFile) print("RPB File read") # Generating a 50*50*50 grid on the normalized space with random normalized heights aGridSz = Pt3di(50, 50, 50) aGridGeoNorm = aRPC.GenerateNormGrid(aGridSz) print(len(aGridGeoNorm)) # Converting the points to image space aGridImNorm = [] for i in range(len(aGridGeoNorm)): aGridImNorm.append(aRPC.InverseRPCNorm(aGridGeoNorm[i])) print(len(aGridImNorm))
def masternodes_deploy(args): init(args) # Load configuration file file = open(args.config) config = json.load(file) file.close() rpc_output = "" rpc = RPC(config["Polis"]["wallet"]["username"], config["Polis"]["wallet"]["password"], config["Polis"]["wallet"]["ip"], config["Polis"]["wallet"]["port"]) if args.lstx: args.listunspent = True args.listlockunspent = True if args.listunspent: rest = rpc.listunspent() rpc_output += "\"listunspent:\" " + "\r\n" cpt = 0 for itr in rest: if itr['spendable'] and itr['solvable']: rpc_output += str(cpt) + " : " rpc_output += str(itr['txid']) + " : " + str(itr['amount']) rpc_output += "\r\n" cpt += 1 if args.listlockunspent: rest = rpc.listlockunspent() rpc_output += "\"listlockunspent:\" " + "\r\n" cpt = 0 for itr in rest: rpc_output += str(cpt) + " : " rpc_output += str(itr['txid']) rpc_output += "\r\n" cpt += 1 if args.listaccounts: rpc_output += "\"listaccounts:\" " + json.dumps(rpc.listaccounts(), indent=2) rpc_output += "\r\n" if args.getbalance: rpc_output += "\"getbalance:\" " + json.dumps(rpc.getbalance(), indent=2) rpc_output += "\r\n" if args.masternode: rpc_output += "\"masternode:\" " + json.dumps( rpc.getMasternode(*str(args.masternode[0])), indent=2) rpc_output += "\r\n" print(rpc_output)
class Daemon(): def __init__(self): self.bitcoind_command = ['bitcoind'] self.rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) def check(self): try: self.rpc.get('getinfo') except: os.system( "kill -9 `ps -ef | grep bitcoind | grep -v grep | awk '{print $2}'`" ) logger.warning( json.dumps({'message': 'unresponsive bitcoind killed'})) sleep(60) # give bitcoind time to die os.system("bitcoind &") logger.warning(json.dumps({'message': 'bitcoind started'})) sleep(300) # wait a bit on the long side for more reliability def get_transactions(self, number): return self.rpc.get('listtransactions', ['*', int(number)]) def get_accountaddress(self, account): return self.rpc.get('getaccountaddress', [account]) def get_receivedbyaddress(self, address, minconf): res = self.rpc.get('getreceivedbyaddress', [address, int(minconf)]) return res['output']['result'] def get_balance(self, minconf): res = self.rpc.get('getbalance', ['*', int(minconf)]) return Decimal(str(res)) def send(self, address, amount): pass
class Daemon: def __init__(self): self.bitcoind_command = ["bitcoind"] self.rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) def check(self): try: self.rpc.get("getinfo") except: os.system("kill -9 `ps -ef | grep bitcoind | grep -v grep | awk '{print $2}'`") logger.warning(json.dumps({"message": "unresponsive bitcoind killed"})) sleep(60) # give bitcoind time to die os.system("bitcoind &") logger.warning(json.dumps({"message": "bitcoind started"})) sleep(300) # wait a bit on the long side for more reliability def get_transactions(self, number): return self.rpc.get("listtransactions", ["*", int(number)]) def get_accountaddress(self, account): return self.rpc.get("getaccountaddress", [account]) def get_receivedbyaddress(self, address, minconf): res = self.rpc.get("getreceivedbyaddress", [address, int(minconf)]) return res["output"]["result"] def get_balance(self, minconf): res = self.rpc.get("getbalance", ["*", int(minconf)]) return Decimal(str(res)) def send(self, address, amount): pass
def query_bitcoin(): if not core_enabled: body = json.dumps({ "result": "error", "message": "Bitcoin Core not enabled for this server" }) return (body, 200, { 'Content-length': len(body), 'Content-type': 'application/json', }) rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) # to begin, get hash, block height, and time for latest, then n-blocks-ago, or for a block hash owner = request.args.get('owner') string = request.args.get('query') sales = db.session.query(Sale).filter(Sale.owner == owner).count() res = [] out = {} if sales == 0: body = json.dumps({ "result": "error", "message": "Account required to make queries" }) return (body, 200, { 'Content-length': len(body), 'Content-type': 'application/json', }) elif string == 'getbydepth': depth = request.args.get('depth') res = rpc.get('getblockcount') if 'output' in res and 'result' in res['output']: height = res['output']['result'] - int(depth) elif string == 'getbyheight': height = request.args.get('height') elif string == 'getbyhash': res = rpc.get('getblockheader', [request.args.get('hash')]) height = res['output']['result']['height'] elif string == 'sendrawtransaction': tx = request.args.get('tx') res = rpc.get('sendrawtransaction', [str(tx)]) if 'output' in res and 'result' in res['output']: out['txid'] = res['output']['result'] body = json.dumps(out) return (body, 200, { 'Content-length': len(body), 'Content-type': 'application/json', }) res = rpc.get('getblockhash', [int(height)]) out['height'] = height if 'output' in res and 'result' in res['output']: out['hash'] = res['output']['result'] res = rpc.get('getblockheader', [str(out['hash'])]) out['time'] = res['output']['result']['time'] out['height'] = height body = json.dumps(out) else: body = json.dumps({ "result": "error", "message": "Invalid depth or RPC error" }) return (body, 200, { 'Content-length': len(body), 'Content-type': 'application/json', })
res = rpc.get('getblockcount') if 'output' in res and 'result' in res['output']: height = res['output']['result'] - int(depth) else: return None res = rpc.get('getblockhash', [height]) out = {} if 'output' in res and 'result' in res['output']: out['hash'] = res['output']['result'] res = rpc.get('getblockheader', [out['hash']]) out['time'] = res['output']['result']['time'] out['height'] = height return out if __name__ == '__main__': if DEBUG: app.debug = True rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) try: rpc.get('getblockcount') core_enabled = CORE_ENABLED except: core_enabled = False print("Core enabled: " + str(core_enabled)) app.run(host='0.0.0.0', port=(os.environ.get('SERVER_PORT', SERVER_PORT))) #app.run(host='127.0.0.1', port=SERVER_PORT)
def stereo_to_xyz(img1_name, img2_name, predictor): # read rgb images as pan img1 = cv2.imread(img1_name, 0) img2 = cv2.imread(img2_name, 0) # read rgb images rgb_img1 = tifffile.imread(img1_name) rgb_img2 = tifffile.imread(img2_name) # get RPC metadata for both images rpc1 = RPC(img1_name) rpc2 = RPC(img2_name) # find corresponding points rows = img1.shape[0] cols = img1.shape[1] F, pts1, pts2 = match_rpc(rpc1, rpc2, rows, cols) # transpose the point matrices x1 = pts1.T x2 = pts2.T # set camera matrix to identity and distortion to zero d = None K = np.identity(3) # rectify the images rimg1, rimg2, rms, max_error, lH, rH, max_yparallax = rectify_images( img1, x1, img2, x2, K, d, F, shearing=False) print('F Matrix Residual RMS Error = ', rms, ' pixels') print('F Matrix Residual Max Error = ', max_error, ' pixels') # skip this pair if residual error is too large # this is not a good indicator of failure if rms > 1.0: return None, None, None, None, None # skip this pair if max y parallax is too large if max_yparallax > 2.0: return None, None, None, None, None # crop down to the center half of the images rows = img1.shape[0] cols = img1.shape[1] row_offset = int(rows / 4) col_offset = int(cols / 4) # rectify the RGB versions of the images and crop to center rgb_rimg1, rgb_rimg2, rgb_rms, rgb_max_error = rectify_images_rgb( rgb_img1, x1, rgb_img2, x2, K, d, F, shearing=False) rimg1 = rgb_rimg1[row_offset:rows - row_offset, col_offset:cols - col_offset, :] rimg2 = rgb_rimg2[row_offset:rows - row_offset, col_offset:cols - col_offset, :] # run DenseMapNet to get stereo disparities # and run IC-Net to get semantic labels if USE_SGM: disparity = sgbm(rimg1, rimg2) else: disparity = predictor.predict_stereo(rimg1, rimg2) # disparity = predictor.predict_stereo_wls(rimg1, rimg2) seg_rimg1 = predictor.predict_semantics(rimg1) # check for invalid disparity predictions rows = rimg1.shape[0] cols = rimg1.shape[1] valid = np.ones((rows, cols), dtype=bool) valid[disparity < -DMAX_SEARCH] = 0 valid[disparity > DMAX_SEARCH] = 0 disparity[disparity < -DMAX_SEARCH] = -DMAX_SEARCH disparity[disparity > DMAX_SEARCH] = DMAX_SEARCH print('Min disparity found: ', disparity.min()) print('Max disparity found: ', disparity.max()) # create a grayscale disparity image disparity_image = (disparity + DMAX_SEARCH) / (DMAX_SEARCH * 2.0) disparity_image[disparity_image < 0.0] = 0.0 disparity_image = img_as_ubyte(disparity_image) # create a color segmentation image cls_image = category_to_color(seg_rimg1) # get left epipolar image coordinates and right coordinates from disparities # add offsets from image cropping back to image coordinates # convert coordinates to original images using homographies from rectification rows = rimg1.shape[0] cols = rimg1.shape[1] left_rows, left_cols = np.mgrid[row_offset:rows + row_offset, col_offset:cols + col_offset] right_cols = deepcopy(left_cols) - disparity right_rows = deepcopy(left_rows) # valid[right_cols < 0] = 0 # valid[right_cols > cols-1] = 0 valid[right_cols < col_offset] = 0 valid[right_cols > cols + col_offset - 1] = 0 # left_rows = left_rows[:,DMAX_SEARCH:cols-DMAX_SEARCH] # left_cols = left_cols[:,DMAX_SEARCH:cols-DMAX_SEARCH] # right_rows = right_rows[:,DMAX_SEARCH:cols-DMAX_SEARCH] # right_cols = right_cols[:,DMAX_SEARCH:cols-DMAX_SEARCH] left_rows = left_rows.ravel() left_cols = left_cols.ravel() right_rows = right_rows.ravel() right_cols = right_cols.ravel() num = len(left_cols) print('left cols = ', num) uv1 = np.array((left_cols, left_rows, np.ones(num))) print(uv1.shape) print(rH.shape) xyw = np.matmul(np.linalg.inv(rH), uv1) left_cols = xyw[0] / xyw[2] left_rows = xyw[1] / xyw[2] uv2 = np.array((right_cols, right_rows, np.ones(num))) xyw = np.matmul(np.linalg.inv(lH), uv2) right_cols = xyw[0] / xyw[2] right_rows = xyw[1] / xyw[2] # get left segmentation labels for valid disparities # left_seg = seg_rimg1[:,DMAX_SEARCH:cols-DMAX_SEARCH] left_seg = seg_rimg1 print('left_seg shape = ', left_seg.shape) left_seg = left_seg.ravel() # crop and ravel valid point list print('valid shape = ', valid.shape) # valid = valid[:,DMAX_SEARCH:cols-DMAX_SEARCH] valid = valid.ravel() print('valid shape = ', valid.shape) # approximate RPCs with local 3x4 matrices # use center coordinate of one of the images for reference clat, clon, zc = rpc1.approximate_wgs84() xc, yc, zone_number, zone_letter = wgs84_to_utm(clat, clon) R1, rms1, ic1, jc1 = rpc1.to_matrix(clat, clon, zc) R2, rms2, ic2, jc2 = rpc2.to_matrix(clat, clon, zc) # triangulate to compute XYZ coordinates for each pixel print('Triangulating...') points1 = np.array((left_cols - ic1, left_rows - jc1)) points2 = np.array((right_cols - ic2, right_rows - jc2)) xyz = cv2.triangulatePoints(R1, R2, points1, points2) xyz /= xyz[3] xyz = xyz[0:3, valid] xyz[0, :] += xc xyz[1, :] += yc xyz[2, :] += zc xyz = np.transpose(xyz) print(zone_number, zone_letter) # add cls to the xyz array xyzc = np.zeros((xyz.shape[0], xyz.shape[1] + 1)) xyzc[:, 0:3] = xyz left_seg = left_seg[valid] xyzc[:, 3] = left_seg return xyzc, rimg1, rimg2, disparity_image, cls_image
async def connect_client(request): game_state = request.app['game_state'] # make a unique id for this connection's IP address connection_ids = request.app['connection_ids'] connection_ids[request.remote] += 1 connection_id = connection_ids[request.remote] ws = web.WebSocketResponse( heartbeat=1.0, ) rpc = RPC(ws, game_state) def log(msg, *args, **kwargs): log_prefix = f'[{request.remote}#{connection_id}]' if rpc.player_id is not None: log_prefix += f' [{rpc.player_id}' if rpc.player is not None: log_prefix += f' ({rpc.player.name})' log_prefix += ']' print(f'{log_prefix} {msg}', *args, **kwargs) log('connecting') # upgrade the HTTP request to a WebSocket connection await ws.prepare(request) log('connected') # tell the game state about the new connection await game_state.connect(rpc) try: # loop through all messages receieved over connection async for msg in rpc.ws: if msg.type == aiohttp.WSMsgType.TEXT: # load message as JSON try: msg = json.loads(msg.data) except json.JSONDecodeError as e: log('message error:', e) continue try: # find a method on the RPC type matching the `type` field msg_type = msg.pop('type') if msg_type is None or msg_type.startswith('_') or not hasattr(RPC, msg_type): raise ClientError(f'unknown message type {msg_type}') cmd = getattr(rpc, msg_type) # TODO: type check arguments log( msg_type + '(' + ', '.join( key + '=' + repr(value) for key, value in msg.items() ) + ')', ) # use inspect module to get argument names of method required_args = [ p.name for p in inspect.signature(cmd).parameters.values() if p.default is inspect.Parameter.empty ] # find which args are missing in WS message missing_args = [ arg for arg in required_args if arg not in msg ] if missing_args: raise ClientError(f'missing arguments to {msg_type}: {", ".join(missing_args)}') game_state.message = '' # call the method with the message as kwargs cmd(**msg) # mark the game state as changed so it will update the connections game_state.mark_dirty() except ClientError as e: log('client error:', e) # tell the client that it did something wrong await rpc.ws.send_json({ 'type': 'error', 'error': e.message, }) except: log('error handling message:') traceback.print_exc() elif msg.type == aiohttp.WSMsgType.ERROR: log('connection closed with exception:', rpc.ws.exception()) finally: # loop ended, client must have disconnected or an error occurred log('disconnected') # tell the game state that this connection is disconnecting await game_state.disconnect(rpc) # mark the game state as changed so it can update the remaining connections about the disconnected one game_state.mark_dirty() return rpc.ws
def __init__(self): self.bitcoind_command = ["bitcoind"] self.rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT)
def get_by_depth(depth): rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) res = rpc.get('getblockcount') if 'output' in res and 'result' in res['output']: height = res['output']['result'] - int(depth) else: return None res = rpc.get('getblockhash', [height]) out = {} if 'output' in res and 'result' in res['output']: out['hash'] = res['output']['result'] res = rpc.get('getblockheader', [out['hash']]) out['time'] = res['output']['result']['time'] out['height'] = height return out if __name__ == '__main__': if DEBUG: app.debug = True rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) try: rpc.get('getblockcount') core_enabled = CORE_ENABLED except: core_enabled = False print("Core enabled: " + str(core_enabled)) app.run(host='0.0.0.0', port=SERVER_PORT)
def update(pid, version, proc_handle, base_address): def return_weapon_or_tool(ply_id, ply_team, tool_id, ply_intel_status): holds_intel = False if ply_id == -1: current_tool = ["largeimagekey_loading", "Loading map..."] return [current_tool, holds_intel] if ply_team == -2: current_tool = ["largeimagekey_teamselection", "Choosing team"] elif ply_team == -1: current_tool = ["largeimagekey_spectating", "Spectating"] else: if tool_id == 2: current_tool = dicts.GUNS[proc_handle.read_int( base_address + dicts.WEAPON_ADDRS_PER_ID_75[ply_id])] else: current_tool = dicts.TOOLS[tool_id] if ply_intel_status[0] == ply_id or ply_intel_status[ 1] == ply_id: # if team1 id == playerId or team2 id == playerId holds_intel = True return [current_tool, holds_intel] return [current_tool, holds_intel] # inside update() try: if version == '0.75': ply_id_75 = proc_handle.read_int(base_address + 0x13B1CF0) tool_id_75 = proc_handle.read_int(base_address + 0x13CF808) ply_intel_status_team1_75 = proc_handle.read_int( base_address + 0x13CF958 ) # it gives the ID of a player that holds an intel from team 1 ply_intel_status_team2_75 = proc_handle.read_int( base_address + 0x13CF924) # < - same here but team 2 if ply_id_75 == -1: ply_team_75 = None else: ply_team_75 = proc_handle.read_int( base_address + dicts.TEAM_ADDRS_PER_ID_75[ply_id_75]) ply_status = return_weapon_or_tool( ply_id_75, ply_team_75, tool_id_75, [ply_intel_status_team1_75, ply_intel_status_team2_75]) elif version == '0.76': ply_id_76 = proc_handle.read_int(base_address + 0x13B19B0) tool_id_76 = proc_handle.read_int(base_address + 0x13CF488) ply_intel_status_team1_76 = proc_handle.read_int( base_address + 0x13CF5D8) # here same thing but for another version ply_intel_status_team2_76 = proc_handle.read_int(base_address + 0x13CF5A4) if ply_id_76 == -1: ply_team_76 = None else: ply_team_76 = proc_handle.read_int( base_address + dicts.TEAM_ADDRS_PER_ID_76[ply_id_76]) ply_status = return_weapon_or_tool( ply_id_76, ply_team_76, tool_id_76, [ply_intel_status_team1_76, ply_intel_status_team2_76]) else: ply_status = [[ "ace_of_spades", "(Server is not broadcasting to master server)" ], None] return ply_status except KeyboardInterrupt: logger.warning('KeyboardInterrupt caught. Closing.') RPC.clear(pid=pid) RPC.close() try: proc_handle.close_process() except pymem.exception.ProcessError: sys.exit(0) sys.exit(0)
def save_block_info(provider, live, blockindex, unconf): data = {} # obtain data to process if live or unconf: raw = '' if provider == 'blockchaininfo': if blockindex != "last": url = "https://blockchain.info/block-height/" + str( blockindex) + "?format=json" elif unconf: url = "https://blockchain.info/unconfirmed-transactions?format=json&offset=" else: url = "https://blockchain.info/latestblock" if not unconf: response = urllib.urlopen(url) raw = response.read() parsed = json.loads(raw) else: txs = [] response = urllib.urlopen( "https://blockchain.info/q/unconfirmedcount") unconf_count = int(response.read()) for i in range(unconf_count, 0, -50): response = urllib.urlopen(url + str(i)) raw = response.read() parsed = json.loads(raw) txs = txs + parsed['txs'] if blockindex != "last" or unconf: if not unconf: height = parsed['blocks'][0]['height'] block_hash = parsed['blocks'][0]['hash'] data = parsed['blocks'][0] else: height = "unconf" block_hash = "unconf" data = {} data['tx'] = txs else: height = parsed['height'] block_hash = parsed['hash'] url = "https://blockchain.info/rawblock/" + parsed['hash'] response = urllib.urlopen(url) raw = response.read() parsed = json.loads(raw) data = parsed f = open( "blocks/" + str(height) + "-" + provider + "-" + block_hash + ".txt", "w") f.write(json.dumps(raw)) f.close() else: from rpc import RPC rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) block_hash = best_block_hash = rpc.get( 'getbestblockhash')['output']['result'] block = rpc.get('getblock', [block_hash])['output']['result'] height = block['height'] if blockindex == 'unprocessed': con = mysql.connector.connect(user=MYSQL_USER, password=MYSQL_PASSWORD, database=MYSQL_DATABASE) cur = con.cursor() while 1: cur.execute('select * from block where height = %s' % height) if cur.fetchall(): height = height - 1 else: break block_hash = rpc.get('getblockhash', [height])['output']['result'] con.close() else: height = blockindex block_hash = rpc.get('getblockhash', [int(blockindex)])['output']['result'] block = rpc.get('getblock', [block_hash])['output']['result'] height = block['height'] block_hash = block['hash'] block_time = block['time'] data['tx'] = [] tx_cache = {} for txid in block['tx']: rawtx = rpc.get('getrawtransaction', [txid])['output']['result'] tx = rpc.get('decoderawtransaction', [rawtx])['output']['result'] if txid not in tx_cache: tx_cache[txid] = tx for txid in block['tx']: rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT) tx = tx_cache[txid] for inp in tx['vin']: if 'txid' not in inp: continue if inp['txid'] not in tx_cache: rawtx = rpc.get('getrawtransaction', [inp['txid']])['output']['result'] inptx = rpc.get('decoderawtransaction', [rawtx])['output']['result'] tx_cache[inp['txid']] = inptx else: inptx = tx_cache[inp['txid']] #TODO: deal with nonstandard transaction inputs whose transactions don't seem to have enough outputs if inp['vout'] < len(inptx['vout']): inp['value'] = inptx['vout'][inp['vout']]['value'] data['tx'].append(tx) else: if provider == 'blockchaininfo': the_file = '000000000000000016bae92da911065f77e52e65c7c5d164ee12b57247176ab0.json' else: the_file = 'last' with open(the_file) as data_file: data = json.load(data_file) normalized_data = {'tx': []} for tx in data['tx']: normalized_data['tx'].append(read_transaction(tx, provider)) stats = process_block(normalized_data, provider) con = mysql.connector.connect(user=MYSQL_USER, password=MYSQL_PASSWORD, database=MYSQL_DATABASE) cur = con.cursor() insertstmt = ( "insert into block (created, time, height, hash) values (now(), FROM_UNIXTIME(%s), '%s', '%s')" % (block_time, height, block_hash)) cur.execute(insertstmt) for key in stats.keys(): val = stats[key] if isinstance(val, dict) and 'count' in val: val = val['count'] cur.execute( "insert into block_info (created, time, height, hash, metric, value) values (now(), FROM_UNIXTIME(%s), '%s', '%s', '%s', '%s')" % (block_time, height, block_hash, key, val)) con.commit() con.close() print json.dumps(stats) return height, block_hash
def rpc(name, server): conf = defaults['rpc'] conf['server'] = server return RPC(name, conf)
from rpc import RPC if __name__ == '__main__': rpc = RPC() rpc.start_server()
def __init__(self): self.bitcoind_command = ['bitcoind'] self.rpc = RPC(RPCUSER, RPCPASS, SERVER, RPCPORT)
def main(): """ Check if the number of churns passed in within our allowed range """ if CHURNS < CHURN_LOWER: print("Can't churn less than {} times. Exiting...".format(CHURN_LOWER)) sys.exit(1) elif CHURNS > CHURN_UPPER: print("Can't churn more than {} times. Exiting...".format(CHURN_UPPER)) sys.exit(1) """ Indicate whether it's a dry run """ if IS_DRY_RUN: print() print("*********************************************") print("DRY RUN IN PROGRESS: FUNDS WILL NOT BE MOVED!") print("*********************************************") """ Check if we need to create new accounts within the walllet """ rpc = RPC() response = rpc.get_accounts() accounts = response["result"]["subaddress_accounts"] total_accounts = len(accounts) print("\nChurns: {}\tTotal accounts: {}\n".format(CHURNS, total_accounts)) if create_accounts(CHURNS, total_accounts, rpc): # Re-fetch accounts response = rpc.get_accounts() accounts = response["result"]["subaddress_accounts"] """ Sweep all to first account Grab a transaction hash, then get churn timings. The transaction hash is needed to get the churn times. """ print("\nChurn 1") # Send all funds to first account # and grab tx_hash to get churn timings tx_hash = churn(accounts, 1, rpc, dry_run=IS_DRY_RUN) wait_times = [] if tx_hash is not None: print( "\n\nUsing transaction hash {} to get wait times".format(tx_hash)) wait_times = get_wait_times_from_transaction(tx_hash, rpc) else: wait_times = get_dry_run_wait_times(CHURNS, quick=IS_QUICK) print_wait_times(CHURNS, wait_times) """ Using the generated churn times: sleep, churn, repeat NOTE: First sweep_all counts as a churn. """ for n in range(2, CHURNS): # Sleep first, then churn current_wait_time = wait_times[n - 2] sleep(current_wait_time) # Start a new churn print("\n\nChurn", n) churn(accounts, n, rpc, dry_run=IS_DRY_RUN) """ Last churn, back to account 0 """ # Sleep first, then do the last churn current_wait_time = wait_times[len(wait_times) - 1] sleep(current_wait_time) # Transfer all back to main account print("\n\nLast churn ({})".format(CHURNS)) churn(accounts, 0, rpc, dry_run=IS_DRY_RUN) """ Exit when done """ print( "\n\nChurns completed successfully\n" "(It may take time for your balance to unlock from the last churn)\n") # print("Exiting...\n") sys.exit(0)
sys.exit(0) price_prefix = 'coingecko:spectresecuritycoin' # Environment configuration rpc_url = os.getenv('RPC_URL', 'http://[::1]:13337') work_url = os.getenv('WORK_URL', None) fcm_api_key = os.getenv('FCM_API_KEY', None) fcm_sender_id = os.getenv('FCM_SENDER_ID', None) debug_mode = True if int(os.getenv('DEBUG', 1)) != 0 else False # Objects loop = asyncio.get_event_loop() rpc = RPC(rpc_url, work_url=work_url, price_prefix=price_prefix) # all currency conversions that are available currency_list = ["BTC", "ARS", "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK", "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN", "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "USD", "VES", "ZAR", "SAR", "AED", "KWD"] # Push notifications async def delete_fcm_token_for_account(account : str, token : str, r : web.Request): await r.app['rfcm'].delete(token) async def update_fcm_token_for_account(account : str, token : str, r : web.Request, v2 : bool = False): """Store device FCM registration tokens in redis""" redisInst = r.app['rfcm'] if v2 else r.app['rdata'] await set_or_upgrade_token_account_list(account, token, r, v2=v2)
def kill(self): if self.status == "RUNNING" and self.container != None: self.cleanup_rpc = RPC(self.container, None, ("CONTAINER_REMOTE_CLEANUP", self.work)) self.rpcManager.send(self.cleanup_rpc) self.pool.activate(self)
import pickle from rpc import RPC, ORDER connection = pika.BlockingConnection( pika.ConnectionParameters(host='localhost')) channel = connection.channel() # create anonymous queue result = channel.queue_declare(exclusive=True) callback_queue = result.method.queue def callback(ch, method, properties, body): if method.routing_key == 'orders': print("Got my order {}".format(pickle.load(body))) channel.basic_consume(callback, queue=callback_queue, no_ack=True) channel.basic_publish(exchange='', routing_key='orders', properties=pika.BasicProperties(reply_to=callback_queue, correlation_id=str( uuid.uuid1())), body=pickle.dumps(RPC(ORDER, {'hamburger': 2}))) print("Order placed") channel.start_consuming() connection.close()
sys.exit(0) price_prefix = 'coingecko:nano' if not banano_mode else 'coingecko:banano' # Environment configuration rpc_url = os.getenv('RPC_URL', 'http://[::1]:7076') work_url = os.getenv('WORK_URL', None) fcm_api_key = os.getenv('FCM_API_KEY', None) fcm_sender_id = os.getenv('FCM_SENDER_ID', None) debug_mode = True if int(os.getenv('DEBUG', 1)) != 0 else False # Objects loop = asyncio.get_event_loop() rpc = RPC(rpc_url, banano_mode, work_url=work_url, price_prefix=price_prefix) util = Util(banano_mode) # all currency conversions that are available currency_list = [ "BTC", "ARS", "AUD", "BRL", "CAD", "CHF", "CLP", "CNY", "CZK", "DKK", "EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PKR", "PLN", "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "USD", "VES", "ZAR", "SAR", "AED", "KWD" ] # Push notifications async def delete_fcm_token_for_account(account: str, token: str, r: web.Request): await r.app['rdata'].delete(token)
from rpc import RPC if __name__ == '__main__': client = RPC() client.ask_node(rpc_port=8000,function='test')