Python re.findall regex and text processing

This may be an X/Y problem, meaning you’re asking how to do something with Regex that may be better solved with parsing (meaning using/modifying/writing a SQL parser). An indication that this is the case is the fact that “convert” calls can be nested. I’m guessing Regex is going to be more of a headache than it’s worth here in the long run if you’re working with a lot of files and they’re at all complicated.

The task:

Swap the parameters of all the 'convert' functions in this given. Parameters can contain any character, including nested 'convert' functions.

A solution:

def convert_py(s):
    #capturing start:
    left=s.index('convert')
    start=s[:left]
    #capturing part_1:
    c=0
    line=''
    for n1,i in enumerate(s[left+8:],start=len(start)+8):
        if i==',' and c==0:
            part_1=line
            break
        if i==')':
            c-=1
        if i=='(':
            c+=1
        line+=i
    #capturing part_2:
    c=0
    line=''
    for n2,i in enumerate(s[n1+1:],start=n1+1):
        if i==')':
            c-=1
        if i=='(':
            c+=1
        if c<0:
            part_2=line
            break
        line+=i
    #capturing end:
    end=s[n2+1:]
    #capturing result:
    result=start+part_2.lstrip()+' :: '+part_1+end
    return result

def multi_convert_py(s):
    converts=s.count('convert')
    for n in range(converts):
        s=convert_py(s)
    return s

Notes:

• Unlike the solution based on the re module, which is presented in another answer - this version should not fail if there are more than two parameters in the 'convert' function in the given string. However, it will swap them only once, for example: convert(a,b, c) --> b, c : a
• I am afraid that unforeseen cases may arise that will lead to failure. Please tell if you find any flaws

The task:

Swap the parameters of all the 'convert' functions in the given string. Parameters can contain any character, including nested 'convert' functions.

A solution based on the re module:

def convert_re(s):
    import re
    start,part_1,part_2,end=re.search(r'''
                               (.*?)   
                               convert\(
                               ([^,)(]+\(.+?\)[^,)(]*|[^,)(]+)
                               ,
                               ([^,)(]+\(.+?\)[^,)(]*|[^,)(]+)
                               \)
                               (.*)                                     
                                       ''',s,re.X).groups()


    result=start+part_2.lstrip()+' :: '+part_1+end
    return result

def multi_convert_re(s):
    converts=s.count('convert')
    for n in range(converts):
        s=convert_re(s)
    return s

Discription of the 'convert_re' function:

Regular expression:

• start is the first group with what comes before 'convert'

• Then follows convert\() which has no group and contains the name of the function and the opening '('

• part_1 is the second group ([^,)(]+\(.+?\)[^,)(]*|[^,)(]+). This should match the first parameter. It can be anything except - ,)(, or a function preceded by anything except ,)(, optionally followed by anything except ,)( and with anything inside (except a new line)

• Then follows a comma ,, which has no group

• part_2 is the third group and it acts like the second, but should catch everything what's left inside the external function

• Then follows ), which has no group

• end is the fourth group (.*) with what's left before the new line.

The resulting string is then created by swapping part_1 and part_2, putting ' :: ' between them, removing spaces on the left from part_2 and adding start to the beginning and end to the end.

Description of the 'multi_convert_re' function

Repeatedly calls 'convert_re' function until there are no "convert" left.

Notes:

• N.B.: The code implies that the 'convert' function in the string has exactly two parameters.
• The code works on the given examples, but I'm afraid there may still be unforeseen flaws when it comes to other examples. Please tell, if you find any flaws.
• I have provided another solution presented in another answer that is not based on the re module. It may turn out that the results will be different.