Python create_and_start_event_loop 예제들

예제 #1

파일: test_compatibility_rpc.py 프로젝트: cryptocrowd-city/xcrc-electrum-wallet

 def setUp (self):
   super ().setUp ()
   self.asyncio_loop, self._stop_loop, self._loop_thread \
       = util.create_and_start_event_loop ()
   self.config = SimpleConfig({'electrum_path': self.electrum_path})
   cmd = Commands (config=self.config)
   self.logic = compatibility_rpc.Logic (cmd)

예제 #2

파일: bitcoin.py 프로젝트: CodeForcer/electrum-segmentation-fault

 def func_wrapper(self, *args, **kwargs):
     self.loop, self.stopping_fut, self.loop_thread = \
         util.create_and_start_event_loop()
     retval = func(self, *args, **kwargs)
     asyncio.run_coroutine_threadsafe(end_thread(self.stopping_fut),
                                      self.loop).result()
     return retval

예제 #3

파일: test_lnrouter.py 프로젝트: JuliusPeng/qtum-electrum

 def setUp(self):
     super().setUp()
     self.asyncio_loop, self._stop_loop, self._loop_thread = create_and_start_event_loop(
     )
     self.config = SimpleConfig({'electrum_path': self.electrum_path})

예제 #4

 def setUp(self):
     super().setUp()
     self.asyncio_loop, self._stop_loop, self._loop_thread = create_and_start_event_loop(
     )
     self.alice_channel, self.bob_channel = create_test_channels()

예제 #5

파일: get_history.py 프로젝트: lucasan123/electrum-bitgesell

import asyncio

from electrum import bitgesell
from electrum.network import Network
from electrum.util import json_encode, print_msg, create_and_start_event_loop, log_exceptions
from electrum.simple_config import SimpleConfig

try:
    addr = sys.argv[1]
except Exception:
    print("usage: get_history <bitgesell_address>")
    sys.exit(1)

config = SimpleConfig()

loop, stopping_fut, loop_thread = create_and_start_event_loop()
network = Network(config)
network.start()


@log_exceptions
async def f():
    try:
        sh = bitgesell.address_to_scripthash(addr)
        hist = await network.get_history_for_scripthash(sh)
        print_msg(json_encode(hist))
    finally:
        stopping_fut.set_result(1)


asyncio.run_coroutine_threadsafe(f(), loop)

예제 #6

 def setUp(self):
     super().setUp()
     self.asyncio_loop, self._stop_loop, self._loop_thread = create_and_start_event_loop(
     )

예제 #7

from electrum.network import Network
from electrum.util import print_msg, create_and_start_event_loop
from electrum.synchronizer import SynchronizerBase
from electrum.simple_config import SimpleConfig

try:
    addr = sys.argv[1]
except Exception:
    print("usage: watch_address <ravencoin_address>")
    sys.exit(1)

config = SimpleConfig()

# start network
loop = create_and_start_event_loop()[0]
network = Network(config)
network.start()


class Notifier(SynchronizerBase):
    def __init__(self, network):
        SynchronizerBase.__init__(self, network)
        self.watched_addresses = set()
        self.watch_queue = asyncio.Queue()

    async def main(self):
        # resend existing subscriptions if we were restarted
        for addr in self.watched_addresses:
            await self._add_address(addr)
        # main loop

예제 #8

파일: servers.py 프로젝트: ahmedbodi/electrum

#!/usr/bin/env python3
import json
import asyncio

from electrum.simple_config import SimpleConfig
from electrum.network import filter_version, Network
from electrum.util import create_and_start_event_loop, log_exceptions
from electrum import constants

import util

# testnet?
#constants.set_testnet()
config = SimpleConfig({'testnet': False})

loop, stopping_fut, loop_thread = create_and_start_event_loop()
network = Network(config)
network.start()

@log_exceptions
async def f():
    try:
        peers = await util.get_peers(network)
        peers = filter_version(peers)
        print(json.dumps(peers, sort_keys=True, indent=4))
    finally:
        stopping_fut.set_result(1)

asyncio.run_coroutine_threadsafe(f(), loop)

예제 #9

파일: watch_address.py 프로젝트: ahmedbodi/electrum

import sys
import asyncio

from electrum.network import Network
from electrum.util import print_msg, create_and_start_event_loop
from electrum.synchronizer import SynchronizerBase


try:
    addr = sys.argv[1]
except Exception:
    print("usage: watch_address <bitcoin_address>")
    sys.exit(1)

# start network
loop = create_and_start_event_loop()[0]
network = Network()
network.start()


class Notifier(SynchronizerBase):
    def __init__(self, network):
        SynchronizerBase.__init__(self, network)
        self.watched_addresses = set()
        self.watch_queue = asyncio.Queue()

    async def main(self):
        # resend existing subscriptions if we were restarted
        for addr in self.watched_addresses:
            await self._add_address(addr)
        # main loop

예제 #10

 def setUp(self):
     super().setUp()
     self.asyncio_loop, self._stop_loop, self._loop_thread = create_and_start_event_loop()
     self._lnworkers_created = []  # type: List[MockLNWallet]

예제 #11

 def setUp(self):
     super().setUp()
     self.asyncio_loop, self._stop_loop, self._loop_thread = util.create_and_start_event_loop()
     self.electrum_path = tempfile.mkdtemp()