def discovery_bulbs_sync(on_complete):
discovered_bulbs = discover_bulbs()
wrappers = []
for bulb_info in discovered_bulbs:
wrappers.append(BulbWrapper(bulb_info))
idle_add(on_complete, wrappers)
def do_call():
error = None
try:
pass
except Exception as err:
error = err
idle_add(lambda: self.on_value_complete(claim, values, error)) #,
def change_delay_off_sync(self, delay, on_complete):
if delay == 0:
self.get_bulb().cron_del(CronType.off)
else:
self.get_bulb().cron_add(CronType.off, delay)
self.update_status_sync()
idle_add(on_complete)
def do_call():
results, error = None, None
try:
results = wikidata.select(var, statements)
except Exception as err:
raise err
idle_add(lambda: callback(results, *cb_args, **kwargs))
async def build_client():
# build user and conversation list
ret = await hangups.build_user_conversation_list(
hangups_client)
user_list, conversation_list = ret
# create wrapper objects
self.__client = Client(hangups_client,
self.__asyncio_queue)
with self.__lists_lock:
self.__conversation_list = ConversationList(
conversation_list, self.__asyncio_queue)
self.__user_list = user_list
# give lists to waiting clients
for cb in self.__get_conversation_callbacks:
idle_add(cb, self.__conversation_list)
for cb in self.__get_userlist_callbacks:
idle_add(cb, self.__user_list)
# remove callbacks
self.__get_conversation_callbacks.clear()
self.__get_userlist_callbacks.clear()
# enable notifications
conversation_list.on_event.add_observer(
self.__incoming_event)
def do_call():
error = None
try:
wikidata.edit(URI, claim, target)
except Exception as err:
error = err
idle_add(lambda: callback(target, error, *cb_args))
def do_call():
entity, error = None, None
try:
entity = wikidata.download(URI, target=target)
except Exception as err:
error = err
idle_add(lambda: callback(URI, entity, error, *cb_args))
def downloadAndParseXSDSchema(self):
""" Download XSD schema from the web and parse it.
In case of download failure, use the hardcoded schema.
In case of parse failure, notify the user.
"""
try:
xsdSchemaFile = urlopen(XSD_SCHEMA_URL, timeout=3)
except Exception as e:
print('Failed to download XSD schema.\n' + str(e))
print('Using hardcoded XSD schema ...')
try:
self.xmlSchema = ET.XMLSchema(
ET.fromstring(XSD_SCHEMA_FALLBACK.encode('utf-8')))
except Exception as e:
print('Failed to parse XSD schema.\n' + str(e))
idle_add(
self.view.dialogs.MessagePopup(
self.view, MessageType.ERROR, 'Error',
'Failed to parse XSD schema.', str(e)).show)
else:
print('Got XSD Schema from', XSD_SCHEMA_URL)
try:
self.xmlSchema = ET.XMLSchema(ET.parse(xsdSchemaFile))
except Exception as e:
print('Failed to parse XSD schema.\n' + str(e))
idle_add(
self.view.dialogs.MessagePopup(
self.view, MessageType.ERROR, 'Error',
'Failed to parse XSD schema.', str(e)).show)
def get_conversation_list_async(self, callback):
with self.__lists_lock:
if self.__conversation_list:
# conversation list is loaded
idle_add(callback, self.__conversation_list)
else:
# is loading
self.__get_conversation_callbacks.append(callback)
def do_call():
error = None
try:
pass
except Exception as err:
print(URI)
raise err
idle_add(lambda: callback(*cb_args)) #claim, j))
def _resize_breadcrumbs (self, bc, size):
"""Update breadcrumbs for new size."""
if self._max_bc_size != size.width:
self._max_bc_size = size.width
# HACK: if we do the update now, stuff goes weird (the buttons
# don't get drawn), so wait until this event handler's returned
# first (I can't find a way to add a callback with higher
# priority)
idle_add(self._update_breadcrumbs)
def toggle_sync(self, status, on_complete):
if status is None:
self.get_bulb().toggle()
elif status:
self.get_bulb().turn_on()
else:
self.get_bulb().turn_off()
self.update_status_sync()
idle_add(on_complete)
def _idleaddUpdateProgress(self, _) -> None:
"""
Call idle_add to call updateProgress.
:param future: Optional future object.
:return:
"""
idle_add(self._updateProgress)
def _resize_breadcrumbs(self, bc, size):
"""Update breadcrumbs for new size."""
if self._max_bc_size != size.width:
self._max_bc_size = size.width
# HACK: if we do the update now, stuff goes weird (the buttons
# don't get drawn), so wait until this event handler's returned
# first (I can't find a way to add a callback with higher
# priority)
idle_add(self._update_breadcrumbs)
def do_call():
result = None
error = None
try:
result = f()
except Exception as err:
error = err
idle_add(lambda: on_done(result, error))
def _dbErrorDialog(self) -> None:
"""
Display a dialog indicating the Anki database is opened.
:return:
"""
idle_add(self._handler.resetProgressbar)
idle_add(AnkiDialog(self._handler).showAll)
def do_call():
results, error = [], None
try:
results = wikidata.search(query, filters=filters)
except Exception as err:
from requests.exceptions import ConnectionError
if type(err) == ConnectionError:
error = err
else:
raise err
idle_add(lambda: callback(results, error, *cb_args, **kwargs))
def change(self, vals):
""" Implementation of daemon class call-back function
NOTE: it is called not from main thread, so it have to add action in main GUI loop queue
It handles daemon status changes by updating icon, creating messages and also update
status information in menu (status, sizes and list of last synchronized items).
It is called when daemon detects any change of its status.
"""
LOGGER.info(
'%sChange event: %s', self.ID, ','.join([
'stat' if vals['statchg'] else '',
'size' if vals['szchg'] else '',
'last' if vals['lastchg'] else ''
]))
def do_change(vals, path):
""" Update information in menu """
self.menu.update(vals, path)
# Handle daemon status change by icon change
if vals['status'] != vals['laststatus']:
LOGGER.info('Status: %s -> %s', vals['laststatus'],
vals['status'])
self.updateIcon(vals['status']) # Update icon
# Create notifications for status change events
if APPCONF['notifications']:
if vals['laststatus'] == 'none': # Daemon has been started
self.notify.send(
_('Yandex.Disk daemon has been started'))
if vals['status'] == 'busy': # Just entered into 'busy'
self.notify.send(_('Synchronization started'))
elif vals['status'] == 'idle': # Just entered into 'idle'
if vals['laststatus'] == 'busy': # ...from 'busy' status
self.notify.send(
_('Synchronization has been completed'))
elif vals[
'status'] == 'paused': # Just entered into 'paused'
if vals['laststatus'] not in [
'none', 'unknown'
]: # ...not from 'none'/'unknown' status
self.notify.send(
_('Synchronization has been paused'))
elif vals[
'status'] == 'none': # Just entered into 'none' from some another status
if vals['laststatus'] != 'unknown': # ... not from 'unknown'
self.notify.send(
_('Yandex.Disk daemon has been stopped'))
else: # status is 'error' or 'no-net'
self.notify.send(_('Synchronization ERROR'))
# Remember current status (required for Preferences dialog)
self.currentStatus = vals['status']
idle_add(do_change, vals, self.config['dir'])
def read_from_file(self, file_name, offset=0):
self.__file_name = file_name
self.emit("file_type", self.file_ext)
if isfile(file_name):
with open(file_name, 'r', encoding="utf-8") as src:
self.text_buffer.set_text(src.read())
self.__last_changes += 1
self.__last_ctime = fstat(src.fileno()).st_ctime
self.text_buffer.set_modified(False)
if offset > -1:
cursor = self.text_buffer.get_iter_at_offset(offset)
self.text_buffer.place_cursor(cursor)
idle_add(self.scroll_to_cursor, cursor)
def update(self, select_row=False):
"""
Sends a status request to core and updates the torrent list with the result.
:param select_row: if the first row in the list should be selected if
no rows are already selected.
:type select_row: boolean
"""
if self.got_state:
if (self.search_box.search_pending is not None
and self.search_box.search_pending.active()):
# An update request is scheduled, let's wait for that one
return
# Send a status request
idle_add(self.send_status_request, None, select_row)
def validateXML(self, rootElement, failureMessage):
""" Validate the contents of rootElement.
In case of validation failure, notify the user with failureMessage.
"""
try:
self.xmlSchema.assertValid(rootElement)
except Exception as e:
print('Validation failed.\n' + str(e))
idle_add(self.view.Dialogs.showMessagePopup, self.view,
MessageType.ERROR, 'Error',
'Validation failed.', str(e), failureMessage)
return False
else:
print('Validation successful.')
return True
def displayOutput(outText, widget):
# # # NOTE: it is called not from main thread, so it have to add action in main loop queue
def do_display(outText, widget):
# global APPLOGO
statusWindow = Gtk.Dialog(
_('Yandex.Disk daemon output message'))
statusWindow.set_icon(APPLOGO)
statusWindow.set_border_width(6)
statusWindow.add_button(_('Close'), Gtk.ResponseType.CLOSE)
textBox = Gtk.TextView(
) # Create text-box to display daemon output
# Set output buffer with daemon output in user language
textBox.get_buffer().set_text(outText)
textBox.set_editable(False)
# Put it inside the dialogue content area
statusWindow.get_content_area().pack_start(
textBox, True, True, 6)
statusWindow.show_all()
statusWindow.run()
statusWindow.destroy()
widget.set_sensitive(True) # Enable menu item
idle_add(do_display, outText, widget)
def period_save_thread(self):
if self.period_save:
if self.__file_name and self.is_modified \
and not self.__pause_period:
idle_add(self.save_to_file)
timeout_add_seconds(self.period_save, self.period_save_thread)
def set_style(self, style):
self.style = style
idle_add(self.do_render)
def fun2(*args, **kwargs):
idle_add(worker, (fun, args, kwargs))
def do_call():
entity = f()
idle_add(lambda: self.on_row_complete(entity, **kwargs))
def do_call():
idle_add(lambda: self.on_page_complete(entity))
def set_writer(self, writer):
assert writer in WRITERS
self.__writer = WRITERS[writer]
klass = self.__writer['class']
self.writer_instance = klass() if klass is not None else None
idle_add(self.do_render)
def _callback(watermark_notification):
idle_add(callback, watermark_notification)
def _callback(typing_message):
idle_add(callback, typing_message)
def _callback(conv_event):
print("Conversation.connect_on_event_callback")
idle_add(callback, conv_event)
async def async_get_events(cb, event_id, max_events):
events = await self.hangups_conversation.get_events(
event_id, max_events)
idle_add(callback, events)
def set_parser(self, parser):
assert parser in PARSERS
self.__parser = PARSERS[parser]
klass = self.__parser['class']
self.parser_instance = klass() if klass is not None else None
idle_add(self.do_render)
def _callback(event):
idle_add(callback, event)
def render(self, src, file_name, pos=0):
self.src = src
self.pos = pos
self.file_name = file_name
idle_add(self.do_render)
async def async_upload_image(callback, image_file, filename, return_uploaded_image):
uploaded_image = await self.hangups_client.upload_image(image_file, filename, return_uploaded_image)
idle_add(callback, uploaded_image)
