def download_cancel(self, all_=False, count=0): """Cancel the last/[count]th download. Args: all_: Cancel all running downloads count: The index of the download to cancel. """ downloads = self._all_downloads() if all_: for download in downloads: if not download.done: download.cancel() else: try: download = downloads[count - 1] except IndexError: self._raise_no_download(count) if download.done: if not count: count = len(self) raise cmdutils.CommandError( "Download {} is already done!".format(count)) download.cancel()
def download_open(self, cmdline: str = None, count: int = 0) -> None: """Open the last/[count]th download. If no specific command is given, this will use the system's default application to open the file. Args: cmdline: The command which should be used to open the file. A `{}` is expanded to the temporary file name. If no `{}` is present, the filename is automatically appended to the cmdline. count: The index of the download to open. """ try: download = self[count - 1] except IndexError: self._raise_no_download(count) if not download.successful: if not count: count = len(self) raise cmdutils.CommandError( "Download {} is not done!".format(count)) download.open_file(cmdline)
def prompt_accept(self, value=None, *, save=False): """Accept the current prompt. // This executes the next action depending on the question mode, e.g. asks for the password or leaves the mode. Args: value: If given, uses this value instead of the entered one. For boolean prompts, "yes"/"no" are accepted as value. save: Save the value to the config. """ question = self._prompt.question try: done = self._prompt.accept(value, save=save) except Error as e: raise cmdutils.CommandError(str(e)) if done: message.global_bridge.prompt_done.emit(self._prompt.KEY_MODE) question.done()
def printpage(tab: Optional[apitypes.Tab], preview: bool = False, *, pdf: str = None) -> None: """Print the current/[count]th tab. Args: preview: Show preview instead of printing. count: The tab index to print, or None. pdf: The file path to write the PDF to. """ if tab is None: return try: if preview: _print_preview(tab) elif pdf: _print_pdf(tab, pdf) else: tab.printing.show_dialog() except apitypes.WebTabError as e: raise cmdutils.CommandError(e)
def replace_variables(win_id, arglist): """Utility function to replace variables like {url} in a list of args.""" tabbed_browser = objreg.get('tabbed-browser', scope='window', window=win_id) values = {} args = [] def repl_cb(matchobj): """Return replacement for given match.""" var = matchobj.group("var") if var not in values: values[var] = VARIABLE_REPLACEMENTS[var](tabbed_browser) return values[var] try: for arg in arglist: # using re.sub with callback function replaces all variables in a # single pass and avoids expansion of nested variables (e.g. # "{url}" from clipboard is not expanded) args.append(VARIABLE_REPLACEMENT_PATTERN.sub(repl_cb, arg)) except utils.ClipboardError as e: raise cmdutils.CommandError(e) return args
def debug_pyeval(s, file=False, quiet=False): """Evaluate a python string and display the results as a web page. Args: s: The string to evaluate. file: Interpret s as a path to file, also implies --quiet. quiet: Don't show the output in a new tab. """ if file: quiet = True path = os.path.expanduser(s) try: with open(path, 'r', encoding='utf-8') as f: s = f.read() except OSError as e: raise cmdutils.CommandError(str(e)) try: exec(s) out = "No error" except Exception: out = traceback.format_exc() else: try: r = eval(s) out = repr(r) except Exception: out = traceback.format_exc() qutescheme.pyeval_output = out if quiet: log.misc.debug("pyeval output: {}".format(out)) else: tabbed_browser = objreg.get('tabbed-browser', scope='window', window='last-focused') tabbed_browser.load_url(QUrl('qute://pyeval'), newtab=True)
def completion_item_del(self): """Delete the current completion item.""" index = self.currentIndex() if not index.isValid(): raise cmdutils.CommandError("No item selected!") self.model().delete_cur_item(index)
def start( self, # pylint: disable=keyword-arg-before-vararg group: str = 'all', target: Target = Target.normal, *args: str, mode: str = None, add_history: bool = False, rapid: bool = False, first: bool = False) -> None: """Start hinting. Args: rapid: Whether to do rapid hinting. With rapid hinting, the hint mode isn't left after a hint is followed, so you can easily open multiple links. This is only possible with targets `tab` (with `tabs.background=true`), `tab-bg`, `window`, `run`, `hover`, `userscript` and `spawn`. add_history: Whether to add the spawned or yanked link to the browsing history. first: Click the first hinted element without prompting. group: The element types to hint. - `all`: All clickable elements. - `links`: Only links. - `images`: Only images. - `inputs`: Only input fields. Custom groups can be added via the `hints.selectors` setting and also used here. target: What to do with the selected element. - `normal`: Open the link. - `current`: Open the link in the current tab. - `tab`: Open the link in a new tab (honoring the `tabs.background` setting). - `tab-fg`: Open the link in a new foreground tab. - `tab-bg`: Open the link in a new background tab. - `window`: Open the link in a new window. - `hover` : Hover over the link. - `right-click`: Right-click the element. - `yank`: Yank the link to the clipboard. - `yank-primary`: Yank the link to the primary selection. - `run`: Run the argument as command. - `fill`: Fill the commandline with the command given as argument. - `download`: Download the link. - `userscript`: Call a userscript with `$QUTE_URL` set to the link. - `spawn`: Spawn a command. - `delete`: Delete the selected element. mode: The hinting mode to use. - `number`: Use numeric hints. - `letter`: Use the chars in the hints.chars setting. - `word`: Use hint words based on the html elements and the extra words. *args: Arguments for spawn/userscript/run/fill. - With `spawn`: The executable and arguments to spawn. `{hint-url}` will get replaced by the selected URL. - With `userscript`: The userscript to execute. Either store the userscript in `~/.local/share/qutebrowser/userscripts` (or `$XDG_DATA_HOME`), or use an absolute path. - With `fill`: The command to fill the statusbar with. `{hint-url}` will get replaced by the selected URL. - With `run`: Same as `fill`. """ tabbed_browser = objreg.get('tabbed-browser', scope='window', window=self._win_id) tab = tabbed_browser.widget.currentWidget() if tab is None: raise cmdutils.CommandError("No WebView available yet!") mode_manager = modeman.instance(self._win_id) if mode_manager.mode == usertypes.KeyMode.hint: modeman.leave(self._win_id, usertypes.KeyMode.hint, 're-hinting') if rapid: if target in [ Target.tab_bg, Target.window, Target.run, Target.hover, Target.userscript, Target.spawn, Target.download, Target.normal, Target.current, Target.yank, Target.yank_primary ]: pass elif target == Target.tab and config.val.tabs.background: pass else: name = target.name.replace('_', '-') raise cmdutils.CommandError("Rapid hinting makes no sense " "with target {}!".format(name)) self._check_args(target, *args) try: baseurl = tabbed_browser.current_url() except qtutils.QtValueError: raise cmdutils.CommandError("No URL set for this page yet!") self._context = HintContext( tab=tab, target=target, rapid=rapid, hint_mode=self._get_hint_mode(mode), add_history=add_history, first=first, baseurl=baseurl, args=list(args), group=group, ) try: selector = webelem.css_selector(self._context.group, self._context.baseurl) except webelem.Error as e: raise cmdutils.CommandError(str(e)) self._context.tab.elements.find_css( selector, callback=self._start_cb, error_cb=lambda err: message.error(str(err)), only_visible=True)
def _parse_key(self, key: str) -> keyutils.KeySequence: """Parse a key argument.""" try: return keyutils.KeySequence.parse(key) except keyutils.KeyParseError as e: raise cmdutils.CommandError(str(e))
def _handle_config_error(self) -> typing.Iterator[None]: """Catch errors in set_command and raise CommandError.""" try: yield except configexc.Error as e: raise cmdutils.CommandError(str(e))
def raise_cmdexc_if_invalid(url: QUrl) -> None: """Check if the given QUrl is invalid, and if so, raise a CommandError.""" try: ensure_valid(url) except InvalidUrlError as e: raise cmdutils.CommandError(str(e))
def knights_who_say_ni() -> None: """We are the Knights Who Say... 'Ni'!""" # noqa: D400 raise cmdutils.CommandError("Do you demand a shrubbery?")
def raise_cmdexc_if_invalid(url): """Check if the given QUrl is invalid, and if so, raise a CommandError.""" if not url.isValid(): raise cmdutils.CommandError(get_errstring(url))
def devtools_focus(tab: apitypes.Tab) -> None: """Toggle focus between the devtools/tab.""" try: tab.data.splitter.cycle_focus() except apitypes.InspectorError as e: raise cmdutils.CommandError(e)
def click_element( tab: apitypes.Tab, filter_: str, value: str = None, *, # noqa: C901 target: apitypes.ClickTarget = apitypes.ClickTarget.normal, force_event: bool = False, select_first: bool = False) -> None: """Click the element matching the given filter. The given filter needs to result in exactly one element, otherwise, an error is shown. Args: filter_: How to filter the elements. - id: Get an element based on its ID. - css: Filter by a CSS selector. - position: Click the element at specified position. Specify `value` as 'x,y'. - focused: Click the currently focused element. value: The value to filter for. Optional for 'focused' filter. target: How to open the clicked element (normal/tab/tab-bg/window). force_event: Force generating a fake click event. select_first: Select first matching element if there are multiple. """ def do_click(elem: apitypes.WebElement) -> None: try: elem.click(target, force_event=force_event) except apitypes.WebElemError as e: message.error(str(e)) def single_cb(elem: Optional[apitypes.WebElement]) -> None: """Click a single element.""" if elem is None: message.error( f"No element found {_FILTER_ERRORS[filter_](value)}!") return do_click(elem) def multiple_cb(elems: Sequence[apitypes.WebElement]) -> None: if not elems: message.error( f"No element found {_FILTER_ERRORS[filter_](value)}!") return if not select_first and len(elems) > 1: message.error( f"Multiple elements found {_FILTER_ERRORS[filter_](value)}!") return do_click(elems[0]) if value is None and filter_ != 'focused': raise cmdutils.CommandError("Argument 'value' is only " "optional with filter 'focused'!") if filter_ == "id": assert value is not None tab.elements.find_id(elem_id=value, callback=single_cb) elif filter_ == "css": assert value is not None tab.elements.find_css( value, callback=multiple_cb, error_cb=lambda exc: message.error(str(exc)), ) elif filter_ == "position": assert value is not None _wrap_find_at_pos(value, tab=tab, callback=single_cb) elif filter_ == "focused": tab.elements.find_focused(callback=single_cb) else: raise utils.Unreachable(filter_)