def _parseQR(self, image):
self.w = image.width()
self.h = image.height()
img_crop_rect = self._get_crop(image, 360)
frame_cropped = image.copy(img_crop_rect)
async def co_parse_qr(image):
# Convert to Y800 / GREY FourCC (single 8-bit channel)
# This creates a copy, so we don't need to keep the frame around anymore
frame_y800 = image.convertToFormat(QImage.Format_Grayscale8)
self.frame_id = 0
# Read the QR codes from the frame
self.qrreader_res = self.qrreader.read_qr_code(
frame_y800.constBits().__int__(), frame_y800.byteCount(),
frame_y800.bytesPerLine(), frame_y800.width(),
frame_y800.height(), self.frame_id)
if len(self.qrreader_res) > 0:
result = self.qrreader_res[0]
self._data = result
self.dataChanged.emit()
self._busy = False
self.busyChanged.emit()
asyncio.run_coroutine_threadsafe(co_parse_qr(frame_cropped),
get_asyncio_loop())
def test_fork_noconflict(self):
blockchain.blockchains = {}
self.interface.q.put_nowait({
'block_height': 8,
'mock': {
'catchup': 1,
'check': lambda x: False,
'connect': lambda x: False
}
})
def mock_connect(height):
return height == 6
self.interface.q.put_nowait({
'block_height': 7,
'mock': {
'backward': 1,
'check': lambda x: False,
'connect': mock_connect,
'fork': self.mock_fork
}
})
self.interface.q.put_nowait({
'block_height': 2,
'mock': {
'backward': 1,
'check': lambda x: True,
'connect': lambda x: False
}
})
self.interface.q.put_nowait({
'block_height': 4,
'mock': {
'binary': 1,
'check': lambda x: True,
'connect': lambda x: True
}
})
self.interface.q.put_nowait({
'block_height': 5,
'mock': {
'binary': 1,
'check': lambda x: True,
'connect': lambda x: True
}
})
self.interface.q.put_nowait({
'block_height': 6,
'mock': {
'binary': 1,
'check': lambda x: True,
'connect': lambda x: True
}
})
ifa = self.interface
fut = asyncio.run_coroutine_threadsafe(
ifa.sync_until(8, next_height=7), util.get_asyncio_loop())
self.assertEqual(('fork', 8), fut.result())
self.assertEqual(self.interface.q.qsize(), 0)
def _lnurl_get_invoice(self) -> None:
assert self._lnurl_data
amount = self.amount_e.get_amount()
if not (self._lnurl_data.min_sendable_sat <= amount <=
self._lnurl_data.max_sendable_sat):
self.show_error(
f'Amount must be between {self._lnurl_data.min_sendable_sat} and {self._lnurl_data.max_sendable_sat} sat.'
)
return
async def f():
try:
invoice_data = await callback_lnurl(
self._lnurl_data.callback_url,
params={'amount': self.amount_e.get_amount() * 1000},
)
except LNURLError as e:
self.show_error_signal.emit(
f"LNURL request encountered error: {e}")
self.clear_send_tab_signal.emit()
return
invoice = invoice_data.get('pr')
self.lnurl6_round2_signal.emit(invoice)
asyncio.run_coroutine_threadsafe(
f(), get_asyncio_loop()) # TODO should be cancellable
self.prepare_for_send_tab_network_lookup()
def generate_seed(self, seed_type='segwit', language='en'):
self._logger.debug('generating seed of type ' + str(seed_type))
async def co_gen_seed(seed_type, language):
self.generatedSeed = mnemonic.Mnemonic(language).make_seed(
seed_type=seed_type)
self._logger.debug('seed generated')
self.generatedSeedChanged.emit()
asyncio.run_coroutine_threadsafe(co_gen_seed(seed_type, language),
get_asyncio_loop())
def set_lnurl6(self, lnurl: str, *, can_use_network: bool = True):
try:
url = decode_lnurl(lnurl)
except LnInvoiceException as e:
self.show_error(_("Error parsing Lightning invoice") + f":\n{e}")
return
if not can_use_network:
return
async def f():
try:
lnurl_data = await request_lnurl(url)
except LNURLError as e:
self.show_error_signal.emit(
f"LNURL request encountered error: {e}")
self.clear_send_tab_signal.emit()
return
self.lnurl6_round1_signal.emit(lnurl_data, url)
asyncio.run_coroutine_threadsafe(
f(), get_asyncio_loop()) # TODO should be cancellable
self.prepare_for_send_tab_network_lookup()
def test_chain_false_during_binary(self):
blockchain.blockchains = {}
self.interface.q.put_nowait({
'block_height': 8,
'mock': {
'catchup': 1,
'check': lambda x: False,
'connect': lambda x: False
}
})
mock_connect = lambda height: height == 3
self.interface.q.put_nowait({
'block_height': 7,
'mock': {
'backward': 1,
'check': lambda x: False,
'connect': mock_connect
}
})
self.interface.q.put_nowait({
'block_height': 2,
'mock': {
'backward': 1,
'check': lambda x: True,
'connect': mock_connect
}
})
self.interface.q.put_nowait({
'block_height': 4,
'mock': {
'binary': 1,
'check': lambda x: False,
'fork': self.mock_fork,
'connect': mock_connect
}
})
self.interface.q.put_nowait({
'block_height': 3,
'mock': {
'binary': 1,
'check': lambda x: True,
'connect': lambda x: True
}
})
self.interface.q.put_nowait({
'block_height': 5,
'mock': {
'catchup': 1,
'check': lambda x: False,
'connect': lambda x: True
}
})
self.interface.q.put_nowait({
'block_height': 6,
'mock': {
'catchup': 1,
'check': lambda x: False,
'connect': lambda x: True
}
})
ifa = self.interface
fut = asyncio.run_coroutine_threadsafe(
ifa.sync_until(8, next_height=6), util.get_asyncio_loop())
self.assertEqual(('catchup', 7), fut.result())
self.assertEqual(self.interface.q.qsize(), 0)
def __init__(self):
self.asyncio_loop = util.get_asyncio_loop()