Python Script editor.replace Bug? concerning the characters '(' and ')'

[Robert Jablko]

Hi, I like padding around my brackets: (a)->( a )

therefore I am using a python script, that works in python, but it does something weird with ‘(’ and ‘)’ in Python Script in Notepad++ with editor.replace( ) , They both disappear, while it works for ‘[’, ‘{’, ‘}’, ‘]’

I am very confused. Please help me.

THIS IS THE SCRIPT I AM USING:
text=editor.getText()

brackets_open=‘([{’
brackets_close=‘)]}’

‘’’ adds padding to brackets, when there is none ‘’’
for index, character in enumerate( text ): #catch beginning and end issues
print( character )
if index==0: #first character in text
trailing_character=" "
if len( text )>1:
following_character=text[ index+1 ]
else:
following_character=" "
elif index==len( text )-1: #last character text
trailing_character=text[ index-1 ]
following_character=" "
else:
trailing_character=text[ index-1 ]
following_character=text[ index+1 ]

if character in brackets_open and following_character!=' ':
    editor.replace( character, character+' ' )
elif character in brackets_close and trailing_character!=' ':
    editor.replace( character, ' '+character )

[Alan Kilborn]

@Robert-Jablko

When wanting a literal ( or ) in replacement text, it must be escaped, i.e., \( or \).

[Robert Jablko]

@Alan-Kilborn

Thank you so much. It works.

If anybody is interested, here is the full python script. It’s NOT python standard, but it really helps me read code.

text=editor.getText()
################################################################################
''' compress operators, removes trailing and following space from operators '''
operators=[ '+', '-', '*', ':', '/' '//', '%', '**', ]
assigners=[ '=', '+=', '-=', '*=', ':=', ]               
comparators=[ '==', '!=', '<', '>', '<=', '>=', ]                 
for character in operators+assigners+comparators:
    if ' '+character+' ' in text:
        editor.replace( ' '+character+' ', character )
################################################################################
''' padd brackets, adds space to brackets right of open, left of close '''
brackets_open='([{'
brackets_close=')]}'
for index, character in enumerate( text ): 
    
    ''' searching edge cases '''
    if index==0: # first character
        trailing_character=" "
        if len( text )>1:
            following_character=text[ index+1 ]
        else:
            following_character=" "
    elif index==len( text )-1:  # last character
        trailing_character=text[ index-1 ] 
        following_character=" "
    else:
        trailing_character=text[ index-1 ]
        following_character=text[ index+1 ]
    
    ''' replacing '''
    if character in brackets_open and following_character!=' ':
        if character=='(':
            editor.replace( character, '\('+' ' ) # '(' needs escape '\('
        else:
            editor.replace( character, character+' ' )
    elif character in brackets_close and trailing_character!=' ':
        if character=='\)':  
            editor.replace( character, ' '+'\)' ) # '(' needs escape '\)'
        else:
            editor.replace(  character, ' '+character )
################################################################################

[Robert Jablko]

@Robert-Jablko

I was a little fast, operators work fine, but replace ‘(’ while working now, padds for every ‘(’. The original script hat functions that took the text, worked character by character and returned the final string, but doesn’t work with script. I have to find another way.

[Mark Olson]

You could replace your entire script with a sequence of regex-replaces (documentation here), which could then be saved as a macro and bound to a keyboard shortcut.

Regex-replace 1 (remove space after and before operators):

1. Open the find/replace form (Edit->Replace... from the Notepad++ main menu, or Ctrl+H with default keybindings)
2. Set the following options:
   • Search mode set to Regular expressions
   • Wrap around checked.
   • Find what: \h*([+-*<>:=]=?|!=|//?|%|\*\*)\h*
   • Replace with: ${1}
3. Hit Replace all

Regex-replace 2 (add exactly one space before and after any of {}[]())
The same as the previous steps, except in step 2,
Find what: (?<!\s)[(){}\[\]](?!\s)
Replace with: \x20${0}\x20 (note that \x20 is a way of rendering the literal space character so that it’s visible)

I haven’t tested either of these regexes, but I’m pretty sure they should do what you want.

By the way, your script’s runtime will be proportional to the square of the length of the text (i.e., will be extremely slow if you run it on a long file), because it does a global operation (editor.replace) for every character in the text. Whenever you’re writing a script in any language, always ask yourself if there’s a way to do a series of local modifications rather than a global modification. And remember: strings are immutable, so you can’t perform local modifications to a string in Python. That’s a lot of the reason why regular expressions are so handy: they avoid having to do potentially very slow and clunky changes to strings.

[Robert Jablko]

@Mark-Olson

Thank you :) I will try that.

But before, I solved my problem by creating a string, clear the editor and then add the string. It works. Don’t know if it’s fast. I am new to programming.

text=editor.getText()
################################################################################
''' compress operators, removes trailing and following space from operatios '''
operators=[ '+', '-', '*', ':', '/' '//', '%', '**', ]
assigners=[ '=', '+=', '-=', '*=', ':=', ]               
comparators=[ '==', '!=', '<', '>', '<=', '>=', ]                 
for character in operators+assigners+comparators:
    if ' '+character+' ' in text:
        editor.replace( ' '+character+' ', character )
################################################################################
''' padd brackets, adds space to brackets right of open, left of close '''
brackets_open='([{'
brackets_close=')]}'
result=''
for index, character in enumerate( text ): 
    
    ''' searching edge cases '''
    if index==0: # first character
        trailing_character=" "
        if len( text )>1:
            following_character=text[ index+1 ]
        else:
            following_character=" "
    elif index==len( text )-1:  # last character
        trailing_character=text[ index-1 ] 
        following_character=" "
    else:
        trailing_character=text[ index-1 ]
        following_character=text[ index+1 ]
    
    ''' replacing '''
    if character in brackets_open and following_character!=' ':
        if character=='(':
            result+='\('+' ' #needs escape '\('
needs escape '\('
        else:
            result+=character+' '
    elif character in brackets_close and trailing_character!=' ':
        if character=='\)':  
            result+=' '+'\(' #needs escape '\)'
        else:
            result+=' '+character
    else:
        result+=character
################################################################################
editor.clearAll( )
editor.addText( result )
################################################################################

[Ekopalypse]

@Robert-Jablko

Are you sure your script is doing what you expect it to do?

Let me recap what you do

1. you retrieve the current text content
2. you replace the operators_assigners_comparators in the current text
3. you iterate the retrieved text (retrieved text != current text) to create a new content and replace the current text.

Furthermore, if you use the replace method, you do not need to escape the (; this is only necessary if you use rereplace (note, rereplace, this is the regular expression replace form)

Instead of deleting and adding text, you can use setText in one go.

General advice:

There is no need to build strings like result+='\('+' '
use result+='\( '

use a script layout like

def main():
    here your code

main()

This gives you the option to return from a function, as the standard exit functions do what they should do, they end the process, in this case this would be notepad++.
Eg.

def main():
    if x == y:
        # oops something went wrong exit the script
        return

main()

vs.

def main():
    if x == y:
        # oops NOW NPP CRAHSES
        exit()

main()

[Mark Olson]

@Robert-Jablko
Your script’s runtime will still be proportional to the square of the length of the file, because the x += y operator (when applied to strings) creates a copy of x with y at the end.

This is actually not true. I tested the runtime of creating a string by +='ing characters one at a time, and it appears to be linear.

Since this is a Notepad++ forum, not a Python forum, I would encourage those interested to look at this StackOverflow post. I probably shouldn’t have even posted this in the first place, but I felt duty-bound because I originally believed that the performance implications of not saying something were too great.

[Robert Jablko]

@Ekopalypse

Thank you for the advice. My code perfectly explained.

1. I realize that I replace the brackets with the editor method, and then create a new string. I have changed that to replace within the string and script the editor method. That way I don’t need any escape characters.

2. Talking about escape characters. I really do not understand the difference between replace and rereplace, but what I do know, is that when I used the replace method in the first iteration, ‘(’ was gone and that was the whole reason to seek help. Alan Kilborn told me that I need the escape character ‘(’ and it worked with replace. Now that I use addText, e.g. SetText (Thank you), it’s actually not an issue anymore.

3. result+=‘(’+’ ’ is actually on purpose, I find it clearer and reusable, I have made it a point to add the variable pad, although in this case it doesn’t make a difference.

4. Layout issues. In my first try I used my original script with definitions, and for some reason, it would not run. I don’t know why and I thought it’s an issue with Python Script, so I made a code without functions. Thanks to you, I have changed that back to my original definitions. Here is the new code. What do you think?

def compress_operators( text, pad_operator=' ' ):
    print( "text in compress:", text , )
    
    ''' removes trailing and following pad from operators '''
    operators=[ '+', '-', '*', ':', '/' '//', '%', '**', ]
    assigners=[ '=', '+=', '-=', '*=', ':=', ]               
    comparators=[ '==', '!=', '<', '>', '<=', '>=', ]                 

    for character in operators+assigners+comparators:
        if pad_operator+character+pad_operator in text: # padded both sides '4 = 5' -> '4=5'
            text=text.replace( pad_operator+character+pad_operator, character )
        elif pad_operator+character in text: # padded left '4 =5' -> '4=5'
            text=text.replace( pad_operator+character, character ) 
        elif character+pad_operator in text: # padded right '4= 5' -> '4=5'
            text=text.replace( character+pad_operator, character )
            
    return text
################################################################################
def padd_brackets( text, pad_bracket=' ' ):
    ''' padds brackets, adds pad to brackets right of open, left of close 
        pad needs to be one character in this code, length_pad=1 '''
    print( "text in brackets:", text , )
    brackets_open='([{'
    brackets_close=')]}'
    
    result=''
    for index, character in enumerate( text ): 
        
        ''' searching edge cases '''
        if index==0: # first character
            trailing_character=pad_bracket
            if len( text )>1:
                following_character=text[ index+1 ]
            else:
                following_character=pad_bracket
        elif index==len( text )-1:  # last character
            trailing_character=text[ index-1 ] 
            following_character=pad_bracket
        else: # all characters in between
            trailing_character=text[ index-1 ]
            following_character=text[ index+1 ]
        
        ''' padding the brackets '''
        if character in brackets_open and following_character!=pad_bracket:
            result+=character+pad_bracket  # pad open bracket '(x' -> '( x'
        elif character in brackets_close and trailing_character!=pad_bracket:
            result+=pad_bracket+character # pad closing bracket 'x)' -> 'x )'
        else:
            result+=character
    
    return result
################################################################################    
def MyPyFormat( text, pad_operator=' ', pad_bracket=' ' ):
    ''' converts standard python code into my invididual format '''
    
    ''' 1st remove trailing and following pad from operators '''
    text_co=compress_operators( text, pad_operator=' ' )
    
    ''' 2nd padd brackets, add pad to brackets right of open, left of close 
        pad needs to be one character in this code, length_pad=1 '''
    text_pb=padd_brackets( text_co, pad_bracket=' ' )
    
    return text_pb
################################################################################
editor.setText( MyPyFormat( editor.getText( ), pad_operator=' ', pad_bracket=' ' ) )

[Robert Jablko]

@Mark-Olson

Thank you for testing. How do you test?

Why not posting it here? The Only problem is see, is that the link doesn’t work. :)

[Mark Olson]

@Robert-Jablko

Discussing how to performance test Python applications is outside the scope of this discussion, so I’ll keep it brief: I use time.perf_counter to measure time elapsed and matplotlib.pyplot to plot lines. Please don’t ask for further details, so as to avoid derailing the discussion.

On a more NPP-related note, your script is looking better now. I still think you would benefit from learning regular expressions, because the regex-based approach is much simpler and doesn’t require plugins.