我们从Python开源项目中，提取了以下9个代码示例，用于说明如何使用re.RegexObject()。
def from_string(cls, raw_filter, rule_limit): """ Creates a new Filter instance from the given string. *raw_filter* is the raw filter : a string that may contain several regular expressions (separated by a newline char) and tags. *rule_limit* is the Rule's limit above which the Action is executed. Raises :class:`exceptions.ValueError` if the given string could not be compiled in at least one suitable :class:`re.RegexObject`. Returns a new :class:`Filter` instance. """ parsed_filter = cls.replace_tags(raw_filter) regexes = cls.build_regex_list(parsed_filter, rule_limit) return cls(regexes)
def _compile_template_re(delimiters): """ Return a regular expresssion object (re.RegexObject) instance. """ # The possible tag type characters following the opening tag, # excluding "=" and "{". tag_types = "!>&/#^" # TODO: are we following this in the spec? # # The tag's content MUST be a non-whitespace character sequence # NOT containing the current closing delimiter. # tag = r""" (?P<whitespace>[\ \t]*) %(otag)s \s* (?: (?P<change>=) \s* (?P<delims>.+?) \s* = | (?P<raw>{) \s* (?P<raw_name>.+?) \s* } | (?P<tag>[%(tag_types)s]?) \s* (?P<tag_key>[\s\S]+?) ) \s* %(ctag)s """ % {'tag_types': tag_types, 'otag': re.escape(delimiters[0]), 'ctag': re.escape(delimiters[1])} return re.compile(tag, re.VERBOSE)
def regex(self): """ A compiled version of the expression :rtype: re.RegexObject :return: compiled regex object """ if self._regex is None: self._regex = re.compile(self.expression) return self._regex
def __init__(self, root_path, url_map, url_pattern): """Initializer for StaticContentHandler. Args: root_path: A string containing the full path of the directory containing the application's app.yaml file. url_map: An appinfo.URLMap instance containing the configuration for this handler. url_pattern: A re.RegexObject that matches URLs that should be handled by this handler. It may also optionally bind groups. """ super(StaticContentHandler, self).__init__(url_map, url_pattern) self._root_path = root_path
def __init__(self, regexes): """ Initializes a newly created Filter with the given list of :class:`re.RegexObject`. *regexes* is a list of :class:`re.RegexObject`s. Raises :class:`exceptions.ValueError` if the given list evaluates to False (empty list, None, ...) """ if regexes: list.__init__(self, regexes) else: raise ValueError("Unable to initialize a Filter without at least " "one valid pattern, please fix your config file")
def __init__(self, pattern=None, name=None, suffix=None, recursive=False, match_pretty_name=True): """ :param Matcher.BasePattern|None pattern: If provided, reject any type that does not match `pattern`. :param str|re.RegexObject|None name: If it's a string, reject any type whose name is different. If it's a regular expression object, reject any type whose name isn't matched by it. The regular expression must match the whole name. :param str|None suffix: If provided, reject any type whose name does not end with `suffix`. :param bool recursive: If true, consider integer basis types (for integer subrange types) or the target type of typedefs for matching in addition to the original type. This behavior can be surprising: for instance typedef layers are used to distinguish unconstrained arrays from accesses to these, so this is disabled by default. :param bool match_pretty_name: If True, match on the pretty GDB type name (`str(gdb_type)`, for instance: "foo.bar"), otherwise, use the raw name (`gdb_type.name`, for instance: "foo__bar___Xb"). """ self.type_pattern = pattern self.name = name self.suffix = suffix self.recursive = recursive self.match_pretty_name = match_pretty_name
def __parse_line(self, regex): """Parse a GNATcheck message line. Adds the message to the current database session. Retrieves following information: * source basename * line in source * rule identification * message description :param re.RegexObject regex: the result of the _MESSAGE regex """ # The following Regex results are explained using this example. # 'input.adb:3:19: use clause for package [USE_PACKAGE_Clauses]' # Extract each component from the message: # ('input.adb', '3', '19', 'use clause for package', # 'USE_PACKAGE_Clauses') base = regex.group('file') src = GNAThub.Project.source_file(base) line = regex.group('line') column = regex.group('column') message = regex.group('message') rule_id = regex.group('rule_id').lower() self.__add_message(src, line, column, rule_id, message)
def __parse_line(self, regex): """Parse a GNATprove message line. Adds the message to the current database session. Retrieves following information: * source basename * line in source * rule identification * message description :param re.RegexObject regex: the result of the _MESSAGE regex """ filename = regex.group('file') src = GNAThub.Project.source_file(filename) line = regex.group('line') column = regex.group('column') message = regex.group('message') msg_id = regex.group('msg_id') category = regex.group('category').lower() record = self.msg_ids.get((filename, int(msg_id))) if record is None: self.log.warn( '%s: failed to get record for msg_id #%s', filename, msg_id) return rule_id = record['rule'].lower() self.__add_message(src, line, column, rule_id, message, category)
def build_regex_list(cls, filter_str, rule_limit): """ Creates a list of :class:`re.RegexObject`s from the given string. *filter_str* is a string containing the regular expressions used to build the Filter. If *filter_str* contains newlines chars, it is split in different regular expressions (one per line). If one of these strings can not be compiled into a :class:`re.RegexObject`, a warning is issued and the pattern is ignored. *rule_limit* is the Rule's limit above which the Action is executed. If *rule_limit* is > 1 and *filter_str* doesn't have at least one named capturing group, a warning is issued and the pattern is ignored. Returns a list of :class:`re.RegexObject`s built upon the given string. """ regexes = [] for f in filter_str.splitlines(): try: regex = re.compile(f, re.MULTILINE) except sre_constants.error: warnings.warn("Unable to compile this pattern: \"{0}\". " "It will be ignored" .format(f)) else: # If the Rule limit is > 1, the pattern MUST have a capturing # group. # (this capturing group will be used later as an index to # count the matches.) # If the pattern doesn't respect this, it will be ignored. if rule_limit > 1 and not regex.groupindex: warnings.warn("The pattern \"{0}\" doesn't have a " "capturing group but needs one." "It will be ignored" .format(f)) else: regexes.append(regex) return regexes
