LexiconCode
commented
4 years ago No offense taken, The dragonfly framework is written in Python. However dragonfly can be used to to create a grammar for any programming language.
To answer your specific question, print("Voice command spoken.") print a message to the natlink messages window or command prompt window.
def _process_recognition(self, node, extras): # Callback when command is spoken.
print("Voice command spoken.")If you spoke do something computer the following would be printed out to the natlink messages window or command prompt window.
Recognized: do something computer
Voice command spoken.Basically _process_recognition callback tells the user when a command was recognized Recognized: do something computer. You could change print("Voice command spoken.") to Text("Voice command spoken.").execute(). Then every time any command is recognized, the phrase Voice command spoken would be typed out as if you use the keyboard. If you're using the example verbatim you'll need to change the imports to from dragonfly import Grammar, CompoundRule, Text to include Text.
While the following wouldn't be included in the readme as it's too large, this might be helpful to you. The readme could be clarified.
To run the following grammar
- Install DNS, Dragonfly and Natlink (you just need Natlink installed, not configured from the GUI necessarily)
- Start DNS
- run from command prompt
python -m dragonfly load --engine natlink _sample.pyin the same directory as_sample.py
# These lines that start with the # are called comments. They don't affect the way the code runs.
# In this tutorial file, I put comments above the relevant lines.
# Before we begin, it's worth noting that the name of this file, sample.py, will cause it to never run.
# You will have to rename it to "_sample.py".
# Putting an underscore as the first character of a grammar Python file will tell dragonfly
# that you want this file to run all the time. Grammars that run all the time are good way to start.
# The alternative is making grammars for specific programs that only trigger when the programs are active.
# You can skip down to the next comment, none of this stuff is really important...
from dragonfly import (BringApp, Key, Function, Grammar, Playback,
IntegerRef, Dictation, Choice, WaitWindow, MappingRule, Text)
def my_function(n, text):
print("put some Python logic here: "+str(text))
class MainRule(MappingRule):
mapping = {
# it is this section that you want to fiddle around with if you're new: mapping, extras, and defaults
# in the next line, there are two things to observe:
# the first is the use of parentheses and the pipe symbol (|)
# --this lets me use either "lock dragon" or "deactivate" to trigger that command.
# The next is the playback action, which lets me tell Dragon to simulate me speaking some words.
'(lock Dragon | deactivate)': Playback([(["go", "to", "sleep"], 0.0)]),
# Here I'm using BringApp-- this is the same as typing what goes in between the parentheses
# into the Windows command prompt, without the quotes and commas, like:
# explorer C:\NatLink\NatLink\MacroSystem
# -- (which would open Windows Explorer at the specified location). Anything you can do with the command line can be done this way
"open natlink folder": BringApp("explorer", r"C:\NatLink\NatLink\MacroSystem"),
# here I'm using the Key action to press some keys -- see the documentation here: https://dragonfly2.readthedocs.io/en/latest/actions.html?highlight=key#module-dragonfly.actions.action_key
"remax": Key("a-space/10,r/10,a-space/10,x"),
# here I'm chaining a bunch of different actions together to do a complex task
"(show | open) documentation": BringApp('C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe') + WaitWindow(executable="chrome.exe") + Key('c-t') + WaitWindow(title="New Tab") + Text('https://dragonfly2.readthedocs.io/en/latest') + Key('enter'),
# here I'm just saying one word to trigger some other words
"hotel": Text("hotels are not cheap"),
# If you need to do more complicated tasks, or use external resources, a function might be what you need.
# note that here, I'm using extras: "n" and "text"
# The angle brackets <> meaning I'm using an extra, and the square brackets [] mean that I don't have to speak that word, it's optional.
# Advice: if you use an optional extra, like I am with "text", you should set a default value in the defaults section down below.
# To trigger the following command, you would have to say the word "function" followed by a number between 1 and 1000.
'[use] function <n> [<text>]': Function(my_function, extra={'n', 'text'}),
}
extras = [
IntegerRef("n", 1, 1000),
Dictation("text"),
Choice("choice",
{"alarm": "alarm", "custom grid": "CustomGrid", "element": "e"
}),
]
defaults = {"n": 1,
"text": "",
}
# this stuff is required too-- where I have the word "sample" below, each grammar file should have external unique
grammar = Grammar('sample')
grammar.add_rule(MainRule())
grammar.load()I hope this helps your understanding :)
BawdyInkSlinger
daanzu
drmfinlay
I mean no offense by what I'm saying, but it's challenging to figure out what dragonfly does. From what I can tell with the example at the bottom, it gives me a way to write some code in Python that will generate text. Like, I think it's an alternative way of creating commands in Dragon software (or other software).
do something computerwillprint("Voice command spoken."), But what it would mean to "print" that content. Doesprintmean it gets typed out at the cursor? I'm not asking for you to explain an excessive amount of detail, but a high level explanation of what this macro does would really help.