def get_as_item(item: Union[Countdown, Stopwatch]): """Return an item - ready to be appended to the items list and be rendered by Albert.""" actions = [v0.FuncAction( "Remove", lambda: delete_item(item), )] if item.started(): actions.append(v0.FuncAction( "Pause", lambda: item.pause(), )) else: actions.append(v0.FuncAction( "Resume", lambda: item.start(), )) return v0.Item( id=__title__, icon=countdown_path if isinstance(item, Countdown) else stopwatch_path, text=str(item), subtext="", completion=__triggers__, actions=actions, )
def get_as_item(p: Process, *extra_actions): """Return an item - ready to be appended to the items list and be rendered by Albert. if Process is not a valid object (.name or .cmdline raise an exception) then return None """ name_field = cmdline(p) if not name_field: return None try: actions = [ v0.FuncAction("Terminate", lambda: p.terminate()), v0.FuncAction("Kill", lambda: p.kill()), v0.ClipAction("Get PID", f"{p.pid}"), v0.FuncAction( "Terminate matching names", lambda name=p.name(): kill_by_name(name, signal=signal.SIGTERM ), ), v0.FuncAction("Kill matching names", lambda name=p.name(): kill_by_name(name)), ] actions = [*extra_actions, *actions] return v0.Item( id=__title__, icon=icon_path, text=name_field, subtext="", completion=p.name(), actions=actions, ) except psutil.NoSuchProcess: return None
def get_googler_result_as_item(googler_item: dict): actions = [ v0.UrlAction("Open in browser", googler_item["url"]), v0.ClipAction("Copy URL", googler_item["url"]), ] # incognito search if inco_cmd: actions.insert( 1, v0.FuncAction( "Open in browser [incognito mode]", lambda url=googler_item["url"]: inco_cmd(url), ), ) # special url handler if url_handler: # check that the handler is actually there actions.insert( 0, v0.FuncAction( url_handler_desc, lambda url_handler=url_handler: subprocess.Popen( f'{url_handler} {googler_item["url"]}', shell=True), ), ) return v0.Item( id=__title__, icon=icon_path, text=googler_item["title"], subtext=googler_item["abstract"], actions=actions, )
def get_as_item_custom(self, caption1=None, caption2=None): if caption1 or caption2: subtext = f"UP: {caption1} | DOWN: {caption2}" else: subtext = f"USAGE: {self.id} [upper-text] | [lower-text]" return v0.Item( id=__title__, icon=str(self.img), text=self.title(), subtext=subtext, completion=f"{__triggers__} {self.id} ", actions=[ v0.FuncAction( "Copy generated custom meme to clipboard", lambda caption1=caption1, caption2=caption2: self. _create_n_copy_to_clipboard(caption1=caption1, caption2=caption2), ), v0.FuncAction( "Copy generated custom meme path", lambda caption1=caption1, caption2=caption2: str( self._create_n_copy_path_to_clipboard( caption1=caption1, caption2=caption2)), ), v0.FuncAction( "Copy generated custom meme to clipboard", lambda caption1=caption1, caption2=caption2: self. _create_n_copy_to_clipboard(caption1=caption1, caption2=caption2), ), ], )
def render_noargs( sources_sinks: List[Union[pulsectl.PulseSourceInfo, pulsectl.PulseSinkInfo]], cards: List[pulsectl.PulseCardInfo], ) -> List[v0.Item]: """Display current source, sink and card profiles.""" results = [] # active port for sources, sinks ---------------------------------------------------------- for s in sources_sinks: # discard if it doesn't have any ports if s.port_active is None: continue icon = sink_icon_path if is_sink(s) else src_icon_path # fill actions actions = [ v0.FuncAction(p.description, lambda s=s, p=p: pulse.port_set(s, p)) for p in s.port_list ] results.append( v0.Item( id=__title__, icon=icon, text=s.port_active.description, subtext=s.description, completion=__triggers__, actions=actions, ) ) # active profile for each sound card ------------------------------------------------------ for c in cards: actions = [ v0.FuncAction( prof.description, lambda c=c, prof=prof: pulse.card_profile_set(c, prof) ) for prof in c.profile_list ] results.append( v0.Item( id=__title__, icon=config_icon_path, text=c.profile_active.description, subtext=c.name, completion=__triggers__, actions=actions, ) ) return results
def get_as_item(result: BingImage): """Return an item. Will return None if the link to the image is not reachable (e.g., on 404) """ try: img = str(result.image.absolute()) except RequestException: return None actions = [ v0.ClipAction("Copy url", result.url), v0.ClipAction("Copy local path to image", img), v0.UrlAction("Open in browser", result.url), ] if result.type != "gif": actions.insert( 0, v0.FuncAction("Copy image", lambda result=result: copy_image(result))) item = v0.Item( id=__title__, icon=str(result.image), text=result.url[-20:], subtext=result.type, completion=f"{__triggers__}", actions=actions, ) return item
def get_as_item(issue: resources.Issue, jira): field = get_as_subtext_field # first action is default action actions = [ v0.UrlAction("Open in jira", f"{issue.permalink()}"), v0.ClipAction("Copy jira URL", f"{issue.permalink()}"), ] # add an action for each one of the available transitions curr_status = issue.fields.status.name for a_transition in jira.transitions(issue): if a_transition["name"] != curr_status: actions.append( v0.FuncAction( f'Mark as "{a_transition["name"]}"', lambda a_transition_id=a_transition["id"]: make_transition( jira, issue, a_transition_id), )) subtext = "{}{}{}{}".format( field(issue.fields.assignee), field(issue.fields.status.name), field(issue.fields.issuetype.name), field(issue.fields.project.key, "proj"), ) subtext += prio_to_text[issue.fields.priority.name] return v0.Item( id=__title__, icon=prio_to_icon[issue.fields.priority.name], text=f"{issue.fields.summary}", subtext=subtext, actions=actions, )
def get_as_albert_item(self): item = super().get_as_albert_item() item.addAction( v0.FuncAction( "Move tasks to the day after", lambda date=self.date: move_tasks_of_date_to_next_day(date), )) return item
def get_as_albert_items_full(self, query_str): item = self.get_as_albert_item() item.subtext = query_str item.addAction( v0.FuncAction( "Add task", lambda args_list=["add", *query_str.split()]: run_tw_action( args_list), )) return [item]
def get_as_item(query_str: str): """Return an item - ready to be appended to the items list and be rendered by Albert.""" query_str = query_str.strip() return v0.Item( id=__title__, icon=icon_path, text="Save to scratchpad", subtext=query_str, completion=f"{__triggers__}{query_str}", actions=[ v0.FuncAction( f"Save to scratchpad -> {s_path}", lambda line=query_str: save_to_scratchpad(line), ), v0.FuncAction( f"Save to scratchpad - New Section -> {s_path}", lambda line=query_str: save_to_scratchpad(line, sep=True), ), ], )
def get_as_albert_items_full(self, query_str: str): item = self.get_as_albert_item() item.subtext = ChangeDeck.usage_str if not query_str else f"Deck to use: {query_str}" item.addAction( v0.FuncAction( "Change deck", lambda new_deck_name=query_str: ChangeDeck.change_to( new_deck_name), )) return [item]
def setup(query) -> list: """Setup is successful if an empty list is returned. Use this function if you need the user to provide you data """ results = [] query_str = query.string # abbreviations file if not abbr_store_fname.is_file(): results.append( v0.Item( id=__title__, icon=icon_path, text=f"Specify file to read/write abbreviations to/from", subtext="Paste the path to the file, then press ENTER", actions=[ v0.FuncAction("Submit path", lambda p=query_str: submit_fname(Path(p))), ], )) return results if not abbr_store_sep.is_file(): results.append( v0.Item( id=__title__, icon=icon_path, text=f"Specify separator *character* for abbreviations", subtext=f"Separator: {query_str}", actions=[ v0.FuncAction("Submit separator", lambda c=query_str: submit_sep(c)), ], )) return results return results
def get_as_item(email): """Return an item - ready to be appended to the items list and be rendered by Albert.""" return v0.Item( id=__title__, icon=icon_path, text=f"Temporary email: <u>{email}</u>", subtext="", completion=f"{__triggers__} {email}", actions=[ v0.FuncAction("Open in browser (and copy email address)", lambda email=email: copy_and_go(email)), ], )
def render_search( sources_sinks: List[Union[pulsectl.PulseSourceInfo, pulsectl.PulseSinkInfo]], cards: List[pulsectl.PulseCardInfo], query_str: str, ) -> List[v0.Item]: results = [] # sinks, sources search_str_to_props: Dict[str, list] = { p.description: [ sink_icon_path if is_sink(s) else src_icon_path, s.description, lambda s=s, p=p: pulse.port_set(s, p), ] for s in sources_sinks for p in s.port_list } # profiles search_str_to_props.update( { prof.description: [ config_icon_path, f"Profile | {c.name}", lambda c=c, prof=prof: pulse.card_profile_set(c, prof), ] for c in cards for prof in c.profile_list } ) # add albert items matched = process.extract(query_str, list(search_str_to_props.keys()), limit=10) for m in [elem[0] for elem in matched]: icon = search_str_to_props[m][0] subtext = search_str_to_props[m][1] action = v0.FuncAction(m, search_str_to_props[m][2]) results.append( v0.Item( id=__title__, icon=icon, text=m, subtext=subtext, completion=" ".join([__triggers__, query_str]), actions=[action], ) ) return results
def get_as_item(path: Path): name = path.name return v0.Item( id=__title__, icon=icon_path, text=name, completion="", actions=[ v0.FuncAction( "Copy 2FA code", lambda name=name: totp_show(name=name).strip(), ) ], )
def fn(): icon=os.path.join(stickersDir, stickerDir, img) albert.info(icon) item = albert.Item( id=__title__, text=stickerDir + ': ' + img, subtext=stickerDir, icon=icon, actions=[ albert.FuncAction(text="Copy Image", callable=lambda: doCopy(icon)) ] ) results.append(item)
def handleQuery(query): results = [] if query.isTriggered: try: query.disableSort() results_setup = setup(query) if results_setup: return results_setup query_str = query.string src, dst = extract_src_dst(query_str) if src and dst: actions = [] for m in available_means: actions.append( v0.FuncAction( m.capitalize(), lambda src=src, dst=dst, m=m: spawn_and_launch_route(src, dst, means=m))) results.append( v0.Item( id=__title__, icon=icon_path, text=f"Open route (takes ~5s)", subtext=f"{src} -> {dst}", actions=actions, )) except Exception: # user to report error results.insert( 0, v0.Item( id=__title__, icon=icon_path, text= "Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{sys.exc_info()}", ) ], ), ) return results
def get_as_item(stream: Stream): icon = stream.icon() or icon_path actions = [ v0.FuncAction("Play", lambda stream=stream: start_stream(stream)) ] if stream.homepage: actions.append(v0.UrlAction("Go to radio homepage", stream.homepage)) return v0.Item( id=__title__, icon=icon, text=stream.name, subtext=stream.description if stream.description else "", completion="", actions=actions, )
def get_as_albert_items_full(self, query_str: str): item = self.get_as_albert_item() query_parts = AddBasicNote.parse_query_str(query_str) if query_parts: front = query_parts[0] back = query_parts[1] item.subtext = f'{front} <span style="color: red">|</span> {back}' else: item.subtext = AddBasicNote.usage_str item.addAction( v0.FuncAction( f"Add {self.name} Note", lambda query_str=query_str: self.add_anki_note(query_str), )) return [item]
def get_as_albert_items_full(self, query_str: str): item = self.get_as_albert_item() if self.detect_cloze_note(query_str): item.subtext = query_str else: item.subtext = AddClozeNote.usage_str item.addAction( v0.FuncAction( "Add a new cloze note", lambda cloze_text=query_str: self.add_cloze_note(cloze_text= cloze_text), )) return [item]
def get_as_item(self): """Return it as item - ready to be appended to the items list and be rendered by Albert. """ return v0.Item( id=__title__, icon=str(self.img), text=self.title(), subtext="", completion=f"{__triggers__} {self.id} ", actions=[ v0.FuncAction("Copy vanilla image", lambda: self.copy_vanilla_img()), v0.ClipAction("Copy vanilla image path", str(self.img)), ], )
def setup(query): """Setup is successful if an empty list is returned.""" results = [] query_str = query.string # abbreviations file if not s_path.is_file(): results.append( v0.Item( id=__title__, icon=icon_path, text=f"Specify the location of the scratchpad file", subtext="Paste the path to the file, then press ENTER", actions=[ v0.FuncAction("Submit path", lambda p=query_str: submit_fname(Path(p))), ], ) ) return results return results
def handleQuery(query): results = [] if query.isTriggered: try: query.disableSort() fields = query.string.split() item = v0.Item( id=__title__, text=__title__, subtext='Enter a query in the form of "<srclang> <dstlang> <text>"', icon=icon_path, completion=query.rawString, ) results.append(item) if len(fields) < 3: keys_monitor.reset() return results def completion(): return f"{__triggers__}{dst} {src} {txt}" src = fields[0] dst = fields[1] txt = " ".join(fields[2:]) results[-1].completion = completion() # determine if we can make the request -------------------------------------------- keys_monitor.report() if keys_monitor.triggered(): url = url_template % (src, dst, urllib.parse.quote_plus(txt)) req = urllib.request.Request(url, headers={"User-Agent": ua}) with urllib.request.urlopen(req) as response: data = json.loads(response.read().decode("utf-8")) result = data[0][0][0] item.text = result item.subtext = "%s -> %s: %s" % ( src.upper(), dst.upper(), txt, ) item.addAction( v0.FuncAction( "Copy translation to clipboard", lambda lang_config={ "src": src, "dst": dst, "src_txt": txt, }, result=result: select_item( lang_config=lang_config, result=result ), ) ) item.addAction( v0.UrlAction( "Open in browser", f"https://translate.google.com/#view=home&op=translate&sl={src.lower()}&tl={dst.lower()}&text={txt}", ) ) # Show previous results iterator = reversed(history_deque) try: next(iterator) for di in iterator: # last is the most recent results.append( get_history_item( src=di["src"], dst=di["dst"], src_txt=di["src_txt"], dst_txt=di["dst_txt"], ) ) except StopIteration: pass except Exception: # user to report error if dev_mode: # let exceptions fly! print(traceback.format_exc()) raise results.insert( 0, v0.Item( id=__title__, icon=icon_path, text="Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{traceback.format_exc()}", ) ], ), ) return results
def handleQuery(query, ) -> list: """Hook that is called by albert with *every new keypress*.""" # noqa results = [] if query.isTriggered: try: query.disableSort() results_setup = setup(query) if results_setup: return results_setup query_parts = query.string.strip().split() name = None if query_parts: name = query_parts.pop(0) subtext = f'Name: {name if name else "Not given"}' results.extend([ v0.Item( id=__title__, icon=countdown_path, text="Create countdown", subtext= f'{subtext}{" - <u>Please provide a duration</u>" if not query_parts else ""}', completion=__triggers__, actions=[ v0.FuncAction( "Create countdown", lambda name=name, query_parts=query_parts: create_countdown( name, *query_parts, ), ) ], ), v0.Item( id=__title__, icon=stopwatch_path, text="Create stopwatch", subtext=subtext, completion=__triggers__, actions=[ v0.FuncAction( "Create stopwatch", lambda name=name, query_parts=query_parts: create_stopwatch( name, *query_parts, ), ) ], ), ]) # cleanup watches that are done for li in [ countdowns, stopwatches, ]: for watch in li: if watch.to_remove(): li.remove(watch) results.extend([get_as_item(item) for item in all_watches()]) except Exception: # user to report error if dev_mode: # let exceptions fly! print(traceback.format_exc()) raise results.insert( 0, v0.Item( id=__title__, icon=countdown_path, text= "Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{traceback.format_exc()}", ) ], ), ) return results
def handleQuery(query) -> list: results = [] if query.isTriggered: try: query.disableSort() results_setup = setup(query) if results_setup: return results_setup query_text = query.string.strip() if not len(query_text): results = [ v0.Item( id=__title__, icon=icon_path, text="Update tldr database", actions=[v0.FuncAction("Update", lambda: update_tldr_db())], ), v0.Item( id=__title__, icon=icon_path, text="Reindex tldr pages", actions=[v0.FuncAction("Reindex", lambda: reindex_tldr_pages())], ), v0.Item( id=__title__, icon=icon_path, text="Need at least 1 letter to offer suggestions", actions=[], ), ] + results return results if query_text in page_paths.keys(): # exact match - show examples results.extend(get_cmd_items((query_text, page_paths[query_text]))) else: # fuzzy search based on word matched = process.extract(query_text, page_paths.keys(), limit=20) for m in [elem[0] for elem in matched]: results.append(get_cmd_as_item((m, page_paths[m]))) except Exception: # user to report error if in_development: raise results.insert( 0, v0.Item( id=__title__, icon=icon_path, text="Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{traceback.format_exc()}", ) ], ), ) return results
def handleQuery(query) -> list: """Hook that is called by albert with *every new keypress*.""" # noqa results = [] if query.isTriggered: try: query.disableSort() results_setup = setup(query) if results_setup: return results_setup query_str = query.string if len(query_str.strip().split()) == 0: results.append( v0.Item( id=__title__, icon=icon_path, text="[new] Add a new abbreviation", subtext="new <u>abbreviation</u> <u>description</u>", completion=f"{__triggers__}new ", )) results.append( v0.Item( id=__title__, icon=icon_path, text="Write more to query the database", subtext="", completion=f"{__triggers__}", )) return results # new behavior tokens = query_str.split() if len(tokens) >= 1 and tokens[0] == "new": if len(tokens) > 1: name = tokens[1] else: name = "" if len(tokens) > 2: desc = " ".join(tokens[2:]) else: desc = "" results.append( v0.Item( id=__title__, icon=icon_path, text=f"New abbreviation: {name}", subtext=f"Description: {desc}", actions=[ v0.FuncAction( f"Save abbreviation to file", lambda name=name, desc=desc: save_abbr( name, desc), ) ], )) return results curr_hash = hash_file(abbreviations_path) global abbr_latest_hash, abbr_latest_d, abbr_latest_d_bi if abbr_latest_hash != curr_hash: abbr_latest_hash = curr_hash with open(abbreviations_path) as f: conts = f.readlines() abbr_latest_d = make_latest_dict(conts) abbr_latest_d_bi = abbr_latest_d.copy() abbr_latest_d_bi.update( {v: k for k, v in abbr_latest_d.items()}) if not abbr_latest_d: results.append( v0.Item( id=__title__, icon=icon_path, text= f'No lines split by "{split_at}" in the file provided', actions=[ v0.ClipAction( f"Copy provided filename", str(abbreviations_path), ) ], )) return results # do fuzzy search on both the abbreviations and their description matched = process.extract(query_str, abbr_latest_d_bi.keys(), limit=10) for m in [elem[0] for elem in matched]: if m in abbr_latest_d.keys(): results.append(get_abbr_as_item((m, abbr_latest_d[m]))) else: results.append(get_abbr_as_item((abbr_latest_d_bi[m], m))) except Exception: # user to report error if dev_mode: # let exceptions fly! print(traceback.format_exc()) raise results.insert( 0, v0.Item( id=__title__, icon=icon_path, text= "Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{traceback.format_exc()}", ) ], ), ) return results
def get_tw_item(task: taskw.task.Task) -> v0.Item: # type: ignore """Get a single TW task as an Albert Item.""" field = get_as_subtext_field task_id = tw_side.get_task_id(task) actions = [ v0.FuncAction( "Complete task", lambda args_list=["done", task_id]: run_tw_action(args_list), ), v0.FuncAction( "Delete task", lambda args_list=["delete", task_id]: run_tw_action(args_list), ), v0.FuncAction( "Start task", lambda args_list=["start", task_id]: run_tw_action(args_list), ), v0.FuncAction( "Stop task", lambda args_list=["stop", task_id]: run_tw_action(args_list), ), v0.FuncAction( "Edit task interactively", lambda args_list=["edit", task_id]: run_tw_action(args_list, need_pty=True), ), v0.FuncAction( "Fail task", lambda args_list=[task_id, "done", failure_annotation]: run_tw_action(args_list), ), v0.ClipAction("Copy task UUID", f"{task_id}"), ] found_urls = url_re.findall(task["description"]) if "annotations" in task.keys(): found_urls.extend(url_re.findall(" ".join(task["annotations"]))) for url in found_urls[-1::-1]: actions.insert(0, v0.UrlAction(f"Open {url}", url)) if reminders_tag_path.is_file(): reminders_tag = load_data(reminders_tag_path) actions.append( v0.FuncAction( f"Add to Reminders (+{reminders_tag})", lambda args_list=[ "modify", task_id, f"+{reminders_tag}", ]: run_tw_action(args_list), )) urgency_str, icon = urgency_to_visuals(task.get("urgency")) text = f'{task["description"]}' if "start" in task: text = f'<p style="color:orange;">{text}</p>' due = None if "due" in task: due = task["due"].astimezone(dateutil.tz.tzlocal()).strftime( "%Y-%m-%d %H:%M:%S") # type: ignore return get_as_item( text=text, subtext="{}{}{}{}{}".format( field(urgency_str), "ID: {}... | ".format(tw_side.get_task_id(task)[:8]), field(task["status"]), field(task.get("tags"), "tags"), field(due, "due"), )[:-2], icon=str(icon), completion=f'{__triggers__}{task["description"]}', actions=actions, )
def handleQuery(query): results = [] # we're into the new day, create and assign a fresh instance last_used = last_used_date.get() current_date = datetime.datetime.today().date() global tw_side, subcommands if last_used < current_date: tw_side = TaskWarriorSideWLock() subcommands = create_subcommands() last_used_date.set(current_date) elif last_used > current_date: # maybe due to NTP? v0.critical( f"Current date {current_date} < last_used date {last_used} ?! Overriding current date, please report this if it persists" ) tw_side = TaskWarriorSideWLock() subcommands = create_subcommands() last_used_date.set(current_date) if not query.isTriggered: if show_items_wo_trigger and len(query.string) < 2: results = [ ActiveTasks().get_as_albert_item(), TodayTasks().get_as_albert_item(), *results, ] else: # join any previously launched threads for i in range(len(workers)): workers.pop(i).join(2) try: query.disableSort() results_setup = setup(query) if results_setup: return results_setup tasks = tw_side.get_all_items(include_completed=False) query_str = query.string if len(query_str) < 2: results.extend([s.get_as_albert_item() for s in subcommands]) results.append( get_as_item( text="Reload list of tasks", actions=[v0.FuncAction("Reload", async_reload_items)], )) tasks.sort(key=lambda t: t["urgency"], reverse=True) results.extend([get_tw_item(task) for task in tasks]) else: subcommand_query = get_subcommand_query(query_str) if subcommand_query: results.extend( subcommand_query.command.get_as_albert_items_full( subcommand_query.query)) if not results: results.append(get_as_item(text="No results")) else: # find relevant results desc_to_task = { task["description"]: task for task in tasks } matched = process.extract(query_str, list(desc_to_task.keys()), limit=30) for m in [elem[0] for elem in matched]: task = desc_to_task[m] results.append(get_tw_item(task)) except Exception: # user to report error if dev_mode: v0.critical(traceback.format_exc()) raise results.insert( 0, v0.Item( id=__title__, icon=icon_path, text= "Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{traceback.format_exc()}", ) ], ), ) return results
def handleQuery(query) -> list: # noqa results = [] if len(query.rawString.strip()) <= 1 and is_radio_on(): results.insert( 0, v0.Item( id=__title__, icon=stop_icon_path, text="Stop Radio", actions=[v0.FuncAction("Stop Radio", lambda: stop_radio())], ), ) reindex_item = v0.Item( id=__title__, icon=repeat_icon_path, text="Reindex stations", actions=[v0.FuncAction("Reindex", lambda: init_streams())], ) if query.isTriggered: try: query.disableSort() results_setup = setup(query) if results_setup: return results_setup query_str = query.string.strip().lower() if not query_str: results.append(reindex_item) for stream in streams: results.append(get_as_item(stream)) else: for stream in streams: if query_str in stream.name.lower() or ( stream.description and query_str.lower() in stream.description.lower()): results.append(get_as_item(stream)) # reindex goes at the end of the list if we are searching for a stream results.append(reindex_item) except Exception: # user to report error if dev_mode: # let exceptions fly! print(traceback.format_exc()) raise results.insert( 0, v0.Item( id=__title__, icon=icon_path, text= "Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{traceback.format_exc()}", ) ], ), ) return results
def handleQuery(query) -> list: """Hook that is called by albert with *every new keypress*.""" # noqa results = [] if query.isTriggered: try: query.disableSort() results_setup = setup(query) if results_setup: return results_setup query_str = query.string.strip() cmdline_to_procs = get_cmdline_to_procs() matched = [ elem[0] for elem in process.extract( query_str, cmdline_to_procs.keys(), limit=15) ] extra_actions = [] if any([symbol in query_str for symbol in "*?[]"]): extra_actions = [ v0.FuncAction( "Terminate by glob", lambda: list( map(lambda p: p.terminate(), globsearch_procs(query_str))), ), v0.FuncAction( "Kill by glob", lambda: list( map(lambda p: p.kill(), globsearch_procs(query_str) )), ), ] for m in matched: for p in cmdline_to_procs[m]: results.append(get_as_item(p, *extra_actions)) # filtering step results = [r for r in results if r is not None] except Exception: # user to report error if dev_mode: # let exceptions fly! print(traceback.format_exc()) raise results.insert( 0, v0.Item( id=__title__, icon=icon_path, text= "Something went wrong! Press [ENTER] to copy error and report it", actions=[ v0.ClipAction( f"Copy error - report it to {__homepage__[8:]}", f"{traceback.format_exc()}", ) ], ), ) return results