A collection of scripts for Wing IDE.

In order to use these scripts in your copy of Wing, download the repo to someplace in your computer, fire up Wing, go to Edit -> Preferences -> IDE Extension Scripting and add the path of the repo's scripts folder to your Search Path. (Possibly you'll need to do edit -> Reload All Scripts to get Wing to see them for the first time.)

After you do that, the commands will become available in Wing; For example you could do Ctrl-F12 and then type flip-case to activate the flip-case script. But you probably want to bind these commands to some key combination; do that in Edit -> Preferences -> Keyboard -> Custom Key Bindings.

Tip: Many of the commands have a suggested binding starting with the Insert key. In order for that to work, you need to bind Insert to nothing in Wing. (i.e. just leave the command text input box empty.) If you're one of the rare people who still like using the Insert key by itself, you can bind Ctrl-Insert to toggle-overtype.

All the scripts are copyright Ram Rachum and released under the MIT open-source license. Some code is by Raymond Hettinger, and licensed to use under the MIT license. (License given by Hettinger in private email on May 25th, 2013.)

I provide Development services in Python and Django <https://chipmunkdev.com>_.

Almost open the current file in Cursor IDE.

Saves the file, copies its path to clipboard and changes focus to the Cursor IDE.

Suggested key combination: Ctrl-Bar (Ctrl-Shift-\)

Turn an argument to __init__ into an instance attribute.

For example, you have just typed this:

class MyObject(object):
    def __init__(self, crunchiness):
        <Cursor is here>

(Of course, you can substitute crunchiness for whatever your argument's name is.)

Now, you might want to put a self.crunchiness = crunchiness line in that __init__ method. But that would take so much typing, because self.crunchiness doesn't exist yet, and won't be autocompleted. That would require you to make around 20 keystrokes. I don't know about you, but I'm just not ready for that kind of a commitment.

Instead, type crunchiness. (You'll get autocompletion because it exists as an argument.) Then run this arg-to-attr script.

The final result is that you'll get a self.crunchiness = crunchiness line and have the cursor ready in the next line.

Suggested key combination: Insert A

Move half a page up.

This is essentially one half of Page-Up.

Suggested key combination: Alt-Page_up (As long as you don't use Wing's folding.)

Select the inside of the current/next pair of braces.

Similar to Wing's built-in brace-match, except it selects only the inside of the braces, not including the braces themselves.

Known limitations: Misses some pairs of braces. Doesn't know to ignore braces found in strings.

Suggested key combination: Alt-Bracketright

Go to the end of the line and insert a colon.

Suggested key combination: Ctrl-Semicolon

Go to the end of the line, insert a comma and a newline.

Suggested key combination: Ctrl-Comma

Create "comment braces" with a title around a piece of code.

For example, if you have this code:

do_something()
do_something_else()
meow = frr + 7
do_something_again()

You can select it, then run the comment-braces script with a title of "doing inane stuff", to get this:

### Doing inane stuff: ####################################################
#                                                                         #
do_something()
do_something_else()
meow = frr + 7
do_something_again()
#                                                                         #
### Finished doing inane stuff. ###########################################

(Don't try this inside a docstring, it works only in real code.)

The title usually has a first word ending with "ing". Don't bother capitalizing the first letter or ending the sentence with any punctuation mark. You may also use an empty title to get a title-less comment line.

Suggested key combination: Insert B

Enter a horizontal line of "#" characters going until character 79.

Example:

#######################################################################

Suggested key combination: Insert H

Copy the full path of the current file to the clipboard.

Suggested key combination: Ctrl-Start-F

Evaluate selection in debug console, doing select-more if nothing selected.

Suggested key combination: Ctrl-Alt-D

Go to a specified line number in editor, temporarily showing line numbers.

This script is intended for people who don't like Wing to always show line numbers in the editors, but who do want to see them temporarily when using Wing's goto-line command, usually invoked by Ctrl-L, to go to a specific line.

Using this script you can see exactly which line you're going to before issuing the command; and if usually keep line numbers hidden, then they will be hidden automatically after Wing has moved to the specified line.

Also, the caret will go to the beginning of the text on the line instead of Wing's default of going to column 0.

Suggested key combination: Ctrl-L

Open a new line. (i.e. enter a newline character.)

If line_offset is set to -1, it will open a line at the line above. If line_offset is set to 1, it will open a line at the line below.

If stand_ground=True, it will make the caret not move when doing the newline.

(The advantage of this over Wing's built-in open-line is that cute-open-line doesn't just insert a newline character like open-line does; it runs Wing's new-line command, which does various intelligent things like auto-indenting your code to the right level, opening your parentheses just so if you're doing function invocation, and a bunch of other goodies.)

Suggested key combinations:

`Alt-Return` for `stand_ground=True`
`Shift-Return` for `line_offset=-1`
`Ctrl-Return` for `line_offset=1`
`Alt-Shift-Return` for `line_offset=-1, stand_ground=True`
`Ctrl-Alt-Return` for `line_offset=1, stand_ground=True`

(The Alt-Return combination requires a AHK shim, at least on Windows.)

Improved version of query-replace for finding and replacing in document.

BUGGY: If text is selected, it will be used as the text to search for, and the contents of the clipboard will be offered as the replace value.

Implemented on Windows only.

Suggested key combination: Alt-Comma

Improved version of replace-string for finding and replacing in document.

BUGGY: If text is selected, it will be used as the text to search for, and the contents of the clipboard will be offered as the replace value.

Implemented on Windows only.

Suggested key combination: Alt-Period

Start selecting by visual lines instead of by character.

What this adds over start-select-line is that it takes the current selection when this command is invoked and expands it to cover all of its lines as the initial selection.

Suggested key combination: Ctrl-F8

Move, select or delete words.

This is a swiss-army knife command for handling "words". Unlike Wing's default word-handling logic, this command separates using underscores and case. For example, foo_bar_baz will be split to 3 words, and so will FooBarBaz and FOO_BAR_BAZ.

When used with no arguments, this command will move a word forward or backward, depending on direction, similarly to Wing's built-in forward-word and backward-word commands.

When used with extend=True, this command will extend the existing selection a word forward or backward, depending on direction, similarly to Wing's built-in forward-word-extend and backward-word-extend commands.

When used with delete=True, this command will delete a word forward or backward, depending on direction, similarly to Wing's built-in forward-delete-word and backward-delete-word commands.

When used with traverse=True, this command will select the next alphanumeric word or the previous alphanumeric word, depending on direction.

Suggested key combinations:

`Ctrl-Alt-Right` for direction=1
`Ctrl-Alt-Left` for direction=-1
`Ctrl-Alt-Shift-Right` for direction=1, extend=True
`Ctrl-Alt-Shift-Left` for direction=-1, extend=True
`Ctrl-Alt-Shift-Down` for direction=1, traverse=True
`Ctrl-Alt-Shift-Up` for direction=-1, traverse=True
`Alt-Delete` for direction=1, delete=True
`Alt-Backspace` for direction=-1, delete=True

(Tip: If you do bind to Ctrl-Alt-Right and Ctrl-Alt-Left as I suggest, then I also suggest you bind Ctrl-Right-Up and Ctrl-Right-Down to goto-previous-bookmark and goto-next-bookmark respectively, so you'll still have bookmark-traversing commands available.)

Create a variable from a deep expression.

When you're programming, you're often writing lines like these:

html_color = self._style_handler.html_color

Or:

location = context_data['location']

Or:

event_handler = super(Foobsnicator, self).get_event_handler()

Or:

user_profile = models.UserProfile.objects.get(pk=pk)

What's common to all these lines is that you're accessing some expression, sometimes a deep one, and then getting an object, and making a variable for that object with the same name that it has in the deep expression.

What this deep-to-var script will do for you is save you from having to write the html_color = part, which is annoying to type because you don't have autocompletion for it.

Just write your deep expression, like self._style_handler.html_color, invoke this deep-to-var script, and you'll get the full line and have the caret put on the next line.

Suggested key combination: Insert E

Delete the current line and send caret to beginning of text in next line.

When you use Wing's default delete-line command to delete a line, it sends the caret to column 0, which is annoying. This script fixes that by first deleting a line, then sending the caret to the beginning of the text on the next line.

Suggested key combination: Ctrl-Shift-C

Turn foo[bar] into foo.get(bar, None).

Suggested key combination: Insert Ctrl-G

Toggle between a view file in Django and the corresponding template file.

If you're currently viewing a template file, this'll open the corresponding view file. If you're currently viewing a view file, this'll open the corresponding template file.

This assumes that the view file has the word view in it and has a definition for the class attribute template_name.

Suggested key combination: Insert Quoteleft (i.e. backtick)

Create a copy of the current file (in the same folder) and open it.

If a filename with no extension will be entered, the same extension used for the original file will be used for the new file.

Suggested key combination: Insert Ctrl-D

Open a dialog for editing a string.

If the caret is standing on a string, it'll edit the current string. Otherwise you can enter a new string and it'll be inserted into the document. The dialog has lots of checkboxes for toggling things about the string: Whether it's unicode, raw, bytes, type of quote, etc.

When is this better than editing a string in the editor?

• When you have a mess of escape character. The dialog automatically translates the escape characters for you so you don't have to think about them. (Very useful when entering Windows paths that have backslashes in them.)

• When you're editing a multiline string of this style: raise Exception("There's some long text here that takes up more than " "one line, and it's broken in a nice way that doesn't " "exceed 79 characters, and every time you edit it you " "see it as one block of text, while the cutting " "points will be automatically determined by the " "dialog.")

Note: Currently doesn't work on docstrings, and other triple-quote multiline strings.

Suggested key combination: Ctrl-Alt-S

Flip between True and False.

Suggested key combination: Insert P

Flip the case of the current word between undercase and camelcase.

For example, if the cursor is on something_like_this and you activate this script, you'll get SomethingLikeThis. Do it again and you'll get something_like_this again.

Suggested key combination: Insert C

Turn things into for thing in things:.

Type any pluarl word, like bananas or directories. Then run this script, and you get for directory in directories.

This also works for making range(number) into for i in range(number):.

Note: The : part is added only on Windows.

Suggested key combination: Insert Ctrl-F

Move half a page down.

This is essentially one half of Page-Down.

Suggested key combination: Alt-Page_down (As long as you don't use Wing's folding.)

Go to the line of the current frame and send caret to beginning of text.

When you use Wing's default frame-show command to go to the line of the current frame, it sends the caret to column 0, which is annoying. This script fixes that by first doing frame-show, then sending the caret to the beginning of the text.

Suggested key combination: Shift-F11

Go down one frame in the debugger, skipping any non-project frames.

Did you ever have Wing stop on an exception, and then drop you in code that belongs to an external module? This is often annoying, because you want to figure out what you did wrong on your code, and the external module is usually not to blame.

go-down-to-project-frame to the rescue! Invoke this script while debugging in order to be taken to the closest lower stack frame that's on a project file rather than an external module.

Suggested key combination: Alt-F12

Go up one frame in the debugger, skipping any non-project frames.

Did you ever have Wing stop on an exception, and then drop you in code that belongs to an external module? This is often annoying, because you want to figure out what you did wrong on your code, and the external module is usually not to blame.

go-up-to-project-frame to the rescue! Invoke this script while debugging in order to be taken to the closest higher stack frame that's on a project file rather than an external module.

Suggested key combination: Alt-F11

Guess the class name based on file name, and replace class name.

Imagine you had a file foo_manager.py with a class FooManager defined in it, and you duplicated it, calling the new file bar_grokker.py. If you run guess-class-name, it'll replace all instances of FooManager in your new file to BarGrokker.

(It finds the original class name by taking the first class defined in the file. If the file defined multiple classes, you might get the wrong results.)

Suggested key combination: Insert Ctrl-C

Convert something like foo.bar into getattr(foo, 'bar', None).

Also selects the None so it could be easily modified.

Suggested key combination: Insert Shift-G

Write my_class_name = MyClassName().

This is used to quickly instantiate a class. Write your class name, like CatNip. It will usually be autocompleted. Then execute this script, and you'll have cat_nip = CatNip(), with the cursor positioned between the brackes.

This saves a lot of typing, because normally you don't have autocompletion for the new instance name cat_nip because it doesn't exist yet.

Note: The () part is added only on Windows.

Suggested key combination: Insert I

Select the previous pair of braces.

Similar to Wing's built-in brace-match, except it goes backwards instead of going forwards. Goes to the nearest pair of braces, whether it's (), [], or {} that's before the current caret position, and selects those braces including all their content.

Known limitations: Misses some pairs of braces. Doesn't know to ignore braces found in strings.

Suggested key combination: Ctrl-Bracketleft

Select the inside of the previous pair of braces.

Similar to Wing's built-in brace-match, except it goes backwards instead of going forwards. Goes to the nearest pair of braces, whether it's (), [], or {} that's before the current caret position, and selects the content of those braces, not including the braces themselves.

Known limitations: Misses some pairs of braces. Doesn't know to ignore braces found in strings.

Suggested key combination: Alt-Bracketleft

Push the current line to the end, aligning it to right border of editor.

This inserts or deletes as many spaces as necessary from the beginning of the line to make the end of the line exactly coincide with the right border of the editor. (Whose width can be configured in the TARGET_LINE_LENGTH constant in the script's module.)

This is useful for creating lines of this style:

if first_long_condition(foo, foobar) and \
                                      second_long_condition(fubaz, bazbar):

Also deletes trailing spaces.

Remove the last invocation, turning whatever.function(value) to value.

Suggested key combinations: Insert 8

Remove all rectangles that Wing drew on the editor.

Wing sometimes draws rectangles on the editor, either for search results or for highlighting appearances of the currently selected word. This command clears all of those squares.

Suggested key combination: Insert Ctrl-R

Reverse the selection, putting the caret on the opposite side.

If the caret was at the beginning of the selection, it'll be put at the end, and if it was in the end, it'll be put in the beginning.

Suggested key combination: Insert Shift-R

Use ChatGPT to modify your code.

Put your OpenAI API key in ~/.roberto-openai-key first. Mark some segment of code and invoke roberto. Then in the dialog, write in text what changes you want ChatGPT to make. Then wait, sometimes even several minutes, for it to complete.

Suggested key combination: Insert Ctrl-Alt-R

Run a command, first terminating any running instances of it.

Select the dotted name that the cursor is currently on, like foo.bar.baz.

This does select-more until the biggest possible dotted name is selected.

Suggested key combination: Alt-Plus

Select the Python expression that the cursor is currently on.

This does select-more until the biggest possible legal Python expression is selected.

Suggested key combination: Ctrl-Alt-Plus

Select the next argument to a callable.

Set limit_to_keywords=True to go only to a keyword argument.

Suggested key combinations: Ctrl-R Ctrl-Alt-R for limit_to_keywords=True

Select the next (or current) assignment in the document.

This includes:

= += -= *= /= **= //= %= |= &= ^= <<= >>=

Suggested key combination: Ctrl-Alt-Backslash

Select the next (or current) camelcase in the document.

Camelcase means a variable name that has a combination of lowercase and uppercase letters.

Suggested key combination: Ctrl-Alt-C

Select the next (or current) comment, starting from caret location.

Suggested key combinations: Ctrl-Alt-3

Select the next (or current) constant in the document.

Constant means a name in all caps, like DEBUG or LOGIN_REDIRECT_URL.

Suggested key combination: Ctrl-Alt-O

Select the next (or current) dotted name in the document, like foo.bar.

Suggested key combination: Ctrl-D

Select the next invocation of a callable, e.g foo.bar(baz).

Suggested key combination: Ctrl-Alt-8

Select the next left-hand-side of an assignment.

Suggested key combination: Ctrl-Alt-9

Select the next (or current) number in the document.

Suggested key combination: Ctrl-0

Select the next (or current) operator in the document.

Operators are:

+ - * / ** // % | & ^ << >> == != < <= > >=

Suggested key combination: Alt-Backslash

Select the next right-hand-side of an assignment.

Suggested key combination: Ctrl-Alt-0

Select the next scope name like def thing(): or class Thing():.

(Selects just the name.)

Suggested key combination: Alt-Semicolon

Select the next (or current) string, starting from caret location.

Provide inner=True to select only the contents of the string.

Suggested key combinations: Ctrl-Apostrophe Alt-Apostrophe for inner=True

Select the previous argument to a callable.

Set limit_to_keywords=True to go only to a keyword argument.

Suggested key combinations: Ctrl-Shift-R Ctrl-Shift-Alt-R for limit_to_keywords=True

Select the previous assignment in the document.

This includes:

= += -= *= /= **= //= %= |= &= ^= <<= >>=

Suggested key combination: Ctrl-Alt-Bar

Select the previous camelcase in the document.

Camelcase means a variable name that has a combination of lowercase and uppercase letters.

Suggested key combination: Ctrl-Alt-Shift-C

Select the previous comment, starting from caret location.

Suggested key combinations: Ctrl-Alt-Numbersign

Select the previous constant in the document.

Constant means a name in all caps, like DEBUG or LOGIN_REDIRECT_URL.

Suggested key combination: Ctrl-Alt-Shift-O

Select the previous dotted name in the document, like foo.bar.

Suggested key combination: Ctrl-Shift-D

Select the previous invocation of a callable, e.g foo.bar(baz).

Suggested key combination: Ctrl-Alt-Asterisk

Select the previous left-hand-side of an assignment.

Suggested key combination: Ctrl-Alt-Parenleft

Select the previous number in the document.

Suggested key combination: Ctrl-9

Select the previous operator in the document.

Operators are:

+ - * / ** // % | & ^ << >> == != < <= > >=

Suggested key combination: Alt-Bar

Select the previous right-hand-side of an assignment.

Suggested key combination: Ctrl-Alt-Parenright

Select the previous scope name like def thing(): or class Thing():.

(Selects just the name.)

Suggested key combination: Alt-Colon

Select the previous string, starting from caret location.

Provide inner=True to select only the contents of the string.

Suggested key combinations: Ctrl-Quotedbl Alt-Quotedbl for inner=True

Select the name of the function or class that the cursor is currently on.

Suggested key combination: Alt-Colon

Select the whitespace-less name that the cursor is currently on.

Example: foo.bar.baz(e=3).

This does select-more until the biggest possible whitespace-less name is selected.

Suggested key combination: Ctrl-Alt-Equal

Show currently-open file in explorer.

Suggested key combination: Insert Comma

Slash a long line into 2 lines, putting a \ character as a separator.

This is good for automatically formatting long lines into this style:

has_corresponding_source_file = \
                           os.path.exists(corresponding_python_source_file)
nose.selector.Selector.wantFile = \
                   types.MethodType(wantFile, None, nose.selector.Selector)

Specify line_offset to slash a line different from the one that the caret is on. For example, line_offset=-1 would slash the previous line.

Specify at_caret=True to use the current caret position as the slashing point, rather than finding one automatically.

Suggested key combination: Insert L for default arguments, Insert Shift-L for line_offset=-1, and Insert Ctrl-L for at_caret=True.

Start SmartGit for the current project.

Suggested key combination: Insert G

Start SmartGit blame on the currently selected line.

Suggested key combination: Insert Ctrl-B

Type super(MyClass, self).my_method()

MyClass and my_method will be copied with the current class and method of the active scope.

Suggested key combination: Insert Ctrl-S

Turn things into (thing,).

Useful for writing things like:

(thing,) == things

See this blog post for more context: http://blog.ram.rachum.com/post/1198230058/python-idiom-for-taking-the-single-item-from-a-list

Suggested key combination: Insert U

Toggle whether Wing wraps lines or not.