from talon.voice import Context, Key ctx = Context("symbol") keymap = { "randall": Key("esc"), "(question [mark] | questo)": "?", "(minus | dash)": "-", "plus": "+", "tilde": "~", "(bang | exclamation point | clamor)": "!", "(dollar [sign] | dolly)": "$", "(downscore | crunder)": "_", "(semi | semicolon | sunk)": ";", "colon": ":", "(square | left square [bracket] | brackorp)": "[", "(rsquare | are square | right square [bracket] | brackose)": "]", "(paren | left paren | precorp)": "(", "(rparen | are paren | right paren | precose)": ")", "(brace | left brace | kirksorp)": "{", "(rbrace | are brace | right brace | kirkos)": "}", "(angle | left angle | less than)": "<", "(rangle | are angle | right angle | greater than)": ">", "(star | asterisk)": "*", "(pound | hash [sign] | octo | number sign)": "#", "percent [sign]": "%", "caret": "^", "at sign": "@", "(and sign | ampersand | amper)": "&", "(pipe | spike)": "|", "(D pipe)": " | ",
from talon.voice import Context # I'm using this to replace my use of words.py ctx = Context('vocab_amy') ctx.vocab = [ # important to keep this in alphabetical order! Here's some R code to print and sort words: # sortedWords = sort(allWords) # test = paste0("'", paste(sortedWords, collapse="', '"), "'") # 'batch effects', # 'bal', # 'Bayes', # 'biostatistics', # 'Bryan', # # 'CAGs', # 'Cholesky', # 'cor', # 'corncob', # 'cov', # # 'dat', # 'deg', # 'dev', # 'dist', # 'dists', # # 'est', # 'exp', # 'expit', #
for i, word in enumerate(words): word = parse_word(word).lower() for name in reversed(fmt): smash, func = formatters[name] word = func(i, word, i == len(words) - 1) spaces = spaces and not smash tmp.append(word) words = tmp sep = ' ' if not spaces: sep = '' Str(sep.join(words))(None) ctx = Context('input') keymap = {} keymap.update(alpha) keymap.update({ 'phrase <dgndictation> [over]': text, 'sentence <dgndictation> [over]': sentence_text, 'comma <dgndictation> [over]': [', ', text], 'period <dgndictation> [over]': ['. ', sentence_text], 'more <dgndictation> [over]': [' ', text], 'word <dgnwords>': word, '(%s)+ [<dgndictation>] [over]' % (' | '.join(formatters)): FormatText,
import string import urllib.parse from talon import ui from talon.voice import Context, Key, press from talon import ctrl from ...utils import select_single, numerals, delay, paste_text from ...misc.basic_keys import get_keys from ...misc import basic_keys ctx = Context( "google_sheets", func=lambda app, win: win.title.endswith("- Google Sheets") or "- Google Sheets -" in win.title, ) # def get_url(): # # TODO: retrieve url in a more direct way # press("cmd-l") # time.sleep(0.25) # copy_selected() def get_url(): win = ui.active_window() return win.children.find(AXTitle="Address and search bar")[0].AXValue def set_url(url): # update the address bar with the updated URL paste_text(url)
import time from talon import ctrl, tap from talon.voice import Key, Context from talon_plugins import eye_mouse from talon_plugins.eye_mouse import Point2d ctx = Context('mouse') eye_mouse.config.velocity = 400 eye_mouse.config.acceleration = { 'cd': (8, 65.0), 'v': (0.0004, 0.0025), 'lmb': 1000.0, 'ratio': 0.7 } x, y = ctrl.mouse_pos() mouse_history = [(x, y, time.time())] force_move = None def on_move(typ, e): mouse_history.append((e.x, e.y, time.time())) if force_move: e.x, e.y = force_move return True tap.register(tap.MMOVE, on_move) def get_initial_mouse_pos(m):
from talon.voice import Word, Key, Context, Str import string terminals = ('com.apple.Terminal', 'com.googlecode.iterm2') ctx = Context('terminal', func=lambda app, win: any( t in app.bundle for t in terminals)) keymap = { 'cd': ['cd ; ls', Key('left'), Key('left'), Key('left'), Key('left')], 'cd back': 'cd -; ls2\n', 'cd develop': 'cd ~/dev; ls\n', 'cd home': 'cd ~; ls\n', 'cd up': 'cd ..; ls\n', 'mux new': 'tmux new -s ', 'mux attach': 'tmux attach -t ', 'mux list': 'tmux ls\n', 'mux horizontal': [Key('ctrl-b'), '\"'], 'mux vertical': [Key('ctrl-b'), '%'], 'mux leave': [Key('ctrl-b'), Key('d')], 'mux scroll': [Key('ctrl-b'), Key('[')], 'run list all': 'ls -lah\n', 'run list long': 'ls -lh\n', 'run get voice': ['git commit -am \' #talon\'', Key('alt-left'), Key('left')], 'run bib': 'bibtex ', 'run socks': 'ssh -D localhost:2020 ', 'run grep': 'grep ', 'run hawk': 'awk ', 'run copy': 'cp -rf ', 'run sink': 'rsync -ravh',
# originally from https://github.com/JonathanNickerson/talon_voice_user_scripts # and https://github.com/pimentel/talon_user/blob/master/repeat.py from talon.voice import Context, Rep, RepPhrase, talon from ..utils import parse_words_as_integer ctx = Context('repeater') # TODO: This could be made more intelligent: # * Apply a timeout after which the command will not repeat previous actions # * Prevent stacking of repetitions upon previous repetitions def repeat(m): repeat_count = parse_words_as_integer(m._words[1:]) if repeat_count != None and repeat_count >= 2: repeater = Rep(repeat_count - 1) repeater.ctx = talon return repeater(None) ctx.keymap({ 'wink': Rep(1), 'creek': RepPhrase(1), 'soup': Rep(2), 'trace': Rep(3), 'quarr':
# originally from https://github.com/JonathanNickerson/talon_voice_user_scripts # and https://github.com/pimentel/talon_user/blob/master/repeat.py # and https://github.com/dwiel/talon_community/blob/f72dabd505fed9a3a9fe304668412bc609b2094f/misc/repeat.py from talon.voice import Context, Rep, RepPhrase, talon, Key, press from .. import utils ctx = Context("repeater") # ordinals = {} # def ordinal(n): # """ # Convert an integer into its ordinal representation:: # ordinal(0) => '0th' # ordinal(3) => '3rd' # ordinal(122) => '122nd' # ordinal(213) => '213th' # """ # n = int(n) # suffix = ["th", "st", "nd", "rd", "th"][min(n % 10, 4)] # if 11 <= (n % 100) <= 13: # suffix = "th" # return str(n) + suffix # for n in range(2, 100): # ordinals[ordinal(n)] = n - 1 # ctx.set_list("ordinals", ordinals.keys()) # def repeat_ordinal(m): # o = m["repeater.ordinals"][0]
from os import system from talon.voice import Context, Key, press from ..utils import parse_words_as_integer ctx = Context("window_control") def jump_tab(m): tab_number = parse_words_as_integer(m._words[1:]) if tab_number is not None and tab_number > 0 and tab_number < 9: press("cmd-%s" % tab_number) ctx.keymap({ # tab control "((open | new) tab | peach)": Key("cmd-t"), "(close tab | totch)": Key("cmd-w"), "([switch] tab (right | next) | goneck)": Key("cmd-shift-]"), "([switch] tab (left | previous | preev) | gopreev)": Key("cmd-shift-["), "[switch] tab (1 | 2 | 3 | 4 | 5 | 6 | 7 | 8)": jump_tab, "[switch] tab (end | rightmost)": Key("cmd-9"), # zooming "zoom in": Key("cmd-="),
from talon.voice import Context, Key ctx = Context('java', func=lambda app, win: win.doc.endswith('.java')) keymap = { 'state this': 'this.', 'state and': ' && ', 'state or': ' || ', 'state super': 'super.', 'state jason': 'Json', 'state sequence': 'Seq', 'state universe': 'UUID', } ctx.keymap(keymap)
import time from .. import utils from talon.voice import Context, Key ctx = Context("sleep") def sleep(m): seconds = extract_num_from_m(m, default=None) time.sleep(seconds) ctx.keymap({"sleep" + utils.numerals: sleep})
parse_words, rot13, sentence_text, surround, text, word, ) def copy_bundle(m): bundle = ui.active_app().bundle clip.set(bundle) app.notify('Copied app bundle', body='{}'.format(bundle)) ctx = Context("input") ctx.keymap({ "say <dgndictation> [over]": text, "sentence <dgndictation> [over]": sentence_text, "comma <dgndictation> [over]": [", ", text], "period <dgndictation> [over]": [". ", sentence_text], "more <dgndictation> [over]": [" ", text], "word <dgnwords>": word, "slap": [Key("cmd-right enter")], "question [mark]": "?", "tilde": "~", "(bang | exclamation point)": "!", "dollar [sign]": "$", "downscore": "_", "colon": ":",
# from https://raw.githubusercontent.com/tuomassalo/atom-talon/master/atom.py # Be sure to copy the instructions from # https://github.com/tuomassalo/atom-talon # to integrate with atom from talon.voice import Key, press, Str, Context ## Note to self(Amy): `ctx = Context('atom', bundle='com.github.atom')` doesn't work ctx = Context('Atom') atom_hotkey = 'cmd-shift-ctrl-alt-t' class Struct: def __init__(self, **entries): self.__dict__.update(entries) # NB! These command names are duplicated in commands.js COMMANDS = Struct( DELETE_TO_BOL='b', DELETE_TO_EOL='e', SELECT_LINES='s', FIND_NEXT='f', FIND_PREVIOUS='p', COPY_LINE='c', MOVE_LINE='m', SELECT_UNTIL='u', )
else: talon.disable() app.icon_color(1, 0, 0, 1) lib.menu_check(b'!Enable Speech Recognition', enable) def on_menu(item): if item == '!Enable Speech Recognition': set_enabled(not talon.enabled) app.register('menu', on_menu) set_enabled(talon.enabled) sleep_group = ContextGroup('sleepy') sleepy = Context('sleepy', group=sleep_group) sleepy.keymap({ 'talon sleep': lambda m: set_enabled(False), 'talon wake': lambda m: set_enabled(True), 'dragon mode': [lambda m: set_enabled(False), lambda m: engine.mimic('wake up'.split())], 'talon mode': [ lambda m: set_enabled(True), lambda m: engine.mimic('go to sleep'.split()) ], }) sleep_group.load()
def emoji_formatter(m): string = join_words(parse_words(m)) insert( "".join([random.choice(alpha_to_emoji.get(c.lower(), [""])) for c in string]) ) def emoji_reaction_formatter(m): string = join_words(parse_words(m)) translated = [random.choice(alpha_to_emoji.get(c.lower(), [""])) for c in string] for t in translated: Str(f"+{t}\n")(m) time.sleep(0.7) ctx = Context("slack", bundle="com.tinyspeck.slackmacgap") ctx.keymap( { "next": [Key("f6")], "jump [<dgndictation>]": [Key("cmd-k"), text], "go (dm's | direct messages | messages)": Key("cmd-shift-k"), "go (and read | unread)": Key("cmd-shift-a"), "go (threads | thread)": Key("cmd-shift-t"), "go activity": Key("cmd-shift-m"), "go channel info": Key("cmd-shift-i"), "go status": Key("cmd-shift-y"), "go (star | stars | starred)": Key("cmd-shift-s"), "react [<dgndictation>]": ["+:", text], "emote [<dgndictation>]": [":", text], "toggle sidebar": Key("cmd-."), "go last unread": Key("alt-shift-up"),
from talon.voice import Context, Key, press from talon import ctrl ctx = Context( "google_slides", func=lambda app, win: win.title.endswith("- Google Slides") or "- Google Slides -" in win.title, ) ctx.keymap({ "(new slide | slide new)": Key("ctrl+m"), "(duplicate slide | slide duplicate)": [Key('cmd-alt-shift-f'), Key("cmd+d")], "undo": Key("cmd+z"), "redo": Key("cmd+y"), "copy": Key("cmd+c"), "cut": Key("cmd+x"), "paste": Key("cmd+v"), "copy formatting of the selected text or shape": Key("cmd+alt+c"), "paste formatting of the selected text or shape": Key("cmd+alt+v"), "insert or edit link": Key("cmd+k"), "open link": Key("alt+enter"),
from talon.voice import Word, Context, Key, Rep, Str, press from talon_init import TALON_HOME, TALON_PLUGINS, TALON_USER import time ctx = Context('Terminal', bundle='com.apple.Terminal') ctx.keymap({ 'cd': 'cd ', 'cd talon home': 'cd {}'.format(TALON_HOME), 'cd talon user': '******'.format(TALON_USER), 'cd talon plugins': 'cd {}'.format(TALON_PLUGINS), 'run make (durr | dear)': 'mkdir ', 'run get': 'git ', 'run get (R M | remove)': 'git rm ', 'run get add': 'git add ', 'run get branch': 'git branch ', 'run get checkout': 'git checkout ', 'run get clone': 'git clone ', 'run get commit': ['git commit -a -m ""', Key('left')], 'run get diff': 'git diff ', 'run get in it': 'git init ', 'run get merge': 'git merge ', 'run get move': 'git mv ', 'run get pull': 'git pull ', 'run get push': 'git push ', 'run get status': 'git status ', 'run (them | vim)': 'vim ', 'run L S': 'ls\n', 'dot pie': '.py', # 'run make': 'make\n',
from talon.voice import Key, Context ctx = Context("iterm", bundle="com.googlecode.iterm2") keymap = { "broadcaster": Key("cmd-alt-i"), "split horizontal": Key("cmd-shift-d"), "split vertical": Key("cmd-d"), "password": Key("cmd-alt-f"), } ctx.keymap(keymap)
def uppercase_letters(m): insert("".join(get_keys(m)).upper()) def press_keys(m): mods = get_modifiers(m) keys = get_keys(m) if mods: press("-".join(mods + [keys[0]])) keys = keys[1:] for k in keys: press(k) ctx = Context("basic_keys") ctx.keymap({ "(uppercase | ship | sky) {basic_keys.alphabet}+ [(lowercase | sunk)]": uppercase_letters, "{basic_keys.modifiers}* {basic_keys.alphabet}+": press_keys, "{basic_keys.modifiers}* {basic_keys.digits}+": press_keys, "{basic_keys.modifiers}* {basic_keys.keys}+": press_keys, "(go | {basic_keys.modifiers}+) {basic_keys.arrows}+": press_keys, }) ctx.set_list("alphabet", alphabet.keys()) ctx.set_list("digits", digits.keys()) ctx.set_list("keys", keys.keys())
def warps(self): try: window = ui.active_window() bundle = window.app.bundle return self.data[bundle].keys() except Exception as e: print(e) return [] def dump(self): with open(warps_file, "w") as f: json.dump(self.data, f, indent=2) mj = MouseWarp() ctx = Context("warp") ctx.keymap({ "mark <dgndictation> [over]": [ lambda m: mj.mark(utils.join_words(utils.parse_words(m))), lambda _: ctx.set_list("warps", mj.warps()), ], "warp {warp.warps}": [lambda m: mj.warp(m["warp.warps"][0])], "list warps": [lambda _: app.notify("Warps:\n" + "\n".join(mj.warps()))], "click {warp.warps}": [ lambda m: mj.warp(m["warp.warps"][0]), lambda _: ctrl.mouse_click(button=0), ], }) ctx.set_list("warps", mj.warps())
import time from talon.voice import Context, Key, press from talon import clip from user import utils ctx = Context('emoji') emojis = { 'thumbs up': ':+1:', 'okay hand': ':ok_hand:', 'okay': ':ok_hand:', 'check': ':white_check_mark:', 'crossed fingers': ':crossed_fingers:', 'fingers': ':crossed_fingers:', 'fingers': ':crossed_fingers:', 'pray': ':pray:', } def react(m): key = utils.join_words(m._words[1:]) emojis[key] old_clipboard = clip.get() try: press('cmd-a', wait=2000) time.sleep(0.25) press('cmd-c', wait=2000) time.sleep(0.25)
from talon.voice import Context, Key, press from talon import app, clip, ui from .utils import parse_words, join_words, insert, parse_words_as_integer ctx = Context('blake') def git_commit(m): message = join_words(parse_words(m)).lower() text = 'git commit -m "%s"' % message insert(text) def npm_run(m): message = join_words(parse_words(m)).lower() text = 'npm run %s' % message insert(text) def multi_arrow(m): times = parse_words_as_integer(m._words[1:]) if times > 0 and times < 10: for t in range(times): press(m._words[0]) def word_travel(m): times = parse_words_as_integer(m._words[2:]) direction = m._words[1] repeat_press(times, 'alt-' + direction)
from talon.voice import Context, Key from ..utils import text ctx = Context("navigation") keymap = { # scrolling "scroll down": [Key("down")] * 30, "scroll up": [Key("up")] * 30, # NB home and end do not work in all apps "(scroll way down | doomway)": Key("cmd-down"), "(scroll way up | jeepway)": Key("cmd-up"), "page up": [Key("pageup")], "page down": [Key("pagedown")], } ctx.keymap(keymap)
def press_keys(m): mods = get_modifiers(m) keys = get_keys(m) if mods == ["shift"] and all(key in alphabet.values() for key in keys): return uppercase_letters(m) if mods: press("-".join(mods + [keys[0]])) keys = keys[1:] for k in keys: press(k) ctx = Context("basic_keys") ctx.keymap({ "(uppercase | ship | sky) {basic_keys.alphabet}+ [(lowercase | sunk)]": uppercase_letters, "{basic_keys.modifiers}* {basic_keys.alphabet}+": press_keys, "{basic_keys.modifiers}* {basic_keys.digits}+": press_keys, "{basic_keys.modifiers}* {basic_keys.keys}+": press_keys, "(go | {basic_keys.modifiers}+) {basic_keys.arrows}+": press_keys, "number {basic_keys.digits}+ [over]": press_keys, "tarsh": Key("shift-tab"),
from talon.voice import Context, Key, press import talon.clip as clip from ..utils import ( text, parse_words, parse_words_as_integer, insert, word, join_words, is_filetype, ) JS_EXTENSIONS = (".js", ".jsx", ".vue", ".ts") context = Context("javascript", func=is_filetype(JS_EXTENSIONS)) def remove_spaces_around_dashes(m): words = parse_words(m) s = " ".join(words) s = s.replace(" – ", "-") insert(s) def CursorText(s): left, right = s.split("{.}", 1) return [left + right, Key(" ".join(["left"] * len(right)))] context.keymap({ "static": "static ",
from talon.voice import Context, Key from ..utils import text PREFIX = "jet " # Note that there are no application or window filters on this context because # git may need to be used outside of the terminal, such as in a browser # terminal, or you may need to send git commands to your friends to help them # out with their git troubles. ctx = Context("git") ctx.keymap({ # TODO: remove duplication between the two groups of commands as we really # only need one set of commands (eg by completing github issue #40 (use a # more comprehensive git grammar)) # git commands originally from std.py # git commands originally from terminal.py # PREFIX + "[<dgndictation>]": ["git ", text], PREFIX + "add [<dgndictation>]": ["git add ", text], PREFIX + "add partial [<dgndictation>]": ["git add -p ", text], PREFIX + "bisect": "git bisect ", PREFIX + "branch": "git branch ", PREFIX + "branch set up stream to [<dgndictation>]": [ "git branch --set-upstream-to=", text, ], PREFIX + "branch delete [<dgndictation>]": ["git branch -D ", text], PREFIX + "branch all [<dgndictation>]": ["git branch -a ", text],
from talon.voice import Context, Key, press import talon.clip as clip from ..utils import ( text, parse_words, parse_words_as_integer, insert, word, join_words, is_filetype, ) CSS_EXTENSIONS = (".css", ".scss") context = Context("css", func=is_filetype(CSS_EXTENSIONS)) context.keymap({ # -------------------------------------------------- # common declarations # -------------------------------------------------- "background image url": "background-image: url();", "clear both": "clear: both;", "cursor default": "cursor: default;", "cursor inherit": "cursor: inherit;", "cursor pointer": "cursor: pointer;", "display block":
import time from talon.voice import Key, Context, Str, press from talon_init import TALON_HOME, TALON_PLUGINS, TALON_USER from talon import ctrl, ui from ..utils import parse_words, text, is_in_bundles, insert from .. import config from ..misc.switcher import switch_app from ..bundle_groups import TERMINAL_BUNDLES # TODO: move application specific commands into their own files: apt-get, etc ctx = Context("terminal", func=is_in_bundles(TERMINAL_BUNDLES)) mapping = {"semicolon": ";", r"new-line": "\n", r"new-paragraph": "\n\n"} def parse_word(word): word = word.lstrip("\\").split("\\", 1)[0] word = mapping.get(word, word) return word def dash(m): words = parse_words(m) press(" ") if len(words) == 1 and len(words[0]) == 1: press("-") Str(words[0])(None) else:
from talon.voice import Context, Key apps = ( "org.rstudio.RStudio", "com.googlecode.iterm2", "org.vim.MacVim", "com.sublimetext.3", ) ctx = Context("R", func=lambda app, win: any(t in app.bundle for t in apps)) ctx.keymap( { "word d-plier": "dplyr", "word tidier": "tidyr", "word reshape 2": "reshape2", "word G G plot": "ggplot", "score (group | grouped) by": "group_by(", "score inner (join | joint)": "inner_join(", "score left (join | joint)": "left_join(", "score bind (rows | rose)": "bind_rows(", "geom point": "geom_point(", "geom line": "geom_line(", "geom point": "geom_point(", "geom segment": "geom_segment(", "geom histogram": "geom_histogram(", "geom bar": "geom_bar(", "geom area": "geom_area(", "geom violin": "geom_violin(", "geom boxplot": "geom_boxplot(", "geom pointrange": "geom_pointrange(", "geom polygon": "geom_polygon(",
from talon.voice import Context, Key, press from talon import ctrl titles = ('- Google Docs', '- Google Sheets', '- Google Slides') ctx = Context('googleDocs', func=lambda app, win: win.title.endswith(titles)) ctx.keymap({ 'copy': Key('cmd+c'), 'cut': Key('cmd+x'), 'paste': Key('cmd+v'), 'paste without formatting': Key('cmd+shift+v'), 'undo': Key('cmd+z'), 'redo': Key('cmd+shift+z'), 'insert or edit link': Key('cmd+k'), 'open link': Key('alt+enter'), 'show common keyboard shortcuts': Key('cmd+/'), 'save every change is automatically saved in drive': Key('cmd+s'), 'print': Key('cmd+p'), 'open': Key('cmd+o'), 'find': Key('cmd+f'), 'find and replace': Key('cmd+shift+h'), 'find again': Key('cmd+g'), 'find previous': Key('cmd+shift+g'), 'hide the menus ': Key('ctrl+shift+f'), 'insert page break': Key('cmd+enter'), 'search the menus': Key('alt+/'), 'bold': Key('cmd+b'), 'italicize': Key('cmd+i'), 'underline': Key('cmd+u'), 'strikethrough': Key('cmd+shift+x'), 'superscript': Key('cmd+.'), 'subscript': Key('cmd+,'),