├── .gitattributes
├── .gitignore
├── CHANGELOG.md
├── Pip Install Dependencies.bat
├── README.md
├── SwitchHere.bat
├── _mathfly_main.py
├── install.bat
├── mathfly
    ├── __init__.py
    ├── apps
    │   ├── __init__.py
    │   ├── app_template.py
    │   ├── sublime.py
    │   ├── sumatrapdf.py
    │   └── wordpad.py
    ├── ccr
    │   ├── LyX.py
    │   ├── ScientificNotebook55.py
    │   ├── __init__.py
    │   ├── alias.py
    │   ├── core.py
    │   ├── latex.py
    │   └── latex_maths.py
    ├── config
    │   ├── ScientificNotebook55.toml
    │   ├── bin
    │   │   └── reboot.bat
    │   ├── core.toml
    │   ├── latex.toml
    │   ├── lyx.toml
    │   └── settings.toml
    ├── docs
    │   ├── Core.pdf
    │   ├── LaTeX.pdf
    │   ├── LyX.pdf
    │   ├── Scientific_Notebook.pdf
    │   └── source
    │   │   ├── Apps.md
    │   │   ├── Core.tex
    │   │   ├── LaTeX.tex
    │   │   ├── LyX.tex
    │   │   └── Scientific_Notebook.tex
    ├── imports.py
    └── lib
    │   ├── __init__.py
    │   ├── actions.py
    │   ├── control.py
    │   ├── ctrl
    │       ├── __init__.py
    │       └── nexus.py
    │   ├── execution.py
    │   ├── integers.py
    │   ├── latex
    │       ├── __init__.py
    │       ├── bibtexer.py
    │       ├── book_citation_generator.py
    │       └── tex_funcs.py
    │   ├── merge
    │       ├── __init__.py
    │       ├── ccrmerger.py
    │       ├── mergepair.py
    │       ├── mergerule.py
    │       ├── nestedrule.py
    │       └── selfmodrule.py
    │   ├── navigation.py
    │   └── utilities.py
└── requirements.txt


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Ignore junk
 2 | **/ccr.toml
 3 | **/aliases.toml
 4 | mathfly/docs/source/*.pdf
 5 | .idea/
 6 | *.pyc
 7 | *.wav
 8 | *.class
 9 | *.aux
10 | *.run.xml
11 | *.bcf
12 | *.html
13 | *.toc
14 | *.synctex.gz
15 | test.py
16 | log.txt
17 | complexity_report*
18 | *.log
19 | *.*\#
20 | *.*~
21 | .cache/
22 | _*.py
23 | !_mathfly_main.py
24 | VirtualDesktopAccessor.dll


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Change Log
 2 | 
 3 | ## [v1.0](https://github.com/mrob95/mathfly/tree/v1.0) (2019-04-07)
 4 | **Merged pull requests:**
 5 | 
 6 | - Delete certain words from the active vocabulary on start-up [\#7](https://github.com/mrob95/mathfly/pull/7) ([mrob95](https://github.com/mrob95))
 7 | - Add self referencing rules WIP [\#6](https://github.com/mrob95/mathfly/pull/6) ([mrob95](https://github.com/mrob95))
 8 | - Fix integer bug [\#5](https://github.com/mrob95/mathfly/pull/5) ([mrob95](https://github.com/mrob95))
 9 | - Switch to using contexts instead of manually enabling and disabling grammars [\#4](https://github.com/mrob95/mathfly/pull/4) ([mrob95](https://github.com/mrob95))
10 | - Added numbered formula for lyx. [\#2](https://github.com/mrob95/mathfly/pull/2) ([alexboche](https://github.com/alexboche))
11 | 
12 | 
13 | 
14 | \* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


--------------------------------------------------------------------------------
/Pip Install Dependencies.bat:
--------------------------------------------------------------------------------
 1 | @echo off
 2 | echo Installing: dragonfly2, wxPython, pillow
 3 | 
 4 | cd c:\python27\scripts
 5 | pip install --upgrade pip
 6 | pip install -U wxpython
 7 | pip install -U pywin32
 8 | pip install -U setuptools
 9 | pip install -U future
10 | pip install -U dragonfly2
11 | pip install -U toml
12 | pip install -U beautifulsoup4
13 | pip install -U six
14 | 
15 | echo ------------------------------------------
16 | echo Mathfly Dependencies Installation Complete
17 | echo ------------------------------------------
18 | 
19 | pause


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | *21/02/2021 Note: this page refers to an old version of mathfly. Talon can do everything that mathfly could and more. See the [mathfly-talon repository](https://github.com/mrob95/mathfly-talon) and [mathfly website](https://mathfly.org) for details.*
 2 | 
 3 | # Mathfly
 4 | A free, open source utility for dictating mathematical notation and LaTeX quickly and easily using [Dragon Professional Individual](https://www.nuance.com/en-gb/dragon/business-solutions/dragon-professional-individual.html). Currently supports the free, open source LyX document processor and Scientific Notebook 5.5 (allowing for drop-in replacement of MathTalk). Based on Natlink, dragonfly and Caster. With thanks to Alex Boche and David Conway.
 5 | 
 6 | * [mathfly.org](https://mathfly.org)
 7 | * [Gitter channel](https://gitter.im/mathfly-dictation/community) - [![Join the chat at https://gitter.im/mathfly-dictation/community](https://badges.gitter.im/mathfly-dictation/community.svg)](https://gitter.im/mathfly-dictation/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 8 | * Contact: mike@mikeroberts.xyz
 9 | * [Installation instructions](https://mathfly.org/installation.html)
10 | * [Implementation details](https://mathfly.org/implementation.html)
11 | * [Change log](CHANGELOG.md)
12 | * For complete lists of the commands which Mathfly provides, read the [Core](mathfly/docs/Core.pdf), [LyX](mathfly/docs/LyX.pdf), [Scientific Notebook 5.5](mathfly/docs/Scientific_Notebook.pdf) and [LaTeX](mathfly/docs/LaTeX.pdf) documentation.
13 | 
14 | ## Quick
15 | Mathfly interprets dictated commands on-the-fly quickly and continuously, making it far faster than other systems. As fast as you can speak, Mathfly can interpret.
16 | 
17 | While I have no data comparing dictation speed with normal writing speed, I will say that I have been using versions of this software to do exams throughout my economics undergraduate degree, and have never needed extra time or struggled to finish. Video demonstration:
18 | 
19 | [![Brief demonstration](http://img.youtube.com/vi/7eZ6fMztvwA/0.jpg)](https://www.youtube.com/watch?v=7eZ6fMztvwA)
20 | 
21 | ## Infinitely modifiable
22 | The vast majority of Mathfly's commands are contained in plaintext config files in `mathfly/config/`, designed to be easy to edit and extend. If you need a new command, it's as simple as adding one line of plaintext. If you keep getting a command wrong, you can change it. If there are commands you don't need, you can delete them.
23 | 
24 | [![modification demonstration](http://img.youtube.com/vi/vLwu9SWK030/0.jpg)](https://youtu.be/vLwu9SWK030)
25 | 
26 | For an even easier way of adding new commands, "alias" turns highlighted text into a new command.
27 | 
28 | [![alias demonstration](http://img.youtube.com/vi/mZ-Y8O5RrUY/0.jpg)](https://www.youtube.com/watch?v=mZ-Y8O5RrUY)
29 | 
30 | ## LaTeX
31 | Mathfly also contains a module for dictating into LaTeX documents, with commands for inserting objects, beginning and ending environments, reproducing premade templates, and crawling the web for references, all with simple voice commands. For a full list of commands, read the [LaTeX](mathfly/docs/LaTeX.pdf) documentation.
32 | 
33 | [![LaTeX demonstration](http://img.youtube.com/vi/N9OzgJFP8tM/0.jpg)](https://youtu.be/N9OzgJFP8tM)
34 | 


--------------------------------------------------------------------------------
/SwitchHere.bat:
--------------------------------------------------------------------------------
1 | set currentpath=%~dp0
2 | cd C:\Python27
3 | python C:\NatLink\NatLink\confignatlinkvocolaunimacro\natlinkconfigfunctions.py -n "%currentpath:~0,-1%"


--------------------------------------------------------------------------------
/_mathfly_main.py:
--------------------------------------------------------------------------------
 1 | import logging
 2 | logging.basicConfig()
 3 | 
 4 | from dragonfly import (Function, Grammar, Text, Dictation, Choice, Pause)
 5 | 
 6 | import os, sys
 7 | import natlink
 8 | 
 9 | from mathfly.lib import control, utilities
10 | from mathfly.lib.merge.mergerule import MergeRule
11 | from mathfly.lib.merge.mergepair import MergeInf
12 | 
13 | BASE_PATH = os.path.realpath(__file__).split("\\_mathfly_main.py")[0].replace("\\", "/")
14 | sys.path.append(BASE_PATH)
15 | 
16 | CORE = utilities.load_toml_relative("config/core.toml")
17 | 
18 | MF_NEXUS = control.nexus()
19 | MF_NEXUS.build(True)
20 | 
21 | class MainRule(MergeRule):
22 | 
23 | 	mapping = {
24 |         "configure math fly [settings]":
25 |             Function(utilities.load_config, config_name="settings.toml"),
26 | 
27 |         "<enable> <name>": Function(MF_NEXUS.rule_changer),
28 | 
29 |         "reboot dragon": Function(utilities.reboot),
30 | 
31 |         "rebuild math fly": Function(MF_NEXUS.build),
32 | 
33 |         "math fly help": Function(utilities.help),
34 | 	}
35 | 	extras=[
36 | 		MF_NEXUS.generate_ccr_choices("name"),
37 |         Choice("enable", {
38 |             "enable": True,
39 |             "disable": False
40 |         }),
41 | 	]
42 | 
43 | grammar = Grammar('general')
44 | main_rule = MainRule()
45 | grammar.add_rule(main_rule)
46 | grammar.load()


--------------------------------------------------------------------------------
/install.bat:
--------------------------------------------------------------------------------
 1 | set currentpath=%~dp0
 2 | echo Installation path: %currentpath%
 3 | 
 4 | cd C:\Python27
 5 | 
 6 | echo Installing dependencies
 7 | python -m pip install -r "%currentpath%requirements.txt"
 8 | 
 9 | echo Activating natlink
10 | python C:\NatLink\NatLink\confignatlinkvocolaunimacro\natlinkconfigfunctions.py -e
11 | 
12 | echo Setting natlink user directory
13 | python C:\NatLink\NatLink\confignatlinkvocolaunimacro\natlinkconfigfunctions.py -n "%currentpath:~0,-1%"
14 | 
15 | echo Installed at %currentpath%
16 | 
17 | pause 1
18 | 


--------------------------------------------------------------------------------
/mathfly/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/__init__.py


--------------------------------------------------------------------------------
/mathfly/apps/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/apps/__init__.py


--------------------------------------------------------------------------------
/mathfly/apps/app_template.py:
--------------------------------------------------------------------------------
 1 | from mathfly.imports import *
 2 | 
 3 | class RuleNameRule(MergeRule):
 4 | 	pronunciation = "AppName"
 5 | 	mcontext = AppContext(title="AppName")
 6 | 
 7 | 	mapping = {
 8 | 		"new file"            : Key("c-n"),
 9 | 		"open file"           : Key("c-o"),
10 | 		"print file"          : Key("c-p"),
11 | 
12 | 		"close tab"           : Key("c-w"),
13 | 		"next tab"            : Key("c-tab"),
14 | 		"previous tab"        : Key("cs-tab"),
15 | 		"<nth> tab"           : Key("a-%(nth)s"),
16 | 
17 | 		"find"                : Key("c-f"),
18 | 		"find next"           : Key("f3"),
19 | 		"find previous"       : Key("s-f3"),
20 | 
21 | 		"zoom in"             : Key("c-equals"),
22 | 		"zoom out"            : Key("c-minus"),
23 | 	}
24 | 
25 | 	extras = [
26 | 		IntegerRef("n", 1, 1000),
27 | 		Choice("nth", {
28 | 			"first"         : "1",
29 | 			"second"        : "2",
30 | 			"third"         : "3",
31 | 			"fourth"        : "4",
32 | 			"fifth"         : "5",
33 | 			"sixth"         : "6",
34 | 			"seventh"       : "7",
35 | 			"eighth"        : "8",
36 | 			"(last | final)": "9",
37 | 			})
38 | 	]
39 | 
40 | 	defaults = {
41 | 		"n": 1,
42 | 	}
43 | 
44 | control.nexus().merger.add_non_ccr_app_rule(RuleNameRule())
45 | 


--------------------------------------------------------------------------------
/mathfly/apps/sublime.py:
--------------------------------------------------------------------------------
  1 | from mathfly.imports import *
  2 | 
  3 | class SublimeRule(MergeRule):
  4 |     pronunciation = "sublime"
  5 |     mcontext = AppContext(executable="sublime_text", title="Sublime Text")
  6 | 
  7 |     mapping = {
  8 |         "new (file | pane)": Key("c-n"),
  9 |         # {"keys": ["ctrl+alt+n"], "command": "new_window"},
 10 |         "new window":   Key("ca-n"),
 11 |         "open file":    Key("c-o"),
 12 |         # {"keys": ["ctrl+shift+o"], "command": "prompt_add_folder"},
 13 |         "open folder":  Key("cs-o"),
 14 |         "save as":  Key("cs-s"),
 15 |         #
 16 |         "comment line": Key("c-slash"),
 17 |         "comment (block | lines)":    Key("cs-slash"),
 18 |         "outdent lines":    Key("c-lbracket"),
 19 |         "join lines [<n3>]":    Key("c-j"),
 20 |         "match bracket":    Key("c-m"),
 21 |         #
 22 |         # "(select | sell) all":  Key("c-a"),
 23 |         "(select | sell) scope [<n2>]": Key("cs-space"),
 24 |         "(select | sell) brackets [<n2>]":  Key("cs-m"),
 25 |         "(select | sell) line [<n2>]":  Key("c-l"),
 26 |         "(select | sell) indent":   Key("cs-j"),
 27 |         # {"keys": ["ctrl+alt+p"], "command": "expand_selection_to_paragraph"},
 28 |         "(select | sell) paragraph":    Key("ca-p"),
 29 |         # SelectUntil
 30 |         "(select | sell) until":    Key("as-s"),
 31 | 
 32 |         "toggle side bar": Key("c-k, c-b"),
 33 | 
 34 |         #
 35 |         "find": Key("c-f"),
 36 |         "get all":  Key("a-enter"),
 37 |         "replace":  Key("c-h"),
 38 |         "edit lines":   Key("cs-l"),
 39 |         "edit next [<n3>]": Key("c-d"),
 40 |         "edit skip next [<n3>]": Key("c-k, c-d"),
 41 |         "edit all": Key("c-d, a-f3"),
 42 |         #
 43 |         "transform upper":  Key("c-k, c-u"),
 44 |         "transform lower":  Key("c-k, c-l"),
 45 |         # {"keys": ["ctrl+k", "ctrl+t"], "command": "title_case"},
 46 |         "transform title":  Key("c-k, c-t"),
 47 |         #
 48 |         "line <n11> [<n12>]": Key("c-g") + Text("%(n11)s" + "%(n12)s") + Key("enter"),
 49 |         "go to file":   Key("c-p"),
 50 |         "go to word":   Key("c-semicolon"),
 51 |         "go to symbol": Key("c-r"),
 52 |         "go to [symbol in] project": Key("cs-r"),
 53 |         "command pallette": Key("cs-p"),
 54 |         "(find | search) in (project | folder | directory)": Key("cs-f"),
 55 |         #
 56 |         "fold": Key("cs-lbracket"),
 57 |         "unfold":   Key("cs-rbracket"),
 58 |         "unfold all":   Key("c-k, c-j"),
 59 |         "fold [level] <n2>":    Key("c-k, c-%(n2)s"),
 60 |         #
 61 |         "full screen":  Key("f11"),
 62 |         "(set | add) bookmark": Key("c-f2"),
 63 |         "next bookmark":    Key("f2"),
 64 |         "previous bookmark":    Key("s-f2"),
 65 |         "clear bookmarks":  Key("cs-f2"),
 66 |         #
 67 |         "build it": Key("c-b"),
 68 |         # "cancel build": Key("c-break")),
 69 |         #
 70 |         "record macro": Key("c-q"),
 71 |         "play [back] macro [<n3>]": Key("cs-q"),
 72 |         "(new | create) snippet":   Key("a-n"),
 73 |         #
 74 |         "close tab":   Key("c-w"),
 75 |         "next tab":    Key("c-pgdown"),
 76 |         "previous tab":    Key("c-pgup"),
 77 |         "<nth> tab":    Key("a-%(n2)s"),
 78 |         #
 79 |         "column <cols>":    Key("as-%(cols)s"),
 80 |         "focus <panel>":    Key("c-%(panel)s"),
 81 |         "move <panel>": Key("cs-%(panel)s"),
 82 |         # {"keys": ["ctrl+alt+v"], "command": "clone_file"}
 83 |         "split right":  Key("as-2, c-1, ca-v, cs-2"),
 84 |         #
 85 |         "open terminal":    Key("cs-t"),
 86 | 
 87 |         "zoom in [<n2>]":   Key("c-equal")*Repeat(extra="n2"),
 88 |         "zoom out [<n2>]":   Key("c-minus")*Repeat(extra="n2"),
 89 | 
 90 |     }
 91 |     extras = [
 92 |         IntegerRef("n11", 1, 100),
 93 |         IntegerRef("n12", 0, 100),
 94 |         IntegerRef("n2", 1, 9),
 95 |         IntegerRef("n3", 1, 21),
 96 |         Choice("nth", {
 97 |             "first": "1",
 98 |             "second": "2",
 99 |             "third": "3",
100 |             "fourth": "4",
101 |             "fifth": "5",
102 |             "sixth": "6",
103 |             "seventh": "7",
104 |             "eighth": "8",
105 |             "ninth": "9",
106 |             "tenth": "10",
107 |             }),
108 |         Choice("cols", {
109 |             "one": "1",
110 |             "two": "2",
111 |             "three": "3",
112 |             "grid": "5",
113 |         }),
114 |         Choice("panel", {
115 |             "one": "1",
116 |             "left": "1",
117 |             "two": "2",
118 |             "right": "2",
119 |             }),
120 |     ]
121 |     defaults = {
122 |         "n12": "",
123 |         "n2": 1,
124 |         "n3": 1,
125 |     }
126 | 
127 | 
128 | #---------------------------------------------------------------------------
129 | 
130 | control.nexus().merger.add_non_ccr_app_rule(SublimeRule())


--------------------------------------------------------------------------------
/mathfly/apps/sumatrapdf.py:
--------------------------------------------------------------------------------
 1 | from mathfly.imports import *
 2 | 
 3 | class SumatraPDFRule(MergeRule):
 4 | 	pronunciation = "SumatraPDF"
 5 | 	mcontext = AppContext(title="SumatraPDF")
 6 | 
 7 | 	mapping = {
 8 | 		# https://www.sumatrapdfreader.org/manual.html
 9 | 		"open file"           : Key("c-o"),
10 | 		"print file"          : Key("c-p"),
11 | 
12 | 		"close tab"           : Key("c-w"),
13 | 		"next tab"            : Key("c-tab"),
14 | 		"previous tab"        : Key("cs-tab"),
15 | 		"<nth> tab"           : Key("a-%(nth)s"),
16 | 
17 | 		"go to page"          : Key("c-g"),
18 | 		"find"                : Key("c-f"),
19 | 		"find next"           : Key("f3"),
20 | 		"find previous"       : Key("s-f3"),
21 | 		"page <n>"            : Key("c-g") + Text("%(n)s") + Key("enter"),
22 | 		"table of contents"   : Key("f12"),
23 | 
24 | 		"zoom in"             : Key("c-equals"),
25 | 		"zoom out"            : Key("c-minus"),
26 | 		"fit page"            : Key("c-0"),
27 | 		"actual size"         : Key("c-1"),
28 | 		"fit width"           : Key("c-2"),
29 | 		"fit content"         : Key("c-3"),
30 | 		"[view] single page"  : Key("c-6"),
31 | 		"facing view"         : Key("c-7"),
32 | 		"book view"           : Key("c-8"),
33 | 		"rotate [right]"      : Key("c-plus"),
34 | 		"rotate left"         : Key("c-minus"),
35 | 		"presentation [mode]" : Key("f11"),
36 | 		"full screen"         : Key("s-f11"),
37 | 	}
38 | 
39 | 	extras = [
40 | 		IntegerRef("n", 1, 1000),
41 | 		Choice("nth", {
42 | 			"first"         : "1",
43 | 			"second"        : "2",
44 | 			"third"         : "3",
45 | 			"fourth"        : "4",
46 | 			"fifth"         : "5",
47 | 			"sixth"         : "6",
48 | 			"seventh"       : "7",
49 | 			"eighth"        : "8",
50 | 			"(last | final)": "9",
51 | 			})
52 | 	]
53 | 
54 | 	defaults = {
55 | 		"n": 1,
56 | 	}
57 | 
58 | control.nexus().merger.add_non_ccr_app_rule(SumatraPDFRule())
59 | 


--------------------------------------------------------------------------------
/mathfly/apps/wordpad.py:
--------------------------------------------------------------------------------
 1 | from mathfly.imports import *
 2 | 
 3 | class WordPadRule(MergeRule):
 4 | 	pronunciation = "WordPad"
 5 | 	mcontext = AppContext(title="WordPad")
 6 | 
 7 | 	mapping = {
 8 | 		"new file"            : Key("c-n"),
 9 | 		"open file"           : Key("c-o"),
10 | 		"print file"          : Key("c-p"),
11 | 
12 | 		"page down [<n>]"     : Key("c-pagedown:%(n)s"),
13 | 		"page up [<n>]"       : Key("c-pageup:%(n)s"),
14 | 	}
15 | 
16 | 	extras = [
17 | 		IntegerRef("n", 1, 1000),
18 | 	]
19 | 
20 | 	defaults = {
21 | 		"n": 1,
22 | 	}
23 | 
24 | control.nexus().merger.add_non_ccr_app_rule(WordPadRule())
25 | 


--------------------------------------------------------------------------------
/mathfly/ccr/LyX.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Created Jan 2019
  3 | 
  4 | @author: Mike Roberts, Alex Boche
  5 | '''
  6 | from mathfly.imports import *
  7 | 
  8 | BINDINGS = utilities.load_toml_relative("config/lyx.toml")
  9 | CORE     = utilities.load_toml_relative("config/core.toml")
 10 | 
 11 | def greek(big, greek_letter):
 12 |     if big:
 13 |         greek_letter = greek_letter.title()
 14 |     Text("\\" + greek_letter + " ").execute()
 15 | 
 16 | def matrix(rows, cols):
 17 |     Text("\\" + BINDINGS["matrix_style"] + " ").execute()
 18 |     Key("a-m, w, i, "*(rows-1) + "a-m, c, i, "*(cols-1)).execute()
 19 | 
 20 | class lyx_nested(NestedRule):
 21 |     mapping = {
 22 |         "[<before>] integral from <sequence1> to <sequence2>":
 23 |             [Text("\\int _"), Key("right, caret"), Key("right")],
 24 | 
 25 |         "[<before>] definite from <sequence1> to <sequence2>":
 26 |             [Key("a-m, lbracket, right, underscore"),
 27 |             Key("right, caret"), Key("right, left:2")],
 28 | 
 29 |         "[<before>] differential <sequence1> by <sequence2>":
 30 |             [Key("a-m, f, d"), Key("down, d"), Key("right")],
 31 | 
 32 |         "[<before>] sum from <sequence1> to <sequence2>":
 33 |             [Text("\\stackrelthree ") + Key("down") + Text("\\sum ") + Key("down"),
 34 |             Key("up:2"), Key("right")],
 35 | 
 36 |         "[<before>] limit from <sequence1> to <sequence2>":
 37 |             [Text("\\underset \\lim ") + Key("down"),
 38 |             Text("\\rightarrow "), Key("right")],
 39 | 
 40 |         "[<before>] argument that <minmax> <sequence1>":
 41 |             [Text("\\underset \\arg \\%(minmax)s ") + Key("down"),
 42 |             Key("right"), None],
 43 | 
 44 |         "[<before>] <minmax> by <sequence1>":
 45 |             [Text("\\underset \\%(minmax)s ") + Key("down"),
 46 |             Key("right"), None],
 47 | 
 48 |         "[<before>] <script1> <singleton1> [<after>]":
 49 |             [Key("%(script1)s"), Key("right"), None],
 50 | 
 51 |         "[<before>] <script1> <singleton1> <script2> <singleton2> [<after>]":
 52 |             [Key("%(script1)s"), Key("right, %(script2)s"), Key("right")],
 53 |     }
 54 |     extras = [
 55 |         Choice("minmax", {
 56 |             "(minimum | minimises)": "min",
 57 |             "(maximum | maximises)": "max",
 58 |             }),
 59 |         Choice("script1", {
 60 |             "sub": "_",
 61 |             "super": "^",
 62 |             }),
 63 |         Choice("script2", {
 64 |             "sub": "_",
 65 |             "super": "^",
 66 |             }),
 67 |     ]
 68 | 
 69 | class lyx_mathematicsNon(MergeRule):
 70 |     mapping = {
 71 |         "<control>":
 72 |             Key("%(control)s"),
 73 |         "<control_repeat> [<n>]":
 74 |             Key("%(control_repeat)s")*Repeat(extra="n"),
 75 |     }
 76 |     extras = [
 77 |         IntegerRef("n", 1, 10),
 78 |         Choice("control",        BINDINGS["control"]),
 79 |         Choice("control_repeat", BINDINGS["control_repeat"]),
 80 |     ]
 81 |     defaults = {
 82 |         "n": 1,
 83 |     }
 84 | 
 85 | class lyx_mathematics(MergeRule):
 86 |     non = lyx_mathematicsNon
 87 |     nested = lyx_nested
 88 |     mwith = CORE["pronunciation"]
 89 |     mcontext = AppContext(executable="lyx")
 90 |     pronunciation = BINDINGS["pronunciation"]
 91 | 
 92 |     mapping = {
 93 |         BINDINGS["symbol1_prefix"] + " <symbol1>":
 94 |             Text("\\%(symbol1)s "),
 95 | 
 96 |         BINDINGS["symbol2_prefix"] + " <symbol2>":
 97 |             Text("\\%(symbol2)s "),
 98 | 
 99 |         BINDINGS["accent_prefix"] + " <accent>":
100 |             Key("a-m, %(accent)s"),
101 | 
102 |         BINDINGS["text_prefix"] + " <text_modes>":
103 |             Text("\\%(text_modes)s "),
104 | 
105 |         BINDINGS["greek_prefix"] + " [<big>] <greek_letter>":
106 |             Function(greek),
107 | 
108 |         "<misc_lyx_keys>":
109 |             Key("%(misc_lyx_keys)s"),
110 | 
111 |         "<command>":
112 |             Alternating("command"),
113 | 
114 |         "matrix <rows> by <cols>":
115 |             Function(matrix),
116 | 
117 |         "<numbers> <denominator>":
118 |             Key("a-m, f") + Text("%(numbers)s") + Key("down") + Text("%(denominator)s") + Key("right"),
119 | 
120 |     }
121 | 
122 |     extras = [
123 |         IntegerRef("rows",    1, BINDINGS["max_matrix_size"]),
124 |         IntegerRef("cols",    1, BINDINGS["max_matrix_size"]),
125 |         IntegerRef("numbers", 0, CORE["numbers_max"]),
126 |         Choice("big",           {CORE["capitals_prefix"]: True}),
127 |         Choice("greek_letter",   BINDINGS["greek_letters"]),
128 |         Choice("symbol1",        BINDINGS["tex_symbols1"]),
129 |         Choice("symbol2",        BINDINGS["tex_symbols2"]),
130 |         Choice("accent",         BINDINGS["accents"]),
131 |         Choice("text_modes",     BINDINGS["text_modes"]),
132 |         Choice("misc_lyx_keys",  BINDINGS["misc_lyx_keys"]),
133 |         Choice("command",        BINDINGS["misc_lyx_commands"]),
134 |         Choice("denominator",    BINDINGS["denominators"]),
135 |     ]
136 | 
137 |     defaults = {
138 |         "big": False,
139 |     }
140 | 
141 | control.nexus().merger.add_app_rule(lyx_mathematics())
142 | 


--------------------------------------------------------------------------------
/mathfly/ccr/ScientificNotebook55.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Created on Sep 4, 2018
  3 | 
  4 | @author: Mike Roberts
  5 | '''
  6 | from mathfly.imports import *
  7 | 
  8 | BINDINGS = utilities.load_toml_relative("config/ScientificNotebook55.toml")
  9 | CORE = utilities.load_toml_relative("config/core.toml")
 10 | 
 11 | #---------------------------------------------------------------------------
 12 | 
 13 | def texchar(symbol):
 14 |     keychain = "ctrl:down, "
 15 |     for character in symbol:
 16 |         keychain = keychain + character + ", "
 17 |     keychain=keychain + "ctrl:up"
 18 |     Key(keychain).execute()
 19 | 
 20 | def greek(big, greek_letter):
 21 |     if big:
 22 |         greek_letter = greek_letter.upper()
 23 |     Key("c-g, " + greek_letter).execute()
 24 | 
 25 | def matrix(rows, cols):
 26 |     Key("f10/5, i/5, down:8, enter/50").execute()
 27 |     Key(str(rows) + "/50, tab, " + str(cols) + "/50, enter").execute()
 28 | 
 29 | class sn_nested(NestedRule):
 30 |     mapping = {
 31 |         "[<before>] integral from <sequence1> to <sequence2>":
 32 |             [Function(lambda: texchar("int")) + Key("c-l"),
 33 |             Key("right, c-h"), Key("right")],
 34 | 
 35 |         "[<before>] definite from <sequence1> to <sequence2>":
 36 |             [Key("c-6, right, c-l"),
 37 |             Key("right, c-h"), Key("right, c-left, left")],
 38 | 
 39 |         "[<before>] differential <sequence1> by <sequence2>":
 40 |             [Key("c-f, d"), Key("down, d"), Key("right")],
 41 | 
 42 |         "[<before>] sum from <sequence1> to <sequence2>":
 43 |             [Key("f10, i, down:11, enter/25, a, enter, f10, i, down:11, enter/25, b, enter") + Function(lambda: texchar("sum")) + Key("down"),
 44 |             Key("up:2"), Key("right")],
 45 | 
 46 |         "[<before>] limit from <sequence1> to <sequence2>":
 47 |             [Key("f10, i, down:11, enter/25, b, enter") + Function(lambda: texchar("lim")) + Key("down"),
 48 |             Function(lambda: texchar("rightarrow")),
 49 |             Key("right")],
 50 | 
 51 |         "[<before>] argument that <minmax> <sequence1>":
 52 |             [Key("f10, i, down:11, enter/25, b, enter") + Text("arg%(minmax)s") + Key("down"),
 53 |             Key("right"), None],
 54 | 
 55 |         "[<before>] <minmax> by <sequence1>":
 56 |             [Key("f10, i, down:11, enter/25, b, enter") + Text("%(minmax)s") + Key("down"),
 57 |             Key("right"), None],
 58 | 
 59 |         "[<before>] <script1> <singleton1> [<after>]":
 60 |             [Key("%(script1)s"), Key("right"), None],
 61 | 
 62 |         "[<before>] <script1> <singleton1> <script2> <singleton2> [<after>]":
 63 |             [Key("%(script1)s"), Key("right, %(script2)s"), Key("right")],
 64 | 
 65 |     }
 66 |     extras = [
 67 |         Choice("minmax", {
 68 |             "(minimum | minimises)": "min",
 69 |             "(maximum | maximises)": "max",
 70 |             }),
 71 |         Choice("script1", {
 72 |             "sub": "c-l",
 73 |             "super": "c-h",
 74 |             }),
 75 |         Choice("script2", {
 76 |             "sub": "c-l",
 77 |             "super": "c-h",
 78 |             }),
 79 |     ]
 80 | 
 81 | class sn_mathematicsNon(MergeRule):
 82 |     mapping = {
 83 |         "text <dict>":
 84 |             Key("c-t") + Function(lambda dict: Text(str(dict).capitalize()).execute()),
 85 |         "<control>":
 86 |             Key("%(control)s"),
 87 |     }
 88 |     extras = [
 89 |         Dictation("dict"),
 90 |         IntegerRef("n", 1, 10),
 91 |         Choice("control", BINDINGS["control"]),
 92 |     ]
 93 | 
 94 | 
 95 | class sn_mathematics(MergeRule):
 96 |     non = sn_mathematicsNon
 97 |     mwith = CORE["pronunciation"]
 98 |     mcontext = AppContext(executable="scientific notebook")
 99 |     pronunciation = BINDINGS["pronunciation"]
100 | 
101 |     nested = sn_nested
102 | 
103 |     mapping = {
104 |         BINDINGS["symbol_prefix"] + " <symbol>":
105 |             Function(texchar),
106 |         #
107 |         BINDINGS["greek_prefix"] + " [<big>] <greek_letter>":
108 |             Function(greek),
109 |         BINDINGS["accent_prefix"] + " <accent>":
110 |             Key("%(accent)s"),
111 | 
112 |         BINDINGS["unit_prefix"] + " <units>":
113 |             Alternating("units"),
114 | 
115 |         "<misc_sn_keys>":
116 |             Key("%(misc_sn_keys)s"),
117 |         "<misc_sn_text>":
118 |             Text("%(misc_sn_text)s"),
119 | 
120 |         "matrix <rows> by <cols>":
121 |             Function(matrix),
122 | 
123 |         "<numbers> <denominator>":
124 |             Key("c-f") + Text("%(numbers)s") + Key("down") + Text("%(denominator)s") + Key("right"),
125 |     }
126 | 
127 |     extras = [
128 |         IntegerRef("rows",    1, BINDINGS["max_matrix_size"]),
129 |         IntegerRef("cols",    1, BINDINGS["max_matrix_size"]),
130 |         IntegerRef("numbers", 0, CORE["numbers_max"]),
131 |         Choice("big",           {CORE["capitals_prefix"]: True}),
132 |         Choice("greek_letter",   BINDINGS["greek_letters"]),
133 |         Choice("units",          BINDINGS["units"]),
134 |         Choice("symbol",         BINDINGS["tex_symbols"]),
135 |         Choice("accent",         BINDINGS["accents"]),
136 |         Choice("misc_sn_keys",   BINDINGS["misc_sn_keys"]),
137 |         Choice("misc_sn_text",   BINDINGS["misc_sn_text"]),
138 |         Choice("denominator",    BINDINGS["denominators"]),
139 |     ]
140 | 
141 |     defaults = {
142 |         "big": False,
143 |     }
144 | 
145 | control.nexus().merger.add_app_rule(sn_mathematics())
146 | 


--------------------------------------------------------------------------------
/mathfly/ccr/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/ccr/__init__.py


--------------------------------------------------------------------------------
/mathfly/ccr/alias.py:
--------------------------------------------------------------------------------
 1 | from mathfly.imports import *
 2 | 
 3 | MF_NEXUS = control.nexus()
 4 | 
 5 | class Alias(SelfModifyingRule):
 6 |     mapping = {"default command": ""}
 7 |     key = "aliases"
 8 |     pronunciation = "alias"
 9 | 
10 |     def delete_all(self, key):
11 |         utilities.save_toml_relative({}, "config/aliases.toml")
12 |         self.refresh()
13 | 
14 |     def alias(self, spec):
15 |         spec = str(spec)
16 |         e, text = utilities.read_selected(True)
17 |         if spec and text:
18 |             self.refresh(spec, str(text))
19 | 
20 |     def refresh(self, *args):
21 |         '''args: spec, text'''
22 |         aliases = utilities.load_toml_relative("config/aliases.toml")
23 |         if not Alias.key in aliases:
24 |             aliases[Alias.key] = {}
25 |         if len(args) > 0:
26 |             aliases[Alias.key][args[0]] = args[1]
27 |             utilities.save_toml_relative(aliases, "config/aliases.toml")
28 |         mapping = {}
29 |         for spec in aliases[Alias.key]:
30 |             mapping[spec] = Function(utilities.paste_string,
31 |                     content=str(aliases[Alias.key][spec]))
32 |         mapping["alias <s>"] = Function(lambda s: self.alias(s))
33 |         mapping["delete aliases"] = Function(self.delete_all, key=Alias.key)
34 |         self.reset(mapping)
35 | 
36 | control.nexus().merger.add_selfmodrule(Alias())
37 | 


--------------------------------------------------------------------------------
/mathfly/ccr/core.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Created on Sep 4, 2018
 3 | 
 4 | @author: Mike Roberts
 5 | '''
 6 | from mathfly.imports import *
 7 | 
 8 | SETTINGS = utilities.load_toml_relative("config/settings.toml")
 9 | CORE = utilities.load_toml_relative("config/core.toml")
10 | 
11 | _LETTERS, _DIRECTIONS = "letters", "directions"
12 | if SETTINGS["alternative_letters"]:
13 | 	_LETTERS += "_alt"
14 | if SETTINGS["alternative_directions"]:
15 | 	_DIRECTIONS += "_alt"
16 | 
17 | def alphabet(big, letter):
18 | 	if big:
19 | 		letter = letter.upper()
20 | 	Key(letter).execute()
21 | 
22 | class coreNon(MergeRule):
23 |     mapping = {
24 |         "configure " + CORE["pronunciation"]:
25 |             Function(utilities.load_config, config_name="core.toml"),
26 |         "configure scientific notebook":
27 |             Function(utilities.load_config, config_name="ScientificNotebook55.toml"),
28 |         "configure (LyX | licks)":
29 |             Function(utilities.load_config, config_name="lyx.toml"),
30 | 
31 |         "<noCCR_repeatable_key> [<n>]":
32 |             Key("%(noCCR_repeatable_key)s")*Repeat(extra="n"),
33 |         "<noCCR_non_repeatable_key>":
34 |             Key("%(noCCR_non_repeatable_key)s"),
35 |     }
36 |     extras = [
37 |         IntegerRef("n", 1, 10),
38 |         Choice("noCCR_repeatable_key", CORE["noCCR_repeatable_keys"]),
39 |         Choice("noCCR_non_repeatable_key", CORE["noCCR_non_repeatable_keys"]),
40 |     ]
41 |     defaults = {
42 |         "n": 1,
43 |     }
44 | 
45 | class core(MergeRule):
46 |     non = coreNon
47 | 
48 |     pronunciation = CORE["pronunciation"]
49 | 
50 |     mapping = {
51 |     	"[<big>] <letter>":
52 |             Function(alphabet),
53 |     	CORE["numbers_prefix"] + " <numbers>":
54 |             Text("%(numbers)s"),
55 |     	"<punctuation>":
56 |             Key("%(punctuation)s"),
57 | 
58 |         "(<direction> | <modifier> [<direction>]) [(<n50> | <extreme>)]":
59 |             Function(navigation.text_nav),
60 |     	"<repeatable_key> [<n>]":
61 |             Key("%(repeatable_key)s")*Repeat(extra="n"),
62 |     	"<non_repeatable_key>":
63 |             Key("%(non_repeatable_key)s"),
64 | 
65 |         CORE["dictation_prefix"] + " <text>":
66 |             Function(lambda text: Text(str(text).lower()).execute()),
67 | 
68 |         "shift click":
69 |             Key("shift:down") + Mouse("left") + Key("shift:up"),
70 |     	}
71 | 
72 |     extras = [
73 |         Dictation("text"),
74 |     	IntegerRef("n", 1, 10),
75 |         IntegerRef("n50", 1, 50),
76 |         IntegerRefMF("numbers", 0,   CORE["numbers_max"]),
77 |         Choice("big",               {CORE["capitals_prefix"]: True}),
78 |     	Choice("letter",             CORE[_LETTERS]),
79 |     	Choice("punctuation",        CORE["punctuation"]),
80 |     	Choice("repeatable_key",     CORE["repeatable_keys"]),
81 |     	Choice("non_repeatable_key", CORE["non_repeatable_keys"]),
82 |     	Choice("direction",          CORE[_DIRECTIONS]),
83 |     	Choice("modifier",           CORE["modifiers"]),
84 |         Choice("extreme",           {CORE["extreme"]: True}),
85 |     ]
86 | 
87 |     defaults = {
88 |         "big"      : False,
89 |         "extreme"  : False,
90 |         "n"        : 1,
91 |         "n50"      : 1,
92 |         "direction": "left",
93 |         "modifier" : "",
94 |     }
95 | 
96 | 
97 | control.nexus().merger.add_global_rule(core())


--------------------------------------------------------------------------------
/mathfly/ccr/latex.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Created on Sep 4, 2018
  3 | @author: Mike Roberts
  4 | '''
  5 | from mathfly.imports import *
  6 | 
  7 | BINDINGS = utilities.load_toml_relative("config/latex.toml")
  8 | CORE = utilities.load_toml_relative("config/core.toml")
  9 | 
 10 | class LaTeXNon(MergeRule):
 11 |     mapping = {
 12 |         "configure " + BINDINGS["pronunciation"]:
 13 |             Function(utilities.load_config, config_name="latex.toml"),
 14 | 
 15 |         "add <ref_type> to bibliography":
 16 |             Function(tex_funcs.selection_to_bib, bib_path=BINDINGS["bibliography_path"]),
 17 | 
 18 |         "(open | edit) bibliography":
 19 |             Function(utilities.load_text_file, path=BINDINGS["bibliography_path"]),
 20 | 
 21 |         BINDINGS["template_prefix"] + " <template>":
 22 |             Function(execution.template),
 23 |     }
 24 |     extras = [
 25 |         Choice("ref_type", {
 26 |                 "book": "book",
 27 |                 "link": "link",
 28 |                 "paper": "paper",
 29 |                 }),
 30 |         Choice("template", BINDINGS["templates"]),
 31 |     ]
 32 | 
 33 | class LaTeX(MergeRule):
 34 |     non = LaTeXNon
 35 | 
 36 |     pronunciation = BINDINGS["pronunciation"]
 37 | 
 38 |     mapping = {
 39 |         "insert comment":  Text("% "),
 40 | 
 41 |         BINDINGS["class_prefix"] + " [<doc_class>]":
 42 |             Function(lambda doc_class: tex_funcs.back_curl("documentclass", doc_class)),
 43 | 
 44 |         BINDINGS["environment_prefix"] + " <environment>":
 45 |             Function(tex_funcs.begin_end),
 46 |         "end <environment>":
 47 |             Function(lambda environment: tex_funcs.back_curl("end", environment)),
 48 |         #
 49 |         BINDINGS["package_prefix"] + " [<packopts>]":
 50 |             Function(tex_funcs.packages),
 51 |         #
 52 |         BINDINGS["symbol_prefix"] + " <symbol>":
 53 |             Function(tex_funcs.symbol),
 54 |         BINDINGS["symbol_prefix"] + " <misc_symbol>":
 55 |             Alternating("misc_symbol"),
 56 | 
 57 |         BINDINGS["accent_prefix"] + " <accent>":
 58 |             Function(lambda accent: execution.paren_function("\\" + accent, "{", "}")),
 59 | 
 60 |         BINDINGS["greek_prefix"] + " [<big>] <greek_letter>":
 61 |             Function(tex_funcs.greek_letters),
 62 |         #
 63 |         BINDINGS["command_prefix"] + " <command>":
 64 |             Function(lambda command: execution.paren_function("\\" + command, "{", "}")),
 65 |         BINDINGS["command_prefix"] + " <commandnoarg>":
 66 |             Text("\\%(commandnoarg)s "),
 67 |         BINDINGS["command_prefix"] + " <commandmisc>":
 68 |             Alternating("commandmisc"),
 69 | 
 70 |         BINDINGS["command_prefix"] + " my (bib resource | bibliography)":
 71 |             Function(lambda: tex_funcs.back_curl("addbibresource", BINDINGS["bibliography_path"])),
 72 | 
 73 |         BINDINGS["command_prefix"] + " quote":
 74 |             Function(tex_funcs.quote),
 75 |         #
 76 | 
 77 |     }
 78 | 
 79 |     extras = [
 80 |         Choice("big",        {CORE["capitals_prefix"]: True}),
 81 |         Choice("packopts",    BINDINGS["packages"]),
 82 |         Choice("doc_class",   BINDINGS["document_classes"]),
 83 |         Choice("greek_letter",BINDINGS["greek_letters"]),
 84 |         Choice("symbol",      BINDINGS["symbols"]),
 85 |         Choice("misc_symbol", BINDINGS["misc_symbols"]),
 86 |         # Choice("latex_misc",BINDINGS["latex_misc"]),
 87 |         Choice("accent",      BINDINGS["accents"]),
 88 |         Choice("command",     BINDINGS["command"]),
 89 |         Choice("commandnoarg",BINDINGS["commandnoarg"]),
 90 |         Choice("commandmisc", BINDINGS["commandmisc"]),
 91 |         Choice("environment", BINDINGS["environments"]),
 92 |         ]
 93 |     defaults = {
 94 |         "big"      : False,
 95 |         "packopts" : "",
 96 |         "doc_class": "",
 97 |     }
 98 | 
 99 | 
100 | control.nexus().merger.add_global_rule(LaTeX())
101 | 


--------------------------------------------------------------------------------
/mathfly/ccr/latex_maths.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Created on Sep 4, 2018
 3 | 
 4 | @author: Mike Roberts
 5 | '''
 6 | from mathfly.imports import *
 7 | 
 8 | BINDINGS = utilities.load_toml_relative("config/latex.toml")
 9 | CORE = utilities.load_toml_relative("config/core.toml")
10 | 
11 | def symbol(symbol):
12 |     if type(symbol) in [str, unicode, int]:
13 |         Text("\\" + symbol + " ").execute()
14 |     else:
15 |         Text("\\" + str(symbol[0])).execute()
16 |         Text("{}"*int(symbol[1])).execute()
17 |         Key("left:" + str(2*int(symbol[1])-1)).execute()
18 | 
19 | class LaTeXmath(MergeRule):
20 |     pronunciation = BINDINGS["pronunciation"]  +  " maths"
21 | 
22 |     mapping = {
23 |         "<numbers>": Text("%(numbers)s"),
24 |         "<symbol>":  Function(symbol),
25 |         "<misc_symbol>":
26 |             Alternating("misc_symbol"),
27 |     }
28 | 
29 |     extras = [
30 |         IntegerRef("numbers", 0, CORE["numbers_max"]),
31 |         Choice("symbol", BINDINGS["symbols"]),
32 |         Choice("misc_symbol", BINDINGS["misc_symbols"]),
33 |         ]
34 |     defaults = {
35 |     }
36 | 
37 | 
38 | control.nexus().merger.add_global_rule(LaTeXmath())
39 | 


--------------------------------------------------------------------------------
/mathfly/config/ScientificNotebook55.toml:
--------------------------------------------------------------------------------
  1 | # Once you have finished making changes, use the "rebuild mathfly"
  2 | # command to enact them.
  3 | "pronunciation"   = "Scientific notebook"
  4 | "greek_prefix"    = "greek"
  5 | "symbol_prefix"   = ""
  6 | "accent_prefix"   = "accent"
  7 | "unit_prefix"     = "unit"
  8 | "max_matrix_size" = 10
  9 | 
 10 | [greek_letters]
 11 | "alpha"   = "a"
 12 | "beater"  = "b"
 13 | "gamma"   = "g"
 14 | "delta"   = "d"
 15 | "epsilon" = "e"
 16 | "zita"    = "z"
 17 | "eater"   = "h"
 18 | "theta"   = "y"
 19 | "iota"    = "i"
 20 | "kappa"   = "k"
 21 | "lambda"  = "l"
 22 | "mu"      = "m"
 23 | "new"     = "n"
 24 | "zee"     = "x"
 25 | "pie"     = "p"
 26 | "row"     = "r"
 27 | "sigma"   = "s"
 28 | "tau"     = "t"
 29 | "upsilon" = "u"
 30 | "phi"     = "f"
 31 | "chi"     = "q"
 32 | "sigh"    = "c"
 33 | "omega"   = "w"
 34 | 
 35 | [misc_sn_keys]
 36 | "(super script | to the power)" = "c-h"
 37 | "fraction"               = "c-f"
 38 | "over"                   = "cs-left, c-f"
 39 | "sub script"           = "c-l"
 40 | "squared"                = "c-h, 2, right"
 41 | "cubed"                  = "c-h, 3, right"
 42 | "inverse"                = "c-h, minus, 1, right"
 43 | "(parens | parentheses)" = "c-0"
 44 | "square brackets"        = "c-6"
 45 | "curly brackets"         = "c-lbrace"
 46 | "absolute"               = "c-backslash"
 47 | "chi squared"            = "c-g, q, c-h, 2, right"
 48 | "(root | square root)"   = "c-r"
 49 | "summation"              = "c-7"
 50 | "prime"                  = "apostrophe"
 51 | "function"               = "f, c-0"
 52 | #
 53 | "label above"            = "f10, i, down:11, enter/25, a, enter"
 54 | "label below"            = "f10, i, down:11, enter/25, b, enter"
 55 | #
 56 | "degrees"                = "c-h, ctrl:down, c, i, r, c, ctrl:up, right"
 57 | 
 58 | [tex_symbols]
 59 | # operators
 60 | "integral"             = "int"
 61 | "double integral"      = "iint"
 62 | "triple integral"      = "iiint"
 63 | "times"                = "times"
 64 | "divide"               = "div"
 65 | "C dot"                = "cdot"
 66 | "plus or minus"        = "pm"
 67 | "partial"              = "partial"
 68 | "infinity"             = "infty"
 69 | "nabla"                = "nabla"
 70 | # trig
 71 | "sine"                 = "sin"
 72 | "cosine"               = "cos"
 73 | "tangent"              = "tan"
 74 | "secant"               = "sec"
 75 | "cosecant"             = "csc"
 76 | "cotangent"            = "cot"
 77 | "arc sine"             = "arcsin"
 78 | "arc cosine"           = "arccos"
 79 | "arc tan"              = "arctan"
 80 | "hyperbolic sine"      = "sinh"
 81 | "hyperbolic cosine"    = "cosh"
 82 | "hyperbolic cotangent" = "coth"
 83 | "hyperbolic tangent"   = "tanh"
 84 | # functions
 85 | "argument"             = "arg"
 86 | "degree"               = "deg"
 87 | "determinant"          = "det"
 88 | "dimension"            = "dim"
 89 | "exponential"          = "exp"
 90 | "(natural (log | logarithm) | log natural)" = "ln"
 91 | "logarithm"            = "log"
 92 | "maximum"              = "max"
 93 | "minimum"              = "min"
 94 | "product"              = "prod"
 95 | "limit"                = "lim"
 96 | "infimum"              = "inf"
 97 | "supremum"             = "sup"
 98 | "probability"          = "Pr"
 99 | # relations
100 | "there exists"         = "exists"
101 | "member"               = "in"
102 | "for all"              = "forall"
103 | "[is] not equal [to]"  = "neq"
104 | "[is] greater [than] [or] equal [to]" = "geq"
105 | "[is] less [than] [or] equal [to]" = "leq"
106 | "[is] approximately [equal] [to]" = "approx"
107 | "proportional [to]"    = "propto"
108 | "preference less [than]" = "prec"
109 | "preference less equal" = "preceq"
110 | "preference greater [than]" = "succ"
111 | "preference greater equal" = "succeq"
112 | # sets
113 | "subset"               = "subset"
114 | "superset"             = "supset"
115 | "strict subset"        = "subsetneq"
116 | "strict superset"      = "supsetneq"
117 | "intersection"         = "cap"
118 | "union"                = "cup"
119 | # logic
120 | "logic and"            = "land"
121 | "logic or"             = "lor"
122 | "logic not"            = "lnot"
123 | #
124 | "dot dot dot"          = "dots"
125 | "left arrow"           = "leftarrow"
126 | "right arrow"          = "rightarrow"
127 | "up arrow"             = "uparrow"
128 | "down arrow"           = "downarrow"
129 | "left right arrow"     = "leftrightarrow"
130 | "maps to"              = "mapsto"
131 | "oh plus"              = "oplus"
132 | "oh times"             = "otimes"
133 | "big oh plus"          = "bigoplus"
134 | "big oh times"         = "bigotimes"
135 | #
136 | "diagonal dots"        = "ddots"
137 | "horizontal dots"      = "cdots"
138 | "vertical dots"        = "vdots"
139 | 
140 | [misc_sn_text]
141 | "miscellaneous test" = "miscellaneous"
142 | 
143 | [accents]
144 | "hat"        = "c-caret"
145 | "tilde"      = "c-tilde"
146 | "dot"        = "c-dot"
147 | "double dot" = "c-dquote"
148 | "bar"        = "c-underscore"
149 | "arrow"      = "c-minus"
150 | 
151 | [denominators]
152 | "(half | halves)"      = 2
153 | "(third | thirds)"     = 3
154 | "(quarter | quarters | fourth | fourths)" = 4
155 | "(fifth | fifths)"     = 5
156 | "(sixth | sixths)"     = 6
157 | "(seventh | sevenths)" = 7
158 | "(eighth | eighths)"   = 8
159 | "(ninth | ninths)"     = 9
160 | "(tenth | tenths)"     = 10
161 | 
162 | [control]
163 | "new file"                         = "f10, f, enter"
164 | "open file"                        = "c-o"
165 | "save file"                        = "f10, f, s"
166 | "save as"                          = "f10, f, down:5, enter"
167 | "print file"                       = "c-p"
168 | "export document"                  = "f10, f, down:7, enter"
169 | "page preview"                     = "f10, f, down:17, enter"
170 | "toggle math"                      = "c-m"
171 | "toggle text"                      = "c-t"
172 | "body math"                        = "a-2, down, enter"
173 | "body text"                        = "a-2, down:2, enter"
174 | "(begin | insert) [bulleted] list" = "a-1, down:2, enter"
175 | "(begin | insert) numbered list"   = "a-1, down:4, enter"
176 | "end [(bulleted | numbered)] list" = "a-1, up, enter"
177 | "insert normal text"               = "a-3, down, enter"
178 | "insert big text"                  = "a-3, down:2, enter"
179 | "insert small text"                = "a-3, down:9, enter"
180 | "insert bold text"                 = "a-3, down:3, enter"
181 | "insert italic text"               = "a-3, down:6, enter"
182 | "insert bold symbols"              = "a-3, down:4, enter"
183 | "insert centred text"              = "a-2, down:3, enter"
184 | "insert left text"                 = "a-2, down:4, enter"
185 | "insert right text"                = "a-2, down:5, enter"
186 | "insert quotation"                 = "a-2, down:11, enter"
187 | "insert (heading | title) [one]"   = "a-2, down:6, enter"
188 | "insert (heading | title) two"     = "a-2, down:7, enter"
189 | "insert (heading | title) three"   = "a-2, down:8, enter"
190 | "insert (heading | title) four"    = "a-2, down:9, enter"
191 | "insert (heading | title) five"    = "a-2, down:10, enter"
192 | "evaluate"                         = "c-e"
193 | 
194 | 
195 | [units]
196 | # Activity
197 | "Becquerels"             = "uBq"
198 | "Curies"                 = "uCi"
199 | # Amount
200 | "Attomoles"              = "uamol"
201 | "Examoles"               = "uEmol"
202 | "Femtomoles"             = "ufmol"
203 | "Gigamoles"              = "uGmol"
204 | "Kilomoles"              = "ukmol"
205 | "Megamoles"              = "uMmol"
206 | "Micromoles"             = "umcmol"
207 | "Millimoles"             = "ummol"
208 | "Moles"                  = "umol"
209 | "Nanomoles"              = "unmol"
210 | "Petamoles"              = "uPmol"
211 | "Picomoles"              = "upmol"
212 | "Teramoles"              = "uTmol"
213 | # Area
214 | "Acres"                  = "uacre"
215 | "Hectares"               = "uhectare"
216 | "Square feet"            = ["uft", "c-h, 2, right"]
217 | "Square inches"          = ["uin", "c-h, 2, right"]
218 | "Square metres"          = ["ume", "c-h, 2, right"]
219 | # Current
220 | "Amperes"                = "uA"
221 | "Kiloamperes"            = "ukA"
222 | "Microamperes"           = "umcA"
223 | "Milliamperes"           = "umA"
224 | "Nanoamperes"            = "unA"
225 | # Capacitance
226 | "Farads"                 = "uF"
227 | "Microfarads"            = "umcF"
228 | "Millifarads"            = "umF"
229 | "Nanofarads"             = "unF"
230 | "Picofarads"             = "upF"
231 | # Charge
232 | "Coulombs"               = "uCo"
233 | # Conductance
234 | "Kilosiemens"            = "ukS"
235 | "Microsiemens"           = "umcS"
236 | "Millisiemens"           = "umS"
237 | "Siemens"                = "uS"
238 | # Potential difference
239 | "Kilovolts"              = "ukV"
240 | "Megavolts"              = "uMV"
241 | "Microvolts"             = "umcV"
242 | "Millivolts"             = "umV"
243 | "Nanovolts"              = "unV"
244 | "Picovolts"              = "upV"
245 | "Volts"                  = "uV"
246 | # Resistance
247 | "Gigaohms"               = "uGohm"
248 | "Kiloohms"               = "ukohm"
249 | "Megaohms"               = "uMohm"
250 | "Milliohms"              = "umohm"
251 | "Ohms"                   = "uohm"
252 | # Energy
253 | "British thermal unit"   = "uBtu"
254 | "Calories"               = "ucal"
255 | "Electron volts"         = "ueV"
256 | "Ergs"                   = "uerg"
257 | "Gigaelectronvolts"      = "uGeV"
258 | "Gigajoules"             = "uGJ"
259 | "Joules"                 = "uJ"
260 | "Kilocalories"           = "ukcal"
261 | "Kilojoules"             = "ukJ"
262 | "Megaelectronvolts"      = "uMeV"
263 | "Megajoules"             = "uMJ"
264 | "Microjoules"            = "umcJ"
265 | "Millijoules"            = "umJ"
266 | "Nanojoules"             = "unJ"
267 | # Force
268 | "Dynes"                  = "udyn"
269 | "Kilonewtons"            = "ukN"
270 | "Meganewtons"            = "uMN"
271 | "Micronewtons"           = "umcN"
272 | "Millinewtons"           = "umN"
273 | "Newtons"                = "uN"
274 | "Ounce force"            = "uozf"
275 | "Pound force"            = "ulbf"
276 | # Frequency
277 | "Exahertz"               = "uEHz"
278 | "Gigahertz"              = "uGHz"
279 | "Hertz"                  = "uHz"
280 | "Kilohertz"              = "ukHz"
281 | "Megahertz"              = "uMHz"
282 | "Petahertz"              = "uPHz"
283 | "Terahertz"              = "uTHz"
284 | # Illuminance
285 | "Footcandle"             = "ufc"
286 | "Lux"                    = "ulx"
287 | "Phot"                   = "uphot"
288 | # Length
289 | "Angstrom"               = "uan"
290 | "Attometers"             = "uame"
291 | "Centimeters"            = "ucm"
292 | "Decimeters"             = "udme"
293 | "Femtometers"            = "ufme"
294 | "Feet"                   = "uft"
295 | "Inches"                 = "uin"
296 | "Kilometers"             = "ukme"
297 | "Meters"                 = "ume"
298 | "Micrometers"            = "umcme"
299 | "Miles"                  = "umi"
300 | "Millimeters"            = "umme"
301 | "Nanometers"             = "unme"
302 | "Picometers"             = "upme"
303 | # Luminance
304 | "Candela"                = "ucd"
305 | "Lumens"                 = "ulm"
306 | # Magnetic flux
307 | "Maxwells"               = "uMx"
308 | "Microwebers"            = "umcWb"
309 | "Milliwebers"            = "umWb"
310 | "Nanowebers"             = "unWb"
311 | "Webers"                 = "uWb"
312 | # Magnetic flux density
313 | "Gauss"                  = "uGa"
314 | "Microteslas"            = "umcT"
315 | "Milliteslas"            = "umT"
316 | "Nanoteslas"             = "unT"
317 | "Picoteslas"             = "upT"
318 | "Teslas"                 = "uTe"
319 | "Henries"                = "uHe"
320 | "microhenries"           = "umcH"
321 | "millihenries"           = "umH"
322 | # Mass
323 | "Atomic mass units"      = "uu"
324 | "Centigrams"             = "ucg"
325 | "Decigrams"              = "udg"
326 | "Grams"                  = "ugr"
327 | "Kilograms"              = "ukg"
328 | "Micrograms"             = "umcg"
329 | "Milligrams"             = "umg"
330 | "Pounds"                 = "ulbm"
331 | "Slug"                   = "uslug"
332 | # Angle
333 | "degrees"                = "udeg"
334 | "Microradians"           = "umcrad"
335 | "Milliradians"           = "umrad"
336 | "Minutes of angle"       = "udmn"
337 | "Seconds of angle"       = "uds"
338 | "Radians"                = "urad"
339 | "Steradian"              = "usr"
340 | # Power
341 | "Gigawatts"              = "uGW"
342 | "Horsepowers"            = "uhp"
343 | "Kilowatts"              = "ukW"
344 | "Megawatts"              = "uMW"
345 | "Microwatts"             = "umcW"
346 | "Milliwatts"             = "umW"
347 | "Nanowatts"              = "unW"
348 | "Watts"                  = "uWa"
349 | # Pressure
350 | "Atmospheres"            = "uatm"
351 | "Bar"                    = "ubar"
352 | "Kilobar"                = "ukbar"
353 | "Kilopascals"            = "ukPa"
354 | "Megapascals"            = "uMPa"
355 | "Micropascals"           = "umcPa"
356 | "Millibar"               = "umbar"
357 | "Millimeters of Mercury" = "ummHg"
358 | "Pascals"                = "uPa"
359 | "Torrs"                  = "utorr"
360 | # Temperature
361 | "Celsiuss"               = "ucel"
362 | "Fahrenheits"            = "ufahr"
363 | "Kelvins"                = "uK"
364 | # Time
365 | "Attoseconds"            = "uas"
366 | "Days"                   = "uda"
367 | "Femtoseconds"           = "ufs"
368 | "Hours"                  = "uhr"
369 | "Microseconds"           = "umcs"
370 | "Milliseconds"           = "ums"
371 | "Minutes"                = "umn"
372 | "Nanoseconds"            = "uns"
373 | "Picoseconds"            = "ups"
374 | "Seconds"                = "use"
375 | "Years"                  = "uy"
376 | # Volume
377 | "Cubic feet"             = ["uft", "c-h, 3, right"]
378 | "Cubic inches"           = ["uin", "c-h, 3, right"]
379 | "Cubic metres"           = ["ume", "c-h, 3, right"]
380 | "Gallons"                = "ugal"
381 | "Liters"                 = "uli"
382 | "Milliliters"            = "uml"
383 | "Pints"                  = "upint"
384 | "Quarts"                 = "uqt"


--------------------------------------------------------------------------------
/mathfly/config/bin/reboot.bat:
--------------------------------------------------------------------------------
1 | taskkill /IM natspeak.exe /f /s localhost
2 | taskkill /IM dgnuiasvr_x64.exe /f /s localhost
3 | taskkill /IM dnsspserver.exe /f /s localhost
4 | taskkill /IM dragonbar.exe /f /s localhost
5 | sleep 1
6 | start "" %1
7 | 
8 | 
9 | 


--------------------------------------------------------------------------------
/mathfly/config/core.toml:
--------------------------------------------------------------------------------
  1 | # Once you have finished making changes, use the "rebuild mathfly"
  2 | # command to enact them.
  3 | "numbers_max"      = 1000
  4 | "pronunciation"    = "(Core | math fly)"
  5 | "capitals_prefix"  = "big"
  6 | # Square brackets mean that a word is optional:
  7 | # the command will work with or without it
  8 | # for example, "numb ten" and "ten" both do the same thing.
  9 | "numbers_prefix"   = "[numb]"
 10 | "dictation_prefix" = "say"
 11 | # "right wally" will produce an "end" keypress
 12 | "extreme"          = "wally"
 13 | 
 14 | # NATO phonetic alphabet
 15 | [letters]
 16 | "alpha"    = "a"
 17 | "bravo"    = "b"
 18 | "charlie"  = "c"
 19 | "delta"    = "d"
 20 | "echo"     = "e"
 21 | "foxtrot"  = "f"
 22 | "golf"     = "g"
 23 | "hotel"    = "h"
 24 | "india"    = "i"
 25 | "juliet"   = "j"
 26 | "kilo"     = "k"
 27 | "lima"     = "l"
 28 | "mike"     = "m"
 29 | "november" = "n"
 30 | "oscar"    = "o"
 31 | "papa"     = "p"
 32 | "quebec"   = "q"
 33 | "romeo"    = "r"
 34 | "sierra"   = "s"
 35 | "tango"    = "t"
 36 | "uniform"  = "u"
 37 | "victor"   = "v"
 38 | "whiskey"  = "w"
 39 | "x-ray"    = "x"
 40 | "yankee"   = "y"
 41 | "zulu"     = "z"
 42 | 
 43 | # My own phonetic alphabet, based on that of Talon.
 44 | # Single syllables speed things up a bit, potentially
 45 | # at the cost of accuracy, enable "alternative_letters"
 46 | # in settings.toml to use these instead of NATO
 47 | [letters_alt]
 48 | "(anti | arch)" = "a"
 49 | "bat"           = "b"
 50 | "cap"           = "c"
 51 | "die"           = "d"
 52 | "each"          = "e"
 53 | "fail"          = "f"
 54 | "(gone | gust)" = "g"
 55 | "(harp | harm)" = "h"
 56 | "sit"           = "i"
 57 | "jury"          = "j"
 58 | "crunch"        = "k"
 59 | "look"          = "l"
 60 | "(made | mad)"  = "m"
 61 | "near"          = "n"
 62 | "odd"           = "o"
 63 | "pit"           = "p"
 64 | "queer"         = "q"
 65 | "red"           = "r"
 66 | "sun"           = "s"
 67 | "trap"          = "t"
 68 | "urge"          = "u"
 69 | "vest"          = "v"
 70 | "whale"         = "w"
 71 | "box"           = "x"
 72 | "yes"           =  "y"
 73 | "zulu"          = "z"
 74 | 
 75 | # (command1 | command2) means that either command
 76 | # will do the same thing
 77 | [punctuation]
 78 | "ampersand"             = "ampersand"
 79 | "apostrophe"            = "apostrophe"
 80 | "(asterisk | starling)" = "asterisk"
 81 | "at sign"               = "at"
 82 | "backslash"             = "backslash"
 83 | "backtick"              = "backtick"
 84 | "pipe symbol"           = "bar"
 85 | "caret"                 = "caret"
 86 | "colon"                 = "colon"
 87 | "comma"                 = "comma"
 88 | "boom"                  = "comma, space"
 89 | "dollar"                = "dollar"
 90 | "(dot | point)"         = "dot"
 91 | "(quote | quotes)"      = "dquote"
 92 | "equals"                = "equal"
 93 | "exclamation"           = "exclamation"
 94 | "hashtag"               = "hash"
 95 | "hyphen"                = "hyphen"
 96 | "minus"                 = "minus"
 97 | "percent"               = "percent"
 98 | "plus"                  = "plus"
 99 | "question mark"         = "question"
100 | "semicolon"             = "semicolon"
101 | "slash"                 = "slash"
102 | "single quote"          = "squote"
103 | "tilde"                 = "tilde"
104 | "underscore"            = "underscore"
105 | "greater than"          = "rangle"
106 | "less than"             = "langle"
107 | "brax"                  = "lbracket, rbracket, left"
108 | "prekris"               = "lparen, rparen, left"
109 | "curly"                 = "lbrace, rbrace, left"
110 | 
111 | # These can be followed by a number to execute multiple times
112 | [repeatable_keys]
113 | "(space | ace)"       = "space"
114 | "(tab | tabby)"       = "tab"
115 | "(enter | shock)"     = "enter"
116 | "check"               = "c-enter"
117 | "(backspace | clear)" = "backspace"
118 | "splat"               = "c-backspace"
119 | "(delete | deli)"     = "del"
120 | "(escape | eskimo)"   = "escape"
121 | "(duple | duplicate)" = "home, s-end, c-c, right, enter, c-v"
122 | 
123 | # these cannot
124 | [non_repeatable_keys]
125 | "shackle"         = "home, s-end"
126 | "(copy | stoosh)" = "c-c"
127 | "(paste | spark)" = "c-v"
128 | "cut"             = "c-x"
129 | "home"            = "home"
130 | "end"             = "end"
131 | "save"            = "c-s"
132 | 
133 | # these require a pause before activation, in order to reduce
134 | # unwanted recognition of destructive commands
135 | [noCCR_repeatable_keys]
136 | "undo" = "c-z"
137 | "redo" = "c-y"
138 | 
139 | [noCCR_non_repeatable_keys]
140 | 
141 | [directions]
142 | "left"  = "left"
143 | "right" = "right"
144 | "up"    = "up"
145 | "down"  = "down"
146 | 
147 | [directions_alt]
148 | "lease" = "left"
149 | "ross"  = "right"
150 | "sauce" = "up"
151 | "dunce" = "down"
152 | 
153 | # for example, "queue left two" executes ctrl-shift-left twice,
154 | # selecting two words to the left.
155 | [modifiers]
156 | "queue" = "cs-"
157 | "shin"  = "s-"
158 | "fly"   = "c-"


--------------------------------------------------------------------------------
/mathfly/config/latex.toml:
--------------------------------------------------------------------------------
  1 | # Once you have finished making changes, use the "rebuild mathfly"
  2 | # command to enact them.
  3 | "pronunciation"      = "LaTeX"
  4 | # Insert your own .bib file here, e.g.
  5 | # "bibliography_path" = "C:/Users/Mike/Documents/bibliography.bib"
  6 | "bibliography_path"  = ""
  7 | "class_prefix"       = "document class"
  8 | "environment_prefix" = "begin"
  9 | "package_prefix"     = "use package"
 10 | "symbol_prefix"      = "symbol"
 11 | "greek_prefix"       = "greek"
 12 | "command_prefix"     = "insert"
 13 | "template_prefix"    = "template"
 14 | "accent_prefix"      = "accent"
 15 | 
 16 | [document_classes]
 17 | "article"     = "article"
 18 | "beamer"      = "beamer"
 19 | "book"        = "book"
 20 | "letter"      = "letter"
 21 | "proceedings" = "proc"
 22 | "report"      = "report"
 23 | 
 24 | [packages]
 25 | "AMS math"    = "amsmath"
 26 | "bib latex"   = ["[style=authoryear]", "biblatex"]
 27 | "colour"      = "color"
 28 | "geometry"    = "geometry"
 29 | "hyper ref"   = "hyperref"
 30 | "graphic X"   =  "graphicx"
 31 | "math tools"  =  "mathtools"
 32 | "multi col"   = "multicol"
 33 | "long table"  = "longtable"
 34 | "tabular X"   = "tabularx"
 35 | "X color"     = "xcolor"
 36 | "wrap figure" =  "wrapfig"
 37 | 
 38 | # These commands produce begin and end tags, and end inside.
 39 | # if included, the second element in lists come after the first begin
 40 | # tag. For example, "begin figure" produces
 41 | # \begin{figure}[h!]
 42 | # \end{figure}
 43 | [environments]
 44 | "abstract"                    = "abstract"
 45 | "add margin"                  = "addmargin"
 46 | "align"                       = "align"
 47 | "(plain | unnumbered) align"  ="align*"
 48 | "center"                      = "center"
 49 | "columns"                     = "columns"
 50 | "column"                      = ["column", "{0.5\\textwidth}"]
 51 | "cases"                       = "cases"
 52 | "display cases"               = "dcases"
 53 | "definition"                  = "definition"
 54 | "description"                 = "description"
 55 | "document"                    = "document"
 56 | "(enumerate | numbered list)" = "enumerate"
 57 | "equation"                    = "equation"
 58 | "(plain  | unnumbered) equation" = "equation*"
 59 | "figure"                      = ["figure", "[h!]"]
 60 | "flush left"                  = "flushleft"
 61 | "flush right"                 = "flushright"
 62 | "frame"                       = "frame"
 63 | "(list | itemise)"            = "itemize"
 64 | "mini page"                   = "minipage"
 65 | "multi (cols | columns)"      = ["multicols", "{2}"]
 66 | "multi line"                  = "multline"
 67 | "proof"                       = "proof"
 68 | "quotation"                   = "quotation"
 69 | "quote"                       = "quote"
 70 | "split"                       = "split"
 71 | "table"                       = ["table", "[h!]\n\\centering"]
 72 | "long table"                  = ["longtable", "{lll}"]
 73 | "tabular"                     = ["tabular", "{llll}"]
 74 | "tabular X"                   = ["tabular X", "{l X}"]
 75 | "theorem"                     = "theorem"
 76 | "title page"                  = "titlepage"
 77 | "verbatim"                    = "verbatim"
 78 | "verse"                       = "verse"
 79 | "wrap figure"                 = "wrapfigure"
 80 | 
 81 | 
 82 | [command]
 83 | "author"                      = "author"
 84 | "[add] bib resource"          = "addbibresource"
 85 | "caption"                     = "caption"
 86 | "chapter"                     = "chapter"
 87 | "simple citation"		   = "cite"
 88 | "frame title"                 = "frametitle"
 89 | "footnote"                    = "footnote"
 90 | "footnote text"               = "footnotetext[]"
 91 | "graphics path"               = "graphicspath"
 92 | "[include] graphics"          = "includegraphics[width=1\\textwidth]"
 93 | "label"                       = "label"
 94 | "new command"                 = "newcommand{}[]"
 95 | "paragraph"                   = "paragraph"
 96 | "paren cite"                  = "parencite"
 97 | "part"                        = "part"
 98 | "reference"                   = "ref"
 99 | "renew command"               = "renewcommand"
100 | "sub paragraph"               = "subparagraph"
101 | "(section | heading)"         = "section"
102 | "sub (section | heading)"     = "subsection"
103 | "sub sub (section | heading)" = "subsubsection"
104 | "text cite"                   = "textcite"
105 | "[text] bold"                 = "textbf"
106 | "[text] italics"              = "textit"
107 | "[text] slanted"              = "textsl"
108 | "emphasis"				   = "emph"
109 | "title"                       = "title"
110 | "use theme"                   = "usetheme"
111 | # Accents
112 | "grave [accent]"              = "`"
113 | "acute [accent]"              = "'"
114 | "dot [accent]"                = "."
115 | "breve [accent]"              = "u"
116 | "(circumflex | hat)"          = "^"
117 | "(umlaut | dieresis)"         = "\""
118 | "(tilde | squiggle)"          = "~"
119 | "(macron | bar)"              = "="
120 | 
121 | [commandnoarg]
122 | "centering"          = "centering"
123 | "column"             = "column{0.5\\textwidth}"
124 | "footnote mark"      = "footnotemark[]"
125 | "horizontal line"    = "hline"
126 | "(lah | lay) tech"   = "LaTeX~ "
127 | "line break"         = "linebreak"
128 | "[list] item"        = "item"
129 | "make title"         = "maketitle"
130 | "new page"           = "newpage"
131 | "no indent"          = "noindent"
132 | "page break"         = "pagebreak"
133 | "print bibliography" = "printbibliography"
134 | "table of contents"  = "tableofcontents"
135 | "tech"               = "TeX~ "
136 | "text backslash"     = "textbackslash"
137 | "text height"        = "textheight"
138 | "text width"         = "textwidth"
139 | "vertical line"      = "vline"
140 | 
141 | [commandmisc]
142 | "line end"           = ["\\\\", "enter"]
143 | 
144 | [greek_letters]
145 | "alpha"   = "alpha"
146 | "beater"  = "beta"
147 | "gamma"   = "gamma"
148 | "delta"   = "delta"
149 | "epsilon" = "epsilon"
150 | "zita"    = "zeta"
151 | "eater"   = "eta"
152 | "theta"   = "theta"
153 | "iota"    = "iota"
154 | "kappa"   = "kappa"
155 | "lambda"  = "lambda"
156 | "mu"      = "mu"
157 | "new"     = "nu"
158 | "zee"     = "xi"
159 | "cherry"  = "pi"
160 | "row"     = "rho"
161 | "sigma"   = "sigma"
162 | "tau"     = "tau"
163 | "upsilon" = "upsilon"
164 | "phi"     = "phi"
165 | "chi"     = "chi"
166 | "sigh"    = "psi"
167 | "omega"   = "omega"
168 | 
169 | 
170 | [misc_symbols]
171 | "inline"                    = [" \\(\\)", "left:2"]
172 | "super [script]"            = ["^{}", "left"]
173 | "sub [script]"              = ["_{}", "left"]
174 | "squared"                   = "^{2} "
175 | "cubed"                     = "^{3} "
176 | "inverse"                   = "^{-1} "
177 | "degrees"                   = "^{\\circ}"
178 | "(parens | parentheses)"    = ["\\left(  \\right) ", "left:9"]
179 | "square brackets"           = ["\\left[  \\right] ", "left:9"]
180 | "(curly brackets | braces)" = ["\\left\\{  \\right\\} ", "left:9"]
181 | "(cardinality bars | absolute value)" = ["\\left|  \\right| ", "left:9"]
182 | "floor"                     = ["\\left\\lfloor  \\right\\rfloor", "left:14"]
183 | "ceiling"                   = ["\\left\\lceil  \\right\\rceil", "left:13"]
184 | 
185 | # if included, a number as the second element in a list
186 | # puts that number of curly braces after the command, e.g.
187 | # "symbol fraction" produces "\frac{}{}"
188 | [symbols]
189 | "square root"                         = ["sqrt", "1"]
190 | "[generic] root"                      = ["sqrt[]", "1"]
191 | "integral"                            = "int"
192 | "double integral"                     = "iint"
193 | "triple integral"                     = "iiint"
194 | "infinity"                            = "infty"
195 | "times"                               = "times"
196 | "divide"                              = "div"
197 | "intersection"                        = "cap"
198 | "union"                               = "cup"
199 | "C dot"                               = "cdot"
200 | "summation"                           = "sum"
201 | "product"                             = "prod"
202 | "(direct sum | oh plus)"              = "oplus"
203 | "(big direct sum | big oh plus)"      = "bigoplus"
204 | "(direct product | oh times)"         = "otimes"
205 | "(big direct product | big oh times)" = "bigotimes"
206 | "plus or minus"                       = "pm"
207 | "partial"                             = "partial"
208 | #
209 | "fraction"                            = ["frac", "2"]
210 | "unit"                                = "unitone"
211 | "unit two"                            = "unittwo"
212 | "unit fraction "                      = "unitfrac"
213 | "text fraction"                       = "tfrac"
214 | "display fraction"                    = "dfrac"
215 | "continued fraction"                  = "cfrac"
216 | "continued fraction (left)"           = "cfracleft"
217 | "continued fraction (right)"          = "cfracright"
218 | "binomial"                            = ["binom", "2"]
219 | # "text binomial"                     = "tbinom"
220 | # "display binomial"                  = "dbinom"
221 | # trig
222 | "sine"                                = "sin"
223 | "cosine"                              = "cos"
224 | "tangent"                             = "tan"
225 | "secant"                              = "sec"
226 | "cosecant"                            = "csc"
227 | "cotangent"                           = "cot"
228 | "arc sine"                            = "arcsin"
229 | "arc cosine"                          = "arccos"
230 | "arc tan"                             = "arctan"
231 | "hyperbolic sine"                     = "sinh"
232 | "hyperbolic cosine"                   = "cosh"
233 | "hyperbolic cotangent"                = "coth"
234 | "hyperbolic tangent"                  = "tanh"
235 | # functions
236 | "argument"                            = "arg"
237 | "modulus"                             = "bmod"
238 | "degree"                              = "deg"
239 | "determinant"                         = "det"
240 | "dimension"                           = "dim"
241 | "exp"                                 = "exp"
242 | "GCD"                                 = "gcd"
243 | "cat hom"                             = "hom"
244 | "kernel"                              = "ker"
245 | "infimum"                             = "inf"
246 | "supremum"                            = "sup"
247 | "limit"                               = "lim"
248 | "liminf"                              = "liminf"
249 | "(natural (log | logarithm) | log natural)" = "ln"
250 | "logarithm"                           = "log"
251 | "max"                                 = "max"
252 | "min"                                 = "min"
253 | "prime"						 = "prime"
254 | "probability"                         = "Pr"
255 | # relations
256 | "[is] not equal [to]"                 = "neq"
257 | "[is] greater [than] [or] equal [to]" = "geq"
258 | "[is] less [than] [or] equal [to]"    = "leq"
259 | "[is] approximately [equal] [to]"     = "approx"
260 | "proportional [to]"                   = "propto"
261 | "preference less [than]"              = "prec"
262 | "preference less equals"              = "preceq"
263 | "preference greater [than]"           = "succ"
264 | "preference greater equals"           = "succeq"
265 | # sets
266 | "subset"                              = "subset"
267 | "superset"                            = "supset"
268 | "strict subset"                       = "subsetneq"
269 | "strict superset"                     = "supsetneq"
270 | "member"                              = "in"
271 | "empty set"							  = "emptyset"
272 | "set minus"                           = "setminus"
273 | # logic
274 | "(land|logic and)"                    = "land"
275 | "logic or"                            = "lor"
276 | "primer"                              = "prime"
277 | "logic not"                           = "lnot"
278 | "for all"                             = "forall"
279 | "there exists"                        = "exists"
280 | # math fonts
281 | "(beebee|blackboard bold)"            = ["mathbb", "1"]
282 | "roman"                               = ["mathrm", "1"]
283 | "bold"                                = ["mathbf", "1"]
284 | "bold symbol"                         = ["boldsymbol", "1"]
285 | "sans serif"                          = ["mathsf", "1"]
286 | "italic"                              = ["mathit", "1"]
287 | "typewriter"                          = ["matttt", "1"]
288 | "blackboard"                          = ["mathbb", "1"]
289 | "fraktur"                             = ["mathfrak", "1"]
290 | "calligraphic"                        = ["mathcal", "1"]
291 | "formal script"                       = ["mathscr", "1"]
292 | "normal text mode"                    = ["textrm", "1"]
293 | #
294 | "real numbers"                        = "mathbb{R}"
295 | "complex numbers"                     = "mathbb{C}"
296 | "integer numbers"                     = "mathbb{Z}"
297 | "rational numbers"                    = "mathbb{Q}"
298 | "natural numbers"                     = "mathbb{N}"
299 | #
300 | "left arrow"                          = "leftarrow"
301 | "right arrow"                         = "rightarrow"
302 | "up arrow"                            = "uparrow"
303 | "down arrow"                          = "downarrow"
304 | "left right arrow"                    = "leftrightarrow"
305 | #
306 | "dots"                                = "dots"
307 | "diagonal dots"                       = "ddots"
308 | "horizontal dots"                     = "cdots"
309 | "vertical dots"                       = "vdots"
310 | "low dots"                            = "ldots"
311 | # note: individual right and left delimiters are needed for things like equations across multiple lines and open/closed interval notation. --Anna
312 | # open and close used instead of left and right to avoid conflict with navigation commands
313 | "invisible delimiter open"            = "left."
314 | "invisible delimiter close"           = "right."
315 | "paren delimiter close"               = "right)"
316 | "paren delimiter open"                = "left("
317 | "square bracket delimiter close"      = "right]"
318 | "square bracket delimiter open"       = "left["
319 | #
320 | "text"                                = ["text", "1"]
321 | #
322 | "sub stack"                           = ["substack", "1"]
323 | 
324 | 
325 | [accents]
326 | "bar"        = "bar"
327 | "breve"      = "breve"
328 | "check"      = "check"
329 | "dot"        = "dot"
330 | "ddot"       = "ddot"
331 | "hat"        = "hat"
332 | "over line"  = "overline"
333 | "wide hat"   = "widehat"
334 | "tilde"      = "tilde"
335 | "wide tilde" = "widetilde"
336 | "vector"     = "vec"
337 | 
338 | 
339 | # These are longer and are pasted in rather than being executed
340 | # as keystrokes. Add as many as you like.
341 | [templates]
342 | "header" = '''
343 | \documentclass[12pt, a4paper]{article}
344 | 
345 | \usepackage{graphicx}
346 | \usepackage[utf8]{inputenc}
347 | \usepackage[style=authoryear]{biblatex}
348 | \addbibresource{}
349 | 
350 | \setlength{\parskip}{1em}
351 | \renewcommand{\baselinestretch}{1.3}
352 | '''
353 | # ------------------------------------------------
354 | "beamer" = '''
355 | \documentclass{beamer}
356 | \usetheme{metropolis}
357 | \usepackage{graphicx}
358 | \usepackage[style=authoryear]{biblatex}
359 | \addbibresource{}
360 | 
361 | \begin{document}
362 | \begin{frame}
363 | \frametitle{}
364 | 
365 | \end{frame}
366 | \end{document}
367 | '''
368 | # ------------------------------------------------
369 | "(graphic | figure)" = '''
370 | \begin{figure}[h!]
371 | \centering
372 | \label{}
373 | \includegraphics[width=1\textwidth]{}
374 | \caption{}
375 | \end{figure}
376 | '''
377 | # ------------------------------------------------
378 | "wrap (graphic | figure)" = '''
379 | \begin{wrapfigure}{l}{0.5\textwidth}
380 | \centering
381 | \label{}
382 | \includegraphics[width=0.4\textwidth]{}
383 | \caption{}
384 | \end{wrapfigure}
385 | '''
386 | # ------------------------------------------------
387 | "table" = '''
388 | \begin{table}[h!]
389 | \centering
390 | \label{}
391 | \begin{tabular}{ccccc}
392 | &  &  &  & \\
393 | \hline
394 | &  &  &  &  \\
395 | \end{tabular}
396 | \caption{}
397 | \end{table}
398 | '''
399 | # ------------------------------------------------


--------------------------------------------------------------------------------
/mathfly/config/lyx.toml:
--------------------------------------------------------------------------------
  1 | # Once you have finished making changes, use the "rebuild mathfly"
  2 | # command to enact them.
  3 | "pronunciation"   = "LyX"
  4 | "greek_prefix"    = "greek"
  5 | "symbol1_prefix"  = ""
  6 | "symbol2_prefix"  = "symbol"
  7 | "text_prefix"     = "text"
  8 | "number_prefix"   = ""
  9 | "accent_prefix"   = "accent"
 10 | "matrix_style"    = "matrix"
 11 | "max_matrix_size" = 10
 12 | 
 13 | # For a full list of the available key formatting options,
 14 | # see https://pythonhosted.org/dragonfly/actions.html
 15 | [misc_lyx_keys]
 16 | "math mode"                       = "c-m"
 17 | "new math line"                   = "escape:10, end, enter, c-m"
 18 | "fraction"                        = "a-m, f"
 19 | "over"                            = "cs-left, a-m, f, down"
 20 | "(super script | to the power)" = "caret"
 21 | "sub script"                    = "underscore"
 22 | "squared"                         = "caret, 2, right"
 23 | "cubed"                           = "caret, 3, right"
 24 | "inverse"                         = "caret, minus, 1, right"
 25 | "(parens | parentheses)"          = "a-m, lparen"
 26 | "square brackets"                 = "a-m, lbracket"
 27 | "curly brackets"                  = "a-m, lbrace"
 28 | "absolute"                        = "a-m, bar"
 29 | "add matrix row"                  = "a-m, w, i"
 30 | "(delete | remove) matrix row"    = "a-m, w, d"
 31 | "add matrix column"               = "a-m, c, i"
 32 | "(delete | remove) matrix column" = "a-m, c, d"
 33 | 
 34 | 
 35 | # Alternates between executing as text and executing as keys
 36 | [misc_lyx_commands]
 37 | "blank summation"        = "\\sum "
 38 | "summation"              = ["\\stackrelthree ", "down", "\\sum ", "down"]
 39 | "(summation | sum) to N" = ["\\stackrelthree ", "n, down", "\\sum ", "down"]
 40 | "blank product"          = "\\prod "
 41 | "product"                = ["\\stackrelthree ", "down", "\\prod ", "down"]
 42 | "product to N"           = ["\\stackrelthree ", "n, down", "\\prod ", "down"]
 43 | "limit"                  = ["\\underset \\lim ", "down"]
 44 | "blank limit"            = "\\lim "
 45 | "label above"            = "\\overset "
 46 | "label below"            = "\\underset "
 47 | "prime"                  = ["^\\prime ", "right"]
 48 | "degrees"                = ["^\\circ ", "right"]
 49 | "exponential"            = ["\\exp ", "a-m, lparen"]
 50 | "expectation"            = ["E", "a-m, lparen"]
 51 | "variance"               = ["Var", "a-m, lparen"]
 52 | #
 53 | "real numbers"           = ["\\mathbb R", "right"]
 54 | "complex numbers"        = ["\\mathbb C", "right"]
 55 | "integer numbers"        = ["\\mathbb Z", "right"]
 56 | "rational numbers"       = ["\\mathbb Q", "right"]
 57 | "natural numbers"        = ["\\mathbb N", "right"]
 58 | 
 59 | 
 60 | [greek_letters]
 61 | "alpha"   = "alpha"
 62 | "beater"  = "beta"
 63 | "gamma"   = "gamma"
 64 | "delta"   = "delta"
 65 | "epsilon" = "varepsilon"
 66 | "zita"    = "zeta"
 67 | "eater"   = "eta"
 68 | "theta"   = "theta"
 69 | "iota"    = "iota"
 70 | "kappa"   = "kappa"
 71 | "lambda"  = "lambda"
 72 | "mu"      = "mu"
 73 | "new"     = "nu"
 74 | "zee"     = "xi"
 75 | "pie"     = "pi"
 76 | "row"     = "rho"
 77 | "sigma"   = "sigma"
 78 | "tau"     = "tau"
 79 | "upsilon" = "upsilon"
 80 | "phi"     = "phi"
 81 | "chi"     = "chi"
 82 | "sigh"    = "psi"
 83 | "omega"   = "omega"
 84 | 
 85 | 
 86 | [tex_symbols1]
 87 | # operators
 88 | "square root"                  = "sqrt"
 89 | "[generic] root"               = "root"
 90 | "integral"                     = "int"
 91 | "double integral"              = "iint"
 92 | "triple integral"              = "iiint"
 93 | "times"                        = "times"
 94 | "divide"                       = "div"
 95 | "stop"                         = "cdot"
 96 | "plus or minus"                = "pm"
 97 | "partial"                      = "partial"
 98 | "infinity"                     = "infty"
 99 | "(nice frack | nice fraction)" = "nicefrac"
100 | "binomial"                     = "binom"
101 | "vector nabla"                 = "nabla"
102 | # trig
103 | "sine"                         = "sin"
104 | "cosine"                       = "cos"
105 | "tangent"                      = "tan"
106 | "secant"                       = "sec"
107 | "cosecant"                     = "csc"
108 | "cotangent"                    = "cot"
109 | "arc sine"                     = "arcsin"
110 | "arc cosine"                   = "arccos"
111 | "arc tan"                      = "arctan"
112 | "hyperbolic sine"              = "sinh"
113 | "hyperbolic cosine"            = "cosh"
114 | "hyperbolic cotangent"         = "coth"
115 | "hyperbolic tangent"           = "tanh"
116 | # functions
117 | "argument"                     = "arg"
118 | "degree"                       = "deg"
119 | "determinant"                  = "det"
120 | "dimension"                    = "dim"
121 | "(natural (log | logarithm) | log natural)" = "ln"
122 | "logarithm"                    = "log"
123 | "maximum"                      = "max"
124 | "minimum"                      = "min"
125 | "(modulo | modulus)"           = "bmod"
126 | "infimum"                      = "inf"
127 | "supremum"                     = "sup"
128 | "probability"                  = "Pr"
129 | # relations
130 | "there exists"                 = "exists"
131 | "member"                       = "in"
132 | "for all"                      = "forall"
133 | "[is] not equal [to]"          = "neq"
134 | "[is] greater [than] [or] equal [to]" = "geq"
135 | "[is] less [than] [or] equal [to]" = "leq"
136 | "[is] approximately [equal] [to]" = "approx"
137 | "proportional [to]"            = "propto"
138 | "preference less [than]"       = "prec"
139 | "preference less equals"       = "preceq"
140 | "preference greater [than]"    = "succ"
141 | "preference greater equal"     = "succeq"
142 | # sets
143 | "empty set"                    = "emptyset"
144 | "subset"                       = "subset"
145 | "superset"                     = "supset"
146 | "strict subset"                = "subsetneq"
147 | "strict superset"              = "supsetneq"
148 | "intersection"                 = "cap"
149 | "union"                        = "cup"
150 | # logic
151 | "logic and"                    = "land"
152 | "logic or"                     = "lor"
153 | "logic not"                    = "lnot"
154 | #
155 | "left arrow"                   = "leftarrow"
156 | "right arrow"                  = "rightarrow"
157 | "up arrow"                     = "uparrow"
158 | "down arrow"                   = "downarrow"
159 | "left right arrow"             = "leftrightarrow"
160 | "maps to"                      = "mapsto"
161 | "oh plus"                      = "oplus"
162 | "oh times"                     = "otimes"
163 | "big oh plus"                  = "bigoplus"
164 | "big oh times"                 = "bigotimes"
165 | #
166 | "dot dot dot"                  = "dots"
167 | "diagonal dots"                = "ddots"
168 | "horizontal dots"              = "cdots"
169 | "vertical dots"                = "vdots"
170 | 
171 | # Require a prefix, as these (I think) are fairly uncommon
172 | # feel free to move this stuff around.
173 | [tex_symbols2]
174 | "GCD"                        = "gcd"
175 | "cat hom"                    = "hom"
176 | "kernel"                     = "ker"
177 | "unit"                       = "unitone"
178 | "unit two"                   = "unittwo"
179 | "unit fraction "             = "unitfrac"
180 | "text fraction"              = "tfrac"
181 | "display fraction"           = "dfrac"
182 | "continued fraction"         = "cfrac"
183 | "continued fraction (left)"  = "cfracleft"
184 | "continued fraction (right)" = "cfracright"
185 | "text binomial"              = "tbinom"
186 | "display binomial"           = "dbinom"
187 | 
188 | [text_modes]
189 | "roman"      = "mathrm"
190 | "bold"       = "mathbf"
191 | "sans serif" = "mathsf"
192 | "italic"     = "mathit"
193 | "typewriter" = "mathtt"
194 | # math fonts
195 | # "normal" = "textrm"
196 | "(beebee|blackboard bold | blackboard)" = "mathbb"
197 | # "bold symbol" = "boldsymbol"
198 | # "fraktur" = "mathfrak"
199 | # "calligraphic" = "mathcal"
200 | # "formal script" = "mathscr"
201 | 
202 | [accents]
203 | "hat"        = "h"
204 | "tilde"      = "ampersand"
205 | "dot"        = "dot"
206 | "double dot" = "dquote"
207 | "bar"        = "minus"
208 | "vector"     = "v"
209 | 
210 | [denominators]
211 | "(half | halves)"      = 2
212 | "(third | thirds)"     = 3
213 | "(quarter | quarters | fourth | fourths)" = 4
214 | "(fifth | fifths)"     = 5
215 | "(sixth | sixths)"     = 6
216 | "(seventh | sevenths)" = 7
217 | "(eighth | eighths)"   = 8
218 | "(ninth | ninths)"     = 9
219 | "(tenth | tenths)"     = 10
220 | 
221 | [control]
222 | "new file"     = "c-n"
223 | "open file"    = "c-o"
224 | "save as"      = "cs-s"
225 | "math mode"    = "c-m"
226 | "display mode" = "cs-m"
227 | "normal mode"  = "a-p, s"
228 | "view PDF"     = "c-r"
229 | "update PDF"   = "cs-r"
230 | #
231 | "insert (in line formula | in line)"             = "a-i, h, i"
232 | "insert (numbered formula)"                      = "a-i, h, n"
233 | "insert (display formula | display)"             = "a-i, h, d"
234 | "insert equation array"                          = "a-i, h, e"
235 | "insert (AMS align environment | AMS align)"     = "a-i, h, a"
236 | "insert AMS align at [environment]"              = "a-i, h, t"
237 | "insert AMS flalign [environment]"               = "a-i, h, f"
238 | "insert (AMS gathered environment | AMS gather)" = "a-i, h, g"
239 | "insert (AMS multline [environment]| multiline)" = "a-i, h, m"
240 | "insert array [environment]"                     = "a-i, h, y"
241 | "insert (cases [environment] | piecewise)"       = "a-i, h, c"
242 | "insert (aligned [environment] | align)"         = "a-i, h, l"
243 | "insert aligned at [environment]"                = "a-i, h, v"
244 | "insert gathered [environment]"                  = "a-i, h, h"
245 | "insert split [environment]"                     = "a-i, h, s"
246 | "insert delimiters"                              = "a-i, h, r"
247 | "insert matrix"                                  = "a-i, h, x"
248 | "insert macro"                                   = "a-i, h, o"
249 | #
250 | "insert [bulleted] list"             = "a-p, b"
251 | "insert numbered list"               = "a-p, e"
252 | "insert description"                 = "a-p, d"
253 | "insert part"                        = "a-p, 0"
254 | "insert (section | heading)"         = "a-p, 2"
255 | "insert sub (section | heading)"     = "a-p, 3"
256 | "insert sub sub (section | heading)" = "a-p, 4"
257 | "insert paragraph"                   = "a-p, 5"
258 | "insert sub paragraph"               = "a-p, 6"
259 | "insert title"                       = "a-p, t"
260 | "insert author"                      = "a-p, s-a"
261 | "insert date"                        = "a-p, s-d"
262 | "insert abstract"                    = "a-p, a"
263 | "insert address"                     = "a-p, a-a"
264 | "insert bibliography"                = "a-p, s-b"
265 | "insert quotation"                   = "a-p, a-q"
266 | "insert quote"                       = "a-p, q"
267 | "insert verse"                       = "a-p, v"
268 | 
269 | [control_repeat]
270 | "next tab"               = "c-pgdown"
271 | "(prior | previous) tab" = "c-pgup"
272 | "close tab"              = "c-w/20"
273 | "move line up"           = "a-up"
274 | "move line down"         = "a-down"
275 | 


--------------------------------------------------------------------------------
/mathfly/config/settings.toml:
--------------------------------------------------------------------------------
 1 | ccr_path = "config/ccr.toml"
 2 | dragon_path = "C:/Program Files (x86)/Nuance/NaturallySpeaking15/Program/natspeak.exe"
 3 | editor_path = "C:/Program Files/Windows NT/Accessories/wordpad.exe"
 4 | # editor_path = "C:/Program Files/Sublime Text 3/sublime_text.exe"
 5 | ccr_modules = ["core",
 6 | 				"ScientificNotebook55",
 7 | 				"LyX",
 8 | 				"latex",
 9 | 				"latex_maths",
10 | 				"alias"
11 | 				]
12 | app_modules = ["sublime",
13 | 				"sumatrapdf",
14 |                 "wordpad"
15 | 				]
16 | max_ccr_repetitions = 16
17 | alternative_letters = false
18 | alternative_directions = false
19 | use_aenea = false
20 | # Words to be removed from the dragon vocabulary
21 | delete_words = ["one-to-one"]
22 | # Words to be added to the dragon vocabulary
23 | add_words = [
24 |     "heteroscedasticity",
25 |     "homoscedasticity",
26 |     "leptokurtosis"
27 |     ]


--------------------------------------------------------------------------------
/mathfly/docs/Core.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/docs/Core.pdf


--------------------------------------------------------------------------------
/mathfly/docs/LaTeX.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/docs/LaTeX.pdf


--------------------------------------------------------------------------------
/mathfly/docs/LyX.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/docs/LyX.pdf


--------------------------------------------------------------------------------
/mathfly/docs/Scientific_Notebook.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/docs/Scientific_Notebook.pdf


--------------------------------------------------------------------------------
/mathfly/docs/source/Apps.md:
--------------------------------------------------------------------------------
  1 | # Mathfly application support
  2 | 
  3 | ## Sumatra pdf
  4 | | Voice command         | Keystroke           |
  5 | |:----------------------|:--------------------|
  6 | | `open file`           | `c-o`               |
  7 | | `print file`          | `c-p`               |
  8 | | `close tab`           | `c-w`               |
  9 | | `next tab`            | `c-tab`             |
 10 | | `previous tab`        | `cs-tab`            |
 11 | | `<nth> tab`           | `a-%(nth)s`         |
 12 | | `go to page`          | `c-g`               |
 13 | | `find`                | `c-f`               |
 14 | | `find next`           | `f3`                |
 15 | | `find previous`       | `s-f3`              |
 16 | | `page <n>`            | `c-g, %(n)s, enter` |
 17 | | `table of contents`   | `f12`               |
 18 | | `zoom in`             | `c-equals`          |
 19 | | `zoom out`            | `c-minus`           |
 20 | | `fit page`            | `c-0`               |
 21 | | `actual size`         | `c-1`               |
 22 | | `fit width`           | `c-2`               |
 23 | | `fit content`         | `c-3`               |
 24 | | `[view] single page`  | `c-6`               |
 25 | | `facing view`         | `c-7`               |
 26 | | `book view`           | `c-8`               |
 27 | | `rotate [right]`      | `c-plus`            |
 28 | | `rotate left`         | `c-minus`           |
 29 | | `presentation [mode]` | `f11`               |
 30 | | `full screen`         | `s-f11`             |
 31 | 
 32 | ## Wordpad
 33 | | Voice command     | Keystroke        |
 34 | |:------------------|:-----------------|
 35 | | `new file`        | `c-n`            |
 36 | | `open file`       | `c-o`            |
 37 | | `print file`      | `c-p`            |
 38 | | `page down [<n>]` | `c-pagedown * n` |
 39 | | `page up [<n>]`   | `c-pageup * n`   |
 40 | 
 41 | 
 42 | ## Sublime text
 43 | | Voice command                                       | Keystroke                      |
 44 | |:----------------------------------------------------|:-------------------------------|
 45 | | `new (file / pane)`                                 | `c-n`                          |
 46 | | `new window*`                                        | `ca-n`                         |
 47 | | `open file`                                         | `c-o`                          |
 48 | | `open folder*`                                       | `cs-o`                         |
 49 | | `save as`                                           | `cs-s`                         |
 50 | | `comment line`                                      | `c-slash`                      |
 51 | | `comment (block / lines)`                           | `cs-slash`                     |
 52 | | `outdent lines`                                     | `c-lbracket`                   |
 53 | | `join lines [<n3>]`                                 | `c-j`                          |
 54 | | `match bracket`                                     | `c-m`                          |
 55 | | `(select / sell) scope [<n2>]`                      | `cs-space`                     |
 56 | | `(select / sell) brackets [<n2>]`                   | `cs-m`                         |
 57 | | `(select / sell) line [<n2>]`                       | `c-l`                          |
 58 | | `(select / sell) indent`                            | `cs-j`                         |
 59 | | `(select / sell) paragraph*`                         | `ca-p`                         |
 60 | | `toggle side bar`                                   | `c-k, c-b`                     |
 61 | | `find`                                              | `c-f`                          |
 62 | | `get all`                                           | `a-enter`                      |
 63 | | `replace`                                           | `c-h`                          |
 64 | | `edit lines`                                        | `cs-l`                         |
 65 | | `edit next [<n3>]`                                  | `c-d`                          |
 66 | | `edit skip next [<n3>]`                             | `c-k, c-d`                     |
 67 | | `edit all`                                          | `c-d, a-f3`                    |
 68 | | `transform upper`                                   | `c-k, c-u`                     |
 69 | | `transform lower`                                   | `c-k, c-l`                     |
 70 | | `transform title*`                                   | `c-k, c-t`                     |
 71 | | `line <n11> [<n12>]`                                | `c-g, %(n11)s, %(n12)s, enter` |
 72 | | `go to file`                                        | `c-p`                          |
 73 | | `go to word`                                        | `c-semicolon`                  |
 74 | | `go to symbol`                                      | `c-r`                          |
 75 | | `go to [symbol in] project`                         | `cs-r`                         |
 76 | | `command pallette`                                  | `cs-p`                         |
 77 | | `(find / search) in (project / folder / directory)` | `cs-f`                         |
 78 | | `fold`                                              | `cs-lbracket`                  |
 79 | | `unfold`                                            | `cs-rbracket`                  |
 80 | | `unfold all`                                        | `c-k, c-j`                     |
 81 | | `fold [level] <n2>`                                 | `c-k, c-%(n2)s`                |
 82 | | `full screen`                                       | `f11`                          |
 83 | | `(set / add) bookmark`                              | `c-f2`                         |
 84 | | `next bookmark`                                     | `f2`                           |
 85 | | `previous bookmark`                                 | `s-f2`                         |
 86 | | `clear bookmarks`                                   | `cs-f2`                        |
 87 | | `build it`                                          | `c-b`                          |
 88 | | `record macro`                                      | `c-q`                          |
 89 | | `play [back] macro [<n3>]`                          | `cs-q`                         |
 90 | | `(new / create) snippet`                            | `a-n`                          |
 91 | | `close tab`                                         | `c-w`                          |
 92 | | `next tab`                                          | `c-pgdown`                     |
 93 | | `previous tab`                                      | `c-pgup`                       |
 94 | | `<nth> tab`                                         | `a-%(n2)s`                     |
 95 | | `column <cols>`                                     | `as-%(cols)s`                  |
 96 | | `focus <panel>`                                     | `c-%(panel)s`                  |
 97 | | `move <panel>`                                      | `cs-%(panel)s`                 |
 98 | | `split right*`                                       | `as-2, c-1, ca-v, cs-2`        |
 99 | | `open terminal`                                     | `cs-t`                         |
100 | | `zoom in [<n2>]`                                    | `c-equal * n2`                 |
101 | | `zoom out [<n2>]`                                   | `c-minus * n2`                 |
102 | 
103 | \* Commands marked with an asterisk require changes to the user key bindings to work.
104 | Adding the following to preferences->key bindings will allow them to work.
105 | ```
106 | {"keys": ["ctrl+alt+n"], "command": "new_window"},                   
107 | {"keys": ["ctrl+shift+o"], "command": "prompt_add_folder"},          
108 | {"keys": ["ctrl+alt+p"], "command": "expand_selection_to_paragraph"},
109 | {"keys": ["ctrl+k", "ctrl+t"], "command": "title_case"},             
110 | {"keys": ["ctrl+alt+v"], "command": "clone_file"}                    
111 | ```
112 | 
113 | ## Creating new rules


--------------------------------------------------------------------------------
/mathfly/docs/source/Core.tex:
--------------------------------------------------------------------------------
  1 | \documentclass[12pt]{article}
  2 | \usepackage[T1]{fontenc}
  3 | \usepackage{longtable}
  4 | \title{Mathfly core commands}
  5 | \author{Mike Roberts}
  6 | \begin{document}
  7 | \maketitle
  8 | \tableofcontents
  9 | \section{Introduction}
 10 | These commands are enabled with the voice command "enable core" and are common across all editors. They can be modified by editing mathfly/config/core.toml in any text editor or saying "configure Core" while the module is enabled.
 11 | 
 12 | \section{Phonetic alphabet}
 13 | By default the NATO phonetic alphabet is used. Letters can be prefixed with "big" to get capitals.
 14 | 
 15 | \begin{longtable}{ l l}
 16 | \noindent
 17 | alpha & a \\
 18 | bravo & b \\
 19 | charlie & c \\
 20 | delta & d \\
 21 | echo & e \\
 22 | foxtrot & f \\
 23 | golf & g \\
 24 | hotel & h \\
 25 | india & i \\
 26 | juliet & j \\
 27 | kilo & k \\
 28 | lima & l \\
 29 | mike & m \\
 30 | november & n \\
 31 | oscar & o \\
 32 | papa & p \\
 33 | quebec & q \\
 34 | romeo & r \\
 35 | sierra & s \\
 36 | tango & t \\
 37 | uniform & u \\
 38 | victor & v \\
 39 | whiskey & w \\
 40 | x-ray & x \\
 41 | yankee & y \\
 42 | zulu & z \\
 43 | \end{longtable}
 44 | 
 45 | \section{Punctuation}
 46 | \begin{longtable}{ l l}
 47 | ampersand & \& \\
 48 | apostrophe & ' \\
 49 | (asterisk | starling) & * \\
 50 | at sign & @ \\
 51 | backslash & \textbackslash \\
 52 | backtick & ` \\
 53 | pipe symbol & | \\
 54 | caret & \textasciicircum \\
 55 | colon & : \\
 56 | comma & , \\
 57 | dollar & \$ \\
 58 | (dot | point) & . \\
 59 | (quote | quotes) & " \\
 60 | equals & = \\
 61 | exclamation & ! \\
 62 | hashtag & \# \\
 63 | hyphen & - \\
 64 | minus & - \\
 65 | percent & \% \\
 66 | plus & + \\
 67 | question mark & ? \\
 68 | semicolon & ; \\
 69 | slash & / \\
 70 | single quote & ' \\
 71 | tilde & \textasciitilde \\
 72 | underscore & \textunderscore \\
 73 | greater than & $>$ \\
 74 | less than & $<$ \\
 75 | brax & [~] \\
 76 | prekris & (~) \\
 77 | curly & \{~\} \\
 78 | \end{longtable}
 79 | 
 80 | \section{Repeatable keys}
 81 | These keys may all be repeated up to 10 times by saying a number afterwards, e.g. "shock two" will press enter twice.
 82 | 
 83 | \noindent
 84 | \begin{longtable}{ l l}
 85 | (space | ace) & space \\
 86 | (tab | tabby) & tab \\
 87 | (enter | shock) & enter \\
 88 | check & ctrl-enter \\
 89 | (backspace | clear) & backspace \\
 90 | (delete | deli) & delete \\
 91 | splat & delete words \\
 92 | \end{longtable}
 93 | 
 94 | \section{Other keys}
 95 | \begin{longtable}{ l l}
 96 | (escape | eskimo) & escape \\
 97 | shackle & selects the current line \\
 98 | (copy | stoosh) & copy the current selection \\
 99 | (paste | spark) & paste from clipboard \\
100 | cut & cut the current selection \\
101 | (duple | duplicate) & duplicate the current line \\
102 | home & home \\
103 | end & end \\
104 | save & save the current file \\
105 | \end{longtable}
106 | 
107 | \section{Movement and selection}
108 | All of these commands are repeatable by saying a number afterwards.
109 | 
110 | \subsection{Directions}
111 | \begin{longtable}{ l l}
112 | left & left \\
113 | right & right \\
114 | up & up \\
115 | down & down \\
116 | \end{longtable}
117 | 
118 | \subsection{Modifiers}
119 | Saying one of these before a direction will change the commands behaviour.
120 | 
121 | \noindent
122 | \begin{longtable}{ l l}
123 | shin & select by character \\
124 | queue & select by word \\
125 | fly & move by word \\
126 | \end{longtable}
127 | 
128 | Saying "wally" after a movement command will use the home/end keys instead of directions.
129 | 
130 | \subsection{Examples}
131 | \begin{longtable}{ l l}
132 | left three & move left three \\
133 | left wally & go to the beginning of the line \\
134 | down wally & go to the bottom of the document \\
135 | queue right four & select four words to the right \\
136 | shin right wally & select until the end of the line \\
137 | \end{longtable}
138 | 
139 | \section{Aliases}
140 | Aliases allow for easy on-the-fly creation of new commands. Simply highlight a piece of text or mathematics (using eg ``queue left two'') and say the command "alias" followed by a memorable command name. From now on, saying that command name will paste in the highlighted text. To delete aliases, use the command ``delete aliases''. Does not work in Scientific Notebook at the moment.
141 | \end{document}


--------------------------------------------------------------------------------
/mathfly/docs/source/LaTeX.tex:
--------------------------------------------------------------------------------
  1 | \documentclass[12pt, a4paper]{article}
  2 | \usepackage{longtable}
  3 | \usepackage{amssymb}
  4 | \usepackage{amsmath}
  5 | \usepackage{tabularx}
  6 | \usepackage{graphicx}
  7 | \usepackage{wrapfig}
  8 | \usepackage[english]{babel}
  9 | \usepackage[utf8]{inputenc}
 10 | \usepackage[style=authoryear]{biblatex}
 11 | \addbibresource{C:/Users/Mike/Documents/1 uni work/bibliography.bib}
 12 | 
 13 | \title{Dictating \LaTeX~ using Mathfly}
 14 | \author{Mike Roberts}
 15 | 
 16 | \begin{document}
 17 | \maketitle
 18 | \tableofcontents
 19 | 
 20 | \section{Introduction}
 21 | All of these commands can be modified or added to by editing ``config/latex.toml'' or using the voice command ``configure latex''.
 22 | 
 23 | \section{Bibliography management}
 24 | Once you have added the location of your .bib file (using regular slashes) to your LaTeX config file, Mathfly includes a number of commands to make bibliography management easy:
 25 | 
 26 | \begin{tabularx}{\linewidth}{ l X}
 27 | Insert my (bib resource | bibliography) & \textbackslash addbibresource\{your\_bibliography.bib\} \\
 28 | Add paper to bibliography & Searches google scholar for the highlighted text (paper title), appends the first resulting bibTeX citation to your bibliography file and adds the tag to the clipboard, ready to be pasted into a document. \\
 29 | Add book to bibliography & Same as above, but searches goodreads instead. \\
 30 | Add link to bibliography & Same as above, but constructs a citation from a url instead. \\
 31 | (edit | open) bibliography & Opens your .bib file in your text editor, for manual alterations and searching. \\
 32 | \end{tabularx}
 33 | 
 34 | \section{Document classes}
 35 | Prefixed by "document class", these commands produce for example:
 36 | 
 37 | \begin{verbatim}
 38 | \documentclass{article}
 39 | \end{verbatim}
 40 | 
 41 | \begin{longtable}{ll}
 42 | \centering
 43 | article & article \\
 44 | beamer & beamer \\
 45 | book & book \\
 46 | letter & letter \\
 47 | proceedings & proc \\
 48 | report & report \\
 49 | \end{longtable}
 50 | 
 51 | \section{Packages}
 52 | Prefixed by "use package", these commands produce for example:
 53 | 
 54 | \begin{verbatim}
 55 | \usepackage{geometry}
 56 | \end{verbatim}
 57 | 
 58 | The second column represents additional arguments.
 59 | 
 60 | \begin{longtable}{lll}
 61 | \centering
 62 | AMS math & & AMS math \\
 63 | bib latex & [style=authoryear] & biblatex \\
 64 | colour & & color \\
 65 | geometry & & geometry \\
 66 | hyper ref & & hyperref \\
 67 | graphic X & & graphicx \\
 68 | math tools & & mathtools \\
 69 | multi col & & multicol \\
 70 | long table & & longtable \\
 71 | tabular X & & tabularx \\
 72 | X color & & xcolor \\
 73 | wrap figure & & wrapfig \\
 74 | \end{longtable}
 75 | 
 76 | \section{Environments}
 77 | Prefixed by "begin", these commands produce for example
 78 | 
 79 | \begin{verbatim}
 80 | \begin{abstract}
 81 | \end{abstract}
 82 | \end{verbatim}
 83 | 
 84 | The third column represents additional arguments.
 85 | 
 86 | \begin{longtable}{lll}
 87 | abstract & abstract & \\
 88 | add margin & addmargin & \\
 89 | align & align & \\
 90 | (plain | unnumbered) align & align & \\
 91 | cases & cases & \\
 92 | display cases & dcases \\
 93 | center & center & \\
 94 | columns & columns & \\
 95 | definition & definition & \\
 96 | description & description & \\
 97 | document & document & \\
 98 | (enumerate | numbered list) & enumerate & \\
 99 | equation & equation & \\
100 | (plain  | unnumbered) equation & equation & \\
101 | figure & figure & [h!] \\
102 | flush left & flushleft & \\
103 | flush right & flushright & \\
104 | frame & frame & \\
105 | (list | itemise) & itemize & \\
106 | mini page & minipage & \\
107 | multi (cols | columns) & multicols & \{2\} \\
108 | multi line & multline & \\
109 | proof & proof & \\
110 | quotation & quotation & \\
111 | quote & quote & \\
112 | split & split & \\
113 | table & table & [h!] \\
114 | theorem & theorem & \\
115 | long table & longtable & \{lll\} \\
116 | tabular & tabular & \{llll\} \\
117 | tabular X & tabular X & \{l X\} \\
118 | title page & titlepage & \\
119 | verbatim & verbatim & \\
120 | verse & verse & \\
121 | wrap figure & wrapfigure & \\
122 | \end{longtable}
123 | 
124 | \section{Commands}
125 | All of these commands are prefixed with "insert".
126 | 
127 | \subsection{With arguments}
128 | These commands finish in a set of curly brackets, ready for an argument, for example ``\textbackslash author \{\}''
129 | 
130 | \begin{longtable}{ll}
131 | author & author \\
132 | {[add]} bib resource & addbibresource \\
133 | caption & caption \\
134 | chapter & chapter \\
135 | frame title & frametitle \\
136 | footnote & footnote \\
137 | footnote text & footnotetext[] \\
138 | graphics path & graphicspath \\
139 | {[include]} graphics & includegraphics[width=1\textbackslash textwidth] \\
140 | label & label \\
141 | new command & newcommand\{\}[] \\
142 | paragraph & paragraph \\
143 | paren cite & parencite \\
144 | part & part \\
145 | reference & ref \\
146 | renew command & renewcommand \\
147 | sub paragraph & subparagraph \\
148 | (section | heading) & section \\
149 | sub (section | heading) & subsection \\
150 | sub sub (section | heading) & subsubsection \\
151 | text cite & textcite \\
152 | {[text]} bold & textbf \\
153 | {[text]} italics & textit \\
154 | {[text]} slanted & textsl \\
155 | emphasis & emph \\
156 | title & title \\
157 | use theme & usetheme \\
158 | \hline
159 | grave [accent] & \`{a} \\
160 | acute [accent] & \'{a} \\
161 | dot [accent] & \.{a} \\
162 | breve [accent] & \u{a} \\
163 | (circumflex | hat) & \^{a} \\
164 | (umlaut | dieresis) & \"{a} \\
165 | (tilde | squiggle) & \~{a} \\
166 | (macron | bar) & \={a} \\
167 | \end{longtable}
168 | 
169 | \subsection{No arguments}
170 | For example ``\textbackslash linebreak''.
171 | 
172 | \begin{longtable}{ll}
173 | centering & centering \\
174 | column & column\{0.5\textbackslash textwidth\} \\
175 | footnote mark & footnotemark[] \\
176 | horizontal line & hline \\
177 | LaTeX & \LaTeX~  \\
178 | line break & linebreak \\
179 | item & item \\
180 | make title & maketitle \\
181 | new page & newpage \\
182 | no indent & noindent \\
183 | page break & pagebreak \\
184 | print bibliography & printbibliography \\
185 | table of contents & tableofcontents \\
186 | TeX & \TeX~  \\
187 | text backslash & textbackslash \\
188 | text height & textheight \\
189 | text width & textwidth \\
190 | vertical line & vline \\
191 | \end{longtable}
192 | 
193 | \subsection{Miscellaneous Commands}
194 | These do not necessarily have to begin with a \textbackslash.
195 | 
196 | \begin{longtable}{ll}
197 | line end & \textbackslash \textbackslash \\
198 | \end{longtable}
199 | 
200 | 
201 | 
202 | \section{Greek letters}
203 | Prefixed by ``greek''. Where relevant I have provided pronunciation tips for best results.
204 | 
205 | \begin{longtable}{llll}
206 | alpha & $\alpha$ & & \\
207 | beta & $\beta$ &  & beater \\
208 | gamma & $\gamma$ & $\Gamma$ & \\
209 | delta & $\delta$ & $\Delta$ & \\
210 | epsilon & $\varepsilon$ & & \\
211 | zeta & $\zeta$ & & \\
212 | eta & $\eta$ & & eater \\
213 | theta & $\theta$ & $\Theta$ & they-tah \\
214 | iota & $\iota$ & & \\
215 | kappa & $\kappa$ & & \\
216 | lambda & $\lambda$ & $\Lambda$ & \\
217 | mu & $\mu$ & & moo \\
218 | nu & $\nu$ & & new \\
219 | xi & $\xi$ & $\Xi$ & zee \\
220 | pi & $\pi$ & $\Pi$ & \\
221 | rho & $\rho$ & & \\
222 | sigma & $\sigma$ & $\Sigma$ & \\
223 | tau & $\tau$ & & \\
224 | upsilon & $\upsilon$ & $\Upsilon$ & \\
225 | phi & $\phi$ & $\Phi$ & \\
226 | chi & $\chi$ & & kie \\
227 | psi & $\psi$ & $\Psi$ & sigh \\
228 | omega & $\omega$ & $\Omega$ & \\
229 | \end{longtable}
230 | 
231 | \section{Mathematics}
232 | \subsection{Symbols}
233 | In normal \LaTeX~ mode, these must all be prefixed with ``symbol''. if you are dictating a large block of mathematics, then use ``enable latex maths'' to remove the need for prefixes before numbers and symbols, so that you can dictate more naturally.
234 | 
235 | \begin{longtable}{ll}
236 | in-line & \$\$ \\
237 | super [script] & $x^{a}$ \\
238 | sub [script] & $x_{a}$ \\
239 | squared & $x^{2} $ \\
240 | cubed & $x^{3} $ \\
241 | inverse & $x^{-1} $ \\
242 | degrees & $x^{\circ}$ \\
243 | (parens | parentheses) & $\left( x \right)$ \\
244 | square brackets & $\left[ x \right] $ \\
245 | (curly brackets | braces) & $\left\{ x \right\} $ \\
246 | (cardinality bars | absolute value) & $\left| x \right|$ \\
247 | floor & $\left \lfloor x \right \rfloor$ \\
248 | ceiling & $\left \lceil x \right \rceil$ \\
249 | left invisible delimiter & \textbackslash $\text{left.}$ \\
250 | right invisible delimiter & \textbackslash $\text{right.}$ \\
251 | square root & $\sqrt{a}$ \\
252 | {[generic]} root & $\sqrt[n]{a}$ \\
253 | integral & $\int$ \\
254 | double integral & $\iint$ \\
255 | triple integral & $\iiint$ \\
256 | infinity & $\infty$ \\
257 | times & $\times$ \\
258 | divide & $\div$ \\
259 | intersection & $\cap$ \\
260 | union & $\cup$ \\
261 | C dot & $\cdot$ \\
262 | summation & $\sum$ \\
263 | product & $\prod$ \\
264 | (direct sum | oh plus) & $\oplus$ \\
265 | (big direct sum | big oh plus) & $\bigoplus$ \\
266 | (direct product | oh times) & $\otimes$ \\
267 | (big direct product | big oh times) & $\bigotimes$ \\
268 | plus or minus & $\pm$ \\
269 | partial & $\partial$ \\
270 | fraction & $\frac{a}{b}$ \\
271 | % unit & $\unitone$ \\
272 | % unit two & $\unittwo$ \\
273 | % unit fraction  & $\unitfrac$ \\
274 | % text fraction & $\tfrac$ \\
275 | % display fraction & $\dfrac$ \\
276 | % continued fraction & $\cfrac$ \\
277 | % continued fraction (left) & $\cfracleft$ \\
278 | % continued fraction (right) & $\cfracright$ \\
279 | binomial & $\binom{a}{b}$ \\
280 | % text binomial & $\tbinom$ \\
281 | % display binomial & $\dbinom$ \\
282 | sine & $\sin$ \\
283 | cosine & $\cos$ \\
284 | tangent & $\tan$ \\
285 | secant & $\sec$ \\
286 | cosecant & $\csc$ \\
287 | cotangent & $\cot$ \\
288 | arc sine & $\arcsin$ \\
289 | arc cosine & $\arccos$ \\
290 | arc tan & $\arctan$ \\
291 | hyperbolic sine & $\sinh$ \\
292 | hyperbolic cosine & $\cosh$ \\
293 | hyperbolic cotangent & $\coth$ \\
294 | hyperbolic tangent & $\tanh$ \\
295 | argument & $\arg$ \\
296 | modulus & $\bmod$ \\
297 | degree & $\deg$ \\
298 | determinant & $\det$ \\
299 | dimension & $\dim$ \\
300 | exp & $\exp$ \\
301 | GCD & $\gcd$ \\
302 | cat hom & $\hom$ \\
303 | kernel & $\ker$ \\
304 | infimum & $\inf$ \\
305 | supremum & $\sup$ \\
306 | limit & $\lim$ \\
307 | liminf & $\liminf$ \\
308 | (natural (log | logarithm) | log natural) & $\ln$ \\
309 | logarithm & $\log$ \\
310 | max & $\max$ \\
311 | min & $\min$ \\
312 | probability & $\Pr$ \\
313 | {[is]} not equal [to] & $\neq$ \\
314 | {[is]} greater [than] [or] equal [to] & $\geq$ \\
315 | {[is]} less [than] [or] equal [to] & $\leq$ \\
316 | {[is]} approximately [equal] [to] & $\approx$ \\
317 | proportional [to] & $\propto$ \\
318 | preference less [than] & $\prec$ \\
319 | preference less equals & $\preceq$ \\
320 | preference greater [than] & $\succ$ \\
321 | preference greater equals & $\succeq$ \\
322 | subset & $\subset$ \\
323 | superset & $\supset$ \\
324 | strict subset & $\subsetneq$ \\
325 | strict superset & $\supsetneq$ \\
326 | member & $\in$ \\
327 | empty set & $\emptyset$ \\
328 | (land|logic and) & $\land$ \\
329 | logic or & $\lor$ \\
330 | primer & $\prime$ \\
331 | logic not & $\lnot$ \\
332 | for all & $\forall$ \\
333 | there exists & $\exists$ \\
334 | % (beebee|blackboard bold) & $\mathbb$ \\
335 | % roman & $\mathrm$ \\
336 | % bold & $\mathbf$ \\
337 | % bold symbol & $\boldsymbol$ \\
338 | % sans serif & $\mathsf$ \\
339 | % italic & $\mathit$ \\
340 | % typewriter & $\matttt$ \\
341 | % blackboard & $\mathbb$ \\
342 | % fraktur & $\mathfrak$ \\
343 | % calligraphic & $\mathcal$ \\
344 | % formal script & $\mathscr$ \\
345 | % normal text mode & $\textrm$ \\
346 | real numbers & $\mathbb{R}$ \\
347 | complex numbers & $\mathbb{C}$ \\
348 | integer numbers & $\mathbb{Z}$ \\
349 | rational numbers & $\mathbb{Q}$ \\
350 | natural numbers & $\mathbb{N}$ \\
351 | left arrow & $\leftarrow$ \\
352 | right arrow & $\rightarrow$ \\
353 | up arrow & $\uparrow$ \\
354 | down arrow & $\downarrow$ \\
355 | left right arrow & $\leftrightarrow$ \\
356 | dots & $\dots$ \\
357 | diagonal dots & $\ddots$ \\
358 | horizontal dots & $\cdots$ \\
359 | vertical dots & $\vdots$ \\
360 | low dots & $\ldots$ \\
361 | text & \textbackslash text\{\} \\
362 | sub stack & \textbackslash substack\{\} \\
363 | \end{longtable}
364 | 
365 | \subsection{Accents}
366 | Prefixed with ``accent''.
367 | 
368 | \begin{longtable}{ll}
369 | bar & $\bar{a}$ \\
370 | breve & $\breve{a}$ \\
371 | check & $\check{a}$ \\
372 | dot & $\dot{a}$ \\
373 | ddot & $\ddot{a}$ \\
374 | hat & $\hat{a}$ \\
375 | wide hat & $\widehat{a}$ \\
376 | tilde & $\tilde{a}$ \\
377 | wide tilde & $\widetilde{a}$ \\
378 | vector & $\vec{a}$ \\
379 | \end{longtable}
380 | 
381 | \section{Templates}
382 | Templates provide a way to insert larger sections of text into your documents, for example you may have a particular set of packages which you always want to import at the head of your files, or a particular diagram which you need to draw over and over again. They are defined in the templates section of config/latex.toml and by default are executed using the ``template template\_name'' command. A couple are included as standard for illustrative purposes but these are designed to be edited to suit your needs. For example, the command ``template wrap figure'' will insert:
383 | 
384 | \begin{verbatim}
385 | \begin{wrapfigure}{l}{0.5\textwidth}
386 | \centering
387 | \label{}
388 | \includegraphics[width=0.4\textwidth]{}
389 | \caption{}
390 | \end{wrapfigure}
391 | \end{verbatim}
392 | 
393 | \end{document}


--------------------------------------------------------------------------------
/mathfly/docs/source/LyX.tex:
--------------------------------------------------------------------------------
  1 | \documentclass[12pt]{article}
  2 | \usepackage{tabularx}
  3 | \usepackage{longtable}
  4 | \usepackage{amssymb}
  5 | \usepackage[T1]{fontenc}
  6 | \usepackage{geometry}
  7 | \title{Dictating mathematics into LyX using Mathfly}
  8 | \author{Mike Roberts}
  9 | \begin{document}
 10 | \maketitle
 11 | \tableofcontents
 12 | 
 13 | \section{Introduction}
 14 | \begin{itemize}
 15 | \item \textbf{All of these bindings can be easily changed by modifying mathfly/config/lyx.toml in any text editor or saying "configure LyX" while the module is enabled.}
 16 | \item (option a | option b) means that both commands will do the same thing.
 17 | \item Square brackets means that the word(s) inside are optional, the command will work with or without them.
 18 | \end{itemize}
 19 | 
 20 | \section{Basics}
 21 | \begin{tabularx}{\linewidth}{ l X}
 22 | new file & Create a new file \\
 23 | open file & Open a file \\
 24 | save as & Save as \\
 25 | math mode & Insert in-line mathematics \\
 26 | display mode & Insert equation \\
 27 | normal mode & Insert regular text \\
 28 | next tab [<n>] & Navigate to next tab n times \\
 29 | previous tab [<n>] & Navigate to previous tab n times \\
 30 | close tab [<n>] & Close the current tab n times \\
 31 | view PDF & View current document as a PDF \\
 32 | update PDF & Refresh changes \\
 33 | move line up [<n>] & Move the current line up \\
 34 | move line down [<n>] & Move the current line down \\
 35 | \hline
 36 | insert [bulleted] list & Insert a list \\
 37 | insert numbered list & Insert a numbered list \\
 38 | insert description & Insert a description \\
 39 | insert part & Create a part label \\
 40 | insert (section | heading) & Insert a heading \\
 41 | insert sub (section | heading) & Insert a subheading \\
 42 | insert sub sub (section | heading) & Insert a sub subheading \\
 43 | insert paragraph & Insert a paragraph \\
 44 | insert sub paragraph & Insert a subparagraph \\
 45 | insert title & Provide a title \\
 46 | insert author & Provide an author \\
 47 | insert date & Provide a date \\
 48 | insert abstract & Insert an abstract \\
 49 | insert address & Insert an address \\
 50 | insert bibliography & Insert a bibliography \\
 51 | insert quotation & Insert a quotation \\
 52 | insert quote & Insert a quote \\
 53 | insert verse & Insert verse \\
 54 | insert delimiters & Insert more complex bracketry \\
 55 | insert matrix & Insert a matrix (see matrix section for more options) \\
 56 | insert macro & Create a new macro \\
 57 | \end{tabularx}
 58 | 
 59 | \section{Miscellaneous}
 60 | \begin{tabularx}{\linewidth}{ l X}
 61 | math mode & Begins a new mathematical dictation environment, necessary for all maths dictation. \\
 62 | new math line & Begins a new mathematical dictation line. \\
 63 | fraction & Creates a fraction. anything highlighted will form the numerator. \\
 64 | over & Creates a fraction with the previous element as the numerator (e.g. "five over three") \\
 65 | (super script | to the power) & Superscript \\
 66 | sub script & Subscript \\
 67 | squared & Superscript 2 \\
 68 | cubed & Superscript 3 \\
 69 | inverse & Superscript -1 \\
 70 | (parens | parentheses) & Parentheses \\
 71 | square brackets & Square brackets \\
 72 | curly brackets & Curly brackets \\
 73 | absolute & Create two bars and moves inside them \\
 74 | summation & $\sum^{a}_{b}$ \\
 75 | blank summation & $\sum$ \\
 76 | (summation | sum) to N & $\sum^{n}_{?}$ \\
 77 | product & $\prod^{a}_{b}$ \\
 78 | blank product & $\prod$ \\
 79 | product to N & $\prod^{n}_{?}$ \\
 80 | limit & $\lim_{?}$ \\
 81 | blank limit & $\lim$ \\
 82 | prime & $\prime$ (prime symbol) \\
 83 | degrees & $^{\circ}$ \\
 84 | exponential & $\exp ()$ \\
 85 | expectation & $E()$ \\
 86 | variance & $Var()$ \\
 87 | label above & Add a label above the selected text \\
 88 | label below & Add a label below the selected text \\
 89 | \end{tabularx}
 90 | 
 91 | 
 92 | \section{Letters}
 93 | \subsection{Greek}
 94 | By default, all of these commands must be prefixed with "greek" for lowercase or "greek big" for uppercase. This behaviour can be changed by modifying greek\_prefix and capitals\_prefix. Where relevant I have provided pronunciation tips for best results.
 95 | 
 96 | 
 97 | \
 98 | 
 99 | \begin{longtable}{llll}
100 | alpha & $\alpha$ & & \\
101 | beta & $\beta$ &  & beater \\
102 | gamma & $\gamma$ & $\Gamma$ & \\
103 | delta & $\delta$ & $\Delta$ & \\
104 | epsilon & $\varepsilon$ & & \\
105 | zeta & $\zeta$ & & \\
106 | eta & $\eta$ & & eater \\
107 | theta & $\theta$ & $\Theta$ & they-tah \\
108 | iota & $\iota$ & & \\
109 | kappa & $\kappa$ & & \\
110 | lambda & $\lambda$ & $\Lambda$ & \\
111 | mu & $\mu$ & & moo \\
112 | nu & $\nu$ & & new \\
113 | xi & $\xi$ & $\Xi$ & zee \\
114 | pi & $\pi$ & $\Pi$ & \\
115 | rho & $\rho$ & & \\
116 | sigma & $\sigma$ & $\Sigma$ & \\
117 | tau & $\tau$ & & \\
118 | upsilon & $\upsilon$ & $\Upsilon$ & \\
119 | phi & $\phi$ & $\Phi$ & \\
120 | chi & $\chi$ & & kie \\
121 | psi & $\psi$ & $\Psi$ & sigh \\
122 | omega & $\omega$ & $\Omega$ & \\
123 | \end{longtable}
124 | 
125 | 
126 | \subsection{Accents}
127 | These commands add accents above the highlighted text, or create an empty accent if nothing is highlighted.
128 | 
129 | \
130 | 
131 | \noindent
132 | \begin{longtable}{ l l}
133 | accent hat & $\hat{a}$ \\
134 | accent tilde & $\tilde{a}$ \\
135 | accent dot & $\dot{a}$ \\
136 | accent double dot & $\ddot{a}$ \\
137 | accent bar & $\bar{a}$ \\
138 | accent vector & $\vec{a}$ \\
139 | \end{longtable}
140 | 
141 | 
142 | \section{Symbols}
143 | In order to avoid clutter and misrecognition, mathematical symbols are split up into two distinct groups: common and uncommon. By default, common symbols (e.g. integral) need no prefix, while uncommon symbols (e.g. up arrow) are prefixed with "symbol". The prefixes are defined by symbol1\_prefix and symbol2\_prefix. It is expected that you will want to move symbols which you happen to use frequently or infrequently between the two groups, or change/remove the prefixes to your liking. There is a trade-off to be made between recognition accuracy and speed of dictation.
144 | 
145 | \subsection{Common symbols}
146 | \noindent
147 | \begin{longtable}{ l l}
148 | [generic] root & $\sqrt[n]{x}$ \\
149 | square root & $\sqrt{x}$ \\
150 | integral & $\int$ \\
151 | double integral & $\int \int$ \\
152 | triple integral & $\int \int \int$ \\
153 | times & $\times$ \\
154 | divide & $\div$ \\
155 | stop & $\cdot$ \\
156 | plus or minus & $\pm$ \\
157 | partial & $\partial$ \\
158 | nice fraction & a/b \\
159 | binomial & ${a \choose b}$ \\
160 | infinity & $\infty$ \\
161 | dot dot dot & $\dots$ \\
162 | vector nabla & $\nabla$ \\
163 | %relations
164 | greater [than] [or] equal [to] & $\geq$ \\
165 | less [than] [or] equal [to] & $\leq$ \\
166 | not equal [to] & $\neq$ \\
167 | approximately [equal] [to] & $\approx$ \\
168 | proportional [to] & $\propto$ \\
169 | preference less [than] & $\prec$ \\
170 | preference less equal & $\preceq$ \\
171 | preference greater [than] & $\succ$ \\
172 | preference greater equal & $\succeq$ \\
173 | % trig
174 | sine & $\sin$ \\
175 | cosine & $\cos$ \\
176 | tangent & $\tan$ \\
177 | secant & $\sec$ \\
178 | cosecant & $\csc$ \\
179 | cotangent & $\cot$ \\
180 | arc sine & $\arcsin$ \\
181 | arc cosine & $\arccos$ \\
182 | arc tan & $\arctan$ \\
183 | hyperbolic sine & $\sinh$ \\
184 | hyperbolic cosine & $\cosh$ \\
185 | hyperbolic tangent & $\tanh$ \\
186 | hyperbolic cotangent & $\coth$ \\
187 | % text
188 | degree & $\deg$ \\
189 | determinant & $\det$ \\
190 | dimension & $\dim$ \\
191 | (natural (log | logarithm) | log natural) & $\ln$ \\
192 | logarithm & $\log$ \\
193 | argument & $\arg$ \\
194 | maximum & $\max$ \\
195 | minimum & $\min$ \\
196 | (modulo | modulus) & $\bmod$ \\
197 | supremum & $\sup$ \\
198 | infimum & $\inf$ \\
199 | probability & $\Pr$ \\
200 | %sets
201 | there exists & $\exists$ \\
202 | member [of] & $\in$ \\
203 | for all & $\forall$ \\
204 | empty set & $\emptyset$ \\
205 | subset & $\subset$ \\
206 | superset & $\supset$ \\
207 | strict subset & $\subsetneq$ \\
208 | strict superset & $\supsetneq$ \\
209 | intersection & $\cap$ \\
210 | union & $\cup$ \\
211 | real numbers & $\mathbb{R}$ \\
212 | complex numbers & $\mathbb{C}$ \\
213 | integer numbers & $\mathbb{Z}$ \\
214 | rational numbers & $\mathbb{Q}$ \\
215 | natural numbers & $\mathbb{N}$ \\
216 | logic and & $\land$ \\
217 | logic or & $\lor$ \\
218 | logic not & $\lnot$ \\
219 | left arrow & $\leftarrow$ \\
220 | right arrow & $\rightarrow$ \\
221 | up arrow & $\uparrow$ \\
222 | down arrow & $\downarrow$ \\
223 | left right arrow & $\leftrightarrow$ \\
224 | maps to & $\mapsto$ \\
225 | oh plus & $\oplus$ \\
226 | oh times & $\otimes$ \\
227 | big oh plus & $\bigoplus$ \\
228 | big oh times & $\bigotimes$ \\
229 | diagonal dots & $\ddots$ \\
230 | horizontal dots & $\cdots$ \\
231 | vertical dots & $\vdots$ \\
232 | \end{longtable}
233 | 
234 | \subsection{Less common symbols}
235 | Prefix with "symbol"
236 | 
237 | \begin{longtable}{ll}
238 | GCD & $\gcd$ \\
239 | cat hom & $\hom$ \\
240 | kernel & $\ker$ \\
241 | % unit & $\unitone$ \\
242 | % unit two & $\unittwo$ \\
243 | % unit fraction  & $\unitfrac$ \\
244 | % text fraction & $\tfrac$ \\
245 | % display fraction & $\dfrac$ \\
246 | % continued fraction & $\cfrac$ \\
247 | % continued fraction (left) & $\cfracleft$ \\
248 | % continued fraction (right) & $\cfracright$ \\
249 | % text binomial & $\tbinom$ \\
250 | % display binomial & $\dbinom$ \\
251 | % strict subset & $\subsetneq$ \\
252 | % strict superset & $\supsetneq$ \\
253 | \end{longtable}
254 | 
255 | \section{Text modes}
256 | These commands allow you to insert various forms of regular text into a mathematical environment. They should all be prefixed with "text".
257 | 
258 | \
259 | 
260 | \begin{longtable}{ l l}
261 | (beebee|blackboard bold | blackboard) & $\mathbb{R N Z}$ \\
262 | roman & $\mathrm{Sample text}$ \\
263 | bold & $\mathbf{Sample text}$ \\
264 | sans serif & $\mathsf{Sample text}$ \\
265 | italic & $\mathit{Sample text}$ \\
266 | typewriter & $\mathtt{Sample text}$ \\
267 | \end{longtable}
268 | 
269 | \section{Fractions}
270 | There are a few ways of easily inserting fractions:
271 | 
272 | \begin{itemize}
273 | \item Use the "fraction" command, and navigate through it using directions.
274 | \item Use the "over" command, which will build a fraction with the previous element as the numerator. e.g. "x-ray squared over five".
275 | \item For denominators up to 10, use their natural names, providing a number for the numerator, e.g. "five thirds".
276 | \end{itemize}
277 | 
278 | \section{Nested commands}
279 | There are a few commands within Mathfly which allow for commands to be inserted within them. These are just examples, you can include any commands you want:
280 | \begin{itemize}
281 | \item ``Integral from minus infinity to infinity'' - integral symbol with superscript and subscript.
282 | \item ``Definite from zero to ten'' - definite integral square brackets with subscript and superscript afterwards.
283 | \item ``Differential x-ray squared by squared yankee'' - creates a differential friction.
284 | \item ``Sum from india equals one to november'' - creates a summation.
285 | \item ``Limit from november to infinity'' - create a limit.
286 | \item ``argument that maximises greek beta'' - argmax.
287 | \item ``minimum by greek beta'' - min.
288 | \item ``sub india'' - quick sub/superscripts
289 | \end{itemize}
290 | 
291 | \section{Matrices}
292 | \begin{itemize}
293 | \item To insert a matrix of a particular size, use the matrix command, e.g. "matrix three by one".
294 | \item To add or remove columns and rows, Use the command "add/remove matrix column/row".
295 | \item Matrices can be encased in brackets as expected, E.g. "parens matrix three by three".
296 | \end{itemize}
297 | 
298 | \section{Environments}
299 | These commands provide more detailed control over equation positioning and alignment.
300 | 
301 | \begin{tabularx}{\linewidth}{ l X}
302 | insert (in line formula | in line) & In-line formula - same as "math mode" \\
303 | insert numbered formula & Numbered formula \\
304 | insert (display formula | display) & Same as "display mode" \\
305 | insert (equation array environment | equation array) & Insert equation array - use the "check" (ctrl-enter) command to start a new line \\
306 | insert (AMS align environment | AMS align) & Insert an aligned equation \\
307 | insert AMS align at [environment] &  \\
308 | insert AMS flalign [environment] &  \\
309 | insert (AMS gathered environment | AMS gather) &  \\
310 | insert (AMS multline [environment]| multiline) &  \\
311 | insert array [environment] &  \\
312 | insert (cases [environment] | piecewise) &  \\
313 | insert (aligned [environment] | align) &  \\
314 | insert aligned at [environment] &  \\
315 | insert gathered [environment] &  \\
316 | insert split [environment] &  \\
317 | \end{tabularx}
318 | 
319 | 
320 | \end{document}


--------------------------------------------------------------------------------
/mathfly/docs/source/Scientific_Notebook.tex:
--------------------------------------------------------------------------------
  1 | \documentclass[12pt]{article}
  2 | \usepackage{tabularx}
  3 | \usepackage{longtable}
  4 | \usepackage{amssymb}
  5 | \usepackage[T1]{fontenc}
  6 | \title{Dictating mathematics into Scientific notebook using Mathfly}
  7 | \author{Mike Roberts}
  8 | \begin{document}
  9 | \maketitle
 10 | \tableofcontents
 11 | 
 12 | \section{Introduction}
 13 | \begin{itemize}
 14 | \item All of these bindings can be easily changed by modifying modifying mathfly/config/scientific\_notebook.toml in any text editor or saying "configure Scientific Notebook" while the module is enabled.
 15 | \item (option a | option b) means that both commands will do the same thing.
 16 | \item Square brackets means that the word(s) inside are optional, the command will work with or without them.
 17 | \end{itemize}
 18 | 
 19 | \section{Basics}
 20 | \begin{tabularx}{\linewidth}{ l X}
 21 | new file & Create a new file \\
 22 | open file & Open a file \\
 23 | save file & Save a file \\
 24 | save as & Save as \\
 25 | print file & Print current document \\
 26 | export document & Export current document as .rtf \\
 27 | page preview & View a preview of the current document \\
 28 | toggle math & Inline mathematics \\
 29 | body math & Block mathematics \\
 30 | toggle text & Inline text \\
 31 | body text & Block text \\
 32 | evaluate & Evaluate expression \\
 33 | begin [bulleted] list & Begin a bulleted list \\
 34 | begin numbered list & Begin a numbered list \\
 35 | end list & End the current list \\
 36 | insert normal text & normal text \\
 37 | insert big text & \large{large text} \\
 38 | insert small text & \small{small text} \\
 39 | insert bold text & \textbf{bold text} \\
 40 | insert italic text & \textit{bold text} \\
 41 | insert bold symbols & $\mathbf{bold symbols}$ \\
 42 | insert centred text & Insert centred text \\
 43 | insert left text & Insert left justified text \\
 44 | insert right text & Insert right justified text \\
 45 | insert quotation & Insert a quotation \\
 46 | insert heading [one] & Large heading \\
 47 | insert heading two & Smaller heading \\
 48 | insert heading three & Smaller heading \\
 49 | insert heading four & Smaller heading \\
 50 | insert heading five & Smaller heading \\
 51 | \end{tabularx}
 52 | 
 53 | \section{Miscellaneous}
 54 | \begin{tabularx}{\linewidth}{ l X}
 55 | fraction & Creates a fraction. anything highlighted will form the numerator. \\
 56 | over & Creates a fraction with the previous element as the numerator (e.g. "five over three") \\
 57 | (super script | to the power) & Superscript \\
 58 | sub script & Subscript \\
 59 | squared & Superscript 2 \\
 60 | cubed & Superscript 3 \\
 61 | inverse & Superscript -1 \\
 62 | (parens | parentheses) & Parentheses \\
 63 | square brackets & Square brackets \\
 64 | curly brackets & Curly brackets \\
 65 | absolute & Create two bars and moves inside them \\
 66 | degrees & Insert a degree symbol \\
 67 | summation & $\sum$ \\
 68 | % blank summation & $\sum$ \\
 69 | % (summation | sum) to N & $\sum^{n}_{?}$ \\
 70 | product & $\prod$ \\
 71 | % blank product & $\prod$ \\
 72 | % product to N & $\sum^{n}_{?}$ \\
 73 | limit & $\lim$ \\
 74 | % blank limit & $\lim$ \\
 75 | label above & Add a label above the selected text \\
 76 | label below & Add a label below the selected text \\
 77 | \end{tabularx}
 78 | 
 79 | 
 80 | \section{Letters}
 81 | \subsection{Greek}
 82 | By default, all of these commands must be prefixed with "greek" for lowercase or "greek big" for uppercase. This behaviour can be changed by modifying greek\_prefix and capitals\_prefix. Where relevant I have provided pronunciation tips for best results.
 83 | 
 84 | \
 85 | 
 86 | 
 87 | \begin{longtable}{llll}
 88 | alpha & $\alpha$ & & \\
 89 | beta & $\beta$ &  & beater \\
 90 | gamma & $\gamma$ & $\Gamma$ & \\
 91 | delta & $\delta$ & $\Delta$ & \\
 92 | epsilon & $\varepsilon$ & & \\
 93 | zeta & $\zeta$ & & \\
 94 | eta & $\eta$ & & eater \\
 95 | theta & $\theta$ & $\Theta$ & they-tah \\
 96 | iota & $\iota$ & & \\
 97 | kappa & $\kappa$ & & \\
 98 | lambda & $\lambda$ & $\Lambda$ & \\
 99 | mu & $\mu$ & & moo \\
100 | nu & $\nu$ & & new \\
101 | xi & $\xi$ & $\Xi$ & zee \\
102 | pi & $\pi$ & $\Pi$ & \\
103 | rho & $\rho$ & & \\
104 | sigma & $\sigma$ & $\Sigma$ & \\
105 | tau & $\tau$ & & \\
106 | upsilon & $\upsilon$ & $\Upsilon$ & \\
107 | phi & $\phi$ & $\Phi$ & \\
108 | chi & $\chi$ & & kie \\
109 | psi & $\psi$ & $\Psi$ & sigh \\
110 | omega & $\omega$ & $\Omega$ & \\
111 | \end{longtable}
112 | 
113 | 
114 | \subsection{Accents}
115 | These commands add accents above the highlighted text, or create an empty accent if nothing is highlighted.
116 | 
117 | \
118 | 
119 | \begin{longtable}{ l l}
120 | accent hat & $\hat{a}$ \\
121 | accent tilde & $\tilde{a}$ \\
122 | accent dot & $\dot{a}$ \\
123 | accent double dot & $\ddot{a}$ \\
124 | accent bar & $\bar{a}$ \\
125 | accent arrow & $\vec{a}$ \\
126 | \end{longtable}
127 | 
128 | 
129 | \section{Symbols}
130 | 
131 | \begin{longtable}{ l l}
132 | [square] root & $\sqrt[n]{x}$ \\
133 | integral & $\int$ \\
134 | double integral & $\int \int$ \\
135 | triple integral & $\int \int \int$ \\
136 | times & $\times$ \\
137 | divide & $\div$ \\
138 | C dot & $\cdot$ \\
139 | plus or minus & $\pm$ \\
140 | partial & $\partial$ \\
141 | infinity & $\infty$ \\
142 | dot dot dot & $\dots$ \\
143 | nabla & $\nabla$ \\
144 | %relations
145 | greater [than] [or] equal [to] & $\geq$ \\
146 | less [than] [or] equal [to] & $\leq$ \\
147 | not equal [to] & $\neq$ \\
148 | approximately [equal] [to] & $\approx$ \\
149 | proportional [to] & $\propto$ \\
150 | preference less [than] & $\prec$ \\
151 | preference less equal & $\preceq$ \\
152 | preference greater [than] & $\succ$ \\
153 | preference greater equal & $\succeq$ \\
154 | % trig
155 | sine & $\sin$ \\
156 | cosine & $\cos$ \\
157 | tangent & $\tan$ \\
158 | secant & $\sec$ \\
159 | cosecant & $\csc$ \\
160 | cotangent & $\cot$ \\
161 | arc sine & $\arcsin$ \\
162 | arc cosine & $\arccos$ \\
163 | arc tan & $\arctan$ \\
164 | hyperbolic sine & $\sinh$ \\
165 | hyperbolic cosine & $\cosh$ \\
166 | hyperbolic tangent & $\tanh$ \\
167 | hyperbolic cotangent & $\coth$ \\
168 | % text
169 | degree & $\deg$ \\
170 | determinant & $\det$ \\
171 | dimension & $\dim$ \\
172 | exponential & $\exp$ \\
173 | (natural (log | logarithm) | log natural) & $\ln$ \\
174 | logarithm & $\log$ \\
175 | argument & $\arg$ \\
176 | maximum & $\max$ \\
177 | minimum & $\min$ \\
178 | (modulo | modulus) & $\bmod$ \\
179 | supremum & $\sup$ \\
180 | infimum & $\inf$ \\
181 | probability & $\Pr$ \\
182 | there exists & $\exists$ \\
183 | member [of] & $\in$ \\
184 | % real numbers & $\mathbb{R}$ \\
185 | % complex numbers & $\mathbb{C}$ \\
186 | % integer numbers & $\mathbb{Z}$ \\
187 | % rational numbers & $\mathbb{Q}$ \\
188 | % natural numbers & $\mathbb{N}$ \\
189 | for all & $\forall$ \\
190 | subset & $\subset$ \\
191 | superset & $\supset$ \\
192 | strict subset & $\subsetneq$ \\
193 | strict superset & $\supsetneq$ \\
194 | intersection & $\cap$ \\
195 | union & $\cup$ \\
196 | logic and & $\land$ \\
197 | logic or & $\lor$ \\
198 | logic not & $\lnot$ \\
199 | left arrow & $\leftarrow$ \\
200 | right arrow & $\rightarrow$ \\
201 | up arrow & $\uparrow$ \\
202 | down arrow & $\downarrow$ \\
203 | left right arrow & $\leftrightarrow$ \\
204 | maps to & $\mapsto$ \\
205 | oh plus & $\oplus$ \\
206 | oh times & $\otimes$ \\
207 | big oh plus & $\bigoplus$ \\
208 | big oh times & $\bigotimes$ \\
209 | diagonal dots & $\ddots$ \\
210 | horizontal dots & $\cdots$ \\
211 | vertical dots & $\vdots$ \\
212 | \end{longtable}
213 | 
214 | 
215 | \section{Fractions}
216 | There are a few ways of easily inserting fractions:
217 | 
218 | \begin{itemize}
219 | \item Use the "fraction" command, and navigate through it using directions.
220 | \item Use the "over" command, which will build a fraction with the previous element as the numerator. e.g. "x-ray squared over five".
221 | \item For denominators up to 10, use their natural names, providing a number for the numerator, e.g. "five thirds".
222 | \end{itemize}
223 | 
224 | \section{Nested commands}
225 | There are a few commands within Mathfly which allow for commands to be inserted within them. These are just examples, you can include any commands you want:
226 | \begin{itemize}
227 | \item ``Integral from minus infinity to infinity'' - integral symbol with superscript and subscript.
228 | \item ``Definite from zero to ten'' - definite integral square brackets with subscript and superscript afterwards.
229 | \item ``Differential x-ray squared by squared yankee'' - creates a differential friction.
230 | \item ``Sum from india equals one to november'' - creates a summation.
231 | \item ``Limit from november to infinity'' - create a limit.
232 | \item ``argument that maximises greek beta'' - argmax.
233 | \item ``minimum by greek beta'' - min.
234 | \item ``sub india'' - quick sub/superscripts.
235 | \end{itemize}
236 | 
237 | 
238 | \section{Matrices}
239 | \begin{itemize}
240 | \item To insert a matrix of a particular size, use the matrix command, e.g. "matrix three by one".
241 | \item To add or remove columns and rows, Use the command "add/remove matrix column/row".
242 | \item Matrices can be encased in brackets as expected, E.g. "parens matrix three by three".
243 | \end{itemize}
244 | 
245 | \section{Units}
246 | These commands insert common scientific units. By default, all of them must be prefixed with "unit", so for example "unit cubic feet" produces ft$^{3}$.
247 | \begin{itemize}
248 | \item \textbf{Activity}--- ~
249 | Becquerels,
250 | Curies
251 | 
252 | \item \textbf{Amount}--- ~
253 | Attomoles,
254 | Examoles,
255 | Femtomoles,
256 | Gigamoles,
257 | Kilomoles,
258 | Megamoles,
259 | Micromoles,
260 | Millimoles,
261 | Moles,
262 | Nanomoles,
263 | Petamoles,
264 | Picomoles,
265 | Teramoles
266 | 
267 | \item \textbf{Area}--- ~
268 | Acres,
269 | Hectares,
270 | Square feet,
271 | Square inches,
272 | Square metres
273 | 
274 | \item \textbf{Current}--- ~
275 | Amperes,
276 | Kiloamperes,
277 | Microamperes,
278 | Milliamperes,
279 | Nanoamperes
280 | 
281 | \item \textbf{Capacitance}--- ~
282 | Farads,
283 | Microfarads,
284 | Millifarads,
285 | Nanofarads,
286 | Picofarads
287 | 
288 | \item \textbf{Charge}--- ~
289 | Coulombs
290 | 
291 | \item \textbf{Conductance}--- ~
292 | Kilosiemens,
293 | Microsiemens,
294 | Millisiemens,
295 | Siemens
296 | 
297 | \item \textbf{Potential difference}--- ~
298 | Kilovolts,
299 | Megavolts,
300 | Microvolts,
301 | Millivolts,
302 | Nanovolts,
303 | Picovolts,
304 | Volts
305 | 
306 | \item \textbf{Resistance}--- ~
307 | Gigaohms,
308 | Kiloohms,
309 | Megaohms,
310 | Milliohms,
311 | Ohms
312 | 
313 | \item \textbf{Energy}--- ~
314 | British thermal unit,
315 | Calories,
316 | Electron volts,
317 | Ergs,
318 | Gigaelectronvolts,
319 | Gigajoules,
320 | Joules,
321 | Kilocalories,
322 | Kilojoules,
323 | Megaelectronvolts,
324 | Megajoules,
325 | Microjoules,
326 | Millijoules,
327 | Nanojoules
328 | 
329 | \item \textbf{Force}--- ~
330 | Dynes,
331 | Kilonewtons,
332 | Meganewtons,
333 | Micronewtons,
334 | Millinewtons,
335 | Newtons,
336 | Ounce force,
337 | Pound force
338 | 
339 | \item \textbf{Frequency}--- ~
340 | Exahertz,
341 | Gigahertz,
342 | Hertz,
343 | Kilohertz,
344 | Megahertz,
345 | Petahertz,
346 | Terahertz
347 | 
348 | \item \textbf{Illuminance}--- ~
349 | Footcandle,
350 | Lux,
351 | Phot
352 | 
353 | \item \textbf{Length}--- ~
354 | Angstrom,
355 | Attometers,
356 | Centimeters,
357 | Decimeters,
358 | Femtometers,
359 | Feet,
360 | Inches,
361 | Kilometers,
362 | Meters,
363 | Micrometers,
364 | Miles,
365 | Millimeters,
366 | Nanometers,
367 | Picometers
368 | 
369 | \item \textbf{Luminance}--- ~
370 | Candela,
371 | Lumens
372 | 
373 | \item \textbf{Magnetic flux}--- ~
374 | Maxwells,
375 | Microwebers,
376 | Milliwebers,
377 | Nanowebers,
378 | Webers
379 | 
380 | \item \textbf{Magnetic flux density}--- ~
381 | Gauss,
382 | Microteslas,
383 | Milliteslas,
384 | Nanoteslas,
385 | Picoteslas,
386 | Teslas,
387 | Henries,
388 | microhenries,
389 | millihenries
390 | 
391 | \item \textbf{Mass}--- ~
392 | Atomic mass units,
393 | Centigrams,
394 | Decigrams,
395 | Grams,
396 | Kilograms,
397 | Micrograms,
398 | Milligrams,
399 | Pounds,
400 | Slug
401 | 
402 | \item \textbf{Angle}--- ~
403 | degrees,
404 | Microradians,
405 | Milliradians,
406 | Minutes of angle,
407 | Seconds of angle,
408 | Radians,
409 | Steradian
410 | 
411 | \item \textbf{Power}--- ~
412 | Gigawatts,
413 | Horsepowers,
414 | Kilowatts,
415 | Megawatts,
416 | Microwatts,
417 | Milliwatts,
418 | Nanowatts,
419 | Watts
420 | 
421 | \item \textbf{Pressure}--- ~
422 | Atmospheres,
423 | Bar,
424 | Kilobar,
425 | Kilopascals,
426 | Megapascals,
427 | Micropascals,
428 | Millibar,
429 | Millimeters of Mercury,
430 | Pascals,
431 | Torrs
432 | 
433 | \item \textbf{Temperature}--- ~
434 | Celsiuss,
435 | Fahrenheits,
436 | Kelvins
437 | 
438 | \item \textbf{Time}--- ~
439 | Attoseconds,
440 | Days,
441 | Femtoseconds,
442 | Hours,
443 | Microseconds,
444 | Milliseconds,
445 | Minutes,
446 | Nanoseconds,
447 | Picoseconds,
448 | Seconds,
449 | Years
450 | 
451 | \item \textbf{Volume}--- ~
452 | Cubic feet,
453 | Cubic inches,
454 | Cubic metres,
455 | Gallons,
456 | Liters,
457 | Milliliters,
458 | Pints,
459 | Quarts
460 | \end{itemize}
461 | \end{document}


--------------------------------------------------------------------------------
/mathfly/imports.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | from mathfly.imports import *
 3 | '''
 4 | 
 5 | from dragonfly import Dictation, MappingRule, Choice, Function, ContextAction, Repetition, Compound
 6 | from dragonfly import Repeat, Playback, Mimic, Window, Clipboard, IntegerRef, ShortIntegerRef
 7 | 
 8 | from mathfly.lib.actions import Text, Key, Mouse, AppContext
 9 | from mathfly.lib.integers import IntegerRefMF
10 | 
11 | from mathfly.lib import control, utilities, execution, navigation
12 | from mathfly.lib.latex import tex_funcs
13 | from mathfly.lib.execution import Alternating
14 | 
15 | from mathfly.lib.merge.mergerule import MergeRule
16 | from mathfly.lib.merge.nestedrule import NestedRule
17 | from mathfly.lib.merge.selfmodrule import SelfModifyingRule
18 | 
19 | import re, os, datetime, sys
20 | from subprocess import Popen


--------------------------------------------------------------------------------
/mathfly/lib/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/lib/__init__.py


--------------------------------------------------------------------------------
/mathfly/lib/actions.py:
--------------------------------------------------------------------------------
 1 | from dragonfly import Key, Mouse, AppContext
 2 | from dragonfly import Text as TextBase
 3 | 
 4 | class Text(TextBase):
 5 |     _pause_default = 0.003
 6 |     def __init__(self, spec=None, static=False, pause=_pause_default, autofmt=False, use_hardware=False):
 7 |         TextBase.__init__(self, spec=spec, static=static, pause=pause, autofmt=autofmt, use_hardware=use_hardware)
 8 | 
 9 | 
10 | from mathfly.lib import utilities
11 | SETTINGS = utilities.load_toml_relative("config/settings.toml")
12 | # Override imported dragonfly actions with aenea's if the 'use_aenea' setting is set to true.
13 | if "use_aenea" in SETTINGS and SETTINGS["use_aenea"]:
14 |     try:
15 |         from aenea import Key, Text, Mouse
16 |         from aenea import ProxyAppContext as AppContext
17 |     except ImportError:
18 |         print("Unable to import aenea actions. Dragonfly actions will be used "
19 |               "instead.")
20 | 


--------------------------------------------------------------------------------
/mathfly/lib/control.py:
--------------------------------------------------------------------------------
 1 | from ctrl.nexus import Nexus
 2 | 
 3 | MF_NEXUS = None
 4 | 
 5 | 
 6 | def nexus():
 7 |     global MF_NEXUS
 8 |     if MF_NEXUS is None:
 9 |         MF_NEXUS = Nexus()
10 |     return MF_NEXUS
11 | 


--------------------------------------------------------------------------------
/mathfly/lib/ctrl/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/lib/ctrl/__init__.py


--------------------------------------------------------------------------------
/mathfly/lib/ctrl/nexus.py:
--------------------------------------------------------------------------------
 1 | from dragonfly import Grammar, Choice
 2 | from dragonfly.grammar.recobs import RecognitionHistory
 3 | 
 4 | from mathfly.lib import utilities
 5 | from mathfly.lib.merge.ccrmerger import CCRMerger
 6 | from mathfly.lib.merge.mergepair import MergeInf
 7 | import sys
 8 | import natlink
 9 | 
10 | class Nexus:
11 |     def __init__(self, real_merger_config=True):
12 |         self.clip = {}
13 |         self.reload_settings()
14 |         self.preserved = None
15 |         self.merger = CCRMerger(real_merger_config)
16 | 
17 | 
18 |     def reload_settings(self):
19 |         self.settings = utilities.load_toml_relative("config/settings.toml")
20 | 
21 |     def delete_words(self, words):
22 |         for word in words:
23 |             try:
24 |                 natlink.deleteWord(word)
25 |             except:
26 |                 pass
27 | 
28 |     def add_words(self, words):
29 |         for word in words:
30 |             try:
31 |                 natlink.addWord(word)
32 |             except:
33 |                 pass
34 | 
35 |     def load_app_rules(self, apps):
36 |         apploaded = []
37 |         for module_name in apps:
38 |             try:
39 |                 lib = __import__("mathfly.apps." + module_name)
40 |                 apploaded.append(module_name)
41 |             except Exception as e:
42 |                 print("Ignoring rule '{}'. Failed to load with: ".format(module_name))
43 |                 print(e)
44 |         if apploaded:
45 |             print("App modules loaded: " + ", ".join(apploaded))
46 | 
47 |     def load_ccr_rules(self, rules):
48 |         ccrloaded = []
49 |         ccrrebuilt = []
50 |         for module_name in rules:
51 |             if "mathfly.ccr." + module_name in sys.modules:
52 |                 try:
53 |                     want_reload_module = sys.modules["mathfly.ccr." + module_name]
54 |                     reload(want_reload_module)
55 |                     ccrrebuilt.append(module_name)
56 |                 except Exception as e:
57 |                     print(e)
58 |             else:
59 |                 try:
60 |                     lib = __import__("mathfly.ccr." + module_name)
61 |                     ccrloaded.append(module_name)
62 |                 except Exception as e:
63 |                     print("Ignoring rule '{}'. Failed to load with: ".format(module_name))
64 |                     print(e)
65 |         if ccrloaded:
66 |             print("CCR modules loaded: " + ", ".join(ccrloaded))
67 |         if ccrrebuilt:
68 |             print("CCR modules rebuilt: " + ", ".join(ccrrebuilt))
69 | 
70 |     def build(self, startup=False):
71 |         self.reload_settings()
72 |         self.delete_words(self.settings["delete_words"])
73 |         self.add_words(self.settings["add_words"])
74 |         self.merger.wipe()
75 |         self.merger._global_rules = {}
76 |         self.merger._app_rules = {}
77 |         self.merger._self_modifying_rules = {}
78 |         if startup:
79 |             self.load_app_rules(self.settings["app_modules"])
80 |         self.load_ccr_rules(self.settings["ccr_modules"])
81 |         self.merger.update_config()
82 |         self.merger.merge(MergeInf.BOOT)
83 |         if startup:
84 |             print("*- Starting Mathfly -*")
85 |             print("Say \"enable <module name>\" to begin, or \n\"configure <module name>\" to make changes.")
86 |         print("Modules available:")
87 |         self.merger.display_rules()
88 | 
89 |     def generate_ccr_choices(self, ref):
90 |         return Choice(ref, {rule: rule for rule in self.merger.global_rule_names()})
91 | 
92 |     def rule_changer(self, enable, name):
93 |         CORE = utilities.load_toml_relative("config/core.toml")
94 | 
95 |         self.merger.global_rule_changer(name=name, enable=enable, save=True)
96 |         if name == CORE["pronunciation"]:
97 |             self.merger.selfmod_rule_changer(name2="alias", enable=enable, save=True)
98 | 


--------------------------------------------------------------------------------
/mathfly/lib/execution.py:
--------------------------------------------------------------------------------
 1 | from dragonfly import ActionBase
 2 | from mathfly.lib.actions import Text, Key, Mouse, AppContext
 3 | from mathfly.lib import utilities
 4 | 
 5 | class Alternating(ActionBase):
 6 |     def __init__(self, command=""):
 7 |         ActionBase.__init__(self)
 8 |         self.command = command
 9 | 
10 |     def _execute(self, data=None):
11 |         command = data[self.command]
12 |         if type(command) in [str, int, unicode]:
13 |             Text(str(command)).execute()
14 |         elif type(command) in [list, tuple]:
15 |             for i in range(len(command)):
16 |                 if i%2==0:
17 |                     Text(command[i]).execute()
18 |                 else:
19 |                     Key(command[i]).execute()
20 | 
21 | def template(template):
22 | 	utilities.paste_string(template)
23 | 
24 | def paren_function(name, dl1="(", dl2=")"):
25 | 	e, text = utilities.read_selected(False)
26 | 	Text(name + dl1).execute()
27 | 	if text:
28 | 		utilities.paste_string(text)
29 | 		Text(dl2).execute()
30 | 	else:
31 | 		Text(dl2).execute()
32 | 		Key("left:" + str(len(dl2))).execute()


--------------------------------------------------------------------------------
/mathfly/lib/integers.py:
--------------------------------------------------------------------------------
 1 | from dragonfly.language.base.integer_internal import MapIntBuilder, MagnitudeIntBuilder, IntegerContentBase, CollectionIntBuilder
 2 | from dragonfly.language.base.integer import Integer
 3 | from dragonfly.grammar.elements_basic import RuleWrap
 4 | 
 5 | 
 6 | 
 7 | 
 8 | 
 9 | int_0           = MapIntBuilder({
10 |                                  "zero":       0,
11 |                                })
12 | int_1_9         = MapIntBuilder({
13 |                                  "one":        1,
14 |                                  "two":        2,
15 |                                  "three":      3,
16 |                                  "four":       4,
17 |                                  "five":       5,
18 |                                  "six":        6,
19 |                                  "seven":      7,
20 |                                  "eight":      8,
21 |                                  "nine":       9,
22 |                                })
23 | int_10_19       = MapIntBuilder({
24 |                                  "ten":       10,
25 |                                  "eleven":    11,
26 |                                  "twelve":    12,
27 |                                  "thirteen":  13,
28 |                                  "fourteen":  14,
29 |                                  "fifteen":   15,
30 |                                  "sixteen":   16,
31 |                                  "seventeen": 17,
32 |                                  "eighteen":  18,
33 |                                  "nineteen":  19,
34 |                                })
35 | int_20_90_10    = MapIntBuilder({
36 |                                  "twenty":     2,
37 |                                  "thirty":     3,
38 |                                  "forty":      4,
39 |                                  "fifty":      5,
40 |                                  "sixty":      6,
41 |                                  "seventy":    7,
42 |                                  "eighty":     8,
43 |                                  "ninety":     9,
44 |                                })
45 | int_20_99       = MagnitudeIntBuilder(
46 |                    factor      = 10,
47 |                    spec        = "<multiplier> [<remainder>]",
48 |                    multipliers = [int_20_90_10],
49 |                    remainders  = [int_1_9],
50 |                   )
51 | int_and_1_99    = CollectionIntBuilder(
52 |                    spec        = "[and] <element>",
53 |                    set         = [int_1_9, int_10_19, int_20_99],
54 |                   )
55 | int_100s        = MagnitudeIntBuilder(
56 |                    factor      = 100,
57 |                    spec        = "<multiplier> hundred [<remainder>]",
58 |                    multipliers = [int_1_9],
59 |                    remainders  = [int_and_1_99],
60 |                   )
61 | int_100big      = MagnitudeIntBuilder(
62 |                    factor      = 100,
63 |                    spec        = "<multiplier> hundred [<remainder>]",
64 |                    multipliers = [int_10_19, int_20_99],
65 |                    remainders  = [int_and_1_99]
66 |                   )
67 | int_1000s       = MagnitudeIntBuilder(
68 |                    factor      = 1000,
69 |                    spec        = "<multiplier> thousand [<remainder>]",
70 |                    multipliers = [int_1_9, int_10_19, int_20_99, int_100s],
71 |                    remainders  = [int_and_1_99, int_100s]
72 |                   )
73 | int_1000000s    = MagnitudeIntBuilder(
74 |                    factor      = 1000000,
75 |                    spec        = "<multiplier> million [<remainder>]",
76 |                    multipliers = [int_1_9, int_10_19, int_20_99, int_100s, int_1000s],
77 |                    remainders  = [int_and_1_99, int_100s, int_1000s],
78 |                   )
79 | 
80 | 
81 | #---------------------------------------------------------------------------
82 | 
83 | class IntegerContent(IntegerContentBase):
84 |     builders = [int_0, int_1_9, int_10_19, int_20_99,
85 |                 int_100s, int_100big, int_1000s, int_1000000s]
86 | 
87 | 
88 | #---------------------------------------------------------------------------
89 | # Integer reference class.
90 | 
91 | class IntegerRefMF(RuleWrap):
92 |     def __init__(self, name, min, max, default=None):
93 |         element = Integer(None, min, max, content=IntegerContent)
94 |         RuleWrap.__init__(self, name, element, default=default)
95 | 


--------------------------------------------------------------------------------
/mathfly/lib/latex/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/lib/latex/__init__.py


--------------------------------------------------------------------------------
/mathfly/lib/latex/bibtexer.py:
--------------------------------------------------------------------------------
 1 | from dragonfly import Clipboard, Key
 2 | from urllib2 import Request, urlopen, quote
 3 | from bs4 import BeautifulSoup
 4 | 
 5 | import re
 6 | import os
 7 | import subprocess
 8 | import datetime
 9 | 
10 | def get_tag(ref):
11 |     query = re.compile(r'@.*{(.*),')
12 |     tag = re.search(query, ref)
13 |     if tag:
14 |         return tag.group(1)
15 |     else:
16 |         return "No tag found"
17 | 
18 | # takes URL, returns beautiful soup
19 | def request_page(url):
20 |     header = {'User-Agent': 'Mozilla/5.0', "Cookie":"GSP=CF=4"}
21 |     request = Request(url, headers=header)
22 |     response = urlopen(request)
23 |     html = response.read()
24 |     htmlsoup = BeautifulSoup(html, features="lxml")
25 |     return htmlsoup
26 | 
27 | def google_scholar_query(searchstr):
28 |     searchstr = '/scholar?q=' + quote(searchstr)
29 |     url = "https://scholar.google.com" + searchstr
30 |     htmlsoup = request_page(url)
31 |     links_list = []
32 |     refre = re.compile(r'https://scholar.googleusercontent.com(/scholar\.bib\?[^"]*)')
33 |     for link in htmlsoup.find_all("a"):
34 |         link_url = link.get("href")
35 |         if refre.search(link_url):
36 |             links_list.append(link_url)
37 |     return links_list
38 | 
39 | def return_bib(scholar_bib_url):
40 |     bib = request_page(scholar_bib_url).p.text
41 |     return bib
42 | 
43 | def bib_from_title(query):
44 |     link_list = google_scholar_query(query)
45 |     bib = return_bib(link_list[0])
46 |     return bib
47 | 
48 | '''
49 | Returns a bibTeX citation for online resources given a url.
50 | eg running bibtex_from_link("https://www.thetimes.co.uk/edition/business/higher-oil-prices-push-shell-profits-up50-x7kk3dg90")
51 | returns:
52 | @online{Higheroilprices,
53 |  title = {Higher oil prices push Shell profits up 50% | Business | The Times},
54 |  author = {},
55 |  year = {},
56 |  url = {https://www.thetimes.co.uk/edition/business/higher-oil-prices-push-shell-profits-up50-x7kk3dg90},
57 |  urldate = {2018-11-01},
58 | }
59 | author and year need to be entered manually.
60 | '''
61 | def bibtex_from_link(url):
62 |     if url[-4:] == ".pdf":
63 |         tag = ""
64 |         title = ""
65 |     else:
66 |         htmlsoup = request_page(url)
67 |         title = htmlsoup.title.text.replace("\n", "").replace(":", "").replace(",", "").strip()
68 |         title_split = title.split()
69 |         if len(title_split) == 0:
70 |             tag = ""
71 |         if len(title_split) == 1:
72 |             tag = title_split[0]
73 |         elif len(title_split) == 2:
74 |             tag = title_split[0] + title_split[1]
75 |         else:
76 |             tag = title_split[0] + title_split[1] + title_split[2]
77 | 
78 |     author_search = re.search(r'([a-z0-9]*\.(uk|com|co\.uk|org))', url)
79 |     if author_search:
80 |         author = author_search.group(1)
81 |     else:
82 |         author = ""
83 | 
84 |     year_search = re.search(r'(19|20)[8901]\d', url)
85 |     if year_search:
86 |         year = year_search.group(0)
87 |     else:
88 |         year = ""
89 | 
90 |     date = datetime.datetime.today().strftime('%Y-%m-%d')
91 |     ref = "@online{" + tag + ",\n title = {" + title + "},\n author = {" + author + "},\n year = {" + year + "},\n url = {" + url + "},\n urldate = {" + date + "}\n}\n"
92 |     return ref


--------------------------------------------------------------------------------
/mathfly/lib/latex/book_citation_generator.py:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | from bs4 import BeautifulSoup
  3 | from urllib2 import Request, urlopen, quote
  4 | from dragonfly import Clipboard, Key
  5 | import re
  6 | 
  7 | # takes URL, returns beautiful soup
  8 | def request_page(url):
  9 |     header = {'User-Agent': 'Mozilla/5.0'}
 10 |     request = Request(url, headers=header)
 11 |     response = urlopen(request)
 12 |     html = response.read()
 13 |     htmlsoup = BeautifulSoup(html, features="lxml")
 14 |     return htmlsoup
 15 | 
 16 | # Returns url of first result from goodreads
 17 | def goodreads_results(searchstr):
 18 |     searchstr = '/search?q=' + quote(searchstr)
 19 |     url = "https://www.goodreads.com" + searchstr
 20 |     htmlsoup = request_page(url)
 21 |     links_list = []
 22 |     refre = re.compile(r'/book/show/.*\?from_search=true')
 23 |     for link in htmlsoup.find_all("a"):
 24 |         link_url = link.get("href")
 25 |         if type(link_url) is str:
 26 |             if refre.search(link_url):
 27 |                 links_list.append("https://www.goodreads.com" + link_url)
 28 |     return links_list
 29 | 
 30 | '''
 31 | get_book_data is the main scraping function. It takes a goodreads book url and returns a
 32 | dict with the following fields:
 33 | title
 34 | authors (list)
 35 | authors_string (string, author names separated with " and ")
 36 | edition
 37 | pub_date (often of the form 29th May 2006)
 38 | pub_year (the last word of pub_date, hopefully the year)
 39 | publisher
 40 | first_published (for old books, this is often different to the edition date)
 41 | '''
 42 | def get_book_data(url):
 43 |     htmlsoup = request_page(url)
 44 |     data = {}
 45 | 
 46 |     data["authors"] = []
 47 |     for link in htmlsoup.find_all("a", { "class": "authorName" }):
 48 |         for span in link.find_all("span", { "itemprop": "name"}):
 49 |             data["authors"].append(span.text)
 50 |     data["authors_string"] =  " and ".join(data["authors"])
 51 | 
 52 |     heading1 = htmlsoup.find("h1", {"id":"bookTitle"})
 53 |     data["title"] = heading1.text.replace("\n", "").strip()
 54 | 
 55 |     details = ""
 56 |     for row in htmlsoup.find_all("div", {"class":"row"}):
 57 |         edition_span = row.find("span", {"itemprop":"bookEdition"})
 58 |         if edition_span is not None:
 59 |             data["edition"] = edition_span.text
 60 |         details = details + row.text
 61 | 
 62 |     pub_date_match = re.search(r'Published\n(.*)\n', details)
 63 |     if pub_date_match:
 64 |         data["pub_date"] = pub_date_match.group(1).strip()
 65 |         data["pub_year"] = data["pub_date"].split(" ")[-1]
 66 |     else:
 67 |         data["pub_date"] = ""
 68 |         data["pub_year"] = ""
 69 | 
 70 |     publisher_match = re.search(r'by\ (.*)\n', details)
 71 |     if publisher_match:
 72 |         data["publisher"] = publisher_match.group(1).strip()
 73 |     else:
 74 |         data["publisher"] = ""
 75 | 
 76 |     first_published_match = re.search(r'first\ published\ (.*)\)', details)
 77 |     if first_published_match:
 78 |         data["first_published"] = first_published_match.group(1).strip().split(" ")[-1]
 79 |     else:
 80 |         data["first_published"] = ""
 81 | 
 82 |     return data
 83 | 
 84 | '''
 85 | Takes the dict from get_book_data and builds a bibTeX-style citation which
 86 | can be appended directly to a .bib file. Example citations:
 87 | 
 88 | @book{wedgwood1938thirty,
 89 |  title={The Thirty Years War},
 90 |  author={C.V. Wedgwood and Anthony Grafton},
 91 |  year={1938},
 92 |  publisher={New York Review of Books},
 93 |  note={2005}
 94 | }
 95 | @book{russell2006like,
 96 |  title={Like Engend'ring Like: Heredity and Animal Breeding in Early Modern England},
 97 |  author={Nicholas Russell},
 98 |  year={2006},
 99 |  publisher={Cambridge University Press}
100 | }
101 | '''
102 | def build_citation(data):
103 |     # create strings for building a bibtex tag - last name of first author, first word of title
104 |     first_name = data["authors"][0].lower().split(" ")[-1]
105 |     first_title = data["title"].lower().replace("the ", "").split(" ")[0]
106 | 
107 |     citation1 = "@book{"
108 |     citation2 = ",\n " + "title={" + data["title"] + "},\n author={" + data["authors_string"] + "},\n year={"
109 |     citation3 = "},\n publisher={" + data["publisher"] + "}"
110 |     citation4 = "\n}\n"
111 | 
112 |     # If the year first published is not the same as the year the returned edition was published,
113 |     # format the year as first published/edition published
114 |     if data["first_published"] == "":
115 |         tag = first_name + data["pub_year"] + first_title
116 |         year_formatted = data["pub_year"]
117 |     elif data["pub_year"] == "":
118 |         tag = first_name + data["first_published"] + first_title
119 |         year_formatted = data["first_published"]
120 |     else:
121 |         tag = first_name + data["first_published"] + first_title
122 |         citation4 = ",\n note={" + data["pub_year"] + "}\n}\n"
123 |         year_formatted = data["first_published"]
124 |     ref = citation1 + tag + citation2 + year_formatted + citation3 + citation4
125 |     return ref
126 | 
127 | '''
128 | Searches a given book name, builds citation from the first result, if any
129 | '''
130 | def citation_from_name(book_name):
131 |     search_results = goodreads_results(book_name)
132 |     if search_results == []:
133 |         print("No results found on goodreads")
134 |         ref = ""
135 |     else:
136 |         url = search_results[0]
137 |         data = get_book_data(url)
138 |         ref = build_citation(data)
139 |     return ref
140 | 


--------------------------------------------------------------------------------
/mathfly/lib/latex/tex_funcs.py:
--------------------------------------------------------------------------------
 1 | from dragonfly import Function, Clipboard
 2 | from mathfly.lib.actions import Text, Key, Mouse, AppContext
 3 | from mathfly.lib import control, utilities
 4 | from mathfly.lib.latex import bibtexer, book_citation_generator
 5 | import codecs
 6 | import sys
 7 | 
 8 | # Execute \first{second}, if second is empty then end inside the brackets for user input
 9 | def back_curl(first, second):
10 |     (Text("\\" + str(first)) + Key("lbrace, rbrace, left") + Text(
11 |             str(second))).execute()
12 |     if str(second) != "":
13 |         Key("right").execute()
14 | 
15 | def greek_letters(big, greek_letter):
16 |     if big:
17 |         greek_letter = greek_letter.title()
18 |     Text("\\" + str(greek_letter) + " ").execute()
19 | 
20 | def symbol(symbol):
21 |     if type(symbol) in [str, unicode, int]:
22 |         Text("\\" + symbol + " ").execute()
23 |     else:
24 |         Text("\\" + str(symbol[0])).execute()
25 |         Text("{}"*int(symbol[1])).execute()
26 |         Key("left:" + str(2*int(symbol[1])-1)).execute()
27 | 
28 | def quote():
29 |     e, text = utilities.read_selected(False)
30 |     if text:
31 |         Text("``" + text + "\'\'").execute()
32 |     else:
33 |         Text("``\'\'").execute()
34 |         Key("left:2").execute()
35 | 
36 | def packages(packopts):
37 |     if type(packopts) in [str, unicode]:
38 |         back_curl("usepackage", packopts)
39 |     elif type(packopts) in [tuple, list]:
40 |         back_curl("usepackage" + packopts[0], packopts[1])
41 | 
42 | def begin_end(environment):
43 |     e, text = utilities.read_selected(False)
44 |     if type(environment) in [str, unicode]:
45 |         env, arg = environment, ""
46 |     elif type(environment) in [tuple, list]:
47 |         env, arg = environment[0], environment[1]
48 |     back_curl("begin", env)
49 |     Text(arg + "\n").execute()
50 |     if text:
51 |         utilities.paste_string(text)
52 |     Key("enter").execute()
53 |     back_curl("end", env)
54 |     if not text:
55 |         Key("up").execute()
56 | 
57 | def selection_to_bib(ref_type, bib_path):
58 |     Key("c-c/20").execute()
59 |     cb = Clipboard.get_system_text()
60 |     if ref_type == "book":
61 |         ref = book_citation_generator.citation_from_name(cb)
62 |     elif ref_type == "paper":
63 |         ref = bibtexer.bib_from_title(cb)
64 |     elif ref_type == "link":
65 |         ref = bibtexer.bibtex_from_link(cb)
66 |     with codecs.open(bib_path, encoding="utf-8", mode="a") as f:
67 |         f.write(ref)
68 |     print("Reference added:\n" + ref)
69 |     Clipboard.set_system_text(bibtexer.get_tag(ref))
70 | 


--------------------------------------------------------------------------------
/mathfly/lib/merge/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mirober/mathfly/c172f853514505045665290728e84e4e6bc796dd/mathfly/lib/merge/__init__.py


--------------------------------------------------------------------------------
/mathfly/lib/merge/ccrmerger.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Created on Sep 12, 2015
  3 | 
  4 | @author: synkarius
  5 | Standard merge filter: app_merge'''
  6 | from collections import OrderedDict
  7 | from itertools import izip_longest
  8 | from dragonfly.grammar.elements import RuleRef, Alternative, Repetition
  9 | from dragonfly.grammar.grammar_base import Grammar
 10 | from dragonfly.grammar.rule_compound import CompoundRule
 11 | 
 12 | from mathfly.lib import utilities
 13 | from mathfly.lib.merge.mergepair import MergePair, MergeInf
 14 | from mathfly.lib.merge.mergerule import MergeRule
 15 | import os
 16 | 
 17 | BASE_PATH = os.path.realpath(__file__).split("\\lib\\")[0].replace("\\", "/")
 18 | 
 19 | SETTINGS = utilities.load_toml_file(BASE_PATH + "/config/settings.toml")
 20 | CCR_PATH = BASE_PATH + "/" + SETTINGS["ccr_path"]
 21 | 
 22 | def app_merge(mp):
 23 |     '''forces app rules to define which parts of the base rule they will accept'''
 24 |     if mp.type == MergeInf.APP:
 25 |         base = mp.rule1  #base copy, actually
 26 |         if base is None:
 27 |             return
 28 |         app = mp.rule2
 29 |         mw = app.get_merge_with()
 30 |         specs_per_rulename = mp.extras
 31 |         '''flatten acceptable specs into a list'''
 32 |         acceptable_specs = []
 33 |         for rulename in specs_per_rulename:
 34 |             if rulename in mw:
 35 |                 acceptable_specs.extend(specs_per_rulename[rulename])
 36 |         '''remove anything the app rule hasn't defined as mergeable'''
 37 |         for spec in base.mapping_actual().keys():
 38 |             if not spec in acceptable_specs:
 39 |                 del base.mapping_actual()[spec]
 40 | 
 41 | 
 42 | class CCRMerger(object):
 43 |     CORE = []
 44 |     _GLOBAL = "global"
 45 |     _APP = "app"
 46 |     _SELFMOD = "selfmod"
 47 |     _ORDER = "enabling_order"
 48 | 
 49 |     def __init__(self, use_real_config=True):
 50 |         self._grammars = [
 51 |         ]  # cannot put multiple large rules in a single grammar despite context separation
 52 |         # original copies of rules
 53 |         self._global_rules = {}
 54 |         self._app_rules = {}
 55 |         # self modifying rules (don't make copies)
 56 |         self._self_modifying_rules = {}
 57 |         # filter functions
 58 |         self._filters = []
 59 |         # active rules
 60 |         self._base_global = None
 61 |         self._global_with_apps = []
 62 |         # config
 63 |         self.use_real_config = use_real_config
 64 |         self.load_config()
 65 |         self.add_filter(app_merge)
 66 | 
 67 |     '''config file stuff'''
 68 | 
 69 |     def save_config(self):
 70 |         if self.use_real_config:
 71 |             utilities.save_toml_file(self._config, CCR_PATH)
 72 | 
 73 |     def load_config(self):
 74 |         if self.use_real_config:
 75 |             self._config = utilities.load_toml_file(CCR_PATH)
 76 |         else:
 77 |             self._config = {}
 78 | 
 79 |     def update_config(self):
 80 |         '''call this after all rules have been added'''
 81 |         # Rebuild ccr.toml, rules which have not been registered will be removed,
 82 |         # new rules will be added
 83 |         new_config = {}
 84 |         for tag, rules in {CCRMerger._GLOBAL: self.global_rule_names(),
 85 |                     CCRMerger._APP: self.app_rule_names(),
 86 |                     CCRMerger._SELFMOD: self.selfmod_rule_names()}.iteritems():
 87 |             new_config[tag] = {}
 88 |             if not tag in self._config:
 89 |                 self._config[tag] = {}
 90 |             for name in rules:
 91 |                 if name in self._config[tag]:
 92 |                     new_config[tag][name] = self._config[tag][name]
 93 |                 else:
 94 |                     new_config[tag][name] = False
 95 | 
 96 |         self._config = new_config
 97 |         self.save_config()
 98 | 
 99 | 
100 |     '''setup: adding rules and filters'''
101 |     def add_global_rule(self, rule):
102 |         assert rule.get_context(
103 |         ) is None, "global rules may not have contexts, " + rule.get_pronunciation(
104 |         ) + " has a context: " + str(rule.get_context())
105 |         assert isinstance(rule, MergeRule) and not hasattr(rule, "set_merger"), \
106 |             "only MergeRules may be added as global rules; use add_selfmodrule() or add_app_rule()"
107 |         self._add_to(rule, self._global_rules)
108 | 
109 |     def add_app_rule(self, rule, context=None):
110 |         if context is not None and rule.get_context() is None: rule.set_context(context)
111 |         assert rule.get_context(
112 |         ) is not None, "app rules must have contexts, " + rule.get_pronunciation(
113 |         ) + " has no context"
114 |         assert rule.get_merge_with(
115 |         ) is not None, "app rules must define mwith, " + rule.get_pronunciation(
116 |         ) + " has no mwith"
117 |         self._add_to(rule, self._app_rules)
118 | 
119 |     def add_non_ccr_app_rule(self, rule, context=None):
120 |         if context is not None and rule.get_context() is None: rule.set_context(context)
121 |         assert rule.get_context() is not None, "app rules must have contexts, " + rule.get_pronunciation() + " has no context"
122 |         grammar = Grammar(str(rule), context=rule.get_context())
123 |         grammar.add_rule(rule)
124 |         if rule.non is not None:
125 |             grammar.add_rule(rule.non())
126 |         grammar.load()
127 | 
128 |     def add_selfmodrule(self, rule):
129 |         assert hasattr(
130 |             rule,
131 |             "set_merger"), "only SelfModifyingRules may be added by add_selfmodrule()"
132 |         assert not hasattr(rule,
133 |                            "master_node"), "NodeRules are not permitted in the merger"
134 |         rule.set_merger(self)
135 |         self._add_to(rule, self._self_modifying_rules)
136 | 
137 |     def add_filter(self, filter):
138 |         if not filter in self._filters:
139 |             self._filters.append(filter)
140 | 
141 |     def _add_to(self, rule, group):
142 |         if rule.get_pronunciation() in \
143 |         self.global_rule_names()+\
144 |         self.app_rule_names()+\
145 |         self.selfmod_rule_names():
146 |             raise Exception("Rule Naming Conflict: " + rule.get_pronunciation())
147 |         if isinstance(rule, MergeRule):
148 |             for name in group.keys():
149 |                 group[name].compatibility_check(
150 |                     rule)  # calculate compatibility for uncombined rules at boot time
151 |             group[rule.get_pronunciation()] = rule
152 | 
153 |     '''getters'''
154 | 
155 |     def global_rule_names(self):
156 |         return self._global_rules.keys()
157 | 
158 |     def app_rule_names(self):
159 |         return self._app_rules.keys()
160 | 
161 |     def selfmod_rule_names(self):
162 |         return self._self_modifying_rules.keys()
163 | 
164 |     def display_rules(self):
165 |         for rule in self.global_rule_names():
166 |             if self._config[CCRMerger._GLOBAL][rule]:
167 |                 print("*" + rule)
168 |             else:
169 |                 print(rule)
170 | 
171 |     '''rule change functions'''
172 |     def global_rule_changer(self, name, enable, save):
173 |         self._config[CCRMerger._GLOBAL][name] = enable
174 |         self.merge(MergeInf.RUN, name, enable, save)
175 |         print(name + " enabled" if enable else name + " disabled")
176 | 
177 |     def selfmod_rule_changer(self, name2, enable, save):
178 |         self._config[CCRMerger._SELFMOD][name2] = enable
179 |         self.merge(MergeInf.SELFMOD, name2, enable, save)
180 | 
181 |     '''merging'''
182 | 
183 |     def _get_rules_by_composite(self, composite, original=False):
184 |         return [rule if original else rule.copy()  \
185 |                 for rule in self._global_rules.values() \
186 |                 if rule.ID in composite]
187 | 
188 |     def _compatibility_merge(self, merge_pair, base, rule):
189 |         '''MergeRule.merge always returns a copy, so there's
190 |         no need to worry about the originals getting modified'''
191 |         if merge_pair.check_compatibility==False or \
192 |         base is None or \
193 |         base.compatibility_check(rule):
194 |             base = rule if base is None else base.merge(rule)
195 |         else:
196 |             # figure out which MergeRules aren't compatible
197 |             composite = base.composite.copy(
198 |             )  # composite is a set of the ids of the rules which make up this rule
199 |             for ID in rule.compatible:
200 |                 if not rule.compatible[ID]: composite.discard(ID)
201 |             # rebuild a base from remaining MergeRules
202 |             base = None
203 |             for _rule in self._get_rules_by_composite(composite):
204 |                 base = _rule if base is None else base.merge(_rule)
205 |             # merge in the new rule
206 |             if base is not None:
207 |                 base = base.merge(rule)
208 |             else:
209 |                 base = rule
210 |         return base
211 | 
212 |     def _add_grammar(self, rule, ccr=False, context=None):
213 |         name = str(rule)
214 |         grammar = Grammar(name, context=context)
215 |         self._grammars.append(grammar)
216 |         if ccr:
217 |             repeaters = self._create_repeat_rule(rule)
218 |             for repeater in repeaters:
219 |                 grammar.add_rule(repeater)
220 |         else:
221 |             grammar.add_rule(rule)
222 | 
223 |     def wipe(self):
224 |         while len(self._grammars) > 0:
225 |             grammar = self._grammars.pop()
226 |             for rule in grammar.rules:
227 |                 rule.disable()
228 |             grammar.disable()
229 |             del grammar
230 | 
231 |     def _sync_enabled(self):
232 |         '''
233 |         When enabling new rules, conflicting ones get automatically disabled.
234 |         Throw these out of enabling order as well. Also prevent excessive size.
235 |         '''
236 |         if CCRMerger._ORDER not in self._config:
237 |             self._config[CCRMerger._ORDER] = []
238 |         enabled = [
239 |             r for r in self._config[CCRMerger._ORDER]
240 |             if self._config[CCRMerger._GLOBAL].get(r)][-100:]
241 |         self._config[CCRMerger._ORDER] = OrderedDict(izip_longest(enabled, [])).keys()
242 | 
243 |     def merge(self, time, name=None, enable=True, save=False):
244 |         '''combines MergeRules, SelfModifyingRules;
245 |         handles CCR for apps;
246 |         instantiates affiliated rules;
247 |         adds everything to its grammar
248 |         ;
249 |         assumptions made:
250 |         * SelfModifyingRules have already made changes to themselves
251 |         * the appropriate activation boolean(s) in the appropriate map has already been set'''
252 |         current_rule = None
253 |         self.wipe()
254 |         base = self._base_global
255 |         named_rule = None
256 |         '''get base CCR rule'''
257 |         if time == MergeInf.BOOT:  # rebuild via config
258 |             for name, rule in self._global_rules.iteritems():
259 |                 '''we want to be able to make permanent changes at boot time, not just
260 |                 to activated rules, but to everything -- but we dont' want it to interfere
261 |                 with normal merge logic-- hence the introduction of the BOOT_NO_MERGE time'''
262 |                 mp = MergePair(
263 |                     MergeInf.BOOT_NO_MERGE, MergeInf.GLOBAL, None, rule, False
264 |                 )  # copies not made at boot time, allows user to make permanent changes
265 |                 self._run_filters(mp)
266 | 
267 |                 if self._config[CCRMerger._GLOBAL][name]:
268 |                     mp = MergePair(
269 |                         time, MergeInf.GLOBAL, base, rule, False
270 |                     )  # copies not made at boot time, allows user to make permanent changes
271 |                     self._run_filters(mp)
272 |                     if base is None: base = rule
273 |                     else: base = self._compatibility_merge(mp, base, rule)
274 |         else:  # rebuild via composite
275 |             composite = base.composite.copy(
276 |             )  # IDs of all rules that the composite rule is made of
277 |             if time != MergeInf.SELFMOD:
278 |                 assert name is not None
279 |                 named_rule = self._global_rules[name]
280 |                 if enable is False:
281 |                     composite.discard(named_rule.ID)  # throw out rule getting disabled
282 |                 else: # enable CCR rule
283 |                     self._config[CCRMerger._ORDER].append(name)
284 |                     current_rule = name
285 |             base = None
286 |             for rule in self._get_rules_by_composite(composite):
287 |                 mp = MergePair(time, MergeInf.GLOBAL, base, rule.copy(), False)
288 |                 self._run_filters(mp)
289 |                 if base is None: base = rule
290 |                 else:
291 |                     base = self._compatibility_merge(
292 |                         mp, base, mp.rule2)  # mp.rule2 because named_rule got copied
293 |             if time != MergeInf.SELFMOD and enable == True:
294 |                 mp = MergePair(time, MergeInf.GLOBAL, base, named_rule.copy(), True)
295 |                 self._run_filters(mp)
296 |                 base = self._compatibility_merge(
297 |                     mp, base, mp.rule2)  # mp.rule2 because named_rule got copied
298 |         '''compatibility check and filter function active selfmodrules'''
299 |         for name2, rule in self._self_modifying_rules.iteritems():
300 |             '''no need to make copies of selfmod rules because even if
301 |             filter functions trash their mapping, they'll just regenerate
302 |             it next time they modify themselves;
303 |             furthermore, they need to preserve state'''
304 |             if self._config[CCRMerger._SELFMOD][name2]:
305 |                 mp = MergePair(time, MergeInf.SELFMOD, base, rule, False)
306 |                 self._run_filters(mp)
307 |                 base = self._compatibility_merge(mp, base, rule)
308 |         '''have base, make copies, merge in apps'''
309 |         active_apps = []
310 |         for rule in self._app_rules.values():
311 |             base_copy = base.copy() if base is not None else base
312 |             # make a copy b/c commands will get stripped out
313 |             context = rule.get_context()
314 |             non_copy = rule.non if rule.non else None
315 |             nested_copy = rule.nested if rule.nested else None
316 |             mp = MergePair(time, MergeInf.APP, base_copy, rule.copy(), False,
317 |                            CCRMerger.specs_per_rulename(self._global_rules))
318 |             self._run_filters(mp)
319 |             rule = self._compatibility_merge(
320 |                 mp, base_copy, mp.rule2)  # mp.rule2 because named_rule got copied
321 |             rule.non = non_copy
322 |             rule.nested = nested_copy
323 |             rule.set_context(context)
324 |             active_apps.append(rule)
325 |         '''negation context for appless version of base rule'''
326 |         contexts = [app_rule.get_context() for app_rule in self._app_rules.values() \
327 |                     if app_rule.get_context() is not None]# get all contexts
328 |         negation_context = None
329 |         for context in contexts:
330 |             negate = ~context
331 |             if negation_context is None: negation_context = negate
332 |             else: negation_context & negate
333 |         '''handle empty merge'''
334 |         if base is None:
335 |             base = MergeRule()
336 |         ''' save results for next merge '''
337 |         self._base_global = base.copy()
338 |         '''instantiate non-ccr rules affiliated with rules in the base CCR rule'''
339 |         active_global = self._get_rules_by_composite(base.composite, True)
340 |         global_non_ccr = [rule.non() for rule in active_global \
341 |                          if rule.non is not None]
342 |         '''update grammars'''
343 |         self._add_grammar(base, True, negation_context)
344 |         for rule in global_non_ccr:
345 |             self._add_grammar(rule)
346 |         for rule in active_apps:
347 |             self._add_grammar(rule, True, rule.get_context())
348 |             if rule.non is not None:
349 |                 self._add_grammar(rule.non(), False, rule.get_context())
350 |         for grammar in self._grammars:
351 |             grammar.load()
352 |         '''save if necessary'''
353 |         if time in [MergeInf.RUN, MergeInf.SELFMOD] and save:
354 |             # everything in base composite is active, everything in selfmod is active, update the config as such
355 |             active_global_names = [rule.get_pronunciation() for rule in active_global]
356 |             for rule_name in self._global_rules:
357 |                 self._config[CCRMerger._GLOBAL][
358 |                     rule_name] = rule_name in active_global_names
359 |             active_selfmod_names = [
360 |                 name3 for name3 in self._config[CCRMerger._SELFMOD]
361 |                 if self._config[CCRMerger._SELFMOD][name3]
362 |             ]  #[rule.get_pronunciation() for rule in selfmod]
363 |             for rule_name in self._self_modifying_rules:
364 |                 self._config[CCRMerger._SELFMOD][
365 |                     rule_name] = rule_name in active_selfmod_names
366 |         self._sync_enabled()
367 |         if len(self._config[CCRMerger._ORDER]) > 0:
368 |             current_rule = self._config[CCRMerger._ORDER][-1]
369 |         # self._apply_format(current_rule)
370 |         if save:
371 |             self.save_config()
372 | 
373 |     @staticmethod
374 |     def specs_per_rulename(d):
375 |         result = {}
376 |         for rulename in d.keys():
377 |             rule = d[rulename]
378 |             specs = rule.mapping_actual().keys()
379 |             result[rulename] = specs
380 |         return result
381 | 
382 |     def _run_filters(self, merge_pair):
383 |         for filter_fn in self._filters:
384 |             try:
385 |                 filter_fn(merge_pair)
386 |             except Exception:
387 |                 print("Filter function '" + filter_fn.__name__ + "' failed.")
388 | 
389 |     def _create_repeat_rule(self, rule):
390 |         ORIGINAL, SEQ, TERMINAL = "original", "caster_base_sequence", "terminal"
391 |         alts = [RuleRef(rule=rule)]  #+[RuleRef(rule=sm) for sm in selfmod]
392 |         single_action = Alternative(alts)
393 |         max = SETTINGS["max_ccr_repetitions"]
394 |         sequence = Repetition(single_action, min=1, max=max, name=SEQ)
395 |         original = Alternative(alts, name=ORIGINAL)
396 |         terminal = Alternative(alts, name=TERMINAL)
397 | 
398 |         class RepeatRule(CompoundRule):
399 |             spec = "[<" + ORIGINAL + "> original] [<" + SEQ + ">] [terminal <" + TERMINAL + ">]"
400 |             extras = [sequence, original, terminal]
401 | 
402 |             def _process_recognition(self, node, extras):
403 |                 original = extras[ORIGINAL] if ORIGINAL in extras else None
404 |                 sequence = extras[SEQ] if SEQ in extras else None
405 |                 terminal = extras[TERMINAL] if TERMINAL in extras else None
406 |                 if original is not None: original.execute()
407 |                 if sequence is not None:
408 |                     for action in sequence:
409 |                         action.execute()
410 |                 if terminal is not None: terminal.execute()
411 | 
412 |         rules = []
413 |         rules.append(RepeatRule(name="Repeater" + MergeRule.get_merge_name()))
414 | 
415 |         if rule.nested is not None:
416 |             bef  = Repetition(single_action, min=1, max=8, name="before")
417 |             aft  = Repetition(single_action, min=1, max=8, name="after")
418 |             seq1 = Repetition(single_action, min=1, max=6, name="sequence1")
419 |             seq2 = Repetition(single_action, min=1, max=6, name="sequence2")
420 |             sing1 = Alternative(alts, name="singleton1")
421 |             sing2 = Alternative(alts, name="singleton2")
422 | 
423 |             if rule.nested.extras is None:
424 |                 rule.nested.extras = [bef, aft, seq1, seq2, sing1, sing2]
425 |             else:
426 |                 rule.nested.extras.extend([bef, aft, seq1, seq2, sing1, sing2])
427 |             nested = rule.nested()
428 |             rules.append(nested)
429 | 
430 |         return rules


--------------------------------------------------------------------------------
/mathfly/lib/merge/mergepair.py:
--------------------------------------------------------------------------------
 1 | class MergeInf(object):
 2 |     '''TYPE'''
 3 |     GLOBAL = 0
 4 |     APP = 1
 5 |     SELFMOD = 2
 6 |     '''TIME'''
 7 |     BOOT = 3
 8 |     RUN = 4
 9 |     BOOT_NO_MERGE = 5
10 | 
11 | 
12 | class MergePair(object):
13 |     def __init__(self, time, type, rule1, rule2, check_compatibility, extras=None):
14 |         self.time = time
15 |         self.type = type
16 |         self.rule1 = rule1
17 |         self.rule2 = rule2
18 |         self.changed = False  # presently unused
19 |         self.check_compatibility = check_compatibility
20 |         self.extras = extras
21 | 


--------------------------------------------------------------------------------
/mathfly/lib/merge/mergerule.py:
--------------------------------------------------------------------------------
  1 | '''
  2 | Created on Sep 1, 2015
  3 | 
  4 | @author: synkarius
  5 | '''
  6 | from dragonfly import MappingRule, Pause, Function
  7 | 
  8 | 
  9 | class MergeRule(MappingRule):
 10 |     @staticmethod
 11 |     def _get_next_id():
 12 |         if not hasattr(MergeRule._get_next_id, "id"):
 13 |             MergeRule._get_next_id.id = 0
 14 |         MergeRule._get_next_id.id += 1
 15 |         return MergeRule._get_next_id.id
 16 | 
 17 |     @staticmethod
 18 |     def get_merge_name():  # returns unique str(int) for procedural rule names
 19 |         return str(MergeRule._get_next_id())
 20 | 
 21 |     mapping = {"hello world default macro": Pause("10")}
 22 |     '''MergeRules which define `pronunciation` will use
 23 |     the pronunciation string rather than their class name
 24 |     for their respective enable/disable commands'''
 25 |     pronunciation = None
 26 |     # Allows for self referencing rules (which include arbitrary sequences of other commands from the rule) to be included
 27 |     nested = None
 28 |     '''MergeRules which define `non` will instantiate
 29 |     their paired non-CCR MergeRule and activate it
 30 |     alongside themselves'''
 31 |     non = None
 32 |     '''MergeRules which define `mcontext` with a
 33 |     Dragonfly AppContext become non-global; this
 34 |     is the same as adding a context to a Grammar'''
 35 |     mcontext = None
 36 |     '''app MergeRules MUST define `mwith` in order to
 37 |     define what else they can merge with -- this is an
 38 |     optimization to prevent pointlessly large global
 39 |     CCR copies; mwith is a list of get_pronunciation()s'''
 40 |     mwith = None
 41 | 
 42 |     def __init__(self,
 43 |                  name=None,
 44 |                  mapping=None,
 45 |                  extras=None,
 46 |                  defaults=None,
 47 |                  exported=None,
 48 |                  ID=None,
 49 |                  composite=None,
 50 |                  compatible=None,
 51 |                  mcontext=None,
 52 |                  mwith=None):
 53 | 
 54 |         self.ID = ID if ID is not None else MergeRule._get_next_id()
 55 |         self.compatible = {} if compatible is None else compatible
 56 |         '''composite is the IDs of the rules which this MergeRule is composed of: '''
 57 |         self.composite = composite if composite is not None else set([self.ID])
 58 |         self._mcontext = self.__class__.mcontext
 59 |         if self._mcontext is None: self._mcontext = mcontext
 60 |         self._mwith = self.__class__.mwith
 61 |         if self._mwith is None: self._mwith = mwith
 62 | 
 63 |         if mapping is not None:
 64 |             mapping["display available commands"] = Function(
 65 |                 lambda: self._display_available_commands())
 66 | 
 67 |         MappingRule.__init__(self, name, mapping, extras, defaults, exported)
 68 | 
 69 |     def __eq__(self, other):
 70 |         if not isinstance(other, MergeRule):
 71 |             return False
 72 |         return self.ID == other.ID
 73 | 
 74 |     ''' "copy" getters used for safe merging;
 75 |     "actual" versions used for filter functions'''
 76 | 
 77 |     def mapping_copy(self):
 78 |         return self._mapping.copy()
 79 | 
 80 |     def mapping_actual(self):
 81 |         return self._mapping
 82 | 
 83 |     def extras_copy(self):
 84 |         return self._extras.copy()
 85 | 
 86 |     def extras_actual(self):
 87 |         return self._extras
 88 | 
 89 |     def defaults_copy(self):
 90 |         return self._defaults.copy()
 91 | 
 92 |     def defaults_actual(self):
 93 |         return self._defaults
 94 | 
 95 |     def merge(self, other):
 96 |         mapping = self.mapping_copy()
 97 |         mapping.update(other.mapping_copy())
 98 |         extras_dict = self.extras_copy()
 99 |         extras_dict.update(
100 |             other.extras_copy())  # not just combining lists avoids duplicates
101 |         extras = extras_dict.values()
102 |         defaults = self.defaults_copy()
103 |         defaults.update(other.defaults_copy())
104 |         context = self._mcontext if self._mcontext is not None else other.get_context(
105 |         )  # one of these should always be None; contexts don't mix here
106 |         return MergeRule(
107 |             "Merged" + MergeRule.get_merge_name() + self.get_pronunciation()[0] +
108 |             other.get_pronunciation()[0],
109 |             mapping,
110 |             extras,
111 |             defaults,
112 |             self._exported and other._exported,  # no ID
113 |             composite=self.composite.union(other.composite),
114 |             mcontext=context)
115 | 
116 |     def get_pronunciation(self):
117 |         return self.pronunciation if self.pronunciation is not None else self.name
118 | 
119 |     def copy(self):
120 |         return MergeRule(self.name, self._mapping.copy(), self._extras.values(),
121 |                          self._defaults.copy(), self._exported, self.ID, self.composite,
122 |                          self.compatible, self._mcontext, self._mwith)
123 | 
124 |     def compatibility_check(self, other):
125 |         if other.ID in self.compatible:
126 |             return self.compatible[other.ID]  # lazily
127 |         compatible = True
128 |         for key in self._mapping.keys():
129 |             if key in other.mapping_actual().keys():
130 |                 compatible = False
131 |                 break
132 |         self.compatible[other.ID] = compatible
133 |         other.compatible[self.ID] = compatible
134 |         return compatible
135 | 
136 |     def incompatible_IDs(self):
137 |         return [ID for ID in self.compatible if not self.compatible[ID]]
138 | 
139 |     def get_context(self):
140 |         return self._mcontext
141 | 
142 |     def set_context(self, context):
143 |         self._mcontext = context
144 | 
145 |     def get_merge_with(self):
146 |         return self._mwith
147 | 
148 |     def _display_available_commands(self):
149 |         for spec in self.mapping_actual().keys():
150 |             print(spec)  # do something fancier when the ui is better
151 | 


--------------------------------------------------------------------------------
/mathfly/lib/merge/nestedrule.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | This rule type allows for the creation of rules which can take arbitrary sequences of commands from another rule. They are declared without extras and added in the nested property of a merge rule, the merged form of which will be used to form the extras list in ccrmerger._create_repeat_rule.
 3 | 
 4 | The specifications in the rule's mapping must include <sequence1> and <sequence2>, <before> and <after> are optional and allow for other commands to be spoken before or after the rule.
 5 | Example command:
 6 | "[<before>] integral from <sequence1> to <sequence2>":
 7 |             [Text("\\int _"), Key("right, caret"), Key("right")],
 8 | 
 9 | Any commands which come before will be executed first, then the first action in the list, then the first sequence, then the second action in the list, then the second sequence, then the final action.  At the moment sequences have a maximum length of 6 commands and before and after 8.
10 | '''
11 | 
12 | from dragonfly import MappingRule
13 | 
14 | class NestedRule(MappingRule):
15 |     def _process_recognition(self, value, extras):
16 |         if "before" in extras:
17 |             for action in extras["before"]: action.execute()
18 |         if value[0] is not None: value[0].execute(extras)
19 |         if "sequence1" in extras:
20 |             for action in extras["sequence1"]: action.execute()
21 |         if "singleton1" in extras: extras["singleton1"].execute(extras)
22 |         if value[1] is not None: value[1].execute(extras)
23 |         if "sequence2" in extras:
24 |             for action in extras["sequence2"]: action.execute()
25 |         if "singleton2" in extras: extras["singleton2"].execute(extras)
26 |         if value[2] is not None: value[2].execute(extras)
27 |         if "after" in extras:
28 |             for action in extras["after"]: action.execute()
29 | 


--------------------------------------------------------------------------------
/mathfly/lib/merge/selfmodrule.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Created on Sep 6, 2015
 3 | 
 4 | @author: synkarius
 5 | '''
 6 | from dragonfly import Dictation, IntegerRef
 7 | 
 8 | from mathfly.lib.merge.mergepair import MergeInf
 9 | from mathfly.lib.merge.mergerule import MergeRule
10 | 
11 | 
12 | class SelfModifyingRule(MergeRule):
13 |     '''
14 |     SelfModifyingRule is a kind of rule which gets its command set changed
15 |     on-the-fly based on some kind of user interaction. Child classes
16 |     must implement their own version of the `refresh` method.
17 |     '''
18 | 
19 |     def __init__(self,
20 |                  name=None,
21 |                  mapping=None,
22 |                  extras=None,
23 |                  defaults=None,
24 |                  exported=None,
25 |                  refresh=True):
26 |         MergeRule.__init__(self, name, mapping, extras, defaults, exported)
27 |         self._merger = None
28 |         if refresh: self.refresh()
29 | 
30 |     def refresh(self, *args):
31 |         '''Does stuff to get mapping, then calls self.reset()'''
32 |         self.reset({})
33 | 
34 |     def set_merger(self, merger):
35 |         '''only set for CCR SelfModifyingRules'''
36 |         self._merger = merger
37 | 
38 |     def reset(self, mapping):
39 |         grammar = self._grammar  # save reference because Grammar.remove_rule nullifies it
40 |         ccr = self._merger is not None
41 | 
42 |         if grammar is not None and not ccr:
43 |             grammar.unload()
44 |             grammar.remove_rule(self)
45 | 
46 |         extras = self.extras if self.extras else [IntegerRef("n", 1, 50), Dictation("s")]
47 |         defaults = self.defaults if self.defaults else { "n": 1, "s": "" }
48 |         MergeRule.__init__(self, self.name, mapping, extras, defaults, self.exported,
49 |                            self.context)
50 | 
51 |         if ccr: self._merger.merge(MergeInf.SELFMOD)
52 | 
53 |         if grammar is not None and not ccr:
54 |             grammar.add_rule(self)
55 |             grammar.load()
56 | 


--------------------------------------------------------------------------------
/mathfly/lib/navigation.py:
--------------------------------------------------------------------------------
 1 | from dragonfly import Key
 2 | 
 3 | def text_nav(modifier, direction, n50, extreme):
 4 |     k = ""
 5 |     if extreme:
 6 |         if direction in ["left", "up"]:
 7 |             k = k + "home"
 8 |         else:
 9 |             k = k + "end"
10 |         if direction in ["up", "down"]:
11 |             k = "c-" + k
12 |     else:
13 |         k = str(direction) + ":" + str(n50)
14 |     if modifier:
15 |         k = str(modifier) + k.replace("c-", "")
16 |     Key(k).execute()


--------------------------------------------------------------------------------
/mathfly/lib/utilities.py:
--------------------------------------------------------------------------------
 1 | # -*- coding: utf-8 -*-
 2 | import io, os, sys, time, re
 3 | import toml
 4 | from subprocess import Popen
 5 | from dragonfly import Choice, Clipboard, Key
 6 | 
 7 | BASE_PATH = os.path.realpath(__file__).split("\\lib\\")[0].replace("\\", "/")
 8 | if BASE_PATH not in sys.path:
 9 |     sys.path.append(BASE_PATH)
10 | 
11 | 
12 | def save_toml_file(data, path):
13 |     try:
14 |         formatted_data = unicode(toml.dumps(data))
15 |         with io.open(path, "wt", encoding="utf-8") as f:
16 |             f.write(formatted_data)
17 |     except Exception:
18 |         raise
19 | 
20 | def load_toml_file(path):
21 |     result = {}
22 |     try:
23 |         with io.open(path, "rt", encoding="utf-8") as f:
24 |             result = toml.loads(f.read())
25 |     except IOError as e:
26 |         if e.errno == 2:  # The file doesn't exist.
27 |             save_toml_file(result, path)
28 |         else:
29 |             raise
30 |     return result
31 | 
32 | def get_full_path(path):
33 |     return BASE_PATH + "/" + path
34 | 
35 | def load_toml_relative(path):
36 |     path = get_full_path(path)
37 |     return load_toml_file(path)
38 | 
39 | def save_toml_relative(data, path):
40 |     path = get_full_path(path)
41 |     return save_toml_file(data, path)
42 | 
43 | def read_selected(same_is_okay=False):
44 |     '''Returns a tuple:
45 |     (0, "text from system") - indicates success
46 |     (1, None) - indicates no change
47 |     (2, None) - indicates clipboard error
48 |     '''
49 |     time.sleep(0.05)
50 |     cb = Clipboard(from_system=True)
51 |     temporary = None
52 |     prior_content = None
53 |     try:
54 |         prior_content = Clipboard.get_system_text()
55 |         Clipboard.set_system_text("")
56 |         Key("c-c").execute()
57 |         time.sleep(0.05)
58 |         temporary = Clipboard.get_system_text()
59 |         cb.copy_to_system()
60 |     except Exception:
61 |         return 2, None
62 |     if prior_content == temporary and not same_is_okay:
63 |         return 1, None
64 |     return 0, temporary
65 | 
66 | def paste_string(content):
67 |     time.sleep(0.05)
68 |     cb = Clipboard(from_system=True)
69 |     try:
70 |         Clipboard.set_system_text(str(content))
71 |         Key("c-v").execute()
72 |         time.sleep(0.05)
73 |         cb.copy_to_system()
74 |     except Exception:
75 |         return False
76 |     return True
77 | 
78 | SETTINGS = load_toml_relative("config/settings.toml")
79 | 
80 | def reboot():
81 |     Popen([BASE_PATH + "/config/bin/reboot.bat", SETTINGS["dragon_path"]])
82 | 
83 | def load_config(config_name):
84 |     parameters = []
85 |     parameters.append(SETTINGS["editor_path"])
86 |     parameters.append(get_full_path("config/" + config_name))
87 |     Popen(parameters)
88 | 
89 | def load_text_file(path):
90 |     parameters = []
91 |     parameters.append(SETTINGS["editor_path"])
92 |     parameters.append(path)
93 |     Popen(parameters)
94 | 
95 | def help():
96 |     print(get_full_path("docs"))
97 |     Popen(['C:/Windows/explorer.exe', get_full_path("docs").replace("/", "\\")])
98 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | wxpython
 2 | pywin32
 3 | setuptools
 4 | future
 5 | dragonfly2
 6 | toml
 7 | beautifulsoup4
 8 | six
 9 | dfly-breathe
10 | 


--------------------------------------------------------------------------------