def _compile_error_catcher(self, node): if node.etype == 'missing': self._compile_missing_catcher_header(node) elif node.etype == 'failed': self._compile_failed_catcher_header(node) elif node.etype == 'generated': self._compile_generated_catcher_header(node) self._write("def _error_{}_(self, e):".format(self.errors)) self._indent() if node.etype == 'generated': self._write( "return RaisedError('{}'.replace('%!', e.e_trigger), e.pos, e.ctx)" .format( replaces(escape_quotes(node.msg), '{', '<LCB>', '}', '<RCB>'))) else: self._write("return RaisedError('{}', e.pos, e.ctx)".format( replaces(escape_quotes(node.msg), '{', '<LCB>', '}', '<RCB>'))) self._dedent() self._skip_line(1) self.errors += 1
def do_insert(host, port, total_request, interval, index_name, args, starting_number=0): file_name_key = 'fileName' logging.info("Starting Insert") for i in range(total_request): new_index_name = index_name + str(starting_number) starting_number += 1 add_dict = {'url': "Test URL", file_name_key: new_index_name, 'fileSize': 1, 'language': 'English', 'category': 'Video', 'description': 'Test Desc'} args_dict = {} if args is not None: args_dict = json.loads(utils.escape_quotes(args)) body_dict = dict(add_dict.items() + args_dict.items()) logging.info("Inserting %s", body_dict[file_name_key]) result = webservice.call(host, port, "PUT", "/add", body_dict) status = utils.get_webservice_call_result(result) if status[0]: logging.info("Returned data: %s", result) else: logging.info("FAILED with reason: %s", status[1]) # don't sleep for the last iteration. All calls have been completed. if i != (total_request - 1): time.sleep(interval) logging.info("Ending Insert")
def _parse_init_or_end_block_part(self): imbrication_add = 0 if self._cur().name == 'LBlock': imbrication_add = 1 elif self._cur().name == 'RBlock': imbrication_add = -1 if (self._cur().name, self._cur().value) == ('keyword', 'node'): return self._parse_node_keyword(), imbrication_add if self._cur().name == 'silcrow': name = self._tok(expected='ident').value self._tok() return GlobalVar(name, self._pos()), 0 elif self._cur().name == 'newline': indentation = self._cur().value self._tok() return NewLine(self._pos(), indentation), 0 elif self._cur().name == 'string': code = "'" + escape_quotes(self._cur().value) + "'" else: code = self._cur().value.strip() self._tok() return RawPythonCode(code, self._pos()), imbrication_add
def _parse_inspection_code_part(self): imbrication_add = 0 if (self._cur().name, self._cur().value) == ('keyword', 'node'): return imbrication_add, self._parse_node_keyword() elif (self._cur().name, self._cur().value) == ('keyword', 'it'): pos = self._pos() self._tok() return imbrication_add, RawPythonCode("ast.get()", pos) elif self._cur().name == 'newline': indentation = self._cur().value self._tok() return imbrication_add, NewLine(self._pos(), indentation) elif self._cur().name == 'silcrow': name = self._tok(expected='ident').value self._tok() return imbrication_add, GlobalVar(name, self._pos()) else: if self._cur().name == 'LBlock': imbrication_add = 1 if self._cur().name == 'RBlock': imbrication_add = -1 if self._cur().name == 'string': raw_code = "'" + escape_quotes(self._cur().value) + "'" else: raw_code = self._cur().value self._tok() return imbrication_add, RawPythonCode(raw_code, self._pos())
def do_search(host, port, total_request, interval, index_name, args, append_number_to_index_name=True): file_name_key = 'fileNamePattern' logging.info("Starting Search") for i in range(total_request): new_index_name = index_name if append_number_to_index_name: new_index_name += str(i) name_dict = {file_name_key: new_index_name, 'category': 'Video'} args_dict = {} if args is not None: args_dict = json.loads(utils.escape_quotes(args)) body_dict = dict(name_dict.items() + args_dict.items()) logging.info("Searching %s", body_dict[file_name_key]) result = webservice.call(host, port, "PUT", "/search", body_dict) status = utils.get_webservice_call_result(result) if status[0]: logging.info("%d items Returned: %s", len(result), result) else: logging.info("FAILED with reason: %s", status[1]) # don't sleep for the last iteration. All calls have been completed. if i != (total_request - 1): time.sleep(interval) logging.info("Ending Search")
def _compile_warning_catcher(self, node): self._write("@warning('{}', {})".format(node.ctx_rule, node.nb)) self._write("def _warning_{}_(self, w):".format(self.warnings)) self._indent() self._write( "return 'Warning : At <LCB><RCB> : {}'.format(w.pos)".format( replaces(escape_quotes(node.msg), '{', '<LCB>', '}', '<RCB>'))) self._dedent() self._skip_line(1) self.warnings += 1
def _compile_warning_trigger(self, node): if node.group_name is None: group_name = 'None' else: group_name = "'" + escape_quotes(node.group_name) + "'" self._write("with self._error_trigger({}, group_name={}, warn=True):".format(node.nb, group_name)) self._indent() for subnode in node.link.definition: self._compile_node(subnode) self._dedent()
def _compile_error_trigger(self, node): if node.group_name is None: group_name = 'None' else: group_name = "'" + escape_quotes(node.group_name) + "'" self._write("with self._error_trigger({}, group_name={}, warn=False):".format(node.nb, group_name)) self._indent() self._compile_node(node.link) self._dedent() self._skip_line(1)
def _find_recursion_guards(self, node, base_rule=None): self._checker.code.ast = self._ast if type(node) is RuleDefinition: definition = get_rule(Code(self._ast), node.whole_name).definition guards = None i = 1 while not guards == '{!ARR}' and not guards and i <= len(definition): guards = self._find_recursion_guards(definition[-i], base_rule=node.whole_name if not base_rule else base_rule) i += 1 if guards != '{!ARR}': return guards else: return "" elif type(node) is Match: return escape_quotes(node.string) elif type(node) is RegexMatch: return 'REGEX~' + node.regex elif type(node) is Choices: guards = [] for option in node.options: for subnode in option.definition: option_guards = self._find_recursion_guards(subnode, base_rule=base_rule) if type(option_guards) is list: guards += option_guards elif type(option_guards) is str and option_guards != '{!ARR}': guards.append(option_guards) return guards elif type(node) is RuleCall: # If there is left recursives calls, it means this rule'll need recursions guards and cannot be used # To set recursions guards for the father rule. left_calls = self._checker.left_calls(get_rule(Code(self._ast), node.whole_name)) if not common(left_calls, self._calls_loops[node.whole_name]) and base_rule not in self._calls_loops[node.whole_name]: # Use this recursions guards. return self._find_recursion_guards(get_rule(Code(self._ast), node.whole_name)) else: return '{!ARR}' # Already Recursive Rulecall.
def _compile_group(self, node): self._write("with self._group(name='{}'):".format(escape_quotes(node.group_name))) self._indent() for subnode in node.definition: self._compile_node(subnode) self._dedent()
def _compile_regex_match(self, node): self._write("self._regex_match('{}'".format(escape_quotes(node.regex)).replace('{', '<LCB>').replace('}', '<RCB>')+(", name='"+node.group_name+"')" if node.group_name else ')'))
def _compile_string_match(self, node): self._write(("self._match('{}'".format(escape_quotes(node.string)).replace('{', '<LCB>').replace('}', '<RCB>')+(", name='"+node.group_name+"')" if node.group_name else ")")) )