def appendList(self, listName, words): listName = utilsqh.convertToBinary(listName) if listName not in self.validLists: raise gramparser.GrammarError( "list %s was not defined in the grammar" % listName , self.scanObj) if type(words) in (six.binary_type, six.text_type): words = utilsqh.convertToBinary(words) self.gramObj.appendList(listName,words) else: for x in words: if type(x) == six.text_type: x = utilsqh.convertToBinary(x) self.gramObj.appendList(listName,x)
def playString(keys, hooks=None): """do smarter and faster playString than natlink.playString If useMarkSendInput is set to 1 (True) (top of this file): the SendInput module of Mark Lillibridge is used. Disadvantage: does not work in elevated windows. This behaviour can be circumvented by adding a hook in the call, or by using SendDragonKeys, SendSystemKeys or SSK (Unimacro). If useMarkSendInput is set to 0 (False), or a hook is added (0x100 for normal behaviour, 0x200 for systemkeys behaviour) then natlink.playString is used, but a {shift} in front of the keystrokes is inserted, in order to prevent doubling or losing keystrokes. (if default behaviour is wanted, you can call natlink.playString directly) """ if not keys: return keys = utilsqh.convertToBinary(keys) if hooks is None and useMarkSendInput: SendInput.send_input( ExtendedSendDragonKeys.senddragonkeys_to_events(keys)) else: if hooks not in (None, 0x100): natlink.playString(keys, hooks) else: shiftkey = natlinkmain.shiftkey natlink.playString(shiftkey + keys)
def activate(self, ruleName, window=0, exclusive=None, noError=0): if type(ruleName) == six.text_type: ruleName = utilsqh.convertToBinary(ruleName) if ruleName not in self.validRules: raise gramparser.GrammarError( "rule %s was not exported in the grammar" % ruleName, self.scanObj) if type(ruleName) != six.binary_type: raise gramparser.GrammarError( 'GrammarBase, wrong type in activate, %s (%s)' % (ruleName, type(ruleName)), self.scanObj) if ruleName in self.activeRules: if window == self.activeRules[ruleName]: print 'rule %s already active for window %s' % (ruleName, window) return else: print 'change rule %s from window %s to window %s' % ( ruleName, self.activeRules[ruleName], window) self.gramObj.deactivate(ruleName) if debugLoad: print 'activate rule %s (window: %s)' % (ruleName, window) self.gramObj.activate(ruleName, window) self.activeRules[ruleName] = window if not exclusive is None: if debugLoad: print 'set exclusive mode to %s for rule %s' % (exclusive, ruleName) self.setExclusive(exclusive) pass
def load(self, gramSpec, allResults=0, hypothesis=0, grammarName=None): # print 'loading grammar %s, gramspec type: %s'% (grammarName, type(gramSpec)) # code upper ascii characters with latin1 if they were in the process entered as unicode if not type(gramSpec) in (six.text_type, six.binary_type, types.ListType): raise TypeError( "grammar definition of %s must be a string or a list of strings, not %s" % (grammarName, type(gramSpec))) # print 'loading %s, type: %s'% (grammarName, type(gramSpec) ) if type(gramSpec) == types.ListType: for i, grampart in enumerate(gramSpec): line = grampart if type(line) == six.binary_type: line = utilsqh.convertToUnicode(line) if type(line) == six.text_type: line = utilsqh.convertToBinary(line) if line != grampart: gramSpec[i] = line if type(gramSpec) == six.binary_type: gramSpec = utilsqh.convertToUnicode(gramSpec) if type(gramSpec) == six.text_type: gramSpec = utilsqh.convertToBinary(gramSpec) gramSpec = gramSpec.split('\n') gramSpec = [g.rstrip() for g in gramSpec] gramparser.splitApartLines(gramSpec) parser = gramparser.GramParser(gramSpec, grammarName=grammarName) parser.doParse() parser.checkForErrors() gramBin = gramparser.packGrammar(parser) self.scanObj = parser.scanObj # for later error messages. try: GramClassBase.load(self, gramBin, allResults, hypothesis) except natlink.BadGrammar: print 'GrammarBase, cannot load grammar, BadGrammar:\n%s\n' % gramSpec raise # we want to keep a list of the rules which can be activated and the # known lists so we can catch errors earlier self.validRules = parser.exportRules.keys() self.validLists = parser.knownLists.keys() # we reverse the rule dictionary so we can convert rule numbers back # to rule names during recognition self.ruleMap = {} for x in parser.knownRules.keys(): self.ruleMap[parser.knownRules[x]] = x return 1
def emptyList(self, listName): if type(listName) == six.text_type: listName = utilsqh.convertToBinary(listName) if listName not in self.validLists: raise gramparser.GrammarError( "list %s was not defined in the grammar" % listName, self.scanObj) self.gramObj.emptyList(listName)
def checkForBinary(line): """ helper for converting to Binary """ if type(line) == six.binary_type: return line elif type(line) == six.text_type: return utilsqh.convertToBinary(line) else: raise ValueError( "BrowseGrammar, checkForBinary should have binary or unicode as input, not: %s (%s)" % (line, type(line)))
def deactivate(self, ruleName, noError=0): if type(ruleName) == six.text_type: ruleName = utilsqh.convertToBinary(ruleName) if ruleName not in self.validRules: if noError: return if type(ruleName) != six.binary_type: print 'GrammarBase, deactivate, %s (%s)'% (ruleName, type(ruleName)) raise gramparser.GrammarError( "rule %s (%s) was not exported in the grammar" % ruleName, type(ruleName), self.scanObj) if ruleName not in self.activeRules: if noError: return raise gramparser.GrammarError( "rule %s is not active", self.scanObj) if debugLoad: print 'deactivate rule %s'% ruleName self.gramObj.deactivate(ruleName) del self.activeRules[ruleName]
def getModifierKeyCodes(modifiers): """return a list with keycodes for modifiers input can be a list of valid modifiers (ctrl, shift or menu == alt ), either in a sequence or as single string. If string contains the + symbol or a space, the string is split before searching the keycodes Invalid input raises a KeyError. Testing in unittestNatLink, see testNatlinkUtilsFunctions """ modifier_dict = dict(ctrl=vk_control, shift=vk_shift, menu=vk_menu, alt=vk_menu) # added alt == menu if not modifiers: return if type(modifiers) == six.text_type: modifiers = utilsqh.convertToBinary(modifiers) if type(modifiers) == six.binary_type: modifiers = modifiers.replace("+", " ").split() return [modifier_dict[m] for m in modifiers]
def splitApartLines(lines): """split apart the lines of a grammar and clean up unwanted spacing see unittest still problems here!! """ for x in range(len(lines) - 1, -1, -1): line = lines[x] if type(line) == six.binary_type: line = utilsqh.convertToUnicode(line) if type(line) == six.text_type: line = utilsqh.convertToBinary(line) lines[x] = line lines[x] = lines[x].rstrip() crlf = lines[x].find('\n') if crlf >= 0: if x > 0: print 'insert lines at item %s: %s' % (x, lines[x]) lines[x:x + 1] = lines[x].split('\n') # spacing at end of lines: for i, line in enumerate(lines): if line != line.rstrip(): lines[i] = line.rstrip() leftSpacing = [len(l) - len(l.lstrip()) for l in lines] if len(leftSpacing) == 0: raise ValueError("splitApartLines, empty grammar: %s" % repr(lines)) if len(leftSpacing) > 1: minLeftSpacing = min(leftSpacing[1:]) for i, line in enumerate(lines): if i == 0: if line != line.lstrip(): lines[i] = line.lstrip() else: if minLeftSpacing: lines[i] = line[minLeftSpacing:]
def setList(self, listName, words): listName = utilsqh.convertToBinary(listName) self.emptyList(listName) self.appendList(listName, words) # other way around?
def gotResults_info(self, words, fullResults): """display in a message box information about the window, user or unimacro """ T = [] extra = [] if self.hasCommon(words, 'window'): m = natlink.getCurrentModule() hwnd = m[2] p = natqh.getProgInfo(m) toporchild = p[2] T.append('---from natqh.getProgInfo:') T.append('0 program: %s' % p[0]) T.append('1 window title: %s' % p[1]) T.append('2 toporchild: %s' % p[2]) overruleIsTop = self.getTopOrChild() T.append('3 window handle: %s' % p[3]) if toporchild == 'top': if not overruleIsTop: T.append( '****** but should be treated as child window according to actions.ini option "top behaves like child"' ) else: if overruleIsTop: T.append( '****** but should be treated as top window according to actions.ini option "top behaves like child"' ) T.append('') T.append('---from getCurrentModule:') T.append('0 program path: %s' % m[0]) T.append('1 window title: %s' % m[1]) T.append('2 window handle: %s' % m[2]) T.append('') T.append('---from GetClassName:') T.append('class name: %s' % win32gui.GetClassName(hwnd)) elif self.hasCommon(words, 'user'): T.append('user:\t\t%s' % natqh.getUser()) T.append('userLanguage:\t%s' % natqh.getUserLanguage()) T.append('language:\t%s' % self.language) bm = natqh.getBaseModel() bt = natqh.getBaseTopic() ut = natqh.getUserTopic() version = natqh.getDNSVersion() if version >= 15: T.append('UserTopic (DPI15):\t%s' % ut) if natqh.getDNSVersion() >= 15: T.append('BaseTopic (pre 15):\t%s' % bt) else: T.append('BaseTopic (or UserTopic):\t%s' % ut) T.append('BaseModel:\t%s' % bm) # T.append('see messages window for trainuser info') extra = [] # extra.append(r'cd d:\natlink\miscscripts (or different folder)') # extra.append(r'python trainuser.py d:\natlink\recordings\recordingcode "user name" "%s" "%s"'%\ # (bm, bt)) # extra.append('change folders, recording code and user name of course') elif self.hasCommon(words, 'unimacro'): version = natqh.getDNSVersion() T.append('DNSVersion:\t\t%s (%s)' % (version, type(version))) wVersion = natqh.getWindowsVersion() T.append('WindowsVersion:\t\t%s (%s)' % (wVersion, type(wVersion))) T.append('UnimacroDirectory:\t%s' % natqh.getUnimacroDirectory()) T.append('UnimacroUserDirectory:\t%s' % natqh.getUnimacroUserDirectory()) T.append('DNSuserDirectory:\t%s' % natqh.getDNSuserDirectory()) elif self.hasCommon(words, 'path'): T.append('the python path:') T.append(pprint.pformat(sys.path)) elif self.hasCommon(words, "class"): T.append() else: T.append('no valid keyword found') try: s = '\n'.join(T) except UnicodeDecodeError: TT = [utilsqh.convertToBinary(t) for t in T] s = '\n'.join(TT) actions.Message(s) print s print for e in extra: print e
def setList(self, listName, words): if type(listName) == six.text_type: listName = utilsqh.convertToBinary(listName) self.emptyList(listName) self.appendList(listName, words) # other way around?