Section, Item) #--------------------------------------------------------------------------- # Set up this module's configuration. config = Config("config manager") config.lang = Section("Language section") config.lang.list_configs = Item("list configs", doc="Command to ...") config.lang.edit_config = Item("edit <config> (config | configuration)", doc="Command to ...") config.lang.show_dragonfly_version = Item("show dragonfly version", doc="Command to ...") config.lang.update_dragonfly = Item("update dragonfly version", doc="Command to ...") config.lang.reload_natlink = Item("reload natlink", doc="Command to ...") config.load() #--------------------------------------------------------------------------- config_map = DictList("config_map") #--------------------------------------------------------------------------- class ConfigManagerGrammar(Grammar): def __init__(self): Grammar.__init__(self, name="config manager", context=None) def _process_begin(self, executable, title, handle): configs = Config.get_instances()
#--------------------------------------------------------------------------- # Set up this module's configuration. config = Config("config manager") config.lang = Section("Language section") config.lang.list_configs = Item("list configs", doc="Command to ...") config.lang.edit_config = Item("edit <config> (config | configuration)", doc="Command to ...") config.lang.show_dragonfly_version = Item("show dragonfly version", doc="Command to ...") config.lang.update_dragonfly = Item("update dragonfly version", doc="Command to ...") config.lang.reload_natlink = Item("reload natlink", doc="Command to ...") config.load() #--------------------------------------------------------------------------- config_map = DictList("config_map") #--------------------------------------------------------------------------- class ConfigManagerGrammar(Grammar): def __init__(self): Grammar.__init__(self, name="config manager", context=None) def _process_begin(self, executable, title, handle):
from dragonfly import Config, Section, Item, AppContext, Grammar, MappingRule, IntegerRef, Dictation, Choice from lib.dynamic_aenea import ( DynamicContext, Key, Text, ) from proxy_nicknames import AppContext as NixAppContext hipchat_config = Config("HipChat") hipchat_config.usernames = Section("Username Mappings") hipchat_config.usernames.map = Item({"All": "all", "Here": "here"}) hipchat_config.load() class NavigationRule(MappingRule): mapping = { "move up [<n>]": Key("cs-tab:%(n)d"), "move down [<n>]": Key("c-tab:%(n)d"), "close tab": Key("c-w"), "(join room | private message) <room>": Key("c-j/25") + Text("%(room)s") + Key("enter"), "search [room] history": Key("c-f"), }
Key, Text, ) from aenea.proxy_contexts import ProxyAppContext as NixAppContext hipchat_config = Config("HipChat") hipchat_config.usernames = Section("Username Mappings") hipchat_config.usernames.map = Item( { "All": "all", "Here": "here" } ) hipchat_config.load() class NavigationRule(MappingRule): mapping = { "move up [<n>]": Key("cs-tab:%(n)d"), "move down [<n>]": Key("c-tab:%(n)d"), "close tab": Key("c-w"), "(join room | private message) <room>": Key("c-j/25") + Text("%(room)s") + Key("enter"), "search [room] history": Key("c-f"), } extras = [ IntegerRef("n", 1, 10), Dictation("room"), ]
from dragonfly import Function, MappingRule, Text, Dictation, Config, Section, Item, Key config = Config("format functions") config.cmd = Section("Command section") config.cmd.map = Item( {}, namespace={ "Key": Key, "Text": Text, } ) namespace = config.load() #--------------------------------------------------------------------------- # Here we prepare the list of formatting functions from the config file. # Retrieve text-formatting functions from this module's config file. Each of these functions must have a name that starts with "format_". format_functions = {} if namespace: for name, function in namespace.items(): if name.startswith("format_") and callable(function): spoken_form = function.__doc__.strip() # We wrap generation of the Function action in a function so that its *function* variable will be local. Otherwise it # would change during the next iteration of the namespace loop. def wrap_function(function): def _function(dictation): formatted_text = function(dictation) Text(formatted_text).execute()
#grammar = Grammar("Dynamic manager", context=None) grammar = DynamicManagerGrammar() grammar.add_rule(series_rule) grammar.load() notify() # Notify that Dragonfly is ready with a sound. def unload(): """Unload function which will be called at unload time.""" # Unload the dynamically loaded modules. global moduleMapping for module in moduleMapping.values(): print "---------- " + __file__.split('\\')[-1] + " unload(): " + str(module.__name__) module.unload() global grammar if grammar: grammar.unload() grammar = None #--------------------------------------------------------------------------- # Set up this module's configuration. In this module's particular case, this doesn't necessarily make alot of sense, as this file/module is not expected to be edited every day, and it doesn't have/need a config file ie .txt, but having this make it easier to bring this module into notepad via _dragonfly_tools.py/config manager "edit dynamic manager module" command # may be should combine dynamics/*.py into one _dragonfly_tools.txt config file, so that on editing the config file the the main .py module gets touced (via a method in _dragonfly_tools.py) and cause it to reload (even thought this reload is not reliable and sometimes needs sleep/wakeup or microphoneOff/microphoneOn to properly reload the newly edited moudle and it's config) # alternatively re-employ the method/function of _dragonfly_tools.py that touches the .py when .txt is edited, to make it re-touch _dynamic_manager.py when any of dynamics/*.py is edited from dragonfly import Config dragonfly_config = Config("dynamic manager") # config is already used for lib/config.py's config.json file dragonfly_config.load()