desc
stringlengths
3
26.7k
decl
stringlengths
11
7.89k
bodies
stringlengths
8
553k
'__init__: This has to be present'
def __init__(self):
self.a = 1 def XXX22(): 'XXX22: This has to be present' pass
'XXX22: This has to be present'
def XXX11():
pass
'Remove recursive references to allow garbage collector to collect this object.'
def cleanup(self):
for dict in (self.rule2func, self.rules, self.rule2name): for i in dict.keys(): dict[i] = None for i in dir(self): setattr(self, i, None)
'Disassemble a code object, returning a list of \'Token\'. The main part of this procedure is modelled after dis.disassemble().'
def disassemble(self, co, classname=None, deob=0):
rv = [] customize = {} Token = self.Token self.code = array('B', co.co_code) linestarts = list(dis.findlinestarts(co)) varnames = list(co.co_varnames) if deob: linestarts = self.deobfuscate(co, linestarts, varnames) code = self.code n = len(code) self.prev = [0] for i in self.op_range(0, n): op = code[i] self.prev.append(i) if (op >= HAVE_ARGUMENT): self.prev.append(i) self.prev.append(i) self.lines = [] linetuple = namedtuple('linetuple', ['l_no', 'next']) j = 0 linestartoffsets = {a for (a, _) in linestarts} (prev_start_byte, prev_line_no) = linestarts[0] for (start_byte, line_no) in linestarts[1:]: while (j < start_byte): self.lines.append(linetuple(prev_line_no, start_byte)) j += 1 last_op = code[self.prev[start_byte]] (prev_start_byte, prev_line_no) = (start_byte, line_no) while (j < n): self.lines.append(linetuple(prev_line_no, n)) j += 1 if classname: classname = (('_' + classname.lstrip('_')) + '__') def unmangle(name): if (name.startswith(classname) and (name[(-2):] != '__')): return name[(len(classname) - 2):] return name free = [unmangle(name) for name in (co.co_cellvars + co.co_freevars)] names = [unmangle(name) for name in co.co_names] varnames = [unmangle(name) for name in varnames] else: free = (co.co_cellvars + co.co_freevars) names = co.co_names self.load_asserts = set() for i in self.op_range(0, n): if ((code[i] == PJIT) and (code[(i + 3)] == LOAD_GLOBAL)): if (names[(code[(i + 4)] + (256 * code[(i + 5)]))] == 'AssertionError'): self.load_asserts.add((i + 3)) cf = self.find_jump_targets(code) last_stmt = self.next_stmt[0] i = self.next_stmt[last_stmt] replace = {} while (i < (n - 1)): if (self.lines[last_stmt].next > i): if (code[last_stmt] == PRINT_ITEM): if (code[i] == PRINT_ITEM): replace[i] = 'PRINT_ITEM_CONT' elif (code[i] == PRINT_NEWLINE): replace[i] = 'PRINT_NEWLINE_CONT' last_stmt = i i = self.next_stmt[i] imports = self.all_instr(0, n, (IMPORT_NAME, IMPORT_FROM, IMPORT_STAR)) if (len(imports) > 1): last_import = imports[0] for i in imports[1:]: if (self.lines[last_import].next > i): if (code[last_import] == IMPORT_NAME == code[i]): replace[i] = 'IMPORT_NAME_CONT' last_import = i extended_arg = 0 for offset in self.op_range(0, n): if (offset in cf): k = 0 for j in cf[offset]: rv.append(Token('COME_FROM', None, repr(j), offset=('%s_%d' % (offset, k)))) k += 1 op = code[offset] opname = dis.opname[op] oparg = None pattr = None if (op >= HAVE_ARGUMENT): oparg = ((code[(offset + 1)] + (code[(offset + 2)] * 256)) + extended_arg) extended_arg = 0 if (op == dis.EXTENDED_ARG): extended_arg = (oparg * 65536L) continue if (op in dis.hasconst): const = co.co_consts[oparg] if (type(const) == types.CodeType): oparg = const if (const.co_name == '<lambda>'): assert (opname == 'LOAD_CONST') opname = 'LOAD_LAMBDA' elif (const.co_name == '<genexpr>'): opname = 'LOAD_GENEXPR' elif (const.co_name == '<dictcomp>'): opname = 'LOAD_DICTCOMP' elif (const.co_name == '<setcomp>'): opname = 'LOAD_SETCOMP' pattr = (('<code_object ' + const.co_name) + '>') else: pattr = const elif (op in dis.hasname): pattr = names[oparg] elif (op in dis.hasjrel): pattr = repr(((offset + 3) + oparg)) elif (op in dis.hasjabs): pattr = repr(oparg) elif (op in dis.haslocal): pattr = varnames[oparg] elif (op in dis.hascompare): pattr = dis.cmp_op[oparg] elif (op in dis.hasfree): pattr = free[oparg] if (op in (BUILD_LIST, BUILD_TUPLE, BUILD_SET, BUILD_SLICE, UNPACK_SEQUENCE, MAKE_FUNCTION, CALL_FUNCTION, MAKE_CLOSURE, CALL_FUNCTION_VAR, CALL_FUNCTION_KW, CALL_FUNCTION_VAR_KW, DUP_TOPX, RAISE_VARARGS)): if ((op == BUILD_TUPLE) and (code[self.prev[offset]] == LOAD_CLOSURE)): continue else: opname = ('%s_%d' % (opname, oparg)) if (op != BUILD_SLICE): customize[opname] = oparg elif (op == JA): target = self.get_target(offset) if (target < offset): if ((offset in self.stmts) and (code[(offset + 3)] not in (END_FINALLY, POP_BLOCK)) and (offset not in self.not_continue)): opname = 'CONTINUE' else: opname = 'JUMP_BACK' elif (op == LOAD_GLOBAL): if (offset in self.load_asserts): opname = 'LOAD_ASSERT' elif (op == RETURN_VALUE): if (offset in self.return_end_ifs): opname = 'RETURN_END_IF' if (offset not in replace): rv.append(Token(opname, oparg, pattr, offset, linestart=(offset in linestartoffsets))) else: rv.append(Token(replace[offset], oparg, pattr, offset, linestart=(offset in linestartoffsets))) if self.showasm: out = self.out for t in rv: print >>out, t print >>out return (rv, customize)
'Find the first <instr> in the block from start to end. <instr> is any python bytecode instruction or a list of opcodes If <instr> is an opcode with a target (like a jump), a target destination can be specified which must match precisely if exact is True, or if exact is False, the instruction which has a target closest to <target> will be returned. Return index to it or None if not found.'
def first_instr(self, start, end, instr, target=None, exact=True):
code = self.code assert ((start >= 0) and (end <= len(code))) try: (None in instr) except: instr = [instr] pos = None distance = len(code) for i in self.op_range(start, end): op = code[i] if (op in instr): if (target is None): return i dest = self.get_target(i, op) if (dest == target): return i elif (not exact): _distance = abs((target - dest)) if (_distance < distance): distance = _distance pos = i return pos
'Find the last <instr> in the block from start to end. <instr> is any python bytecode instruction or a list of opcodes If <instr> is an opcode with a target (like a jump), a target destination can be specified which must match precisely if exact is True, or if exact is False, the instruction which has a target closest to <target> will be returned. Return index to it or None if not found.'
def last_instr(self, start, end, instr, target=None, exact=True):
code = self.code if (not ((start >= 0) and (end <= len(code)))): return None try: (None in instr) except: instr = [instr] pos = None distance = len(code) for i in self.op_range(start, end): op = code[i] if (op in instr): if (target is None): pos = i else: dest = self.get_target(i, op) if (dest == target): distance = 0 pos = i elif (not exact): _distance = abs((target - dest)) if (_distance <= distance): distance = _distance pos = i return pos
'Find all <instr> in the block from start to end. <instr> is any python bytecode instruction or a list of opcodes If <instr> is an opcode with a target (like a jump), a target destination can be specified which must match precisely. Return a list with indexes to them or [] if none found.'
def all_instr(self, start, end, instr, target=None, include_beyond_target=False):
code = self.code assert ((start >= 0) and (end <= len(code))) try: (None in instr) except: instr = [instr] result = [] for i in self.op_range(start, end): op = code[i] if (op in instr): if (target is None): result.append(i) else: t = self.get_target(i, op) if (include_beyond_target and (t >= target)): result.append(i) elif (t == target): result.append(i) return result
'Find all <instr> in the block from start to end. <instr> is any python bytecode instruction or a list of opcodes If <instr> is an opcode with a target (like a jump), a target destination can be specified which must match precisely. Return a list with indexes to them or [] if none found.'
def rem_or(self, start, end, instr, target=None, include_beyond_target=False):
code = self.code assert ((start >= 0) and (end <= len(code))) try: (None in instr) except: instr = [instr] result = [] for i in self.op_range(start, end): op = code[i] if (op in instr): if (target is None): result.append(i) else: t = self.get_target(i, op) if (include_beyond_target and (t >= target)): result.append(i) elif (t == target): result.append(i) pjits = self.all_instr(start, end, PJIT) filtered = [] for pjit in pjits: tgt = (self.get_target(pjit) - 3) for i in result: if ((i <= pjit) or (i >= tgt)): filtered.append(i) result = filtered filtered = [] return result
'Return the next jump that was generated by an except SomeException: construct in a try...except...else clause or None if not found.'
def next_except_jump(self, start):
if (self.code[start] == DUP_TOP): except_match = self.first_instr(start, len(self.code), POP_JUMP_IF_FALSE) if except_match: jmp = self.prev[self.get_target(except_match)] self.ignore_if.add(except_match) self.not_continue.add(jmp) return jmp count_END_FINALLY = 0 count_SETUP_ = 0 for i in self.op_range(start, len(self.code)): op = self.code[i] if (op == END_FINALLY): if (count_END_FINALLY == count_SETUP_): assert (self.code[self.prev[i]] in (JA, JF, RETURN_VALUE)) self.not_continue.add(self.prev[i]) return self.prev[i] count_END_FINALLY += 1 elif (op in (SETUP_EXCEPT, SETUP_WITH, SETUP_FINALLY)): count_SETUP_ += 1
'Restrict pos to parent boundaries.'
def restrict_to_parent(self, target, parent):
if (not (parent['start'] < target < parent['end'])): target = parent['end'] return target
'Detect structures and their boundaries to fix optimizied jumps in python2.3+'
def detect_structure(self, pos, op=None):
code = self.code if (op is None): op = code[pos] parent = self.structs[0] start = parent['start'] end = parent['end'] for s in self.structs: _start = s['start'] _end = s['end'] if ((_start <= pos < _end) and ((_start >= start) and (_end <= end))): start = _start end = _end parent = s origStructCount = len(self.structs) if (op == SETUP_LOOP): start = (pos + 3) target = self.get_target(pos, op) end = self.restrict_to_parent(target, parent) if (target != end): self.fixed_jumps[pos] = end (line_no, next_line_byte) = self.lines[pos] jump_back = self.last_instr(start, end, JA, next_line_byte, False) if (jump_back and (jump_back != self.prev[end]) and (code[(jump_back + 3)] in (JA, JF))): if ((code[self.prev[end]] == RETURN_VALUE) or ((code[self.prev[end]] == POP_BLOCK) and (code[self.prev[self.prev[end]]] == RETURN_VALUE))): jump_back = None if (not jump_back): jump_back = (self.last_instr(start, end, RETURN_VALUE) + 1) if (not jump_back): return if (code[self.prev[next_line_byte]] not in (PJIF, PJIT)): loop_type = 'for' else: loop_type = 'while' self.ignore_if.add(self.prev[next_line_byte]) target = next_line_byte end = (jump_back + 3) else: if (self.get_target(jump_back) >= next_line_byte): jump_back = self.last_instr(start, end, JA, start, False) if ((end > (jump_back + 4)) and (code[end] in (JF, JA))): if (code[(jump_back + 4)] in (JA, JF)): if (self.get_target((jump_back + 4)) == self.get_target(end)): self.fixed_jumps[pos] = (jump_back + 4) end = (jump_back + 4) elif (target < pos): self.fixed_jumps[pos] = (jump_back + 4) end = (jump_back + 4) target = self.get_target(jump_back, JA) if (code[target] in (FOR_ITER, GET_ITER)): loop_type = 'for' else: loop_type = 'while' test = self.prev[next_line_byte] if (test == pos): loop_type = 'while 1' else: self.ignore_if.add(test) test_target = self.get_target(test) if (test_target > (jump_back + 3)): jump_back = test_target self.not_continue.add(jump_back) self.loops.append(target) self.structs.append({'type': (loop_type + '-loop'), 'start': target, 'end': jump_back}) if ((jump_back + 3) != end): self.structs.append({'type': (loop_type + '-else'), 'start': (jump_back + 3), 'end': end}) elif (op == SETUP_EXCEPT): start = (pos + 3) target = self.get_target(pos, op) end = self.restrict_to_parent(target, parent) if (target != end): self.fixed_jumps[pos] = end self.structs.append({'type': 'try', 'start': start, 'end': (end - 4)}) end_else = start_else = self.get_target(self.prev[end]) i = end while (self.code[i] != END_FINALLY): jmp = self.next_except_jump(i) if (self.code[jmp] == RETURN_VALUE): self.structs.append({'type': 'except', 'start': i, 'end': (jmp + 1)}) i = (jmp + 1) else: if (self.get_target(jmp) != start_else): end_else = self.get_target(jmp) if (self.code[jmp] == JF): self.fixed_jumps[jmp] = (-1) self.structs.append({'type': 'except', 'start': i, 'end': jmp}) i = (jmp + 3) if (end_else != start_else): r_end_else = self.restrict_to_parent(end_else, parent) self.structs.append({'type': 'try-else', 'start': (i + 1), 'end': r_end_else}) self.fixed_jumps[i] = r_end_else else: self.fixed_jumps[i] = (i + 1) elif (op in (PJIF, PJIT)): start = (pos + 3) target = self.get_target(pos, op) rtarget = self.restrict_to_parent(target, parent) pre = self.prev if ((target != rtarget) and (parent['type'] == 'and/or')): self.fixed_jumps[pos] = rtarget return if ((code[pre[target]] in (JUMP_IF_FALSE_OR_POP, JUMP_IF_TRUE_OR_POP, PJIF, PJIT)) and (target > pos)): self.fixed_jumps[pos] = pre[target] self.structs.append({'type': 'and/or', 'start': start, 'end': pre[target]}) return if (op == PJIF): match = self.rem_or(start, self.next_stmt[pos], PJIF, target) match = self.remove_mid_line_ifs(match) if match: if ((code[pre[rtarget]] in (JF, JA)) and (pre[rtarget] not in self.stmts) and (self.restrict_to_parent(self.get_target(pre[rtarget]), parent) == rtarget)): if ((code[pre[pre[rtarget]]] == JA) and self.remove_mid_line_ifs([pos]) and (target == self.get_target(pre[pre[rtarget]])) and ((pre[pre[rtarget]] not in self.stmts) or (self.get_target(pre[pre[rtarget]]) > pre[pre[rtarget]])) and (1 == len(self.remove_mid_line_ifs(self.rem_or(start, pre[pre[rtarget]], (PJIF, PJIT), target))))): pass elif ((code[pre[pre[rtarget]]] == RETURN_VALUE) and self.remove_mid_line_ifs([pos]) and (1 == len((set(self.remove_mid_line_ifs(self.rem_or(start, pre[pre[rtarget]], (PJIF, PJIT), target))) | set(self.remove_mid_line_ifs(self.rem_or(start, pre[pre[rtarget]], (PJIF, PJIT, JA), pre[rtarget], True))))))): pass else: fix = None jump_ifs = self.all_instr(start, self.next_stmt[pos], PJIF) last_jump_good = True for j in jump_ifs: if (target == self.get_target(j)): if ((self.lines[j].next == (j + 3)) and last_jump_good): fix = j break else: last_jump_good = False self.fixed_jumps[pos] = (fix or match[(-1)]) return else: self.fixed_jumps[pos] = match[(-1)] return else: if ((pos + 3) in self.load_asserts): if (code[pre[rtarget]] == RAISE_VARARGS): return self.load_asserts.remove((pos + 3)) next = self.next_stmt[pos] if (pre[next] == pos): pass elif ((code[next] in (JF, JA)) and (target == self.get_target(next))): if (code[pre[next]] == PJIF): if ((code[next] == JF) or (target != rtarget) or (code[pre[pre[rtarget]]] not in (JA, RETURN_VALUE))): self.fixed_jumps[pos] = pre[next] return elif ((code[next] == JA) and (code[target] in (JA, JF))): next_target = self.get_target(next) if (self.get_target(target) == next_target): self.fixed_jumps[pos] = pre[next] return elif ((code[next_target] in (JA, JF)) and (self.get_target(next_target) == self.get_target(target))): self.fixed_jumps[pos] = pre[next] return if (pos in self.ignore_if): return if ((code[pre[rtarget]] == JA) and (pre[rtarget] in self.stmts) and (pre[rtarget] != pos) and (pre[pre[rtarget]] != pos)): if ((code[rtarget] == JA) and (code[(rtarget + 3)] == POP_BLOCK)): if (code[pre[pre[rtarget]]] != JA): pass elif (self.get_target(pre[pre[rtarget]]) != target): pass else: rtarget = pre[rtarget] else: rtarget = pre[rtarget] if (code[pre[rtarget]] in (JA, JF)): if_end = self.get_target(pre[rtarget]) if ((if_end < pre[rtarget]) and (code[pre[if_end]] == SETUP_LOOP)): if (if_end > start): return end = self.restrict_to_parent(if_end, parent) self.structs.append({'type': 'if-then', 'start': start, 'end': pre[rtarget]}) self.not_continue.add(pre[rtarget]) if (rtarget < end): self.structs.append({'type': 'if-else', 'start': rtarget, 'end': end}) elif (code[pre[rtarget]] == RETURN_VALUE): self.structs.append({'type': 'if-then', 'start': start, 'end': rtarget}) self.return_end_ifs.add(pre[rtarget]) elif (op in (JUMP_IF_FALSE_OR_POP, JUMP_IF_TRUE_OR_POP)): target = self.get_target(pos, op) self.fixed_jumps[pos] = self.restrict_to_parent(target, parent)
'Detect all offsets in a byte code which are jump targets. Return the list of offsets. This procedure is modelled after dis.findlables(), but here for each target the number of jumps are counted.'
def find_jump_targets(self, code):
hasjrel = dis.hasjrel hasjabs = dis.hasjabs n = len(code) self.structs = [{'type': 'root', 'start': 0, 'end': (n - 1)}] self.loops = [] self.fixed_jumps = {} self.ignore_if = set() self.build_stmt_indices() self.not_continue = set() self.return_end_ifs = set() targets = {} for i in self.op_range(0, n): op = code[i] self.detect_structure(i, op) if (op >= HAVE_ARGUMENT): label = self.fixed_jumps.get(i) oparg = (code[(i + 1)] + (code[(i + 2)] * 256)) if (label is None): if ((op in hasjrel) and (op != FOR_ITER)): label = ((i + 3) + oparg) elif (op in hasjabs): if (op in (JUMP_IF_FALSE_OR_POP, JUMP_IF_TRUE_OR_POP)): if (oparg > i): label = oparg if ((label is not None) and (label != (-1))): targets[label] = (targets.get(label, []) + [i]) elif ((op == END_FINALLY) and (i in self.fixed_jumps)): label = self.fixed_jumps[i] targets[label] = (targets.get(label, []) + [i]) return targets
'exec_stmt ::= expr exprlist DUP_TOP EXEC_STMT exec_stmt ::= expr exprlist EXEC_STMT'
def n_exec_stmt(self, node):
self.write(self.indent, 'exec ') self.preorder(node[0]) if (node[1][0] != NONE): sep = ' in ' for subnode in node[1]: self.write(sep) sep = ', ' self.preorder(subnode) self.print_() self.prune()
'prettyprint a mapexpr \'mapexpr\' is something like k = {\'a\': 1, \'b\': 42 }"'
def n_mapexpr(self, node):
p = self.prec self.prec = 100 assert (node[(-1)] == 'kvlist') node = node[(-1)] self.indentMore(INDENT_PER_LEVEL) line_seperator = (',\n' + self.indent) sep = INDENT_PER_LEVEL[:(-1)] self.write('{') for kv in node: assert (kv in ('kv', 'kv2', 'kv3')) if (kv == 'kv'): name = self.traverse(kv[(-2)], indent='') value = self.traverse(kv[1], indent=(self.indent + ((len(name) + 2) * ' '))) elif (kv == 'kv2'): name = self.traverse(kv[1], indent='') value = self.traverse(kv[(-3)], indent=(self.indent + ((len(name) + 2) * ' '))) elif (kv == 'kv3'): name = self.traverse(kv[(-2)], indent='') value = self.traverse(kv[0], indent=(self.indent + ((len(name) + 2) * ' '))) self.write(sep, name, ': ', value) sep = line_seperator self.write('}') self.indentLess(INDENT_PER_LEVEL) self.prec = p self.prune()
'prettyprint a list or tuple'
def n_build_list(self, node):
p = self.prec self.prec = 100 lastnode = node.pop() lastnodetype = lastnode.type if lastnodetype.startswith('BUILD_LIST'): self.write('[') endchar = ']' elif lastnodetype.startswith('BUILD_TUPLE'): self.write('(') endchar = ')' elif lastnodetype.startswith('BUILD_SET'): self.write('{') endchar = '}' elif lastnodetype.startswith('ROT_TWO'): self.write('(') endchar = ')' else: raise 'Internal Error: n_build_list expects list or tuple' flat_elems = [] for elem in node: if (elem == 'expr1024'): for subelem in elem: for subsubelem in subelem: flat_elems.append(subsubelem) elif (elem == 'expr32'): for subelem in elem: flat_elems.append(subelem) else: flat_elems.append(elem) self.indentMore(INDENT_PER_LEVEL) if (lastnode.attr > 3): line_separator = (',\n' + self.indent) else: line_separator = ', ' sep = INDENT_PER_LEVEL[:(-1)] for elem in flat_elems: if (elem == 'ROT_THREE'): continue assert (elem == 'expr') value = self.traverse(elem) self.write(sep, value) sep = line_separator if ((lastnode.attr == 1) and lastnodetype.startswith('BUILD_TUPLE')): self.write(',') self.write(endchar) self.indentLess(INDENT_PER_LEVEL) self.prec = p self.prune()
'Special handling for opcodes that take a variable number of arguments -- we add a new entry for each in TABLE_R.'
def customize(self, customize):
for (k, v) in customize.items(): if TABLE_R.has_key(k): continue op = k[:k.rfind('_')] if (op == 'CALL_FUNCTION'): TABLE_R[k] = ('%c(%P)', 0, (1, (-1), ', ', 100)) elif (op in ('CALL_FUNCTION_VAR', 'CALL_FUNCTION_VAR_KW', 'CALL_FUNCTION_KW')): if (v == 0): str = '%c(%C' p2 = (0, 0, None) else: str = '%c(%C, ' p2 = (1, (-2), ', ') if (op == 'CALL_FUNCTION_VAR'): str += '*%c)' entry = (str, 0, p2, (-2)) elif (op == 'CALL_FUNCTION_KW'): str += '**%c)' entry = (str, 0, p2, (-2)) else: str += '*%c, **%c)' if p2[2]: p2 = (1, (-3), ', ') entry = (str, 0, p2, (-3), (-2)) TABLE_R[k] = entry
'If the name of the formal parameter starts with dot, it\'s a tuple parameter, like this: # def MyFunc(xx, (a,b,c), yy): # print a, b*2, c*42 In byte-code, the whole tuple is assigned to parameter \'.1\' and then the tuple gets unpacked to \'a\', \'b\' and \'c\'. Since identifiers starting with a dot are illegal in Python, we can search for the byte-code equivalent to \'(a,b,c) = .1\''
def get_tuple_parameter(self, ast, name):
assert (ast == 'stmts') for i in range(len(ast)): assert (ast[i][0] == 'stmt') node = ast[i][0][0] if ((node == 'assign') and (node[0] == ASSIGN_TUPLE_PARAM(name))): del ast[i] assert (node[1] == 'designator') return (('(' + self.traverse(node[1])) + ')') raise ("Can't find tuple parameter" % name)
'Dump function defintion, doc string, and function body.'
def make_function(self, node, isLambda, nested=1):
def build_param(ast, name, default): 'build parameters:\n - handle defaults\n - handle format tuple parameters\n ' if name.startswith('.'): name = self.get_tuple_parameter(ast, name) if default: if self.showast: print '--', name print default print '--' result = ('%s = %s' % (name, self.traverse(default, indent=''))) if (result[(-2):] == '= '): result += 'None' return result else: return name defparams = node[:node[(-1)].attr] code = node[(-2)].attr assert (type(code) == CodeType) code = Code(code, self.scanner, self.currentclass) argc = code.co_argcount paramnames = list(code.co_varnames[:argc]) paramnames.reverse() defparams.reverse() try: ast = self.build_ast(code._tokens, code._customize, isLambda=isLambda, noneInNames=('None' in code.co_names)) except ParserError as p: self.write(str(p)) self.ERROR = p return params = [] for (name, default) in map((lambda a, b: (a, b)), paramnames, defparams): params.append(build_param(ast, name, default)) params.reverse() if (4 & code.co_flags): params.append(('*%s' % code.co_varnames[argc])) argc += 1 if (8 & code.co_flags): params.append(('**%s' % code.co_varnames[argc])) argc += 1 indent = self.indent if isLambda: self.write('lambda ', ', '.join(params), ': ') else: self.print_('(', ', '.join(params), '):') if ((len(code.co_consts) > 0) and (code.co_consts[0] != None)): self.print_docstring(indent, code.co_consts[0]) code._tokens = None assert (ast == 'stmts') all_globals = find_all_globals(ast, set()) for g in ((all_globals & self.mod_globs) | find_globals(ast, set())): self.print_(self.indent, 'global ', g) self.mod_globs -= all_globals rn = (('None' in code.co_names) and (not find_none(ast))) self.gen_source(ast, code._customize, isLambda=isLambda, returnNone=rn) code._tokens = None code._customize = None
'Dump class definition, doc string and class body.'
def build_class(self, code):
assert (type(code) == CodeType) code = Code(code, self.scanner, self.currentclass) indent = self.indent ast = self.build_ast(code._tokens, code._customize) code._tokens = None assert (ast == 'stmts') if (ast[0][0] == NAME_MODULE): del ast[0] if (code.co_consts and (code.co_consts[0] != None) and (ast[0][0] == ASSIGN_DOC_STRING(code.co_consts[0]))): self.print_docstring(indent, code.co_consts[0]) self.print_() del ast[0] if (ast[(-1)][0] == RETURN_LOCALS): del ast[(-1)] for g in find_globals(ast, set()): self.print_(indent, 'global ', g) self.gen_source(ast, code._customize) code._tokens = None code._customize = None
'convert AST to source code'
def gen_source(self, ast, customize, isLambda=0, returnNone=False):
rn = self.return_none self.return_none = returnNone if (len(ast) == 0): self.print_(self.indent, 'pass') else: self.customize(customize) if isLambda: self.write(self.traverse(ast, isLambda=isLambda)) else: self.print_(self.traverse(ast, isLambda=isLambda)) self.return_none = rn
'Places new Gmail notifications in the Notifier\'s queue.'
def handleEmailNotifications(self, lastDate):
emails = Gmail.fetchUnreadEmails(self.profile, since=lastDate) if emails: lastDate = Gmail.getMostRecentDate(emails) def styleEmail(e): return ('New email from %s.' % Gmail.getSender(e)) for e in emails: self.q.put(styleEmail(e)) return lastDate
'Returns a notification. Note that this function is consuming.'
def getNotification(self):
try: notif = self.q.get(block=False) return notif except Queue.Empty: return None
'Return a list of notifications in chronological order. Note that this function is consuming, so consecutive calls will yield different results.'
def getAllNotifications(self):
notifs = [] notif = self.getNotification() while notif: notifs.append(notif) notif = self.getNotification() return notifs
'Calculates a revision from phrases by using the SHA1 hash function. Arguments: phrases -- a list of phrases Returns: A revision string for given phrases.'
@classmethod def phrases_to_revision(cls, phrases):
sorted_phrases = sorted(phrases) joined_phrases = '\n'.join(sorted_phrases) sha1 = hashlib.sha1() sha1.update(joined_phrases) return sha1.hexdigest()
'Initializes a new Vocabulary instance. Optional Arguments: name -- (optional) the name of the vocabulary (Default: \'default\') path -- (optional) the path in which the vocabulary exists or will be created (Default: \'.\')'
def __init__(self, name='default', path='.'):
self.name = name self.path = os.path.abspath(os.path.join(path, self.PATH_PREFIX, name)) self._logger = logging.getLogger(__name__)
'Returns: The path of the the revision file as string'
@property def revision_file(self):
return os.path.join(self.path, 'revision')
'Checks if the vocabulary is compiled by checking if the revision file is readable. This method should be overridden by subclasses to check for class-specific additional files, too. Returns: True if the dictionary is compiled, else False'
@abstractproperty def is_compiled(self):
return os.access(self.revision_file, os.R_OK)
'Reads the compiled revision from the revision file. Returns: the revision of this vocabulary (i.e. the string inside the revision file), or None if is_compiled if False'
@property def compiled_revision(self):
if (not self.is_compiled): return None with open(self.revision_file, 'r') as f: revision = f.read().strip() self._logger.debug("compiled_revision is '%s'", revision) return revision
'Convenience method to check if this vocabulary exactly contains the phrases passed to this method. Arguments: phrases -- a list of phrases Returns: True if phrases exactly matches the phrases inside this vocabulary.'
def matches_phrases(self, phrases):
return (self.compiled_revision == self.phrases_to_revision(phrases))
'Compiles this vocabulary. If the force argument is True, compilation will be forced regardless of necessity (which means that the preliminary check if the current revision already equals the revision after compilation will be skipped). This method is not meant to be overridden by subclasses - use the _compile_vocabulary()-method instead. Arguments: phrases -- a list of phrases that this vocabulary will contain force -- (optional) forces compilation (Default: False) Returns: The revision of the compiled vocabulary'
def compile(self, phrases, force=False):
revision = self.phrases_to_revision(phrases) if ((not force) and (self.compiled_revision == revision)): self._logger.debug(('Compilation not neccessary, compiled ' + 'version matches phrases.')) return revision if (not os.path.exists(self.path)): self._logger.debug(("Vocabulary dir '%s' does not exist, " + 'creating...'), self.path) try: os.makedirs(self.path) except OSError: self._logger.error("Couldn't create vocabulary dir '%s'", self.path, exc_info=True) raise try: with open(self.revision_file, 'w') as f: f.write(revision) except (OSError, IOError): self._logger.error("Couldn't write revision file in '%s'", self.revision_file, exc_info=True) raise else: self._logger.info('Starting compilation...') try: self._compile_vocabulary(phrases) except Exception as e: self._logger.error(('Fatal compilation Error occured, ' + 'cleaning up...'), exc_info=True) try: os.remove(self.revision_file) except OSError: pass raise e else: self._logger.info('Compilation done.') return revision
'Checks if the vocabulary is compiled by checking if the revision file is readable. Returns: True if this vocabulary has been compiled, else False'
@property def is_compiled(self):
return super(self.__class__, self).is_compiled
'Does nothing (because this is a dummy class for testing purposes).'
def _compile_vocabulary(self, phrases):
pass
'Returns: The path of the the pocketsphinx languagemodel file as string'
@property def languagemodel_file(self):
return os.path.join(self.path, 'languagemodel')
'Returns: The path of the pocketsphinx dictionary file as string'
@property def dictionary_file(self):
return os.path.join(self.path, 'dictionary')
'Checks if the vocabulary is compiled by checking if the revision, languagemodel and dictionary files are readable. Returns: True if this vocabulary has been compiled, else False'
@property def is_compiled(self):
return (super(self.__class__, self).is_compiled and os.access(self.languagemodel_file, os.R_OK) and os.access(self.dictionary_file, os.R_OK))
'Convenience property to use this Vocabulary with the __init__() method of the pocketsphinx.Decoder class. Returns: A dict containing kwargs for the pocketsphinx.Decoder.__init__() method. Example: decoder = pocketsphinx.Decoder(**vocab_instance.decoder_kwargs, hmm=\'/path/to/hmm\')'
@property def decoder_kwargs(self):
return {'lm': self.languagemodel_file, 'dict': self.dictionary_file}
'Compiles the vocabulary to the Pocketsphinx format by creating a languagemodel and a dictionary. Arguments: phrases -- a list of phrases that this vocabulary will contain'
def _compile_vocabulary(self, phrases):
text = ' '.join([('<s> %s </s>' % phrase) for phrase in phrases]) self._logger.debug('Compiling languagemodel...') vocabulary = self._compile_languagemodel(text, self.languagemodel_file) self._logger.debug('Starting dictionary...') self._compile_dictionary(vocabulary, self.dictionary_file)
'Compiles the languagemodel from a text. Arguments: text -- the text the languagemodel will be generated from output_file -- the path of the file this languagemodel will be written to Returns: A list of all unique words this vocabulary contains.'
def _compile_languagemodel(self, text, output_file):
with tempfile.NamedTemporaryFile(suffix='.vocab', delete=False) as f: vocab_file = f.name self._logger.debug("Creating vocab file: '%s'", vocab_file) cmuclmtk.text2vocab(text, vocab_file) self._logger.debug("Creating languagemodel file: '%s'", output_file) cmuclmtk.text2lm(text, output_file, vocab_file=vocab_file) self._logger.debug(('Getting words from vocab file and removing it ' + 'afterwards...')) words = [] with open(vocab_file, 'r') as f: for line in f: line = line.strip() if ((not line.startswith('#')) and (line not in ('<s>', '</s>'))): words.append(line) os.remove(vocab_file) return words
'Compiles the dictionary from a list of words. Arguments: words -- a list of all unique words this vocabulary contains output_file -- the path of the file this dictionary will be written to'
def _compile_dictionary(self, words, output_file):
self._logger.debug('Getting phonemes for %d words...', len(words)) g2pconverter = PhonetisaurusG2P(**PhonetisaurusG2P.get_config()) phonemes = g2pconverter.translate(words) self._logger.debug("Creating dict file: '%s'", output_file) with open(output_file, 'w') as f: for (word, pronounciations) in phonemes.items(): for (i, pronounciation) in enumerate(pronounciations, start=1): if (i == 1): line = ('%s DCTB %s\n' % (word, pronounciation)) else: line = ('%s(%d) DCTB %s\n' % (word, i, pronounciation)) f.write(line)
'Returns: The path of the the julius dfa file as string'
@property def dfa_file(self):
return os.path.join(self.path, 'dfa')
'Returns: The path of the the julius dict file as string'
@property def dict_file(self):
return os.path.join(self.path, 'dict')
'Prepare the client and music variables'
def __init__(self, server='localhost', port=6600):
self.server = server self.port = port self.client = mpd.MPDClient() self.client.timeout = None self.client.idletimeout = None self.client.connect(self.server, self.port) self.playlists = [x['playlist'] for x in self.client.listplaylists()] self.client.clear() for playlist in self.playlists: self.client.load(playlist) self.songs = [] self.song_titles = [] self.song_artists = [] soup = self.client.playlist() for i in range(0, (len(soup) / 10)): index = (i * 10) id = soup[index].strip() title = soup[(index + 3)].strip().upper() artist = soup[(index + 2)].strip().upper() album = soup[(index + 4)].strip().upper() self.songs.append(Song(id, title, artist, album)) self.song_titles.append(title) self.song_artists.append(artist)
'Plays the current song or accepts a song to play. Arguments: songs -- a list of song objects playlist_name -- user-defined, something like "Love Song Playlist"'
@reconnect def play(self, songs=False, playlist_name=False):
if songs: self.client.clear() for song in songs: try: self.client.add(song.id) except: pass if playlist_name: self.client.clear() self.client.load(playlist_name) self.client.play()
'Returns the list of unique words that comprise song and artist titles'
def get_soup(self):
soup = [] for song in self.songs: song_words = song.title.split(' ') artist_words = song.artist.split(' ') soup.extend(song_words) soup.extend(artist_words) title_trans = ''.join(((chr(c) if (chr(c).isupper() or chr(c).islower()) else '_') for c in range(256))) soup = [x.decode('utf-8').encode('ascii', 'ignore').upper().translate(title_trans).replace('_', '') for x in soup] soup = [x for x in soup if (x != '')] return list(set(soup))
'Returns the list of unique words that comprise playlist names'
def get_soup_playlist(self):
soup = [] for name in self.playlists: soup.extend(name.split(' ')) title_trans = ''.join(((chr(c) if (chr(c).isupper() or chr(c).islower()) else '_') for c in range(256))) soup = [x.decode('utf-8').encode('ascii', 'ignore').upper().translate(title_trans).replace('_', '') for x in soup] soup = [x for x in soup if (x != '')] return list(set(soup))
'Returns the list of PHRASES that comprise song and artist titles'
def get_soup_separated(self):
title_soup = [song.title for song in self.songs] artist_soup = [song.artist for song in self.songs] soup = list(set((title_soup + artist_soup))) title_trans = ''.join(((chr(c) if (chr(c).isupper() or chr(c).islower()) else '_') for c in range(256))) soup = [x.decode('utf-8').encode('ascii', 'ignore').upper().translate(title_trans).replace('_', ' ') for x in soup] soup = [re.sub(' +', ' ', x) for x in soup if (x != '')] return soup
'Returns songs matching a query best as possible on either artist field, etc'
def fuzzy_songs(self, query):
query = query.upper() matched_song_titles = difflib.get_close_matches(query, self.song_titles) matched_song_artists = difflib.get_close_matches(query, self.song_artists) strict_priority_title = [x for x in matched_song_titles if (x == query)] strict_priority_artists = [x for x in matched_song_artists if (x == query)] if strict_priority_title: matched_song_titles = strict_priority_title if strict_priority_artists: matched_song_artists = strict_priority_artists matched_songs_bytitle = [song for song in self.songs if (song.title in matched_song_titles)] matched_songs_byartist = [song for song in self.songs if (song.artist in matched_song_artists)] matches = list(set((matched_songs_bytitle + matched_songs_byartist))) return matches
'returns playlist names that match query best as possible'
def fuzzy_playlists(self, query):
query = query.upper() lookup = {n.upper(): n for n in self.playlists} results = [lookup[r] for r in difflib.get_close_matches(query, lookup)] return results
'Initiates the pocketsphinx instance. Arguments: speaker -- handles platform-independent audio output passive_stt_engine -- performs STT while Jasper is in passive listen mode acive_stt_engine -- performs STT while Jasper is in active listen mode'
def __init__(self, speaker, passive_stt_engine, active_stt_engine):
self._logger = logging.getLogger(__name__) self.speaker = speaker self.passive_stt_engine = passive_stt_engine self.active_stt_engine = active_stt_engine self._logger.info((('Initializing PyAudio. ALSA/Jack error messages ' + 'that pop up during this process are normal and ') + 'can usually be safely ignored.')) self._audio = pyaudio.PyAudio() self._logger.info('Initialization of PyAudio completed.')
'Listens for PERSONA in everyday sound. Times out after LISTEN_TIME, so needs to be restarted.'
def passiveListen(self, PERSONA):
THRESHOLD_MULTIPLIER = 1.8 RATE = 16000 CHUNK = 1024 THRESHOLD_TIME = 1 LISTEN_TIME = 10 stream = self._audio.open(format=pyaudio.paInt16, channels=1, rate=RATE, input=True, frames_per_buffer=CHUNK) frames = [] lastN = [i for i in range(30)] for i in range(0, ((RATE / CHUNK) * THRESHOLD_TIME)): data = stream.read(CHUNK) frames.append(data) lastN.pop(0) lastN.append(self.getScore(data)) average = (sum(lastN) / len(lastN)) THRESHOLD = (average * THRESHOLD_MULTIPLIER) frames = [] didDetect = False for i in range(0, ((RATE / CHUNK) * LISTEN_TIME)): data = stream.read(CHUNK) frames.append(data) score = self.getScore(data) if (score > THRESHOLD): didDetect = True break if (not didDetect): print 'No disturbance detected' stream.stop_stream() stream.close() return (None, None) frames = frames[(-20):] DELAY_MULTIPLIER = 1 for i in range(0, ((RATE / CHUNK) * DELAY_MULTIPLIER)): data = stream.read(CHUNK) frames.append(data) stream.stop_stream() stream.close() with tempfile.NamedTemporaryFile(mode='w+b') as f: wav_fp = wave.open(f, 'wb') wav_fp.setnchannels(1) wav_fp.setsampwidth(pyaudio.get_sample_size(pyaudio.paInt16)) wav_fp.setframerate(RATE) wav_fp.writeframes(''.join(frames)) wav_fp.close() f.seek(0) transcribed = self.passive_stt_engine.transcribe(f) if any(((PERSONA in phrase) for phrase in transcribed)): return (THRESHOLD, PERSONA) return (False, transcribed)
'Records until a second of silence or times out after 12 seconds Returns the first matching string or None'
def activeListen(self, THRESHOLD=None, LISTEN=True, MUSIC=False):
options = self.activeListenToAllOptions(THRESHOLD, LISTEN, MUSIC) if options: return options[0]
'Records until a second of silence or times out after 12 seconds Returns a list of the matching options or None'
def activeListenToAllOptions(self, THRESHOLD=None, LISTEN=True, MUSIC=False):
RATE = 16000 CHUNK = 1024 LISTEN_TIME = 12 if (THRESHOLD is None): THRESHOLD = self.fetchThreshold() self.speaker.play(jasperpath.data('audio', 'beep_hi.wav')) stream = self._audio.open(format=pyaudio.paInt16, channels=1, rate=RATE, input=True, frames_per_buffer=CHUNK) frames = [] lastN = [(THRESHOLD * 1.2) for i in range(30)] for i in range(0, ((RATE / CHUNK) * LISTEN_TIME)): data = stream.read(CHUNK) frames.append(data) score = self.getScore(data) lastN.pop(0) lastN.append(score) average = (sum(lastN) / float(len(lastN))) if (average < (THRESHOLD * 0.8)): break self.speaker.play(jasperpath.data('audio', 'beep_lo.wav')) stream.stop_stream() stream.close() with tempfile.SpooledTemporaryFile(mode='w+b') as f: wav_fp = wave.open(f, 'wb') wav_fp.setnchannels(1) wav_fp.setsampwidth(pyaudio.get_sample_size(pyaudio.paInt16)) wav_fp.setframerate(RATE) wav_fp.writeframes(''.join(frames)) wav_fp.close() f.seek(0) return self.active_stt_engine.transcribe(f)
'Delegates user input to the handling function when activated.'
def handleForever(self):
self._logger.info("Starting to handle conversation with keyword '%s'.", self.persona) while True: notifications = self.notifier.getAllNotifications() for notif in notifications: self._logger.info("Received notification: '%s'", str(notif)) self._logger.debug("Started listening for keyword '%s'", self.persona) (threshold, transcribed) = self.mic.passiveListen(self.persona) self._logger.debug("Stopped listening for keyword '%s'", self.persona) if ((not transcribed) or (not threshold)): self._logger.info('Nothing has been said or transcribed.') continue self._logger.info("Keyword '%s' has been said!", self.persona) self._logger.debug('Started to listen actively with threshold: %r', threshold) input = self.mic.activeListenToAllOptions(threshold) self._logger.debug('Stopped to listen actively with threshold: %r', threshold) if input: self.brain.query(input) else: self.mic.say('Pardon?')
'Instantiates a new Brain object, which cross-references user input with a list of modules. Note that the order of brain.modules matters, as the Brain will cease execution on the first module that accepts a given input. Arguments: mic -- used to interact with the user (for both input and output) profile -- contains information related to the user (e.g., phone number)'
def __init__(self, mic, profile):
self.mic = mic self.profile = profile self.modules = self.get_modules() self._logger = logging.getLogger(__name__)
'Dynamically loads all the modules in the modules folder and sorts them by the PRIORITY key. If no PRIORITY is defined for a given module, a priority of 0 is assumed.'
@classmethod def get_modules(cls):
logger = logging.getLogger(__name__) locations = [jasperpath.PLUGIN_PATH] logger.debug('Looking for modules in: %s', ', '.join([("'%s'" % location) for location in locations])) modules = [] for (finder, name, ispkg) in pkgutil.walk_packages(locations): try: loader = finder.find_module(name) mod = loader.load_module(name) except: logger.warning("Skipped module '%s' due to an error.", name, exc_info=True) else: if hasattr(mod, 'WORDS'): logger.debug("Found module '%s' with words: %r", name, mod.WORDS) modules.append(mod) else: logger.warning(("Skipped module '%s' because it misses " + 'the WORDS constant.'), name) modules.sort(key=(lambda mod: (mod.PRIORITY if hasattr(mod, 'PRIORITY') else 0)), reverse=True) return modules
'Passes user input to the appropriate module, testing it against each candidate module\'s isValid function. Arguments: text -- user input, typically speech, to be parsed by a module'
def query(self, texts):
for module in self.modules: for text in texts: if module.isValid(text): self._logger.debug(("'%s' is a valid phrase for module " + "'%s'"), text, module.__name__) try: module.handle(text, self.mic, self.profile) except Exception: self._logger.error('Failed to execute module', exc_info=True) self.mic.say(("I'm sorry. I had some trouble with " + 'that operation. Please try again later.')) else: self._logger.debug(("Handling of phrase '%s' by " + "module '%s' completed"), text, module.__name__) finally: return self._logger.debug(('No module was able to handle any of these ' + 'phrases: %r'), texts)
'Initiates the pocketsphinx instance. Arguments: vocabulary -- a PocketsphinxVocabulary instance hmm_dir -- the path of the Hidden Markov Model (HMM)'
def __init__(self, vocabulary, hmm_dir=('/usr/local/share/' + 'pocketsphinx/model/hmm/en_US/hub4wsj_sc_8k')):
self._logger = logging.getLogger(__name__) try: import pocketsphinx as ps except: import pocketsphinx as ps with tempfile.NamedTemporaryFile(prefix='psdecoder_', suffix='.log', delete=False) as f: self._logfile = f.name self._logger.debug(('Initializing PocketSphinx Decoder with hmm_dir ' + "'%s'"), hmm_dir) if (not os.path.exists(hmm_dir)): msg = (("hmm_dir '%s' does not exist! Please make sure that you " + 'have set the correct hmm_dir in your profile.') % hmm_dir) self._logger.error(msg) raise RuntimeError(msg) missing_hmm_files = [] for fname in ('mdef', 'feat.params', 'means', 'noisedict', 'transition_matrices', 'variances'): if (not os.path.exists(os.path.join(hmm_dir, fname))): missing_hmm_files.append(fname) mixweights = os.path.exists(os.path.join(hmm_dir, 'mixture_weights')) sendump = os.path.exists(os.path.join(hmm_dir, 'sendump')) if ((not mixweights) and (not sendump)): missing_hmm_files.append('mixture_weights or sendump') if missing_hmm_files: self._logger.warning((("hmm_dir '%s' is missing files: %s. Please " + 'make sure that you have set the correct ') + 'hmm_dir in your profile.'), hmm_dir, ', '.join(missing_hmm_files)) self._decoder = ps.Decoder(hmm=hmm_dir, logfn=self._logfile, **vocabulary.decoder_kwargs)
'Performs STT, transcribing an audio file and returning the result. Arguments: fp -- a file object containing audio data'
def transcribe(self, fp):
fp.seek(44) data = fp.read() self._decoder.start_utt() self._decoder.process_raw(data, False, True) self._decoder.end_utt() result = self._decoder.get_hyp() with open(self._logfile, 'r+') as f: for line in f: self._logger.debug(line.strip()) f.truncate() transcribed = [result[0]] self._logger.info('Transcribed: %r', transcribed) return transcribed
'Arguments: api_key - the public api key which allows access to Google APIs'
def __init__(self, api_key=None, language='en-us'):
self._logger = logging.getLogger(__name__) self._request_url = None self._language = None self._api_key = None self._http = requests.Session() self.language = language self.api_key = api_key
'Performs STT via the Google Speech API, transcribing an audio file and returning an English string. Arguments: audio_file_path -- the path to the .wav file to be transcribed'
def transcribe(self, fp):
if (not self.api_key): self._logger.critical(('API key missing, transcription request ' + 'aborted.')) return [] elif (not self.language): self._logger.critical(('Language info missing, transcription ' + 'request aborted.')) return [] wav = wave.open(fp, 'rb') frame_rate = wav.getframerate() wav.close() data = fp.read() headers = {'content-type': ('audio/l16; rate=%s' % frame_rate)} r = self._http.post(self.request_url, data=data, headers=headers) try: r.raise_for_status() except requests.exceptions.HTTPError: self._logger.critical('Request failed with http status %d', r.status_code) if (r.status_code == requests.codes['forbidden']): self._logger.warning(('Status 403 is probably caused by an ' + 'invalid Google API key.')) return [] r.encoding = 'utf-8' try: response = json.loads(list(r.text.strip().split('\n', 1))[(-1)]) if (len(response['result']) == 0): raise ValueError('Nothing has been transcribed.') results = [alt['transcript'] for alt in response['result'][0]['alternative']] except ValueError as e: self._logger.warning('Empty response: %s', e.args[0]) results = [] except (KeyError, IndexError): self._logger.warning('Cannot parse response.', exc_info=True) results = [] else: results = tuple((result.upper() for result in results)) self._logger.info('Transcribed: %r', results) return results
'Does Jasper recognize his name (i.e., passive listen)?'
def testTranscribeJasper(self):
with open(self.jasper_clip, mode='rb') as f: transcription = self.passive_stt_engine.transcribe(f) self.assertIn('JASPER', transcription)
'Does Jasper recognize \'time\' (i.e., active listen)?'
def testTranscribe(self):
with open(self.time_clip, mode='rb') as f: transcription = self.active_stt_engine.transcribe(f) self.assertIn('TIME', transcription)
'Does Brain correctly log errors when raised by modules?'
def testLog(self):
my_brain = TestBrain._emptyBrain() unclear = my_brain.modules[(-1)] with mock.patch.object(unclear, 'handle') as mocked_handle: with mock.patch.object(my_brain._logger, 'error') as mocked_log: mocked_handle.side_effect = KeyError('foo') my_brain.query('zzz gibberish zzz') self.assertTrue(mocked_log.called)
'Does Brain sort modules by priority?'
def testSortByPriority(self):
my_brain = TestBrain._emptyBrain() priorities = filter((lambda m: hasattr(m, 'PRIORITY')), my_brain.modules) target = sorted(priorities, key=(lambda m: m.PRIORITY), reverse=True) self.assertEqual(target, priorities)
'Does Brain correctly send query to higher-priority module?'
def testPriority(self):
my_brain = TestBrain._emptyBrain() hn_module = 'HN' hn = filter((lambda m: (m.__name__ == hn_module)), my_brain.modules)[0] with mock.patch.object(hn, 'handle') as mocked_handle: my_brain.query(['hacker news']) self.assertTrue(mocked_handle.called)
'Generic method for spoofing conversation. Arguments: query -- The initial input to the server. inputs -- Additional input, if conversation is extended. Returns: The server\'s responses, in a list.'
def runConversation(self, query, inputs, module):
self.assertTrue(module.isValid(query)) mic = test_mic.Mic(inputs) module.handle(query, mic, self.profile) return mic.outputs
'The lines below is a spider contract. For more info see: http://doc.scrapy.org/en/latest/topics/contracts.html @url http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/ @scrapes name'
def parse(self, response):
sites = response.css('#site-list-content > div.site-item > div.title-and-desc') items = [] for site in sites: item = Website() item['name'] = site.css('a > div.site-title::text').extract_first().strip() item['url'] = site.xpath('a/@href').extract_first().strip() item['description'] = site.css('div.site-descr::text').extract_first().strip() items.append(item) return items
'Since the original function always creates the directory, to resolve the issue a new function had to be created. It\'s a simple copy and was reduced for this case. More info at: https://github.com/scrapy/scrapy/pull/2005'
def _copytree(self, src, dst):
ignore = IGNORE names = os.listdir(src) ignored_names = ignore(src, names) if (not os.path.exists(dst)): os.makedirs(dst) for name in names: if (name in ignored_names): continue srcname = os.path.join(src, name) dstname = os.path.join(dst, name) if os.path.isdir(srcname): self._copytree(srcname, dstname) else: copy2(srcname, dstname) copystat(src, dst)
'Command syntax (preferably one-line). Do not include command name.'
def syntax(self):
return ''
'A short description of the command'
def short_desc(self):
return ''
'A long description of the command. Return short description when not available. It cannot contain newlines, since contents will be formatted by optparser which removes newlines and wraps text.'
def long_desc(self):
return self.short_desc()
'An extensive help for the command. It will be shown when using the "help" command. It can contain newlines, since not post-formatting will be applied to its contents.'
def help(self):
return self.long_desc()
'Populate option parse with options available for this command'
def add_options(self, parser):
group = OptionGroup(parser, 'Global Options') group.add_option('--logfile', metavar='FILE', help='log file. if omitted stderr will be used') group.add_option('-L', '--loglevel', metavar='LEVEL', default=None, help=('log level (default: %s)' % self.settings['LOG_LEVEL'])) group.add_option('--nolog', action='store_true', help='disable logging completely') group.add_option('--profile', metavar='FILE', default=None, help='write python cProfile stats to FILE') group.add_option('--pidfile', metavar='FILE', help='write process ID to FILE') group.add_option('-s', '--set', action='append', default=[], metavar='NAME=VALUE', help='set/override setting (may be repeated)') group.add_option('--pdb', action='store_true', help='enable pdb on failure') parser.add_option_group(group)
'Entry point for running commands'
def run(self, args, opts):
raise NotImplementedError
'Generate the spider module, based on the given template'
def _genspider(self, module, name, domain, template_name, template_file):
tvars = {'project_name': self.settings.get('BOT_NAME'), 'ProjectName': string_camelcase(self.settings.get('BOT_NAME')), 'module': module, 'name': name, 'domain': domain, 'classname': ('%sSpider' % ''.join((s.capitalize() for s in module.split('_'))))} if self.settings.get('NEWSPIDER_MODULE'): spiders_module = import_module(self.settings['NEWSPIDER_MODULE']) spiders_dir = abspath(dirname(spiders_module.__file__)) else: spiders_module = None spiders_dir = '.' spider_file = ('%s.py' % join(spiders_dir, module)) shutil.copyfile(template_file, spider_file) render_templatefile(spider_file, **tvars) print(('Created spider %r using template %r ' % (name, template_name)), end=('' if spiders_module else '\n')) if spiders_module: print(('in module:\n %s.%s' % (spiders_module.__name__, module)))
'You can use this function to update the Scrapy objects that will be available in the shell'
def update_vars(self, vars):
pass
'Start the execution engine'
@defer.inlineCallbacks def start(self):
assert (not self.running), 'Engine already running' self.start_time = time() (yield self.signals.send_catch_log_deferred(signal=signals.engine_started)) self.running = True self._closewait = defer.Deferred() (yield self._closewait)
'Stop the execution engine gracefully'
def stop(self):
assert self.running, 'Engine not running' self.running = False dfd = self._close_all_spiders() return dfd.addBoth((lambda _: self._finish_stopping_engine()))
'Close the execution engine gracefully. If it has already been started, stop it. In all cases, close all spiders and the downloader.'
def close(self):
if self.running: return self.stop() elif self.open_spiders: return self._close_all_spiders() else: return defer.succeed(self.downloader.close())
'Pause the execution engine'
def pause(self):
self.paused = True
'Resume the execution engine'
def unpause(self):
self.paused = False
'Does the engine have capacity to handle more spiders'
def has_capacity(self):
return (not bool(self.slot))
'Called when a spider gets idle. This function is called when there are no remaining pages to download or schedule. It can be called multiple times. If some extension raises a DontCloseSpider exception (in the spider_idle signal handler) the spider is not closed until the next loop and this function is guaranteed to be called (at least) once again for this spider.'
def _spider_idle(self, spider):
res = self.signals.send_catch_log(signal=signals.spider_idle, spider=spider, dont_log=DontCloseSpider) if any(((isinstance(x, Failure) and isinstance(x.value, DontCloseSpider)) for (_, x) in res)): return if self.spider_is_idle(spider): self.close_spider(spider, reason='finished')
'Close (cancel) spider and clear all its outstanding requests'
def close_spider(self, spider, reason='cancelled'):
slot = self.slot if slot.closing: return slot.closing logger.info('Closing spider (%(reason)s)', {'reason': reason}, extra={'spider': spider}) dfd = slot.close() def log_failure(msg): def errback(failure): logger.error(msg, exc_info=failure_to_exc_info(failure), extra={'spider': spider}) return errback dfd.addBoth((lambda _: self.downloader.close())) dfd.addErrback(log_failure('Downloader close failure')) dfd.addBoth((lambda _: self.scraper.close_spider(spider))) dfd.addErrback(log_failure('Scraper close failure')) dfd.addBoth((lambda _: slot.scheduler.close(reason))) dfd.addErrback(log_failure('Scheduler close failure')) dfd.addBoth((lambda _: self.signals.send_catch_log_deferred(signal=signals.spider_closed, spider=spider, reason=reason))) dfd.addErrback(log_failure('Error while sending spider_close signal')) dfd.addBoth((lambda _: self.crawler.stats.close_spider(spider, reason=reason))) dfd.addErrback(log_failure('Stats close failure')) dfd.addBoth((lambda _: logger.info('Spider closed (%(reason)s)', {'reason': reason}, extra={'spider': spider}))) dfd.addBoth((lambda _: setattr(self, 'slot', None))) dfd.addErrback(log_failure('Error while unassigning slot')) dfd.addBoth((lambda _: setattr(self, 'spider', None))) dfd.addErrback(log_failure('Error while unassigning spider')) dfd.addBoth((lambda _: self._spider_closed_callback(spider))) return dfd
'Open the given spider for scraping and allocate resources for it'
@defer.inlineCallbacks def open_spider(self, spider):
self.slot = Slot() (yield self.itemproc.open_spider(spider))
'Close a spider being scraped and release its resources'
def close_spider(self, spider):
slot = self.slot slot.closing = defer.Deferred() slot.closing.addCallback(self.itemproc.close_spider) self._check_if_closing(spider, slot) return slot.closing
'Return True if there isn\'t any more spiders to process'
def is_idle(self):
return (not self.slot)
'Handle the downloaded response or failure through the spider callback/errback'
def _scrape(self, response, request, spider):
assert isinstance(response, (Response, Failure)) dfd = self._scrape2(response, request, spider) dfd.addErrback(self.handle_spider_error, request, response, spider) dfd.addCallback(self.handle_spider_output, request, response, spider) return dfd
'Handle the different cases of request\'s result been a Response or a Failure'
def _scrape2(self, request_result, request, spider):
if (not isinstance(request_result, Failure)): return self.spidermw.scrape_response(self.call_spider, request_result, request, spider) else: dfd = self.call_spider(request_result, request, spider) return dfd.addErrback(self._log_download_errors, request_result, request, spider)
'Process each Request/Item (given in the output parameter) returned from the given spider'
def _process_spidermw_output(self, output, request, response, spider):
if isinstance(output, Request): self.crawler.engine.crawl(request=output, spider=spider) elif isinstance(output, (BaseItem, dict)): self.slot.itemproc_size += 1 dfd = self.itemproc.process_item(output, spider) dfd.addBoth(self._itemproc_finished, output, response, spider) return dfd elif (output is None): pass else: typename = type(output).__name__ logger.error('Spider must return Request, BaseItem, dict or None, got %(typename)r in %(request)s', {'request': request, 'typename': typename}, extra={'spider': spider})
'Log and silence errors that come from the engine (typically download errors that got propagated thru here)'
def _log_download_errors(self, spider_failure, download_failure, request, spider):
if (isinstance(download_failure, Failure) and (not download_failure.check(IgnoreRequest))): if download_failure.frames: logger.error('Error downloading %(request)s', {'request': request}, exc_info=failure_to_exc_info(download_failure), extra={'spider': spider}) else: errmsg = download_failure.getErrorMessage() if errmsg: logger.error('Error downloading %(request)s: %(errmsg)s', {'request': request, 'errmsg': errmsg}, extra={'spider': spider}) if (spider_failure is not download_failure): return spider_failure
'ItemProcessor finished for the given ``item`` and returned ``output``'
def _itemproc_finished(self, output, item, response, spider):
self.slot.itemproc_size -= 1 if isinstance(output, Failure): ex = output.value if isinstance(ex, DropItem): logkws = self.logformatter.dropped(item, ex, response, spider) logger.log(extra={'spider': spider}, *logformatter_adapter(logkws)) return self.signals.send_catch_log_deferred(signal=signals.item_dropped, item=item, response=response, spider=spider, exception=output.value) else: logger.error('Error processing %(item)s', {'item': item}, exc_info=failure_to_exc_info(output), extra={'spider': spider}) else: logkws = self.logformatter.scraped(output, response, spider) logger.log(extra={'spider': spider}, *logformatter_adapter(logkws)) return self.signals.send_catch_log_deferred(signal=signals.item_scraped, item=output, response=response, spider=spider)
'Lazy-load the downloadhandler for a scheme only on the first request for that scheme.'
def _get_handler(self, scheme):
if (scheme in self._handlers): return self._handlers[scheme] if (scheme in self._notconfigured): return None if (scheme not in self._schemes): self._notconfigured[scheme] = 'no handler available for that scheme' return None path = self._schemes[scheme] try: dhcls = load_object(path) dh = dhcls(self._crawler.settings) except NotConfigured as ex: self._notconfigured[scheme] = str(ex) return None except Exception as ex: logger.error('Loading "%(clspath)s" for scheme "%(scheme)s"', {'clspath': path, 'scheme': scheme}, exc_info=True, extra={'crawler': self._crawler}) self._notconfigured[scheme] = str(ex) return None else: self._handlers[scheme] = dh return self._handlers[scheme]
'Return a deferred for the HTTP download'
def download_request(self, request, spider):
agent = ScrapyAgent(contextFactory=self._contextFactory, pool=self._pool, maxsize=getattr(spider, 'download_maxsize', self._default_maxsize), warnsize=getattr(spider, 'download_warnsize', self._default_warnsize), fail_on_dataloss=self._fail_on_dataloss) return agent.download_request(request)
'Asks the proxy to open a tunnel.'
def requestTunnel(self, protocol):
tunnelReq = tunnel_request_data(self._tunneledHost, self._tunneledPort, self._proxyAuthHeader) protocol.transport.write(tunnelReq) self._protocolDataReceived = protocol.dataReceived protocol.dataReceived = self.processProxyResponse self._protocol = protocol return protocol
'Processes the response from the proxy. If the tunnel is successfully created, notifies the client that we are ready to send requests. If not raises a TunnelError.'
def processProxyResponse(self, rcvd_bytes):
self._connectBuffer += rcvd_bytes if ('\r\n\r\n' not in self._connectBuffer): return self._protocol.dataReceived = self._protocolDataReceived respm = TunnelingTCP4ClientEndpoint._responseMatcher.match(self._connectBuffer) if (respm and (int(respm.group('status')) == 200)): try: sslOptions = self._contextFactory.creatorForNetloc(self._tunneledHost, self._tunneledPort) except AttributeError: sslOptions = self._contextFactory self._protocol.transport.startTLS(sslOptions, self._protocolFactory) self._tunnelReadyDeferred.callback(self._protocol) else: if respm: extra = {'status': int(respm.group('status')), 'reason': respm.group('reason').strip()} else: extra = rcvd_bytes[:32] self._tunnelReadyDeferred.errback(TunnelError(('Could not open CONNECT tunnel with proxy %s:%s [%r]' % (self._host, self._port, extra))))
'Propagates the errback to the appropriate deferred.'
def connectFailed(self, reason):
self._tunnelReadyDeferred.errback(reason)
'Return a deferred for the HTTP download'
def download_request(self, request, spider):
factory = self.HTTPClientFactory(request) self._connect(factory) return factory.deferred
'Upload file to S3 storage'
def persist_file(self, path, buf, info, meta=None, headers=None):
key_name = ('%s%s' % (self.prefix, path)) buf.seek(0) if self.is_botocore: extra = self._headers_to_botocore_kwargs(self.HEADERS) if headers: extra.update(self._headers_to_botocore_kwargs(headers)) return threads.deferToThread(self.s3_client.put_object, Bucket=self.bucket, Key=key_name, Body=buf, Metadata={k: str(v) for (k, v) in six.iteritems((meta or {}))}, ACL=self.POLICY, **extra) else: b = self._get_boto_bucket() k = b.new_key(key_name) if meta: for (metakey, metavalue) in six.iteritems(meta): k.set_metadata(metakey, str(metavalue)) h = self.HEADERS.copy() if headers: h.update(headers) return threads.deferToThread(k.set_contents_from_string, buf.getvalue(), headers=h, policy=self.POLICY)
'Convert headers to botocore keyword agruments.'
def _headers_to_botocore_kwargs(self, headers):
mapping = CaselessDict({'Content-Type': 'ContentType', 'Cache-Control': 'CacheControl', 'Content-Disposition': 'ContentDisposition', 'Content-Encoding': 'ContentEncoding', 'Content-Language': 'ContentLanguage', 'Content-Length': 'ContentLength', 'Content-MD5': 'ContentMD5', 'Expires': 'Expires', 'X-Amz-Grant-Full-Control': 'GrantFullControl', 'X-Amz-Grant-Read': 'GrantRead', 'X-Amz-Grant-Read-ACP': 'GrantReadACP', 'X-Amz-Grant-Write-ACP': 'GrantWriteACP'}) extra = {} for (key, value) in six.iteritems(headers): try: kwarg = mapping[key] except KeyError: raise TypeError(('Header "%s" is not supported by botocore' % key)) else: extra[kwarg] = value return extra
YAML Metadata Warning: empty or missing yaml metadata in repo card (https://huggingface.co/docs/hub/datasets-cards)

HF version of Edinburgh-NLP's Code docstrings corpus

Downloads last month
32
Edit dataset card