def select_identity(): identity = get_selection(identities.keys(), 'identity', case_insensitive=True, lines=5, font="@wmFontDmenu@") return identities.get(identity, None)
def select_issue(issues): issues_map = {} for issue in issues: issues_map[issue.key + " | " + issue.fields.summary + " | " + issue.fields.created] = issue selected_issue = get_selection(issues_map.keys(), 'issue', case_insensitive=True, lines=5, font="@wmFontDmenu@") return issues_map.get(selected_issue, None)
def issue_log_work(issue): unloddeg_dates = [ datetime.strftime(d, "%d/%m/%y") for d in issue_get_unlogged_dates(issue) ] date_to_log = get_selection(sorted(unloddeg_dates), 'date', case_insensitive=True, lines=15, font="@wmFontDmenu@") if not date_to_log: notify("[jira]", f"Cancelled logging work for `{issue.key}`", urgency=URGENCY_CRITICAL) sys.exit(1) started = datetime.combine(datetime.strptime(date_to_log, "%d/%m/%y"), datetime.now().time()) amount, comment = None, None while not comment: result = worklog_get_amount_and_comment() if result: amount, comment = result.split("|")[:-1] if not comment: notify("[jira]", f"comment in worklog is mandatory'", urgency=URGENCY_CRITICAL) else: break if amount and comment: tz = pytz.timezone("@systemTimeZone@") started_with_tz = tz.localize(started) wlog = client.add_worklog(issue, timeSpent=amount, started=started_with_tz, comment=comment) notify( "[jira]", f"Logged `{amount}` of work for `{issue.key}` at {date_to_log}'", urgency=URGENCY_NORMAL)
from pystdlib import shell_cmd parser = argparse.ArgumentParser(description="Searchengines") parser.add_argument("--fallback", dest="use_fallback", action="store_true", default=False, help="Use fallback browser to open URL") args = parser.parse_args() r = redis.Redis(host='localhost', port=6379, db=0) searchengines = json.loads(r.get("nav/searchengines")) searchengine = get_selection(searchengines.keys(), "search with", case_insensitive=True, lines=15, font="@wmFontDmenu@") if searchengine: meta = searchengines[searchengine] url = meta["url"] browser_cmd = meta.get("browser", "@defaultBrowser@") if args.use_fallback: browser_cmd = "@fallbackBrowser@" vpn = meta.get("vpn", None) if vpn: shell_cmd(f"vpnctl --start {vpn}") search_term = shell_cmd("xsel -o").replace(" ", "+")
import redis from pystdlib.uishim import get_selection, notify, show_text_dialog, URGENCY_CRITICAL from pystdlib.shell import tmux_create_window from pystdlib import shell_cmd service_modes = ["status", "logs"] r = redis.Redis(host='localhost', port=6379, db=0) extra_hosts_data = json.loads(r.get("net/extra_hosts")) swarm_meta = json.loads(r.get("virt/swarm_meta")) swarm = get_selection(swarm_meta.keys(), "swarm", case_insensitive=True, lines=5, font="@wmFontDmenu@") if not swarm: notify("[virt]", "No swarm selected") sys.exit(0) swarm_host = swarm_meta[swarm] os.environ["DOCKER_HOST"] = f"ssh://{swarm_host}" host_meta = extra_hosts_data.get(swarm_host, None) if not host_meta: notify("[docker]", f"Host '{swarm_host}' not found", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1)
CONTAINER_STATUSES = [ "alive", "all" ] hostnames = [] with open("/etc/hosts", "r") as hosts: for host in hosts: host_list = list(reversed(host.strip(";\n").split())) if host_list: hostnames.extend(host_list[:-1]) hostnames = sorted(list(set(hostnames))) hostname = get_selection(hostnames, "host", case_insensitive=True, lines=10, font="@wmFontDmenu@") host_meta = extra_hosts_data.get(hostname, None) if not host_meta: notify("[docker]", f"Host '{hostname}' not found", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) if hostname == "localhost": os.environ["DOCKER_HOST"] = "unix:///var/run/docker.sock" else: os.environ["DOCKER_HOST"] = f"ssh://{hostname}" host_vpn = host_meta.get("vpn", None) if host_vpn: shell_cmd(f"vpnctl --start {host_vpn}") container_status = get_selection(CONTAINER_STATUSES, "status", case_insensitive=True, lines=3, font="@wmFontDmenu@")
import sys from pystdlib.uishim import get_selection, notify, URGENCY_CRITICAL from pystdlib.shell import tmux_create_window from pystdlib import shell_cmd keyword_result = get_selection([], 'keyword', font="@wmFontDmenu@") if not keyword_result: notify("[search repos]", "no keyword provided", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) matching_repos = shell_cmd(f"fd -t d -d @searchDepth@ {keyword_result} @searchReposRoot@", split_output="\n") selected_repo = get_selection(matching_repos, 'repo', case_insensitive=True, lines=10, font="@wmFontDmenu@") if not selected_repo: notify("[search repos]", "no repository selected", timeout=5000) sys.exit(0) elisp_cmd = f'(dired "{selected_repo}")' emacs_cmd = f'emacsclient -c -s /run/user/1000/emacs/server -e \'{elisp_cmd}\'' # TODO: make SPOT for socket path shell_cmd(emacs_cmd)
from pystdlib.uishim import get_selection, show_text_dialog from pystdlib import shell_cmd ifconfig_result = shell_cmd("ifconfig -s", split_output="\n") iface_names = [iface_meta.split()[0] for iface_meta in ifconfig_result[1:]] iface_name = get_selection(iface_names, "describe", case_insensitive=True, lines=10, font="@wmFontDmenu@") iface_traits = shell_cmd(f"ifconfig {iface_name}") shell_cmd(["xsel", "-ib"], universal_newlines=True, input=f"{iface_traits.encode('utf-8')}") show_text_dialog(text=iface_traits)
from pystdlib import shell_cmd parser = argparse.ArgumentParser(description="Searchengines") parser.add_argument("--fallback", dest="use_fallback", action="store_true", default=False, help="Use fallback browser to open URL") args = parser.parse_args() r = redis.Redis(host='localhost', port=6379, db=0) searchengines = json.loads(r.get("nav/searchengines")) searchengine = get_selection(searchengines.keys(), "search with", case_insensitive=True, lines=15, font="@wmFontDmenu@") if searchengine: meta = searchengines[searchengine] url = meta["url"] browser_cmd = meta.get("browser", "@defaultBrowser@") if args.use_fallback: browser_cmd = "@fallbackBrowser@" vpn = meta.get("vpn", None) if vpn: shell_cmd(f"vpnctl --start {vpn}") search_term = get_selection([],
deps_dict = {} go_mod_path = os.getcwd() + "/go.mod" if not (os.path.exists(go_mod_path) and os.path.isfile(go_mod_path)): notify("[modedit]", "No go.mod found", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) with open(go_mod_path, "r") as f: deps_list = re.search(pattern, f.read(), re.DOTALL).group(0).split("\n")[1:-1] deps_list = [dep for dep in deps_list if not dep.startswith("//")] deps_list = [dep for dep in deps_list if dep.startswith("\t")] for dep in deps_list: deps_dict[dep.split()[0]] = dep.split()[1] dep_path = get_selection(deps_dict.keys(), "replace", case_insensitive=True, lines=10, font="@wmFontDmenu@") if not dep_path: notify("[modedit]", "Nothing selected", timeout=5000) sys.exit(0) dep_path_local = "@globalWorkspaceRoot@/" + dep_path if dep_path_local.endswith(".git"): dep_path_local = dep_path_local[:-4] if not (os.path.exists(dep_path_local) and os.path.isdir(dep_path_local)): notify("[modedit]", "No dependency repo found locally", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) with open(go_mod_path, "a") as f: f.write(f"\nreplace {dep_path} => {dep_path_local}")
import redis from pystdlib.uishim import get_selection, notify, URGENCY_CRITICAL from pystdlib.shell import tmux_create_window from pystdlib import shell_cmd r = redis.Redis(host='localhost', port=6379, db=0) dbms_meta = json.loads(r.get("misc/dbms_meta")) extra_hosts_data = json.loads(r.get("net/extra_hosts")) if not len(dbms_meta): notify("[dbms]", "No entries", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) dbms_entry = get_selection(dbms_meta.keys(), "", lines=5, font="@wmFontDmenu@") if dbms_entry: dbms_pass = None if dbms_meta[dbms_entry].get("passwordPassPath"): # using pass dbms_pass = shell_cmd( f'pass {dbms_meta[dbms_entry]["passwordPassPath"]}', split_output="\n")[0] elif dbms_meta[dbms_entry].get("password"): # password in plaintext dbms_pass = dbms_meta[dbms_entry].get("password") else: notify("[dbms]", f"No password provided for '{dbms_entry}'", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1)
def fetch_tags_cloud(): tags_cloud = shell_cmd("buku --np --st", split_output="\n") return [ " ".join(tag.strip().split(" ")[1:-1]) for tag in tags_cloud if tag ] bookmark_text = shell_cmd("xsel -o -b") if bookmark_text is not None: if not is_valid_url(bookmark_text): notify("error", "URL is not valid", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) result = get_selection([bookmark_text], 'bookmark', font="@wmFontDmenu@") if not result: notify("OK", "Aborted adding bookmark", timeout=5000) sys.exit(1) tags_cloud = fetch_tags_cloud() bookmark_tags = [] while True: tag = get_selection(tags_cloud, 'add tag', lines=15, font="@wmFontDmenu@") if tag: bookmark_tags.append(tag) tags_cloud.remove(tag) else: break
import redis from pystdlib import shell_cmd from pystdlib.shell import tmux_create_window from pystdlib.uishim import get_selection, notify, URGENCY_CRITICAL from pystdlib.xlib import switch_named_desktop r = redis.Redis(host='localhost', port=6379, db=0) bookmarks = json.loads(r.get("nav/bookmarks")) if not len(bookmarks): notify("[bookmarks]", "No entries", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) bookmark = get_selection(bookmarks.keys(), "", lines=15, font="@wmFontDmenu@") if bookmark: meta = bookmarks[bookmark] path = meta["path"] shell = meta.get("shell", None) if shell: tmux_session = meta.get("tmux", "@tmuxDefaultSession@") tmux_create_window(None, tmux_session, window_title=path.split("/")[-1], attach=True, start_directory=path) elisp_cmd = f'(dired "{path}")' emacs_cmd = f'emacsclient -c -s /run/user/1000/emacs/server -e \'{elisp_cmd}\' &' # TODO: make SPOT for socket path shell_cmd(emacs_cmd, oneshot=True)
action="store_true", default=False, help="Use fallback browser to open URL") parser.add_argument("--copy", dest="copy_url", action="store_true", default=False, help="Copy webjump's url to clipboard") args = parser.parse_args() r = redis.Redis(host='localhost', port=6379, db=0) webjumps = json.loads(r.get("nav/webjumps")) webjump = get_selection(webjumps.keys(), "jump to", case_insensitive=True, lines=15, font="@wmFontDmenu@") if webjump: vpn = webjumps[webjump].get("vpn", None) if vpn: shell_cmd(f"vpnctl --start {vpn}") browser_cmd = webjumps[webjump].get("browser", "@defaultBrowser@") if args.use_fallback: browser_cmd = "@fallbackBrowser@" url = webjumps[webjump]['url'] if not args.copy_url: shell_cmd(f"{browser_cmd} {url}", oneshot=True) shell_cmd(["xsel", "-ib"], input=url.encode('utf-8'))
identity = select_identity() if not identity: notify("[jira]", "invalid identity", urgency=URGENCY_CRITICAL) sys.exit(1) client = get_client(server=identity["jira"]["server"], auth=tuple(identity["jira"]["creds"])) issues = get_issues(client, identity["jira"]["project"]) issue = select_issue(issues) if not issue: notify("[jira]", "No issue selected", urgency=URGENCY_NORMAL) sys.exit(0) op = get_selection(OPS.keys(), '>', case_insensitive=True, lines=5, font="@wmFontDmenu@") if not op: notify("[timetracking]", "No operation selected", urgency=URGENCY_NORMAL) sys.exit(0) if op not in OPS: notify("[timetracking]", "Invalid operation `{op}`", urgency=URGENCY_NORMAL) sys.exit(0) OPS[op](issue)
from pystdlib.browser import collect_sessions, collect_sessions_with_size, \ collect_session_urls, init_mgmt_argparser, rotate_sessions parser = init_mgmt_argparser("qutebrowser-session-auto") args = parser.parse_args() if not args.sessions_path: notify("[qutebrowser]", f"No sessions base path provided", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) if args.save_session: session_name = get_selection([], "save as", case_insensitive=True, lines=1, font="@wmFontDmenu@") if session_name: shell_cmd(f"qb-dump-session {session_name}") elif args.open_session: session_name = get_selection(sorted(collect_sessions(args.sessions_path)), "open", case_insensitive=True, lines=15, font="@wmFontDmenu@") if session_name: urls, _ = collect_session_urls(args.sessions_path, session_name) shell_cmd(f"emacsclient -c {args.sessions_path}/{session_name}") # NOTE: direct opening is not implemented yet because of non-flat session layout elif args.delete_session:
import os from pystdlib import shell_cmd from pystdlib.shell import tmuxp_load_session, tmuxp_collect_sessions from pystdlib.uishim import get_selection result = get_selection(sorted(tmuxp_collect_sessions()), 'config', lines=10, font="@wmFontDmenu@") if result: shell_cmd(f"tmuxp load -y -d {os.getenv('HOME')}/.tmuxp/{result}.yml")
import json import sys import redis from pystdlib.uishim import get_selection from pystdlib import shell_cmd r = redis.Redis(host='localhost', port=6379, db=0) snippets = json.loads(r.get("nav/snippets")) if not len(snippets): notify("[snippets]", "No entries", urgency=URGENCY_CRITICAL, timeout=5000) sys.exit(1) snippet = get_selection(snippets.keys(), "", lines=15, font="@wmFontDmenu@") if snippet: snippet_data = snippets[snippet] shell_cmd(["xsel", "-ib"], universal_newlines=True, input=f"{snippet_data}")
args = parser.parse_args() # provide copying to clipboard # provide option to use (py)fzf if args.add_entry: # how to: # iterate over nested levels, collecting nodes under previously selected nodes # full entry path should be accumulated during this loop # on every level we check if current input exists as path part # if it exists we are going deeper # otherwise we create inexistent node and starting the loop over # there should be a show-stopper keybinding to be able to end this loop # afterwards we get last component of accumelated path and assuming it to be # leaf(gpg) node, that will actually contain secret data # then ask password type - manual or autogenerated # think of how to provide password length in autogenerated case though print("add entry") else: pass_files = collect_entries("@passwordStorePath@") path = get_selection(pass_files, ">", lines=10, font="@wmFontDmenu@") if path: annotated = annotate_entry(read_entry_raw(path)) field = get_selection(annotated.keys(), "type >", lines=3, font="@wmFontDmenu@") if field: shell_cmd(f"xdotool type {annotated[field]}")
"80": "@defaultBrowser@", "8080": "@defaultBrowser@", "8000": "@defaultBrowser@" } ip_address_format = "{{range $network, $settings :=.NetworkSettings.Networks}}{{$settings.IPAddress}}{{end}}" ports_format = "{{range $port, $mappings :=.NetworkSettings.Ports}}{{$port}}{{end}}" if "DOCKER_HOST" in os.environ: del os.environ["DOCKER_HOST"] # ensure we cosidering only local containers container_names = shell_cmd("docker ps --format '{{.Names}}'", split_output="\n") selected_container = get_selection(container_names, "container", case_insensitive=True, lines=10, font="@wmFontDmenu@") if not selected_container: sys.exit(1) container_ip = shell_cmd( f"docker inspect {selected_container} --format='{ip_address_format}'") container_ports = shell_cmd( f"docker inspect {selected_container} --format='{ports_format}'", split_output="\n") port_result = None for port in container_ports_result: port_number = port.split("/")[0]
from bs4 import BeautifulSoup from pystdlib.uishim import get_selection, notify from pystdlib import shell_cmd def is_valid_url(url): return re.search("@urlRegexPy@", url) is not None page_url = shell_cmd("xsel -o -b") if page_url is not None: if is_valid_url(page_url): session_name = get_selection([], "save as", lines=1, font="@wmFontDmenu@") if not session_name: sys.exit(1) page_content = urlopen(page_url) soup = BeautifulSoup(page_content, "html.parser") tags = soup.findAll("a", attrs={"href": re.compile("^https?://")}) org_content = [ f"#+TITLE: {soup.title.string}\n", f"#+PROPERTY: url {page_url}\n" ] for tag in tags: org_content.append(f"* {tag.get('href')}\n") with open(f"@firefoxSessionsPath@/{session_name}.org", "w") as f: f.writelines(org_content) notify("[scrape]",
help="show predefined command choices") parser.add_argument( "--ignore-tmux", dest="ignore_tmux", action="store_true", default=False, help="open connection in new terminal window rather than tmux pane") args = parser.parse_args() r = redis.Redis(host='localhost', port=6379, db=0) extra_hosts_data = json.loads(r.get("net/extra_hosts")) host = get_selection(extra_hosts_data.keys(), "ssh to", case_insensitive=True, lines=10, font="@wmFontDmenu@") if host: host_meta = extra_hosts_data[host] host_vpn = host_meta.get("vpn", None) if host_vpn: shell_cmd(f"vpnctl --start {host_vpn}") ssh_user = host_meta.get("user", None) ssh_port = host_meta.get("port", None) cmd = f"ssh{' -l ' + ssh_user if ssh_user else ''}{' -p ' + str(ssh_port) if ssh_port else ''} {host_meta['ips'][0]}" if args.show_choices: command_choices = json.loads(r.get("net/command_choices")) choice = get_selection(command_choices, "execute",
if args.invalidate: shell_cmd("pkexec systemctl daemon-reload", shell=True, stdout=sys.stdout, stderr=sys.stdout) r.delete("system/services") sys.exit(0) if not r.exists("system/services"): r.lpush("system/services", *list_units()) service = get_selection(sorted( list( dict.fromkeys([ service.decode() for service in r.lrange("system/services", 0, -1) ]))), 'service', lines=20, font="@wmFontDmenu@") if not service: sys.exit(1) operation = get_selection(operations, '> ', lines=5, font="@wmFontDmenu@") if not operation: sys.exit(1) if operation in ["journal", "status"]: unit_show(service, operation, user=('user' in service), shell=["@defaultTerminal@", "-e"], tmux_session="@tmuxDefaultSession@")
import json import os import re import redis from pystdlib.uishim import get_selection from pystdlib import shell_cmd r = redis.Redis(host='localhost', port=6379, db=0) ebooks = r.get("content/ebooks_list") if ebooks: ebooks = json.loads(ebooks) result = get_selection(ebooks, 'book', case_insensitive=True, lines=30, font="@wmFontDmenu@") if result: shell_cmd(f"zathura {re.escape(result)}")
import json import redis r = redis.Redis(host='localhost', port=6379, db=0) bookmarks = json.loads(r.get("nav/bookmarks")) from pystdlib import shell_cmd from pystdlib.shell import tmux_create_window from pystdlib.uishim import get_selection from pystdlib.xlib import switch_named_desktop left_pane_path = get_selection(bookmarks.keys(), "left >", lines=15, font="@wmFontDmenu@") or " " right_pane_path = get_selection(bookmarks.keys(), "right >", lines=15, font="@wmFontDmenu@") or " " cmd = f"@mcCmd@ {left_pane_path} {right_pane_path}".strip(" ") tmux_create_window(cmd, "main", window_title="copier", create_if_not=True, attach=True) # shell_cmd(cmd, oneshot=True)