def refresh(self, *args):
'''args: spec, list of lists of strings'''
# get mapping
recorded_macros = utilities.load_toml_file(
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
if len(args) > 0:
recorded_macros[args[0]] = args[1]
utilities.save_toml_file(
recorded_macros,
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
mapping = {}
for spec in recorded_macros:
sequences = recorded_macros[spec]
delay = settings.SETTINGS["miscellaneous"][
"history_playback_delay_secs"]
play = Playback([(sequence, delay) for sequence in sequences])
command = play * Repeat(
extra="n") if spec.endswith("[times <n>]") else play
mapping[spec] = R(command, rdescript="Recorded Macro: " + spec)
mapping["record from history"] = R(Function(self.record_from_history),
rdescript="Record From History")
mapping["delete recorded macros"] = R(
Function(self.delete_recorded_macros),
rdescript="Delete Recorded Macros")
# reload with new mapping
self.reset(mapping)
def refresh(self, *args):
'''args: spec, list of lists of strings'''
# get mapping
recorded_macros = utilities.load_toml_file(
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
if len(args) > 0:
recorded_macros[args[0]] = args[1]
utilities.save_toml_file(
recorded_macros,
settings.SETTINGS["paths"]["RECORDED_MACROS_PATH"])
mapping = {}
for spec in recorded_macros:
# Create a copy of the string without Unicode characters.
ascii_str = str(spec)
sequences = recorded_macros[spec]
delay = settings.SETTINGS["miscellaneous"][
"history_playback_delay_secs"]
# It appears that the associative string (ascii_str) must be ascii, but the sequences within Playback must be Unicode.
mapping[ascii_str] = R(
Playback([(sequence, delay) for sequence in sequences]),
rdescript="Recorded Macro: " + ascii_str) * Repeat(extra="n")
mapping["record from history"] = R(Function(self.record_from_history),
rdescript="Record From History")
mapping["delete recorded macros"] = R(
Function(self.delete_recorded_macros),
rdescript="Delete Recorded Macros")
# reload with new mapping
self.reset(mapping)
class NPPRule(MergeRule):
pronunciation = "notepad plus plus"
mapping = {
"(line | zeile) <n>": R(Key("c-g") + Text("%(n)d") + Key("enter")),
"(save | speichern)": R(Key("c-s")),
"(save as | speichern als)": R(Key("ca-s")),
}
extras = [IntegerRefST("n", 1, 1000)]
defaults = {"n": 1}
class Decker(MergeRule):
pronunciation = "test rule"
mapping = {
"doon [<nnavi200>]": R(Key("pagedown")) * Repeat(extra="nnavi200"),
}
extras = [IntegerRefST("n", 1, 50), IntegerRefST("nnavi200", 1, 200)]
def __init__(self, num_choice_500s, num_specs):
mapping = {}
extras = []
defaults = {}
w500 = get_500_words()
spec_base = ""
text_base = ""
for k in range(0, num_choice_500s):
extra_name = "giant_" + str(k)
spec_base += " <" + extra_name + ">"
text_base += " %(" + extra_name + ")s"
extras.append(get_giant_choice(extra_name))
for i in range(0, num_specs):
word = w500[i]
mapping[word + spec_base] = R(Text(word + text_base), show=False)
MergeRule.__init__(self,
name="complexity test",
mapping=mapping,
extras=extras,
defaults=defaults)
def test_cancel(self):
mutable_integer = {"value": 0}
def increment():
mutable_integer["value"] += 1
'''make fake AsynchronousAction'''
context_set = S(["test", "words"], increment)
unused_context_set = S(["other"], Text, "words")
context_level = L(context_set, unused_context_set)
aa1 = AsynchronousAction([context_level],
time_in_seconds=0.2,
repetitions=20,
blocking=False)
aa1.set_nexus(self.nexus)
'''make fake StackItemAsynchronous'''
alt = MockAlternative(u"gray", u"fox")
sia1 = StackItemAsynchronous(
aa1, {"_node": alt}) # the dictionary is fake Dragonfly data
'''add it'''
self.nexus.state.add(sia1)
'''make fake canceling RegisteredAction'''
cancel = R(NullAction(), rspec="test")
cancel.set_nexus(self.nexus)
'''make fake StackItemRegisteredAction'''
alt2 = MockAlternative(u"my", u"spoken", u"words")
sira1 = StackItemRegisteredAction(cancel, {"_node": alt2})
'''add it'''
self.nexus.state.add(sira1)
'''AsynchronousAction should have executed exactly once,
when it was added, then immediately gotten canceled'''
self.assertEqual(mutable_integer["value"], 1)
def add_modkeys(rule):
release = R(Key("shift:up, ctrl:up, alt:up"), rdescript="Mod Keys Up")
if not hasattr(rule, "marked") and\
rule.get_pronunciation()[0:6] != "Merged": # don't augment merged rules-- they'd get it twice
for spec in rule.mapping_actual().keys():
rule.mapping_actual(
)[spec] = release + rule.mapping_actual()[spec] + release
rule.marked = True
def test_blocking(self):
'''
Tests:
1 - successful termination (queued actions execute immediately)
2 - unsuccessful termination (queued actions are dropped)
3 - cancellation (queued actions are dropped)
'''
for i in range(0, 3):
'''make fake AsynchronousAction'''
context_set = S(["cancel", "words"], NullAction())
context_level = L(context_set)
aa1 = AsynchronousAction([context_level],
blocking=True) # turn blocking on
aa1.set_nexus(self.nexus)
'''make fake StackItemAsynchronous'''
alt = MockAlternative(u"run", u"blocker")
sia1 = StackItemAsynchronous(
aa1, {"_node": alt}) # the dictionary is fake Dragonfly data
'''add it'''
self.nexus.state.add(sia1)
'''blocked function'''
mutable_integer = {"value": 0}
def increment():
mutable_integer["value"] += 1
'''make fake incrementing RegisteredAction'''
inc = R(Function(increment), rspec="inc")
inc.set_nexus(self.nexus)
'''make fake StackItemRegisteredAction'''
alt2 = MockAlternative(u"my", u"spoken", u"words")
sira1 = StackItemRegisteredAction(inc, {"_node": alt2})
'''add it'''
self.nexus.state.add(sira1)
'''incrementing should be blocked at this point'''
self.assertEqual(mutable_integer["value"], 0)
if i == 0:
'''incrementing should happen that moment of unblocking'''
self.nexus.state.terminate_asynchronous(True)
self.assertEqual(mutable_integer["value"], 1)
elif i == 1:
'''incrementing gets dropped'''
self.nexus.state.terminate_asynchronous(False)
self.assertEqual(mutable_integer["value"], 0)
elif i == 2:
'''make fake canceling RegisteredAction'''
cancel = NullAction(rspec="cancel")
cancel.set_nexus(self.nexus)
'''make fake StackItemRegisteredAction'''
alt3 = MockAlternative(u"my", u"cancel", u"words")
sira2 = StackItemRegisteredAction(cancel, {"_node": alt3})
'''add it'''
self.nexus.state.add(sira2)
'''incrementing gets dropped'''
self.assertEqual(mutable_integer["value"], 0)
class DragonRule(MergeRule):
pronunciation = "dragon"
mapping = {
"reboot (dragon|caster) (german|deutsch)":
R(Function(utilities.reboot_Deutsch),
rdescript="Reboot Dragon Naturallyspeaking"),
"reboot (dragon|caster) (english|englisch)":
R(Function(utilities.reboot_Englisch),
rdescript="Reboot Dragon Naturallyspeaking"),
}
extras = [
Dictation("text"),
Dictation("mim"),
IntegerRefST("n", 1, 1000),
]
defaults = {"n": 1, "mim": ""}
class HexChatRule(MergeRule):
pronunciation = "hex chat"
mapping = {
"network list":
R(Key("c-s")),
# from nav: next / prior tab
}
class Zahlen(MergeRule):
pronunciation = "zahlen"
mapping = {
"wort ziffer <wn>": R(Function(wort_zahl, extra="wn")),
}
extras = [
IntegerRefST("wn", 0, 10),
]
defaults = {}
class IERule(MergeRule):
pronunciation = "explorer"
mapping = {
"get up [<n>]": R(Key("a-up")) * Repeat(extra="n"),
"get back [<n>]": R(Key("a-left")) * Repeat(extra="n"),
"get forward [<n>]": R(Key("a-right")) * Repeat(extra="n"),
"new folder": R(Key("cs-n")),
"address bar": R(Key("c-l")),
"search": R(Key("c-l, tab")),
"left pane": R(Key("c-l, tab:2")),
"center pane": R(Key("c-l, tab:3")),
"sort": R(Key("c-l, tab:4")),
}
extras = [IntegerRefST("n", 1, 10)]
defaults = {
"n": 1,
}
class Punctuation(MergeRule):
pronunciation = CCRMerger.CORE[3]
mapping = {
"[<long>] <text_punc> [<npunc>]":
R(Text("%(long)s" + "%(text_punc)s" + "%(long)s")) *
Repeat(extra="npunc"),
# For some reason, this one doesn't work through the other function
"[<long>] backslash [<npunc>]":
R(Text("%(long)s" + "\\" + "%(long)s")) * Repeat(extra="npunc"),
}
extras = [
IntegerRefST("npunc", 0, 10),
Choice("long", {
"long": " ",
}),
Choice("text_punc", text_punc_dict)
]
defaults = {
"npunc": 1,
"long": "",
}
def test_list_pruning(self):
'''make fake RegisteredAction'''
action = R(NullAction(), rspec="test")
action.set_nexus(self.nexus)
for i in range(0, self.nexus.state.stack.max_list_size + 5):
'''make fake StackItemRegisteredAction'''
alt = MockAlternative(u"my", u"spoken", u"words")
sira1 = StackItemRegisteredAction(action, {"_node": alt})
'''add it'''
self.nexus.state.add(sira1)
self.assertEqual(len(self.nexus.state.stack.list),
self.nexus.state.stack.max_list_size)
def test_preserving_spoken_words(self):
'''make fake RegisteredAction'''
action = R(NullAction(), rspec="test")
action.set_nexus(self.nexus)
'''make fake StackItemRegisteredAction'''
spoken = [u"my", u"spoken", u"words"]
alt = MockAlternative(*spoken)
sira1 = StackItemRegisteredAction(action, {"_node": alt})
'''add it'''
self.nexus.state.add(sira1)
last_item = self.nexus.state.stack.list[
len(self.nexus.state.stack.list) - 1]
self.assertEqual(spoken, last_item.get_preserved())
class DevelopmentHelp(MappingRule):
mapping = {
# castervoice development tools
"(show | open) <url> documentation":
Function(launch_url),
"open natlink folder":
R(BringApp("C:/Windows/explorer.exe",
settings.SETTINGS["paths"]["BASE_PATH"].replace("/", "\\")),
rdescript="Open Natlink Folder"),
"refresh debug file":
R(Function(devgen.refresh), rdescript="Dev: Refreshed Debug File"),
"Agrippa <filetype> <path>":
Function(grep_this),
"run rule complexity test":
Function(lambda: run_tests()),
"run unit tests":
Function(testrunner.run_tests),
"run remote debugger":
Function(run_remote_debugger),
}
extras = [
Dictation("text"),
Choice("path", {
"natlink": "c:/natlink/natlink",
"sea": "C:/",
}),
Choice("filetype", {
"java": "*.java",
"python": "*.py",
}),
Choice(
"url", {
"caster": "https://caster.readthedocs.io/en/latest/",
"dragonfly": "https://dragonfly2.readthedocs.io/en/latest/",
}),
]
defaults = {"text": ""}
class Punctuation(MergeRule):
pronunciation = CCRMerger.CORE[3]
mapping = {
"[<long>] <text_punc> [<npunc>]":
R(Text("%(long)s" + "%(text_punc)s" + "%(long)s")) *
Repeat(extra="npunc"),
# For some reason, this one doesn't work through the other function
"[<long>] backslash [<npunc>]":
R(Text("%(long)s" + "\\" + "%(long)s")) * Repeat(extra="npunc"),
"<double_text_punc> [<npunc>]":
R(Text("%(double_text_punc)s") + Key("left")) * Repeat(extra="npunc"),
"tabby [<npunc>]":
R(Key("tab")) * Repeat(extra="npunc"),
"(back | shin) tabby [<npunc>]":
R(Key("s-tab")) * Repeat(extra="npunc"),
"boom [<npunc>]":
R(Text(", ")) * Repeat(extra="npunc"),
"bam [<npunc>]":
R(Text(". ")) * Repeat(extra="npunc"),
"ace [<npunc100>]":
R(Text(" ")) * Repeat(extra="npunc100"),
}
extras = [
IntegerRefST("npunc", 0, 10),
IntegerRefST("npunc100", 0, 100),
Choice("long", {
"long": " ",
}),
Choice("text_punc", text_punc_dict),
Choice("double_text_punc", double_text_punc_dict)
]
defaults = {
"npunc": 1,
"npunc100": 1,
"long": "",
}
class GridControlRule(MergeRule):
mapping = {
"<x> [by] <y> [<action>]":
R(Function(send_input, nexus=_NEXUS),
rdescript="Douglas Grid: Action"),
"<x1> [by] <y1> select <x2> [by] <y2>":
R(Function(send_input_select, nexus=_NEXUS),
rdescript="Douglas Grid: Select (long version)"),
"<x1> [by] <y1> select <x2>":
R(Function(send_input_select_short, nexus=_NEXUS),
rdescript="Douglas Grid: Select (short version)"),
"point <point>":
R(Function(store_point), rdescript="Douglas Grid: Stor point"),
"select":
R(Function(select_text, nexus=_NEXUS),
rdescript="Douglas Grid: Select (point version)"),
"exit | escape | cancel":
R(Function(kill, nexus=_NEXUS), rdescript="Douglas Grid: Exit"),
}
extras = [
IntegerRefST("x", 0, 300),
IntegerRefST("y", 0, 300),
IntegerRefST("x1", 0, 300),
IntegerRefST("y1", 0, 300),
IntegerRefST("x2", 0, 300),
IntegerRefST("y2", 0, 300),
Choice("action", {
"kick": 0,
"psychic": 1,
"move": 2,
}),
Choice("point", {
"one": 1,
"two": 2,
}),
]
defaults = {
"action": 0,
}
class GridControlRule(MergeRule):
mapping = {
"[<pre>] <color> <n> [<action>]":
R(Function(send_input, nexus=_NEXUS),
rdescript="Rainbow Grid: Action"),
"[<pre1>] <color1> <n1> select [<pre2>] <color2> <n2>":
R(Function(send_input_select, nexus=_NEXUS),
rdescript="Rainbow Grid: Select (long version)"),
"[<pre1>] <color1> <n1> select <n2>":
R(Function(send_input_select_short, nexus=_NEXUS),
rdescript="Rainbow Grid: Select (short version)"),
"point <point>":
R(Function(store_point), rdescript="Rainbow Grid: Store point"),
"select":
R(Function(select_text, nexus=_NEXUS),
rdescript="Rainbow Grid: Select (point version)"),
"exit | escape | cancel":
R(Function(kill, nexus=_NEXUS), rdescript="Rainbow Grid: Exit"),
}
extras = [
IntegerRefST("pre", 0, 9),
IntegerRefST("pre1", 0, 9),
IntegerRefST("pre2", 0, 9),
Choice(
"color", {
"(red | rot)": 0,
"(orange | tan | brown | braun)": 1,
"(yellow | gelb)": 2,
"(green | gruen)": 3,
"(blue | blau)": 4,
"(purple | lila)": 5
}),
Choice(
"color1", {
"(red | rot)": 0,
"(orange | tan | brown | braun)": 1,
"(yellow | gelb)": 2,
"(green | gruen)": 3,
"(blue | blau)": 4,
"(purple | lila)": 5
}),
Choice(
"color2", {
"(red | rot)": 0,
"(orange | tan | brown | braun)": 1,
"(yellow | gelb)": 2,
"(green | gruen)": 3,
"(blue | blau)": 4,
"(purple | lila)": 5
}),
IntegerRefST("n", 0, 100),
IntegerRefST("n1", 0, 100),
IntegerRefST("n2", 0, 100),
Choice("action", {
"kick": 0,
"psychic": 1,
"move": 2,
}),
Choice("point", {
"one": 1,
"two": 2,
}),
]
defaults = {
"pre": 0,
"pre1": 0,
"pre2": 0,
"action": 0,
}
class MainRule(MergeRule):
@staticmethod
def generate_ccr_choices(nexus):
choices = {}
for ccr_choice in nexus.merger.global_rule_names():
choices[ccr_choice] = ccr_choice
return Choice("name", choices)
@staticmethod
def generate_sm_ccr_choices(nexus):
choices = {}
for ccr_choice in nexus.merger.selfmod_rule_names():
choices[ccr_choice] = ccr_choice
return Choice("name2", choices)
mapping = {
# update management
"update caster":
R(DependencyUpdate([pip, "install", "--upgrade", "castervoice"])),
"update dragonfly":
R(DependencyUpdate([pip, "install", "--upgrade", "dragonfly2"])),
# hardware management
"volume <volume_mode> [<n>]":
R(Function(navigation.volume_control, extra={'n', 'volume_mode'})),
"change monitor":
R(Key("w-p") + Pause("100") + Function(change_monitor)),
# window management
'minimize':
R(Playback([(["minimize", "window"], 0.0)])),
'maximize':
R(Playback([(["maximize", "window"], 0.0)])),
"remax":
R(Key("a-space/10,r/10,a-space/10,x")),
# passwords
# mouse alternatives
"legion [<monitor>]":
R(Function(navigation.mouse_alternates, mode="legion", nexus=_NEXUS)),
"rainbow [<monitor>]":
R(Function(navigation.mouse_alternates, mode="rainbow", nexus=_NEXUS)),
"douglas [<monitor>]":
R(Function(navigation.mouse_alternates, mode="douglas", nexus=_NEXUS)),
# ccr de/activation
"<enable> <name>":
R(Function(_NEXUS.merger.global_rule_changer(), save=True)),
"<enable> <name2>":
R(Function(_NEXUS.merger.selfmod_rule_changer(), save=True)),
"enable caster":
R(Function(_NEXUS.merger.merge, time=MergeInf.RUN, name="numbers")),
"disable caster":
R(Function(_NEXUS.merger.ccr_off)),
}
extras = [
IntegerRefST("n", 1, 50),
Dictation("text"),
Dictation("text2"),
Dictation("text3"),
Choice("enable", {
"enable": True,
"disable": False
}),
Choice("volume_mode", {
"mute": "mute",
"up": "up",
"down": "down"
}),
generate_ccr_choices.__func__(_NEXUS),
generate_sm_ccr_choices.__func__(_NEXUS),
IntegerRefST("monitor", 1, 10)
]
defaults = {
"n": 1,
"nnv": 1,
"text": "",
"volume_mode": "setsysvolume",
"enable": -1
}
class StackTest(MappingRule):
'''test battery for the ContextStack'''
mapping = {
"close last tag":
ContextSeeker([
L(
S(["cancel"], None),
S(["html spoken"], close_last_spoken, use_spoken=True),
S(["span", "div"], close_last_rspec, use_rspec=True))
]),
"html":
R(Text("<html>")),
"divider":
R(Text("<div>")),
"span":
R(Text("<span>")),
"backward seeker [<text>]":
ContextSeeker([
L(
S(["ashes"], Text("ashes1 [%(text)s] ")),
S(["bravery"], Text("bravery1 [%(text)s] "))),
L(
S(["ashes"], Text("ashes2 [%(text)s] ")),
S(["bravery"], Text("bravery2 [%(text)s] ")))
]),
"forward seeker [<text>]":
ContextSeeker(forward=[
L(
S(["ashes"], Text("ashes1 [%(text)s] ")),
S(["bravery"], Text("bravery1 [%(text)s] "))),
L(
S(["ashes"], Text("ashes2 [%(text)s] ")),
S(["bravery"], Text("bravery2 [%(text)s] ")))
]),
"asynchronous test":
AsynchronousAction([
L(
S(["ashes", "charcoal"], print_time, None),
S(["bravery"], Text, "bravery1"))
],
time_in_seconds=0.2,
repetitions=20,
finisher=Text(FINISHER_TEXT),
blocking=False),
"ashes":
RegisteredAction(Text("ashes _ ")),
"bravery":
RegisteredAction(Text("bravery _ ")),
"charcoal <text> [<n>]":
R(Text("charcoal _ %(text)s")),
"test confirm action":
ConfirmAction(
Key("a"), rdescript="Confirm Action Test",
instructions="some words here"),
"test box action":
BoxAction(
lambda data: _abc(data),
rdescript="Test Box Action",
box_type=settings.QTYPE_DEFAULT,
log_failure=True),
}
extras = [Dictation("text"), Dictation("text2"), IntegerRefST("n", 1, 5)]
defaults = {"text": "", "text2": ""}
def lazy_value(c,f,**kwargs):
return R(Function(noob_send, command = c, format = f,**kwargs))
class FirefoxRule(MergeRule):
pronunciation = "fire fox"
mapping = {
"(new tab|neuer Tab) [<n>]": R(Key("c-t")) * Repeat(extra="n"),
"reopen tab [<n>]": R(Key("cs-t")) * Repeat(extra="n"),
"show history": R(Key("c-h")),
"show downloads": R(Key("c-j")),
"show bookmarks": R(Key("c-b")),
"[add] bookmark": R(Key("c-d")),
"cancel bookmark": # Call this after "[add] bookmark" if you want to cancel
R(Key("a-b")),
"delete bookmark": # Call if you are on a page you have bookmarked before
R(Key("c-d") + Pause("200") + Key("a-e")),
"full screen": R(Key("f11")),
"zoom in [<n>]": R(Key("c-plus/20")) * Repeat(extra="n"),
"zoom out [<n>]": R(Key("c-minus/20")) * Repeat(extra="n"),
"(leiste | address bar)": R(Key("c-l")),
# the following commands requires the vim vixen extension
"(scroll down | runter) [<n>]": R(Key("c-f")) * Repeat(extra="n"),
"(scroll down | runter) half [<n>]": R(Key("c-d")) * Repeat(extra="n"),
"(scroll up | hoeher) [<n>]": R(Key("c-b")) * Repeat(extra="n"),
"(scroll up | hoeher) half [<n>]": R(Key("c-u")) * Repeat(extra="n"),
"scroll top": R(Key("g") + Key("g")),
"scroll bottom": R(Key("G")),
"reload": R(Key("r")),
"toggle pin": R(Key("z") + Key("p")),
"(loesche pin | delete pin)": R(Key("!") + Key("d")),
"(history back|zurueck) [<n>]": R(Key("H")) * Repeat(extra="n"),
"(history forward|vorwaerts) [<n>]": R(Key("L")) * Repeat(extra="n"),
"parent [<n>]": R(Key("g") + Key("u")) * Repeat(extra="n"),
"root": R(Key("g") + Key("U")),
"link": # opens in new tab
R(Key("F")),
"link here": R(Key("f")),
"mark <letter>": R(Key("m") + Text("%(letter)s")),
"jump <letter>": R(Key("'") + Text("%(letter)s")),
"focus input": R(Text("gi")),
"copy url": # copy URL in current tab
R(Text("y")),
"clipboard tab": # open clipboard's URL in current tab
R(Text("p")),
"clipboard new tab": # open clipboard's URL in new tab
R(Text("P")),
"toggle": # enables / disables add on
R(Key("s-escape")),
# from nav: next / prior / close tab
}
extras = [
IntegerRefST("n", 1, 100),
alphanumeric.get_alphabet_choice("letter"),
]
defaults = {"n": 1}
def update_carrot(rule):
if "carrot" in rule.mapping_actual().keys():
rule.mapping_actual()["carrot"] = R(
Key("caret") + Key("left") + Key("delete"))
class GitterRule(MergeRule):
pronunciation = "Gitter"
mapping = {
"(rooms | raeume)":
R(Key("cs-1") + Key("right")),
"(search | suche)":
R(Key("cs-1") + Key("cs-2")),
"chat":
R(Key("escape") + Key("cs-c")),
"edit":
R(Key("up")),
"(bold | fett)":
R(Text("****") + Key("left:2")),
"(emphasize | hervorheben)":
R(Text("**") + Key("left")),
"(new line | neue zeile)":
R(Key("s-enter")),
"(block quote | zitat)":
R(Text("> ")),
"(mention | erwaehnen)":
R(Text("@")),
"(insert link | link einfuegen)":
R(Text("[]()") + Key("left:3")),
"(short code | kurzer code)":
R(Text("```") + Key("left")),
"(insert code | code einfuegen)":
R(
Text("```") + Key("backspace") + Key("backspace") + Text("```") +
Key("s-enter") + Key("s-enter") + Text("```") + Key("backspace") +
Key("backspace") + Text("```") + Text("```") + Key("backspace") +
Key("backspace") + Key("backspace") + Key("up")),
}
def add_is_to_python(rule):
if rule.get_pronunciation() == "Python":
rule.mapping_actual()["identity is"] = R(Text(" is "),
rdescript="Python: Is")
def update_python(rule):
if "shells" in rule.mapping_actual().keys():
rule.mapping_actual()["shells"] = R(Text("not allowed to use 'else'"),
rdescript="Troll Replacement")
class ThunderbirdRule(MergeRule):
pronunciation = "thunderbird"
mapping = {
"(new message | neue nachricht)": R(Key("c-n")),
"(reply | antworten)": R(Key("c-r")),
"(reply all | allen antworten)": R(Key("cs-r")),
"(forward message | nachricht weiterleiten)": R(Key("cs-r")),
"(retrieve | abholen)": R(Key("s-f5")),
"(expand | aufklappen)": R(Key("*")),
"(collapse | einklappen)": R(Key("\\")),
"(toggle read | gelesen | ungelesen)": R(Key("m")),
"(no | kein) spam": R(Key("s-j")),
"spam": R(Key("j")),
"(toggle star | favorit)": R(Key("s")),
"(next message | weitere nachricht)": R(Key("n")),
"(previous message | vorherige nachricht)": R(Key("p")),
"toggle pane": R(Key("f6")),
"(next | naechster) tab": R(Key("c-tab")),
"(previous | vorheriger) tab": R(Key("cs-tab")),
"(attach file | datei anhaengen)": R(Key("cs-a")),
}
class FileDialogueRule(MergeRule):
pronunciation = "file dialogue"
mapping = {
"get up [<n>]": R(Key("a-up")) * Repeat(extra="n"),
"get back [<n>]": R(Key("a-left")) * Repeat(extra="n"),
"get forward [<n>]": R(Key("a-right")) * Repeat(extra="n"),
"new folder": R(Key("cs-n")),
"address bar": R(Key("c-l")),
"search": R(Key("c-l, tab")),
"left pane": R(Key("c-l, tab:3")),
"center pane": R(Key("c-l, tab:4")),
"sort": R(Key("c-l, tab:5")),
"organize": R(Key("c-l, tab:2")),
"(dateiname | filename)": R(Key("c-l, tab:6")),
"(dateityp | file type)": R(Key("c-l, tab:7")),
}
extras = [IntegerRefST("n", 1, 10)]
defaults = {
"n": 1,
}
class SlackRule(MergeRule):
pronunciation = "Slack"
mapping = {
"(up | hoch)":
R(Key("a-up")),
"(down | runter)":
R(Key("a-down")),
"(next message | naechste nachricht)":
R(Key("as-up")),
"(previous message | vorherige nachricht)":
R(Key("as-down")),
"edit":
R(Key("up")),
"(new line | neue zeile)":
R(Key("s-enter")),
"(bold | fett)":
R(Text("**") + Key("left")),
"(emphasize | hervorheben)":
R(Text("__") + Key("left")),
"(search | suche)":
R(Key("c-f")),
"(block quote | zitat)":
R(Text("> ")),
"(mention | erwaehnen)":
R(Text("@")),
"(short code | kurzer code)":
R(Text("```") + Key("left")),
"(insert code | code einfuegen)":
R(
Text("```") + Key("backspace") + Text("```") + Key("s-enter") +
Key("s-enter") + Text("```") + Key("backspace") +
Key("backspace") + Text("```") + Text("```") + Key("backspace") +
Key("backspace") + Key("backspace") + Key("up")),
}