Example #1
0
    def _replace(self, match: re.Match, replacement: str,
                 operation: Callable) -> str:
        groups = match.groupdict()

        if '%s' in replacement:
            token = groups.get('token')
            prefix = ''
            suffix = ''
            if token:
                # Looks like prefix/suffix groups matter only if token-group
                # was in a pattern
                prefix = groups.get('prefix', '')
                suffix = groups.get('suffix', '')
            else:
                token = match.group()

            alias = operation(token)

            replacement = replacement.replace('%s', prefix + alias + suffix)

        replacement = self._fix_replacement_groups(replacement)

        try:
            return match.expand(replacement)
        except IndexError as error:
            raise TransformerError(f'Invalid replacement: {error}')
Example #2
0
 def replace(match: re.Match) -> str:
     variables = match.groupdict()
     variable_parts = {}
     for capture, (variable, directive) in date_patterns.captures.items():
         parts = variable_parts.setdefault(variable, {})
         parts[directive] = variables[capture]
     for variable, parts in variable_parts.items():
         directives, values = zip(*parts.items())
         fmt = " ".join(map("%{}".format, directives))
         value = " ".join(values)
         variables[variable] = datetime.datetime.strptime(value, fmt)
     return match.expand(replacement.format_map(variables))
Example #3
0
def expand_match(match: re.Match, value: Any) -> Any:
    """ Return the value obtained by doing backslash substitution on the template string template

    :param match: The match object.
    :param value: The template value.
    :return: The value replaced.
    """
    if isinstance(value, dict):
        return {
            expand_match(match, k): expand_match(match, v)
            for k, v in value.items()
        }
    elif isinstance(value, list):
        return [expand_match(match, v) for v in value]
    elif isinstance(value, str):
        return match.expand(value.replace(r'\0', r'\g<0>'))
    else:
        return value
Example #4
0
def expand_template(match: re.Match, template: Any) -> Any:
    """
    Return the string obtained by doing backslash substitution on the template.

    :param match: The match object.
    :param template: The template.
    :return: The template replaced with backslash substitution symbols.
    """
    if template is None:
        return match.group(0)
    elif isinstance(template, str):
        return match.expand(template.replace(r'\0', r'\g<0>'))
    elif isinstance(template, list):
        return [expand_template(match, t) for t in template]
    elif isinstance(template, dict):
        return {expand_template(match, k): expand_template(match, v) for k, v in template.items()}
    else:
        return template
Example #5
0
 def __call__(self, match: re.Match):
     matched = match.group(0)
     replaced = match.expand(self.replacement).format(
         self.manager._generate_id(matched))
     self.occurrences.append((matched, replaced))
     return replaced
Example #6
0
def validate_replacement(re_match: re.Match, replacement_pattern: str):
    """Test if it's valid in terms of regex rules"""
    simplified = replacement_pattern.replace('\\L', '').replace('\\U', '')
    simplified = re.sub(r'\\P(\d+)', '', simplified)
    re_match.expand(simplified)