User:Huhu9001Bot/import tempParser

brackets_temp = {'{{': '}}'}
brackets_temp_and_link = {'{{': '}}', ']'}

def find_Bracket(str, brackets, p_start = 0):
    def find_left(str, brackets, pos_start):
        p1_result = len(str)
        for bl in iter(brackets):
            p1_this = str.find(bl, pos_start)
            if p1_this != -1 and p1_this < p1_result:
                p1_result = p1_this
                p2_result = p1_this + len(bl)
                br_result = bl
        if p1_result == len(str): return 
        return 
        
    p0 = find_left(str, brackets, p_start)
    if p0 == -1: return 
    nest = ]]
    
    while len(nest) > 0:
        p0 = nest
        p1 = str.find(p0, p0)
        if p1 == -1: return 
        if len(p0) == 0: raise Exception('Any bracket must not have zero length.')
        p2 = find_left(str, brackets, p0)
        if p2 == -1:
            n = len(nest) - 1
            while n > 0:
                p1 = str.find(nest, p1 + len(nest))
                if p1 == -1: return 
                n -= 1
            p0 = p1 + len(nest)
            break
        else:
            if len(p2) == 0: raise Exception('Any bracket must not have zero length.')
            if p2 < p1:
                nest.append(brackets])
                p0 = p2
            else:
                p0 = p1 + len(nest)
                del nest
            
    p0 = str:p0]
    return p0
    
def gfind_Bracket(str, brackets):
    p0 = find_Bracket(str, brackets)
    while p0 != -1:
        yield p0
        p0 = find_Bracket(str, brackets, p0)
        
def find_IgnoringBrackets(str, brackets, pat, init = 0, *args):
    p0 = str.find(pat, init, *args)
    if p0 == -1: return -1
    
    p1 = find_Bracket(str, brackets)
    while p1 != -1 and p1 <= p0 + len(pat): p1 = find_Bracket(str, brackets, p1)
    
    while p1 != -1 and p1 <= p0 + len(pat) - 1:
        p0 = str.find(pat, p1, *args)
        if p0 == -1: return -1
        while p1 != -1 and p1 <= p0 + len(pat): p1 = find_Bracket(str, brackets, p1)
    
    return p0

def gsplit_IgnoringBrackets(str, brackets, sep):
    if len(sep) > 0:
        p0 = 0
        p1 = find_IgnoringBrackets(str, brackets, sep)
        while p1 != -1:
            yield str
            p0 = p1 + len(sep)
            p1 = find_IgnoringBrackets(str, brackets, sep, p0)
        yield str
    else:
        p0 = 0
        for i in range(len(str)):
            if i == find_IgnoringBrackets(str, brackets, sep, i):
                if p0 < i: yield str
                yield str
                p0 = i + 1

def parseTemp(str):
    if str != '{{' or str != '}}': return None
    stri = str
    
    p_titleEnd = find_IgnoringBrackets(stri, brackets_temp_and_link, '|')
    if p_titleEnd == -1: return stri, {}
    args_result = {}
    
    count = 0
    for arg in gsplit_IgnoringBrackets(stri, brackets_temp_and_link, '|'):
        p_eqsign = find_IgnoringBrackets(arg, brackets_temp_and_link, '=')
        if p_eqsign != -1:
            arg_name = arg
            if arg_name.isdecimal() and arg_name.isascii():
                arg_name = int(arg_name)
                if arg_name == 0: arg_name = '0'
            else: arg_name = arg_name.strip(' \x09\x0A\x0B\x0C\x0D')
            args_result = arg.strip(' \x09\x0A\x0B\x0C\x0D')
        else:
            count += 1
            args_result = arg

    return stri, args_result
    
def iterNumArg(args):
    if len(args) > 0:
        def func_sort(k): return type(k) is int and k or 0
        max_index = max(args, key = func_sort)
        if type(max_index) is int:
            for i in range(1, max_index + 1):
                if i in args: yield i, args
    
def glueTemp(title, args):
    result = 
    for i, v in iterNumArg(args):
        if i == len(result): result.append(v)
        else: result.append('{0}={1}'.format(i, v))
    for k in iter(args):
        if type(k) is str:
            result.append('{0}={1}'.format(k, args))
    return '{{{{{}}}}}'.format('|'.join(result))
    
import re

def subTemp(pat, repl, str):
    result = 
    p0 = 0
    for p1, p2, t_temp in gfind_Bracket(str, brackets_temp):
        title, args = parseTemp(t_temp)
        if re.search(pat, title):
            result.append(str)
            if callable(repl): result.append(glueTemp(*repl(title, args)))
            elif type(repl) is dict: result.append(glueTemp(title, repl))
            else: result.append('{}'.format(repl))
            p0 = p2
    result.append(str)
    return ''.join(result)