def button_press(self, x, y, button): if not self.connect(): return False try: status = self.client.status() if button == 3: if not status: self.client.play() else: self.client.pause() elif button == 4: self.client.previous() elif button == 5: self.client.next() elif button == 8: if status: self.client.setvol( max(int(status['volume']) - self.inc, 0) ) elif button == 9: if status: self.client.setvol( min(int(status['volume']) + self.inc, 100) ) except Exception: logger.exception('Mpd error on click')
def _get_status(self): playing = self.msg_nc try: self.status = self.client.status() self.song = self.client.currentsong() if self.status['state'] != 'stop': text = self.do_format(self.fmt_playing) if (self.do_color_progress and self.status and self.status.get('time')): elapsed, total = self.status['time'].split(':') percent = float(elapsed) / float(total) progress = int(percent * len(text)) playing = '<span color="%s">%s</span>%s' % ( utils.hex(self.foreground_progress), pangocffi.markup_escape_text(text[:progress]), pangocffi.markup_escape_text(text[progress:]) ) else: playing = pangocffi.markup_escape_text(text) else: playing = self.do_format(self.fmt_stopped) except Exception: logger.exception('Mpd error on update') return playing
def poll(self): was_connected = self.connected if not self.connected: if self.reconnect: while not self.stop and not self.connect(quiet=True): time.sleep(self.reconnect_interval) else: return if self.stop: return if was_connected: try: self.client.send_idle() self.client.fetch_idle() except mpd.ConnectionError: self.client.disconnect() self.connected = False return self.msg_nc except Exception: logger.exception('Error communicating with mpd') self.client.disconnect() return return self._get_status()
def __init__(self, name="prompt", **config): base._TextBox.__init__(self, "", bar.CALCULATED, **config) self.add_defaults(Prompt.defaults) self.name = name self.active = False self.completer = None # Define key handlers (action to do when hit an specific key) self.keyhandlers = { xkeysyms.keysyms['Tab']: self._trigger_complete, xkeysyms.keysyms['BackSpace']: self._delete_char(), xkeysyms.keysyms['Delete']: self._delete_char(False), xkeysyms.keysyms['KP_Delete']: self._delete_char(False), xkeysyms.keysyms['Escape']: self._unfocus, xkeysyms.keysyms['Return']: self._send_cmd, xkeysyms.keysyms['KP_Enter']: self._send_cmd, xkeysyms.keysyms['Up']: self._get_prev_cmd, xkeysyms.keysyms['KP_Up']: self._get_prev_cmd, xkeysyms.keysyms['Down']: self._get_next_cmd, xkeysyms.keysyms['KP_Down']: self._get_next_cmd, xkeysyms.keysyms['Left']: self._move_cursor(), xkeysyms.keysyms['KP_Left']: self._move_cursor(), xkeysyms.keysyms['Right']: self._move_cursor("right"), xkeysyms.keysyms['KP_Right']: self._move_cursor("right"), } printables = [int(hex(x), 16) for x in range(127)] printables = {x: self._write_char for x in printables if chr(x) in string.printable} self.keyhandlers.update(printables) if self.bell_style == "visual": self.original_background = self.background # If history record is on, get saved history or create history record if self.record_history: self.history_path = os.path.join(utils.get_cache_dir(), 'prompt_history') if os.path.exists(self.history_path): with open(self.history_path, 'rb') as f: try: self.history = pickle.load(f) if self.ignore_dups_history: self._dedup_history() except: # noqa: E722 # unfortunately, pickle doesn't wrap its errors, so we # can't detect what's a pickle error and what's not. logger.exception("failed to load prompt history") self.history = {x: deque(maxlen=self.max_history) for x in self.completers} # self.history of size does not match. if len(self.history) != len(self.completers): self.history = {x: deque(maxlen=self.max_history) for x in self.completers} if self.max_history != \ self.history[list(self.history)[0]].maxlen: self.history = {x: deque(self.history[x], self.max_history) for x in self.completers} else: self.history = {x: deque(maxlen=self.max_history) for x in self.completers}
def worker(): try: text = self.poll() if self.qtile is not None: self.qtile.call_soon_threadsafe(self.update, text) except: logger.exception("problem polling to update widget %s", self.name)
def main(): rename_process() q = make_qtile() try: q.loop() except Exception: logger.exception('Qtile crashed') logger.info('Exiting...')
def _load_file(self, name): try: path = os.path.join(BACKLIGHT_DIR, self.backlight_name, name) with open(path, 'r') as f: return f.read().strip() except: logger.exception("Failed to read file: %s" % name) raise
def _load_file(self, name): try: path = os.path.join(BACKLIGHT_DIR, self.backlight_name, name) with open(path, "r") as f: return f.read().strip() except IOError: return False except Exception: logger.exception("Failed to get %s" % name)
def get_wallpapers(self): try: # get path of all files in the directory self.images = list( filter(os.path.isfile, map(self.get_path, os.listdir(self.directory)))) except IOError as e: logger.exception("I/O error(%s): %s", e.errno, e.strerror)
def _xpoll(self) -> None: """Poll the connection and dispatch incoming events""" assert self.qtile is not None while True: try: event = self.conn.conn.poll_for_event() if not event: break if event.__class__ in _IGNORED_EVENTS: continue event_type = event.__class__.__name__ if event_type.endswith("Event"): event_type = event_type[:-5] logger.debug(event_type) for target in self._get_target_chain(event_type, event): logger.debug("Handling: {event_type}".format(event_type=event_type)) ret = target(event) if not ret: break # Catch some bad X exceptions. Since X is event based, race # conditions can occur almost anywhere in the code. For example, if # a window is created and then immediately destroyed (before the # event handler is evoked), when the event handler tries to examine # the window properties, it will throw a WindowError exception. We # can essentially ignore it, since the window is already dead and # we've got another event in the queue notifying us to clean it up. except ( xcffib.xproto.WindowError, xcffib.xproto.AccessError, xcffib.xproto.DrawableError, xcffib.xproto.GContextError, xcffib.xproto.PixmapError, xcffib.render.PictureError, ): pass except Exception: error_code = self.conn.conn.has_error() if error_code: error_string = xcbq.XCB_CONN_ERRORS[error_code] logger.exception( "Shutting down due to X connection error {error_string} ({error_code})".format( error_string=error_string, error_code=error_code ) ) self._remove_listener() self.qtile.stop() return logger.exception("Got an exception in poll loop") self.conn.flush()
def get_wallpapers(self): try: # get path of all files in the directory self.images = list( filter( os.path.isfile, map(self.get_path, os.listdir(os.path.expanduser(self.directory))), ) ) except IOError as e: logger.exception("I/O error(%s): %s", e.errno, e.strerror)
def _load_file(self, name): try: path = os.path.join(BAT_DIR, self.battery_name, name) with open(path, 'r') as f: return f.read().strip() except IOError: if name == 'current_now': return 0 return False except Exception: logger.exception("Failed to get %s" % name)
async def service(self): if self._service is None: try: bus = await MessageBus().connect() self._service = NotificationService(self) bus.export(SERVICE_PATH, self._service) await bus.request_name(BUS_NAME) except Exception: logger.exception('Dbus connection failed') self._service = None return self._service
def unsubscribe(self): """unsubscribe all hooks""" try: hook.unsubscribe.client_focus(self.on_focus_change) except utils.QtileError as err: logger.exception("Scratchpad failed to unsubscribe on_focus_change" ": %s" % err) try: hook.unsubscribe.setgroup(self.on_focus_change) except utils.QtileError as err: logger.exception("Scratchpad failed to unsubscribe on_focus_change" ": %s" % err)
def __try_call(self, attr_name, obj=None): err1 = 'Class {Class} has no attribute {attr}.' err2 = 'attribute "{Class}.{attr}" is not callable.' context = obj or self try: getattr(context, attr_name)() except (AttributeError, TypeError) as e: if isinstance(e, AttributeError): err = err1.format(Class=type(context).__name__, attr=attr_name) else: err = err2.format(Class=type(context).__name__, attr=attr_name) logger.exception(err + " {}".format(e.args[0]))
def _get_status(self): try: self.status = self.client.status() self.song = self.client.currentsong() except Exception: logger.exception('Mpd error on update') return self.msg_nc if self.status['state'] == 'stop': return self.do_format(self.fmt_stopped) else: return self._status_playing()
def poll(self): if not self.parse or not self.url: return "Invalid config" body = self.fetch() try: text = self.parse(body) except Exception: logger.exception('got exception polling widget') text = "Can't parse" return text
def _connect(self): """Try to connect to the player if it exists""" try: self.player = self.bus.get_object(self.objname, "/Player") self.iface = dbus.Interface(self.player, dbus_interface="org.freedesktop.MediaPlayer") # See: http://xmms2.org/wiki/MPRIS for info on signals # and what they mean. self.iface.connect_to_signal("TrackChange", self.handle_track_change) self.iface.connect_to_signal("StatusChange", self.handle_status_change) self.connected = True except dbus.exceptions.DBusException: logger.exception("exception initializing mpris") self.connected = False
def _decode_to_image_surface(bytes_img, width=None, height=None): try: surf, fmt = cairocffi.pixbuf.decode_to_image_surface( bytes_img, width, height) return _SurfaceInfo(surf, fmt) except TypeError: from libqtile.log_utils import logger logger.exception( "Couldn't load cairo image at specified width and height. " "Falling back to image scaling using cairo. " "Need cairocffi > v0.8.0") surf, fmt = cairocffi.pixbuf.decode_to_image_surface(bytes_img) return _SurfaceInfo(surf, fmt)
def setup_images(self): """Create image structures for each icon files.""" for img_name, iconfile in self.icons_files.items(): if iconfile is None: logger.warning( 'No icon found for application "%s" (%s) switch to text mode', img_name, iconfile, ) # if no icon is found and no default icon was set, we just # print the name, based on a textbox. textbox = base._TextBox() textbox._configure(self.qtile, self.bar) textbox.layout = self.drawer.textlayout( textbox.text, self.foreground, self.font, self.fontsize, self.fontshadow, markup=textbox.markup, ) # the name will be displayed textbox.text = img_name textbox.calculate_length() self.icons_widths[img_name] = textbox.width self.surfaces[img_name] = textbox continue else: try: img = cairocffi.ImageSurface.create_from_png(iconfile) except cairocffi.Error: logger.exception( 'Error loading icon for application "%s" (%s)', img_name, iconfile) return input_width = img.get_width() input_height = img.get_height() sp = input_height / (self.bar.height - 4) width = int(input_width / sp) imgpat = cairocffi.SurfacePattern(img) scaler = cairocffi.Matrix() scaler.scale(sp, sp) scaler.translate(self.padding * -1, -2) imgpat.set_matrix(scaler) imgpat.set_filter(cairocffi.FILTER_BEST) self.surfaces[img_name] = imgpat self.icons_widths[img_name] = width
def __init__(self, name="prompt", **config): base._TextBox.__init__(self, "", bar.CALCULATED, **config) self.add_defaults(Prompt.defaults) self.name = name self.active = False self.completer = None # Define key handlers (action to do when hit an specific key) self.keyhandlers = { xkeysyms.keysyms['Tab']: self._trigger_complete, xkeysyms.keysyms['BackSpace']: self._delete_char(), xkeysyms.keysyms['Delete']: self._delete_char(False), xkeysyms.keysyms['KP_Delete']: self._delete_char(False), xkeysyms.keysyms['Escape']: self._unfocus, xkeysyms.keysyms['Return']: self._send_cmd, xkeysyms.keysyms['KP_Enter']: self._send_cmd, xkeysyms.keysyms['Up']: self._get_prev_cmd, xkeysyms.keysyms['KP_Up']: self._get_prev_cmd, xkeysyms.keysyms['Down']: self._get_next_cmd, xkeysyms.keysyms['KP_Down']: self._get_next_cmd, xkeysyms.keysyms['Left']: self._move_cursor(), xkeysyms.keysyms['KP_Left']: self._move_cursor(), xkeysyms.keysyms['Right']: self._move_cursor("right"), xkeysyms.keysyms['KP_Right']: self._move_cursor("right"), } printables = [int(hex(x), 16) for x in range(127)] printables = {x: self._write_char for x in printables if chr(x) in string.printable} self.keyhandlers.update(printables) if self.bell_style == "visual": self.original_background = self.background # If history record is on, get saved history or create history record if self.record_history: self.history_path = os.path.expanduser('~/.qtile_history') if os.path.exists(self.history_path): with open(self.history_path, 'rb') as f: try: self.history = pickle.load(f) except: # unfortunately, pickle doesn't wrap its errors, so we # can't detect what's a pickle error and what's not. logger.exception("failed to load prompt history") self.history = {x: deque(maxlen=self.max_history) for x in self.completers if x} if self.max_history != \ self.history[list(self.history)[0]].maxlen: self.history = {x: deque(copy.copy(self.history[x]), self.max_history) for x in self.completers if x} else: self.history = {x: deque(maxlen=self.max_history) for x in self.completers if x}
def from_file(cls, kore: base.Core, path: str): "Create a Config() object from the python file located at path." try: sys.path.insert(0, os.path.dirname(path)) config = __import__(os.path.basename(path)[:-3]) # noqa: F811 except Exception: import traceback from libqtile.log_utils import logger logger.exception('Could not import config file %r', path) tb = traceback.format_exc() raise ConfigError(tb) cnf = cls(file_path=path, **vars(config)) cnf.validate(kore) return cnf
def send(self, msg: Any, is_json=False) -> None: assert self.transport is not None if is_json: send_data = _IPC.pack_json(msg) else: send_data = _IPC.pack(msg) self.transport.write(send_data) try: self.transport.write_eof() except AttributeError: logger.exception('Swallowing AttributeError due to asyncio bug!')
def _handle_exception( self, loop: asyncio.AbstractEventLoop, context: dict, ) -> None: # message is always present, but we'd prefer the exception if available if 'exception' in context: exc = context['exception'] # CancelledErrors happen when we simply cancel the main task during # a normal restart procedure if not isinstance(exc, asyncio.CancelledError): logger.exception(exc) else: logger.error(f'unhandled error in event loop: {context["msg"]}')
def get(DISPLAY=None, defaults=None): """ Get the X resources in an X servers resource manager. Parameters ========== DISPLAY : str (optional) DISPLAY name to query. This will be taken from the environment if not specified. defaults : dict (optional) Default values to act as a fallback for missing values or in the event of a failed connection. Returns ======= resources: dict Dictionary containing all (available) X resources. Resources that are specified in an Xresources/Xdefaults file as wildcards e.g. '*.color1' have the leading '*.' stripped. """ if DISPLAY is None: DISPLAY = os.environ.get("DISPLAY") if defaults is None: resources = {} else: resources = defaults try: conn = xcffib.connect(display=DISPLAY) except xcffib.ConnectionException as e: logger.exception(e) return resources root = conn.get_setup().roots[0].root atom = conn.core.InternAtom(False, 16, 'RESOURCE_MANAGER').reply().atom reply = conn.core.GetProperty(False, root, atom, xcffib.xproto.Atom.STRING, 0, (2**32) - 1).reply() conn.disconnect() resource_string = reply.value.buf().decode("utf-8") resource_list = filter(None, resource_string.split('\n')) for resource in resource_list: key, value = resource.split(':\t') resources[key.strip('*.')] = value return resources
def start(options): try: locale.setlocale(locale.LC_ALL, locale.getdefaultlocale()) except locale.Error: pass rename_process() q = make_qtile(options) try: q.loop() except Exception: logger.exception("Qtile crashed") exit(1) logger.info("Exiting...")
def get_taskname(self, window): """ Get display name for given window. Depending on its state minimized, maximized and floating appropriate characters are prepended. """ state = '' markup_str = self.markup_normal # Enforce markup and new string format behaviour when # at least one markup_* option is used. # Mixing non markup and markup may cause problems. if self.markup_minimized or self.markup_maximized\ or self.markup_floating or self.markup_focused: enforce_markup = True else: enforce_markup = False if window is None: pass elif window.minimized: state = self.txt_minimized markup_str = self.markup_minimized elif window.maximized: state = self.txt_maximized markup_str = self.markup_maximized elif window.floating: state = self.txt_floating markup_str = self.markup_floating elif window is window.group.current_window: markup_str = self.markup_focused window_name = window.name if window and window.name else "?" if callable(self.parse_text): try: window_name = self.parse_text(window_name) except: logger.exception("parse_text function failed:") # Emulate default widget behavior if markup_str is None if enforce_markup and markup_str is None: markup_str = "%s{}" % (state) if markup_str is not None: self.markup = True window_name = pangocffi.markup_escape_text(window_name) return markup_str.format(window_name) return "%s%s" % (state, window_name)
def __init__(self, **config): if NewWidgetBase: super().__init__("", **config) else: super().__init__(**config) self.add_defaults(OpenWeatherMap.defaults) if not self.api_key: logger.exception( "OpenWeatherMap: An API key is required. Pass as the `api_key` parameter" ) self.url = f"https://api.openweathermap.org/data/2.5/weather?lat={self.latitude}&lon={self.longitude}&appid={self.api_key}&units={self.units}" if not self.icon_font: # pylint: disable=access-member-before-definition # icon_font created by add_defaults self.icon_font = ICON_FONT self.markup = True
def poll(self): self.gmail = imaplib.IMAP4_SSL("imap.gmail.com") self.gmail.login(self.username, self.password) answer, raw_data = self.gmail.status(self.email_path, "(MESSAGES UNSEEN)") if answer == "OK": dec = raw_data[0].decode() messages = int(re.search("MESSAGES\s+(\d+)", dec).group(1)) unseen = int(re.search("UNSEEN\s+(\d+)", dec).group(1)) if self.status_only_unseen: return self.fmt % unseen else: return self.fmt % (messages, unseen) else: logger.exception("GmailChecker UNKNOWN error, answer: %s, raw_data: %s", answer, raw_data) return "UNKNOWN ERROR"
def fire(event, *args, **kwargs): if event not in subscribe.hooks: raise utils.QtileError("Unknown event: %s" % event) if event not in SKIPLOG: logger.debug("Internal event: %s(%s, %s)", event, args, kwargs) for i in subscriptions.get(event, []): try: if asyncio.iscoroutinefunction(i): _fire_async_event(i(*args, **kwargs)) elif asyncio.iscoroutine(i): _fire_async_event(i) else: i(*args, **kwargs) except: # noqa: E722 logger.exception("Error in hook %s", event)
def setup_images(self): """ Create image structures for each icon files. """ for img_name, iconfile in self.icons_files.items(): if iconfile is None: logger.warning( 'No icon found for application "%s" (%s) switch to text mode', img_name, iconfile) # if no icon is found and no default icon was set, we just # print the name, based on a textbox. textbox = base._TextBox() textbox._configure(self.qtile, self.bar) textbox.layout = self.drawer.textlayout( textbox.text, textbox.foreground, textbox.font, textbox.fontsize, textbox.fontshadow, markup=textbox.markup, ) # the name will be displayed textbox.text = img_name textbox.calculate_length() self.icons_widths[img_name] = textbox.width self.surfaces[img_name] = textbox continue else: try: img = cairocffi.ImageSurface.create_from_png(iconfile) except cairocffi.Error: logger.exception('Error loading icon for application "%s" (%s)', img_name, iconfile) return input_width = img.get_width() input_height = img.get_height() sp = input_height / (self.bar.height - 4) width = int(input_width / sp) imgpat = cairocffi.SurfacePattern(img) scaler = cairocffi.Matrix() scaler.scale(sp, sp) scaler.translate(self.padding * -1, -2) imgpat.set_matrix(scaler) imgpat.set_filter(cairocffi.FILTER_BEST) self.surfaces[img_name] = imgpat self.icons_widths[img_name] = width
def play_sound(path): """ Play an audio file. This accepts a full path to an audio file. This is mostly a snippet from the playsound library. """ playbin = Gst.ElementFactory.make('playbin', 'playbin') playbin.props.uri = 'file://' + path set_result = playbin.set_state(Gst.State.PLAYING) if set_result == Gst.StateChangeReturn.ASYNC: bus = playbin.get_bus() bus.poll(Gst.MessageType.EOS, Gst.CLOCK_TIME_NONE) playbin.set_state(Gst.State.NULL) else: logger.exception( "qtools.play_sound failed with file: {0}".format(path))
def poll(self): if not self.parse or not self.url: return "Invalid config" try: body = self.fetch() except URLError: return "No network" try: text = self.parse(body) except Exception: logger.exception("got exception polling widget") text = "Can't parse" return text
def _connect(self): """Try to connect to the player if it exists""" try: self.player = self.bus.get_object(self.objname, '/Player') self.iface = dbus.Interface( self.player, dbus_interface='org.freedesktop.MediaPlayer') # See: http://xmms2.org/wiki/MPRIS for info on signals # and what they mean. self.iface.connect_to_signal("TrackChange", self.handle_track_change) self.iface.connect_to_signal("StatusChange", self.handle_status_change) self.connected = True except dbus.exceptions.DBusException: logger.exception("exception initializing mpris") self.connected = False
def _setup_images(self): """ Loads layout icons. """ for layout_name in self._get_layout_names(): icon_file_path = self.find_icon_file_path(layout_name) if icon_file_path is None: logger.warning('No icon found for layout "{}"'.format(layout_name)) icon_file_path = self.find_icon_file_path("unknown") try: img = cairocffi.ImageSurface.create_from_png(icon_file_path) except (cairocffi.Error, IOError) as e: # Icon file is guaranteed to exist at this point. # If this exception happens, it means the icon file contains # an invalid image or is not readable. self.icons_loaded = False logger.exception( 'Failed to load icon from file "{}", ' "error was: {}".format(icon_file_path, e.message) ) return input_width = img.get_width() input_height = img.get_height() sp = input_height / (self.bar.height - 1) width = input_width / sp if width > self.length: self.length = int(width) + self.actual_padding * 2 imgpat = cairocffi.SurfacePattern(img) scaler = cairocffi.Matrix() scaler.scale(sp, sp) scaler.scale(self.scale, self.scale) factor = (1 - 1 / self.scale) / 2 scaler.translate(-width * factor, -width * factor) scaler.translate(self.actual_padding * -1, 0) imgpat.set_matrix(scaler) imgpat.set_filter(cairocffi.FILTER_BEST) self.surfaces[layout_name] = imgpat self.icons_loaded = True
def _load_file(self, name) -> Optional[Tuple[str, str]]: try: path = os.path.join(self.BAT_DIR, self.battery, name) if 'energy' in name or 'power' in name: value_type = 'uW' elif 'charge' in name: value_type = 'uAh' elif 'current' in name: value_type = 'uA' else: value_type = '' with open(path, 'r') as f: return f.read().strip(), value_type except Exception: logger.exception("Failed to get %s" % name) return None
def finalize(self): try: for widget in self.widgets_map.values(): widget.finalize() for layout in self.config.layouts: layout.finalize() for screen in self.screens: for bar in [screen.top, screen.bottom, screen.left, screen.right]: if bar is not None: bar.finalize() except: # noqa: E722 logger.exception('exception during finalize') finally: hook.clear() self.core.finalize()
def poll(self): statuses: List[str] = [] try: # pylint: disable=I1101 ifaces = netifaces.interfaces() wifi_ifaces = [iface for iface in ifaces if iface.startswith("wl")] eth_ifaces = [iface for iface in ifaces if iface.startswith("en")] for iface in wifi_ifaces: self.format_wifi(statuses, iface) for iface in eth_ifaces: self.format_eth(statuses, iface) return " ".join(statuses) except Exception: logger.exception("CustomNetwork is broke!")
def poll(self): self.gmail = imaplib.IMAP4_SSL('imap.gmail.com') self.gmail.login(self.username, self.password) answer, raw_data = self.gmail.status(self.email_path, '(MESSAGES UNSEEN)') if answer == "OK": dec = raw_data[0].decode() messages = int(re.search(r'MESSAGES\s+(\d+)', dec).group(1)) unseen = int(re.search(r'UNSEEN\s+(\d+)', dec).group(1)) if (self.status_only_unseen): return self.display_fmt.format(unseen) else: return self.display_fmt.format(messages, unseen) else: logger.exception( 'GmailChecker UNKNOWN error, answer: %s, raw_data: %s', answer, raw_data) return "UNKNOWN ERROR"
def __init__(self, name="prompt", **config) -> None: base._TextBox.__init__(self, "", bar.CALCULATED, **config) self.add_defaults(Prompt.defaults) self.name = name self.active = False self.completer = None # type: Optional[AbstractCompleter] # If history record is on, get saved history or create history record if self.record_history: self.history_path = os.path.join(utils.get_cache_dir(), "prompt_history") if os.path.exists(self.history_path): with open(self.history_path, "rb") as f: try: self.history = pickle.load(f) if self.ignore_dups_history: self._dedup_history() except: # noqa: E722 # unfortunately, pickle doesn't wrap its errors, so we # can't detect what's a pickle error and what's not. logger.exception("failed to load prompt history") self.history = { x: deque(maxlen=self.max_history) for x in self.completers } # self.history of size does not match. if len(self.history) != len(self.completers): self.history = { x: deque(maxlen=self.max_history) for x in self.completers } if self.max_history != self.history[list( self.history)[0]].maxlen: self.history = { x: deque(self.history[x], self.max_history) for x in self.completers } else: self.history = { x: deque(maxlen=self.max_history) for x in self.completers }
def _configure(self): """ This is the part of init that needs to happen after the event loop is fully set up. asyncio is required to listen and respond to backend events. """ self._process_screens() self.current_screen = self.screens[0] # Map and Grab keys for key in self.config.keys: self.grab_key(key) for button in self.config.mouse: self.grab_button(button) # no_spawn is set when we are restarting; we only want to run the # startup hook once. if not self.no_spawn: hook.fire("startup_once") hook.fire("startup") if self._state: try: with open(self._state, 'rb') as f: st = pickle.load(f) st.apply(self) except: # noqa: E722 logger.exception("failed restoring state") finally: os.remove(self._state) self.core.scan() if self._state: for screen in self.screens: screen.group.layout_all() self._state = None self.update_desktops() hook.subscribe.setgroup(self.update_desktops) if self.config.reconfigure_screens: hook.subscribe.screen_change(self.cmd_reconfigure_screens) hook.fire("startup_complete")
def _load_icon(self, notif): if not notif.app_icon: return None if notif.app_icon in self._icons: return self._icons.get(notif.app_icon) try: img = images.Img.from_path(notif.app_icon) if img.width > img.height: img.resize(width=self.icon_size) else: img.resize(height=self.icon_size) surface, _ = images._decode_to_image_surface( img.bytes_img, img.width, img.height) self._icons[notif.app_icon] = surface, surface.get_height() except (FileNotFoundError, images.LoadingError, IsADirectoryError) as e: logger.exception(e) self._icons[notif.app_icon] = None return self._icons[notif.app_icon]
def on_done(future): try: result = future.result() except Exception: logger.exception('poll() raised exceptions, not rescheduling') if result is not None: try: self.update(result) if self.update_interval is not None: self.timeout_add(self.update_interval, self.timer_setup) else: self.timer_setup() except Exception: logger.exception('Failed to reschedule.') else: logger.warning('poll() returned None, not rescheduling')
def button_press(self, x, y, button): client = mpd.MPDClient() try: client.connect(host=self.host, port=self.port) status = client.status() if button == 3: if status['state'] == 'pause': client.play() else: client.pause() elif button == 4: client.setvol(min(int(status['volume']) + self.inc, 100)) elif button == 5: client.setvol(max(int(status['volume']) - self.inc, 0)) except Exception: logger.exception('Mpd error on click') try: client.disconnect() except mpd.ConnectionError: pass
def formatter(self, status, currentsong): play_status = self.play_states[status['state']] # Dirty hack to prevent keys conflict currentsong['fulltime'] = currentsong['time'] del currentsong['time'] self.prepare_formatting(status, currentsong) status.update(currentsong) fmt = self.status_format if not isinstance(fmt, str): fmt = str(fmt) try: formatted = fmt.format(play_status=play_status, **status) return formatted except KeyError as e: logger.exception("mpd client did not return status: {}".format(e.args[0])) return "ERROR"
def poll(self): if not self.parse or not self.url: return "Invalid config" data = self.data headers = {"User-agent": self.user_agent} if self.json: headers['Content-Type'] = 'application/json' if data and not isinstance(data, str): data = json.dumps(data).encode() headers.update(self.headers) body = self.fetch(self.url, data, headers, self.json, self.xml) try: text = self.parse(body) except Exception: logger.exception('got exception polling widget') text = "Can't parse" return text
def connect(self, quiet=False): if self.connected: return True try: self.client.connect(host=self.host, port=self.port) except Exception: if not quiet: logger.exception('Failed to connect to mpd') return False if self.password: try: self.client.password(self.password) except Exception: logger.warning('Authentication failed. Disconnecting') try: self.client.disconnect() except Exception: pass self.connected = True return True
def poll(self): if not self.connect(): return if self.first_poll: self.first_poll = False return self._get_status() try: self.client.send_idle() canRead = select.select([self.client], [], [], 5.0)[0] if canRead: self.client.fetch_idle() else: self.client.noidle() except mpd.ConnectionError: self.connected = False return self.msg_nc except Exception: logger.exception('Error communicating with mpd') return return self._get_status()
def setup_images(self): for img_name in ( 'audio-volume-high', 'audio-volume-low', 'audio-volume-medium', 'audio-volume-muted' ): try: img = cairocffi.ImageSurface.create_from_png( os.path.join(self.theme_path, '%s.png' % img_name) ) except cairocffi.Error: self.theme_path = None self.length_type = bar.CALCULATED logger.exception('Volume switching to text mode') return input_width = img.get_width() input_height = img.get_height() sp = input_height / float(self.bar.height - 1) width = input_width / sp if width > self.length: self.length = int(width) + self.actual_padding * 2 imgpat = cairocffi.SurfacePattern(img) scaler = cairocffi.Matrix() scaler.scale(sp, sp) scaler.translate(self.actual_padding * -1, 0) imgpat.set_matrix(scaler) imgpat.set_filter(cairocffi.FILTER_BEST) self.surfaces[img_name] = imgpat
def _wrapper(self, method, *method_args): try: method(*method_args) except: logger.exception('got exception from widget timer')
def make_qtile(): from argparse import ArgumentParser parser = ArgumentParser( description='A full-featured, pure-Python tiling window manager.', prog='qtile', ) parser.add_argument( '--version', action='version', version=VERSION, ) parser.add_argument( "-c", "--config", action="store", default=None, dest="configfile", help='Use specified configuration file,' ' "default" will load the system default config.' ) parser.add_argument( "-s", "--socket", action="store", default=None, dest="socket", help='Path to Qtile comms socket.' ) parser.add_argument( "-n", "--no-spawn", action="store_true", default=False, dest="no_spawn", help='Avoid spawning apps. (Used for restart)' ) parser.add_argument( '-l', '--log-level', default='WARNING', dest='log_level', choices=('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'), help='Set qtile log level' ) parser.add_argument( '--with-state', default=None, dest='state', help='Pickled QtileState object (typically used only internally)', ) options = parser.parse_args() log_level = getattr(logging, options.log_level) init_log(log_level=log_level) try: config = confreader.File(options.configfile, is_restart=options.no_spawn) except Exception as e: logger.exception('Error while reading config file (%s)', e) raise # XXX: the import is here becouse we need to call init_log # before start importing stuff from libqtile import manager try: return manager.Qtile( config, fname=options.socket, no_spawn=options.no_spawn, state=options.state, ) except: logger.exception('Qtile crashed during startup') raise
def make_qtile(): from argparse import ArgumentParser parser = ArgumentParser( description='A full-featured, pure-Python tiling window manager.', prog='qtile', ) parser.add_argument( '--version', action='version', version=VERSION, ) parser.add_argument( "-c", "--config", action="store", default=path.expanduser(path.join( getenv('XDG_CONFIG_HOME', '~/.config'), 'qtile', 'config.py')), dest="configfile", help='Use the specified configuration file', ) parser.add_argument( "-s", "--socket", action="store", default=None, dest="socket", help='Path to Qtile comms socket.' ) parser.add_argument( "-n", "--no-spawn", action="store_true", default=False, dest="no_spawn", help='Avoid spawning apps. (Used for restart)' ) parser.add_argument( '-l', '--log-level', default='WARNING', dest='log_level', choices=('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'), help='Set qtile log level' ) parser.add_argument( '--with-state', default=None, dest='state', help='Pickled QtileState object (typically used only internally)', ) options = parser.parse_args() log_level = getattr(logging, options.log_level) init_log(log_level=log_level) try: config = confreader.Config.from_file(options.configfile) except Exception as e: logger.exception('Error while reading config file (%s)', e) config = confreader.Config() from libqtile.widget import TextBox widgets = config.screens[0].bottom.widgets widgets.insert(0, TextBox('Config Err!')) # XXX: the import is here because we need to call init_log # before start importing stuff from libqtile import manager return manager.Qtile( config, fname=options.socket, no_spawn=options.no_spawn, state=options.state, )