Wing Tips

Turbo Completion Mode in Wing Pro

Wed, 19 Jan 2022 01:00:00 GMT

In this issue of Wing Tips we look at how to use Wing Pro's turbo completion mode for Python. Auto-completion normally requires pressing a completion key, as configured by the Editor > Auto-completion > Completion Keys preference, before a completion is entered into the editor.

Wing Pro also provides a Python Turbo Mode for auto-completion, where completion occurs on any key that cannot be part of a symbol. This allows you to type just enough of a symbol until it is selected in the completer, then move right on to typing the code that follows that symbol. It takes some getting used to, but it can greatly reduce typing once you become comfortable with it.

The following example shows the code that can be produced simply by typing the characters p=x.p.e.P( without pressing any completion keys:

This particular case requires only a single character to match each symbol in the auto-completer. In a more cluttered name space, it may take more characters to match the desired symbol, but in many cases two or three characters is all that is needed before you can move on to the next part of the expression you are trying to type.

Notice that turbo mode distinguishes between contexts where a new symbol may be defined and those where an existing symbol must be used. For example, if you type c followed by = on a new line, Wing knows that the = indicates you may be defining a new symbol and does not place the current selection from the auto-completer. When you do want completion to occur in a defining context, you can press Tab or another completion key.

In a context where you are trying to type something other than what is in the completer, you can press Ctrl, Alt or Command briefly by itself to hide the auto-completer and thus disable turbo-completion until you type more symbol characters and the completer is displayed once again.

Turbo completion is enabled with the Editor > Auto-completion > Python Turbo Mode preference in Wing Pro.

That's it for now! We'll be back next week with more Wing Tips for Wing Python IDE.

Debug Python Code Run by Docker Compose with Wing Pro

Tue, 21 Sep 2021 01:00:00 GMT

This Wing Tip describes how to configure Docker Compose so that Python code running on selected container services can be debugged with Wing Pro. This makes it easy to develop and debug containerized applications written in Python.

Getting Started

Before you can work with Docker Compose you will need to download and install it and then create a working test cluster. See Install Docker Compose for details.

You should also install Wing Pro if you don't already have it.

Configuration

To configure Wing to use New Project in the Project menu. After selecting your source directory, choose Use Existing Python on the second dialog page, and then select Cluster:

Next create a new cluster configuration by pressing the New button. This displays the cluster configuration dialog. You will need to enter an identifier to use within Wing and point it at the docker-compose.yml file for the cluster. You will also need to select the main service to use as the default place to run your Python Shell and unit test processes:

Once you have created your cluster configuration, submit the New Project dialog to complete your project setup.

Working with the Cluster

You can now control your cluster from Wing's Containers tool, found in the Tools menu. This tool lists the services in your cluster and their status. You can right-click on items here or use the Options menu to build, start, debug, and stop your cluster:

Debug processes, unit tests, Wing's integrated Python Shell and OS Commands can all be run in context of the cluster, or optionally instead within isolated containers that match the cluster configuration but run without launching the whole cluster.

See Using Wing Pro with Docker Compose for more information working with clusters in Wing Pro.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems, have any questions, or have topic suggestions for future Wing Tips!

Using Docker with Wing Pro 8

Mon, 13 Sep 2021 01:00:00 GMT

Wing Pro 8 significantly improved support for working with Python code that runs on containers like those provided by Docker, making it easier to configure projects that use Docker, and adding support for creating new Docker environments during project creation.

Prerequisites

Before you can work with Docker you will need to download and install it.

On Windows and macOS, downloading Docker Desktop from the Docker website is the easiest way to install it. Be sure to launch the Docker Desktop after you install it, so the daemon is started.

On most Linux distributions, Docker CE (the free community edition) can be installed with the docker-engine package as described here.

You should also install Wing Pro if you don't already have it.

Project Configuration

You can either create a new Docker container along with a new Wing project or use an existing container configuration.

In order to experiment with Docker, the easier of these two options is to create a new Docker container along with your project. To do this, choose New Project from the Project menu, select or create a source directory, and then on the second dialog screen choose Create New Environment with environment type Docker and Create New Container. You should be able to use the default values entered for Image ID, Host-side Directory, and Container-side Directory and simply go ahead with the environment and project creation by pressing Create Project:

If you want to use an existing Docker container configuration instead, create a new project with New Project in the Project menu, select or create a source directory, and then on the second dialog page select Create New Environment with environment type Docker and With Existing Container. You will need to enter at least the container image and host-to-container file mapping. In most cases, selecting a Dockerfile is easier than entering and image ID, since this also reads the host to container file mapping from the Dockerfile:

Both of these options create a new container configuration and set up Python Executable in your new project's Project Properties to use that container. You can make later changes to your configuration from there.

If you created a new Docker container, it will be built in the Containers tool, which is available in Wing's Tools menu. The container won't be ready for use until that process completes. This may take some time if container images are being downloaded.

How it Works

Once your project setup is complete and the Docker container has been built, Wing will run debug processes, unit tests, and the Python Shell on an instance of the selected container. Filenames are mapped automatically between the local and container-side copy of files. The debugger will display the local file even though the container's copy of the file is being executed.

OS Commands can optionally run commands on the container or on the local host. This is controlled by toggling the Run in Container option in the OS Command configuration.

Note that each debug process, each unit test run, and each instance of the Python Shell creates its own independent instance of the container.

Python Package Management in Wing Python IDE

Sun, 12 Sep 2021 01:00:00 GMT

Last time we looked at how to configure and create Python environments from Wing Pro. In this Wing Tip we'll take a look at managing your pip, pipenv, or conda Python environment from Wing Pro's Packages tool.

Prerequisites

Wing Pro's Packages tool (in the Tools menu) can work with Python environments that are managed by pip, pipenv, or conda. Regardless of which one is used, Wing assumes that pip is available in your selected Python installation. This is almost always the case in modern Python versions, or use getpip.py to install it.

Before trying Wing's package management features, you will want to set up a new project with a new virtualenv, pipenv, or conda environment and save the project to the top level of your source directory. This way you can experiment with the Packages tool without altering one of your Python environments unexpectedly.

Conda package management will only work from Wing if the base Anaconda installation can be found. See Package Management with conda for details.

Viewing Packages

Once your project is saved, Wing should auto-detect which package manager is in use in the Python environment you selected for the project and determine whether a requirements.txt file is in use. A summary of the found Python environment is shown in the Packages tool, along with a list of packages installed into that environment:

Managing Packages

To install new packages into your environment, use Install New Packages in the Packages tool's Options menu:

You can remove, update, or set a specific package version by right-clicking on the packages list:

Wing runs the appropriate package management operations, updates the package list, and displays any output from the package management command in a console that may be viewed with Show Console in the Packages tool's Options menu.

Updating requirements.txt

If you are using pip or conda, Wing can automatically update a requirements.txt that is located in the same directory as your project file or in the Project Home Directory configured under the Options tab of Project Properties.

A new requirements.txt file may be created from your current Python environment with Initialize requirements.txt from the Options menu and later updated with Freeze to requirements.txt. If the Auto-Update requirements.txt item is checked in the Options menu, then the file will automatically be updated after all package management operations run from Wing:

From here you can also set up your Python environment based on an existing requirements.txt file, with Install Missing Packages and Remove Unused Packages. This is useful the first time you check out a code base on a new machine, in order to get your Python environment set up quickly.

Pipenv

If you are using pipenv, Pipfile and Pipfile.lock are used instead of requirements.txt. Wing defers to pipenv to keep the Pipfile up to date as you issue package management commands. You can however refresh the Pipfile.lock file from the Packages tool's Options menu and Install Missing Packages can be used to initialize a pipenv environment from Pipfile.lock on a new development machine.

Conclusion

In most cases, these are all the package management operations you will need in order to set up and manage your Python environment on each development machine.

See the Package Manager documentation for a detailed description of all the available package management features and options. This also describes the quirks of each package management system, some of which you may need to understand in order to use them successfully with Wing.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Using virtualenv, pipenv, and Anaconda environments with Wing Python IDE

Sat, 11 Sep 2021 01:00:00 GMT

Last time we looked at how to create projects in Wing. In this Wing Tip let's look more closely at how to configure your project to use or create Python environments managed by virtualenv, pipenv, or Anaconda.

Configuring an Existing Project

For an existing Wing project, you can specify an environment as the Python Executable in Project Properties (from the Project menu) in one of two ways:

(1) Select Activated Env and enter the full path to the environments activation script. This is the activate or activate.bat associated with the environment:

The drop down menu next to the entry area lists discovered environments and those which have been used recently:

or (2) Select Command Line and enter the full path to the environment's python or python.exe. This executable both activates the env and runs Python, so all the code Wing launches will run in the environment:

When in doubt about which path to use, run your environment outside of Wing and inspect the value of sys.executable after import sys. That is the value you want to use.

Activated environments can be used in the same way in other settings where a Python Executable can be specified, for example for Launch Configurations and in a Remote Host configuration.

Creating a New Project

There are two options available for environments, when starting a new project from the Project menu: (1) Creating a new enviroment and new Wing project at the same time, or (2) Creating a new Wing project that uses an existing environment.

Creating a New Environment

To create a new environment along with your project, select New Project from the Project menu, select or create your source directory, and press Next. On the second screen, choose Create New Environment and select the type of environment you wish to create. You will then need to enter the name for the environment, select a parent directory, and optionally specify packages to install and/or the base Python Executable to use. For example:

The options to enter vary slightly by type of environment being created. For example, pipenv uses the selected source directory and does not need environment name and parent directory. Also, Anaconda environments require that you install at least one package.

When you press Create Project, Wing will create the environment, install packages, and then configure and save a project file. You can immediately start working in your new environment, which Wing automatically activates for you whenever you have the project open.

Using an Existing Environment

To use an existing virtualenv or Anaconda environment, select New Project from the Project menu, select or create your source directory, and press Next. On the second screen, select Use Existing Python and select Activated Env under Python Executable. You can then select a recent or found environment from the drop down or manually enter your activation command:

To use an existing pipenv, you instead simply select Use Existing Directory in the New Project dialog and Wing will auto-detect that this directory already contains a pipenv to use with the project:

In this case, Wing immediately displays the Create Project button and will use that pipenv with your project.

Notes

Once your project has been set up, you can use the Packages tool in the Tools menu to add, remove, or upgrade packages in your Python environment. We'll describe this in more details the next Wing Tip, or see Package Manager for details.

For some additional details on each type of environment, see Using Wing with virtualenv, Using Wing with pipenv, and Using Wing with Anaconda.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Creating a Project for an Existing Code Base

Fri, 10 Sep 2021 01:00:00 GMT

Wing 8 introduced some improvements and new capabilities for the project creation process. In this Wing Tip, we'll take a look at the options available during project creation in Wing Pro.

Note that Wing Personal also has the concept of projects, but omits support for remote development, cloning from revision control repositories, creating Python environments with the project, and support for specific third party packages and tools like Django, Flask, Jupyter, Docker, pipenv, and others. As a result, many of the options described below are not available in Wing Personal.

Selecting Directory and Project Type

New projects are created with New Project in the Project menu. This displays a dialog that allows you to select the source code to use with the new project and to select or configure the Python environment you plan to use:

From here it's possible to create an entirely blank project, which you can configure later, or you can set up your project with an existing source directory or create a new source directory along with the project.

Note that you can create a project for remote development here, but for now ignore this option and leave Host set to Local Host. We'll talk about remote development in future Wing Tips.

Using an Existing Directory

If you already have a Python code base you want to use with Wing, select Use Existing Directory and choose the directory to use:

Creating a New Directory

If you are starting a new project from scratch, select Create New Directory and enter the directory name, parent directory, optionally select a revision control repository to clone into the new directory (for example, by entering a Github repository url), and select the unit testing framework that you plan to use, if any:

Project Type

Whether you're using an existing directory or creating a new one, you will be able to specify a Project Type from this page of the New Project dialog. If you are using a Python package listed in the Project Type drop down, select that also. This tells Wing how to configure your project to work properly with your code:

If your project type is not listed, leave this value set to Custom. In this case, you can opt to ask Wing to configure your project to allow debug processes to be launched from outside of the IDE, for example by a web server or another app. If this will be the case, check on the Use wingdbstub for Debugging option. If you don't yet know how you will launch debug, leave this unchecked. You can always configure this later.

Selecting a Python Environment

At this point, if you used an existing source directory, Wing looks in the directory for a Python environment managed by pipenv or virtualenv and pip. If it finds one, it will use that with the new project and you can simply press the Create Project button.

Otherwise, press Next to select or configure a Python environment for the project.

You can then either use an existing Python environment with your project or create a new one. If you already have a Python environment to use, select Use Existing Python:

You can specify the Python to use by selecting the default Python, entering a custom command line that invokes Python, selecting an activated environment, or setting up a container or cluster environment. The latter two options will be described in future Wing Tips.

The Use default option causes Wing to use the Python that is run from the command line or the latest found version if Python is not on the PATH.

Command Line is used to specify the full path command line that invokes Python. For virtualenv and pipenv this can be the python or python.exe executable that is found in the environment.

Activated Env is used to specify the activation command for an existing Python environment. Wing runs this command and then starts Python within the env.

Both the Command Line and Activated Env options provide a drop down that lists all the found Python installations and environments Wing was able to find on your system.

Creating a Python Environment

Another option is to create a new Python environment along with your project. This is done by selecting Create New Environment on the second New Project screen and then choosing the type of environment to create:

Wing can create environments managed by Anaconda, Docker, pipenv, and virtualenv with pip. The options entered for each of these differ. We'll describe this in more detail in the next Wing Tip or take a look at these links for more information: Anaconda | Docker | pipenv | virtualenv

Finishing Up

Once your Python environment has been selected or configured, press Create Project and Wing will show a progress dialog as it creates and configures everything.

As part of this process, Wing saves the project automatically if you created a new source directory. Otherwise, you will need to save the project, which is typically best done to the top level of your project source tree.

That's it for now! We'll be back next week to continue this Wing Tips mini-series on navigating Python code with Wing.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Multiple Selections in Wing Python IDE

Thu, 01 Oct 2020 01:00:00 GMT

In this issue of Wing Tips we look at how to use multiple concurrent selections in Wing's editor. These can be used to replace all occurrences of some text or to apply the same edits to any number of selections, for example surround them all with quotes or remove common surrounding characters. Multiple selections can be created from the keyboard, from the mouse, or by using commands that select all occurrences of some text found within a selected code.

Creating Multiple Selections

The most common way to make multiple selections is to select a range of text in Wing's editor and then add other occurrences of the same text with Add Selection for Next Occurrence in the Edit > Multiple Selections menu. The default key binding for this is Ctrl-D, or Command-D on macOS, and Ctrl-> in the emacs keyboard personality.

Another way to add selections is to click on the multi-selection toolbar item . This menu includes items to select all occurrences in a file, class, function/method, or block of code:

Editing Selections

Once the selections are made your edits will be applied to all of them in the same way, as in the following example which replaces all occurrences of the word "stocks" with "trades":

Edits applied to all selections may include cursor movement, pasting, and other editing actions. For example selecting a number of commas, pressing the right arrow key, and then Space adds a space after all the commas:

Multi-Selecting with the Mouse

Multiple selections can also be made by clicking or double-clicking the mouse while holding Ctrl-Alt (or Option-Command on macOS). This allows selecting ranges that don't necessarily contain the same text:

Omitting Selections

By default, Wing displays a floating window that enumerates the selection made. You can omit selections from here by moving the mouse over an item and clicking on the red X icon that appears over it. Edits made subsequently are applied only to the selections that remain:

Configuration Options

Whether occurrences used for multi-selection match any text or only whole words, and whether they are case sensitive, may be controlled from the Edit > Multiple Selections menu or the multi-selection toolbar item .

The multi-selection popup window can also be entirely enabled or disabled from here, with the Configure Selections Window item.

That's it for now! We'll be back next week with more Wing Tips for Wing Python IDE.

Extend Microsoft Excel with Python Using Wing and PyXLL

Wed, 24 Jun 2020 01:00:00 GMT

This Wing Tip describes how to use Wing and PyXLL to develop and debug Microsoft Excel add-ins that are written in Python. PyXLL is a commercial product that embeds Python into Microsoft Excel on Windows. It allows you to expose Python code to Excel as worksheet functions, macros, menus, and ribbon toolbars.

Install PyXLL

Before getting started you will need to install Microsoft Excel, Python or Anaconda, Wing, and PyXLL if you don't already have them.

Important: Excel, PyXLL and Python all need to be either 32 bit or 64 bit and can't be mixed. To find out what version of Excel you have see Do I have 32 bit or 64 bit Excel? You will also need to match the version of PyXLL that you download to your Python version.

To install PyXLL, unzip the download and then edit the included pyxll.cfg and set executable to the full path of your Python executable. This can be a python.exe from a virtualenv or conda env, or a base Python install. For example:

[PYTHON]
executable = C:\Users\joebloggs\Anaconda\envs\py38\python.exe

Next, install the PyXLL add-in into Excel. To do that, open Excel and select the File menu. Navigate to Options, then Add-Ins, and click the Manage Excel Add-Ins button. Select Browse, navigate to the folder where you unzipped the PyXLL download, and select the pyxll.xll file. If Excel asks if you want to copy the add-in to your add-ins folder, select No as you want to leave it where it is. The PyXLL add-in should now appear in your list of loaded add-ins.

If you're having trouble installing the add-in, check the PyXLL log file located in the logs folder where you unzipped PyXLL. You can change the log level to debug in your pyxll.cfg file to obtain more detailed logging. If you get stuck contact the PyXLL support team who will help you get started.

You can also find more detailed installation instructions in Installing the PyXLL Excel Add-In.

Create a Wing Project

Next create a new project in Wing with New Project in the Project menu. Select Use Existing Directory and select the directory where you installed PyXLL and set Project Type to PyXLL.

After pressing Next, select Use Existing Python, set Python Executable to Command Line and enter the same Python used as the executable in pyxll.cfg above:

Now you can submit the dialog and Wing will create and configure your new project.

Write an Excel Function With PyXLL

Before we look at setting up Wing's debugger, let's write an Excel function to debug. This example uses pandas and numpy, so you will need to make sure those are installed into the Python you configured above. If you are using Anaconda, then you should already have them. In other cases, this can be done with pip. For example:

C:\Users\joebloggs\Anaconda\envs\py38\python.exe -m pip install pandas numpy

Now create a Python module for your Excel function by creating a new directory on disk and placing a Python file into that directory, with the following contents:

from pyxll import xl_func
import pandas as pd
import numpy as np

@xl_func("int, int: dataframe<index=True>", auto_resize=True)
def random_dataframe(rows, columns):
    """
    Creates a DataFrame of random numbers.

    :param rows: Number of rows to create the DataFrame with.
    :param columns: Number of columns to create the DataFrame with.
    """
    data = np.random.rand(rows, columns)
    column_names = [chr(ord('A') + x) for x in range(columns)]
    df = pd.DataFrame(data, columns=column_names)

    return df

The directory and filenames can be anything, but in this example we'll use C:\Users\joebloggs\Projects\PyXLL\src for the directory and xlfuncs.py as the file name.

Next update the pythonpath and modules setting in the same pyxll.cfg file where you set executable earlier:

[PYTHON]
pythonpath =
    C:\Users\joebloggs\Projects\PyXLL\src

[PYXLL]
modules =
    xlfuncs

Note that the entry under modules omits the .py in the filename.

Once this is done, reload the PyXLL add-in via the PyXLL ribbon tool bar or the add-ins menu in Excel, or restart Excel. PyXLL can also be configured to auto-reload after any change made to the Python code. See Reloading in the PyXLL guide for details.

How it Works

As you may already have figured out, the example Excel function random_dataframe given above creates a pandas DataFrame containing random data, and returns that to Excel as an array function.

The @xl_func decorator tells PyXLL to use it as an Excel worksheet function. The first argument to the decorator is an optional function signature. PyXLL uses this to determine how arguments and return values should be converted between the Excel and Python data types. The example here uses the dataframe return type to tell PyXLL to expand the pandas DataFrame to an array of values when returning to Excel, including the index. The auto_resize option tells PyXLL that the Excel formula should be resized automatically to fit the size of the returned array.

Tip: In order for Wing to recognise the @xl_func decorator as a valid defined symbol, you will need to install the .whl file included in the PyXLL download using pip install followed by the full path of the .whl file. You can also invoke pip with the -m command line argument for Python, as shown above for installation of pandas and numpy.

Invoke the PyXLL Function

Now you should be able to call the random_dataframe function from Excel by entering it as a formula in an Excel worksheet. This is done in the same way as Excel's standard functions by using = followed by the function name, for example =random_dataframe(10, 10):

Shown Above: Type "=random_dataframe(10,10)" and press Enter to insert a random DataFrame into Excel

For complete instructions on writing Excel worksheet functions in Python with PyXLL, please see Worksheet Functions in the PyXLL user guide.

Set up Wing's Debugger

To enable debugging, you need to tell Wing to accept connections from Python code running under Excel and then configure and load the debugger into Excel. To do this from the project you created earlier, click on the bug icon in the lower left of Wing's window, and check Accept Debug Connections:

Now hovering your mouse over the bug icon should show that Wing is listening for externally initiated debug connections on the local host:

If Wing is not listening, it may be that it has not been allowed to do so by Windows. In that case, try restarting Wing so that Windows will prompt you to allow network connections.

Next, find the Install Directory listed in the About box accessed from the Help menu in Wing. Copy wingdbstub.py from that directory to the directory that contains xlfuncs.py.

Then open your copy of wingdbstub.py and make the following changes:

Make sure WINGHOME is set to the full path of your Wing installation, where you just found wingdbstub.py. This is usually set automatically during installation of the IDE.

Change the value of kEmbedded to 1. This alters some aspects of how code is debugged, to match the environment your Python code will be running in.

To get Excel to load Wing's debugger, add wingdbstub to the modules list in your pyxll.cfg file:

[PYXLL]
modules =
    wingdbstub
    xlfuncs

Finally, restart Excel or reload the PyXLL add-in. When the wingdbstub module is loaded it will connect to Wing and the bug icon in the lower left of Wing's window will turn green, in order to let you know that the debugger is connected:

Debugging Python Code Invoked from Excel

You can now step through the Python code running in Excel.

To try it out, set a breakpoint in xlfuncs.py by opening it in Wing and clicking on the leftmost margin next to the the line that reads data = np.random.rand(rows, columns) within random_dataframe. When you call the function from Excel, the debugger will stop on the breakpoint:

Shown Above: Enter "random_dataframe(10,10)" into Excel on the left, reach a breakpoint in Wing on the right, and step through code

From here, you can inspect your debug process in the Debug Console (Wing Pro only) or Stack Data in Wing's Tools menu, set other breakpoints or conditional breakpoints (Wing Pro only), step through code, and so forth. For more information on the capabilities of Wing's debugger, see the Debugger Quick Start or the Tutorial in Wing's Help menu.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems, have any questions, or have topic suggestions for future Wing Tips!

Configuring Wing's Python Debugger for Your Code Base

Thu, 04 Jun 2020 01:00:00 GMT

This Wing Tip provides a roadmap to the configuration options available for Wing Pro's debugger, to make it easier to understand the available possibilities and how these can be applied to your development projects.

In short: Wing can develop and debug just about any kind of Python code, regardless of whether is resides locally or on a remote host, on a container or cluster, whether it's launched by the IDE from from the outside, and whether it is asynchronous, threaded, or runs in multiple processes. Read on for the details.

Configuration Options

Broadly speaking there are six ways to configure Wing's debugger:

Local Stand-Alone Code -- Wing can debug stand-alone scripts and applications that run on your local machine and that are launched on demand from within Wing. This development approach can be used for anything that is convenient to launch from the IDE, including scripts, desktop apps, and most web frameworks. See the Debugger Quick-Start for a quick introduction to this simple case.

Remote Stand-Alone Code -- Wing Pro can also debug stand-alone code running on a remote host, virtual machine or device, in the same way as it debugs locally running code. Wing uses a remote agent launched by SSH in order to work directly with files stored on the remote host, as if Wing were itself running on that system. For details, see Remote Development with Wing Pro.

Container and Cluster Code -- Wing Pro can debug code that runs on a container like those hosted by Docker or LXC/LXD, or clusters hosted by Docker Compose. In this case, editing, version control, and search operate files stored on your local disk, but code is transparently executed and debugged in the context of a container instance. For details, see Working with Containers and Clusters.

Local Externally Launched or Embedded Code -- Wing can debug locally running code that is launched by a web server or framework, embedded Python code that is used to script a larger application, and any other Python code that cannot be directly launched from the IDE. In this case, the code is started from outside of Wing and connects to the IDE by importing Wing's debugger. Debug can be controlled from the IDE and through an API accessible from the debug process. For details, see Debugging Externally Launched Code

Remote Externally Launched or Embedded Code -- Wing Pro can also debug externally launched or embedded code that is running on a remote system. In this case, Wing uses a remote agent to access the remote host via SSH and the debugged code imports Wing's debugger in order to connect back to the IDE through an automatically established reverse SSH tunnel. See Debugging Externally Launched Remote Code for brief instructions or Remote Web Development for a more detailed guide.

Manually Configured Remote Debugging -- For remote hosts and devices that are not accessible through SSH, or where Wing's remote agent cannot be run, Wing provides a manual configuration option to make debugging on these systems possible. In this case, the device must be able to connect to the host where Wing is running via TCP/IP, and there must be some file sharing configuration so files are available both locally and on the remote system. In this approach, connectivity, file sharing, and other configuration needed to make debugging possible is accomplished entirely manually, so it can be tailored to unusual custom environments. For details, see Manually Configured Remote Debugging.

VirtualEnv, pipenv, and Anaconda Environments

In context of the above , Wing may be used with or without an environment created by virtualenv, pipenv, or Anaconda's conda create.

Environments can be created with your Wing project as described in Creating Python Environments.

Alternatively, environments may be selected after the fact. For local debugging, this is done by setting the Python Executable in Project Properties. For remote debugging, it is set in the remote host configuration.

For virtualenv and pipenv, you can either set the Python Executable to Command Line and enter the full path to the virtualenv's Python, or you can select Activated Env and enter the command that activates the environment. See Using Wing with virtualenv and Using Wing with pipenv for details.

For Anaconda environments, you must select Activated Env and then choose the environment from the drop down list to the right of this field. See Using Wing with Anaconda for details.

If you are working with containers or clusters, Wing uses the environment set up and managed by the container. See Working with Containers and Clusters, Using Wing with Docker, and Using Wing with LXC/LXD for details.

Specific Frameworks and Tools

Some frameworks and tools require some additional custom configuration to make them easy to work with in Wing. In addition to understanding the general options explained above, it is a good idea to seek out configuration details for the frameworks and tools that you use:

Wing's documentation contains configuration instructions for specific frameworks and tools such as Flask, Django, Jupyter, wxPython, PyQt, Blender, Maya, and others.
There is also additional information available for specific kinds of remote development for AWS, Docker, Vagrant, Windows Subsystem for Linux, Raspberry Pi, and others.

The New Project dialog accessed from the Project menu provides some assistance for setting up new Wing projects for most of these.

Multi-threaded and Multi-process Debugging

Wing automatically debugs any multi-threaded code without any additional configuration.

Multi-process code can also be debugged but requires turning on the Debug/Execute > Debug Child Processes option in Project Properties before child processes are automatically debugged. In this case, you may also want to configure specific options for how Wing handles and terminates child processes. See Multi-Process Debugging for details.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Conditional Breakpoints Wing Pro's Python Debugger

Wed, 20 May 2020 01:00:00 GMT

This Wing Tip describes how to use conditional breakpoints in Wing Pro to stop in Python code only when certain conditions are true. This is useful for isolating a single case out of many that may be processed by the same code in a particular run, in order to investigate how that case is being handled.

Conditional breakpoints are also a great way to select the runtime state for which you want to write new Python code, with the ability to immediately try out what you write.

Use Conditional Breakpoints in Debugging

To set a conditional breakpoint, right-click on the breakpoint margin in the editor and select Set Conditional Breakpoint:

Shown above: Right-click on the breakpoint margin to set a conditional breakpoint.

Then start debug with Start/Continue in the Debug menu, from the toolbar, or as shown here with Debug Tests in the Testing tool:

Shown above: Select a set of unit tests and debug them to reach the conditional breakpoint, then run to the next hit, step over a few lines, and press Shift-Space to view the value of all visible variables.

Use Conditional Breakpoints to Write New Code

Since Wing lets you stop at breakpoints to work on new Python code interactively in the live runtime state of the debug process, conditional breakpoints are also a great way to select the specific runtime case for which you want to write new code. You'll have access to auto-completion that works off the actual runtime state, and can try your code right away in the Debug Console:

Shown above: Enter code with auto-completion and auto-editing features that inspect the live runtime state of the debug process, then try out an invocation in the Debug Console.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Moving the Program Counter in Wing's Python Debugger

Tue, 12 May 2020 01:00:00 GMT

This Wing Tip describes how to move the program counter while debugging Python code in Wing Personal and Wing Pro. This is a good way to go back and re-execute previously visited Python code, in order to trace through to the cause of a bug without having to restart the debug process.

To move the program counter, the debugger must be running and paused or stopped at a breakpoint. Then right-click on the target line in the editor and select Move Program Counter Here:

Shown above: Right-click to select Move Program Counter Here, then continue stepping with Step Over and Step Into in the toolbar.

Limitations: Due to the way Python is implemented, the program counter can only be moved within the current inner-most stack frame and it may not be moved within an exception handler, after an exception has been raised but not yet handled.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Quick Navigation to Project Files in Wing Python IDE

Wed, 22 Apr 2020 01:00:00 GMT

This Wing Tip highlights a simple but useful feature in Wing Personal and Wing Pro that you might have missed up until now: Open from Project in the File menu.

This is usually accessed with its key binding, Ctrl-Shift-O, or Command-Shift-O on macOS. If you've selected a non-default Keyboard Personality in the Edit menu, a different key binding may be used. Or, if none is defined for that keyboard setting, you can add a binding for command open-from-project with the User Interface > Keyboard > Custom Key Bindings preference.

Executing the command displays a dialog. Entering a fragment narrows the list to include only matching project files:

Matching is on the file name only. However, if the fragment includes the path separator, then the match is applied to the full path of the file, including also enclosing directory names:

Before any fragment is typed, the first few items in the dialog are the most recently opened files. These can be selected quickly with the down arrow and by pressing Enter. Even if a file is already open, using Open From Project is often the fastest way to move between different source files.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Debug Python Services Running on AWS with Wing Pro

Tue, 07 Apr 2020 01:00:00 GMT

In this Wing Tip we're continuing our look at how to use Wing Pro to remotely develop Python code running on an AWS instance. This time we'll set up remote debugging of code that is launched from outside of the IDE. This can be useful in debugging web apps and other services.

Prerequisites

Before getting started, you will need an AWS instance that you can SSH into, and you'll want to set up a Wing project for that AWS instance. If you don't already have this working, take a look at last's weeks Wing Tip: Remote Python Development on AWS with Wing Pro.

The small debugging example given in the above link launched the remote code being debugged from the IDE. The code actually runs on the AWS instance, but Wing launches it with the help of its remote agent. Now we're instead going to set up debugging remote code that is launched outside of control of the IDE.

This is done by (1) using Wing Pro's remote development support to set up a reverse SSH tunnel to the remote AWS instance, so that the debugger can connect back to the IDE, and then (2) inserting an import into code that starts debug and makes the connection to the IDE.

Setting up Remote Listening

In the project you have set up for your remote AWS instance, click on the bug icon in the lower left of Wing's window to check on Accept Debug Connections:

Now if you hover the mouse over the bug icon, you will see that Wing reports that it is listening for debug connections on the remote host on port 50050, as well as listening on the local host:

Starting Debug

To keep things simple, rather than setting up a web development framework or other service, we'll test with a simple helloworld.py example that we launch manually from the command line outside of Wing.

You can create this file on the AWS instance by right-clicking on a directory you previously added to Wing's Project tool and selecting Create New File. This collects the new file name in a dialog or, in some keyboard configurations, in the status area at the bottom of Wing's window, and then opens the file in the editor.

Then paste in the following code and save the file:

import wingdbstub
x = 1
print("Hello", x)
x +=1
print("Goodbye",x)

Notice that the first line import wingdbstub starts debug and connects to the IDE through the reverse SSH tunnel you set up in the previous section.

In order for this to work, you need to copy the automatically preconfigured file ~/.wingpro7/remote-#.#.#.#/wingdbstub.py on the remote host (where #.#.#.# is the version of Wing you running) into the same directory as helloworld.py. This can be done by opening the file in Wing and using Save As. Or just connect to your AWS instance, cd into your target directory, and copy it into place:

cp ~/.wingpro7/remote-#.#.#.#/wingdbstub.py .

If you are using Lightsail, a convenient way to connect to your instance is Connect Using SSH under the Connect tab in the Amazon Lightsail management interface.

Finally, set a breakpoint on line 3 of the test code so it will not just run to completion, but instead will stop in Wing's debugger. This is done by clicking on the leftmost margin in the editor:

Now you can start debug just by launching the test code outside of Wing:

python3 helloworld.py

The first time you do this, Wing may refuse the connection and ask whether you want to accept the security token for this host. This happens if you installed the remote agent earlier from a different Wing installation:

If this dialog appears, click Accept and then start the test code a second time:

python3 helloworld.py

This time Wing will accept the connection and should stop on your breakpoint:

From here, you can inspect your debug process in the Debug Console or Stack Data, set other breakpoints or conditional breakpoints, step through code, and so forth. For more information on the capabilities of Wing's debugger, see the Debugger Quick Start or the tutorial in Wing's Help menu.

Notes

To actually set up Wing to work with a web development framework on your AWS instance, see our How-Tos for Flask, Django, or other web development frameworks. These explain additional configuration that may be needed in each case.

Wing's debugger also provides a simple debugger API that may be useful, for example in developing a way to turn the debugger on and off on demand or controlling which threads are debugged.

For detailed documentation see the Debugger and Advanced Debugging Topics chapters in Wing Pro's user manual.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Remote Python Development on AWS with Wing Pro

Tue, 24 Mar 2020 01:00:00 GMT

In this Wing Tip we'll start looking at how to use Wing Pro to remotely develop Python code running on an AWS instance. With minimal configuration, Wing Pro can edit, debug, test, inspect, and navigate Python code residing on an AWS instance, as if it were on the local host.

Minimum Requirements

You will need an AWS instance that has Python installed on it, is running 32-bit or 64-bit Intel Linux, and that you can connect to using OpenSSH or PuTTY. PuTTY is recommended on Windows because it tends to be prone to fewer problems. You will need the following in order to configure Wing Pro to use your AWS instance:

(1) The user name and static IP address or DNS name used to connect to the AWS instance. Amazon Lightsail typically uses an IP address while EC2 and other variants of AWS may provide a DNS name as well. The static IP address will work in any case.

(2) The SSH key pair in a *.pem file, as downloaded from AWS.

If you do not already have Wing Pro installed, download it now.

Setting up AWS

If you already have an AWS instance to work with, you can skip this section.

Amazon Lightsail is the easiest way to get an AWS instance, in about 5 minutes. You will need to set up an account. Then create a Linux/Unix instance, selecting the OS Only option and the most recent Ubuntu or any other Intel Linux with Python 2 or 3 on it.

While setting up your instance, you can download your SSH key pair under the AWS SSH key pair manager. You'll need this on your local machine, where Wing is running, in order to be able to connect to the instance.

After the instance is created, it will remain in pending state for a minute or so. Once it is up and running, create a static IP address under the Network tab in the AWS Lightsail management area and attach it to your instance.

At this point you have all that is needed to start using Wing Pro with AWS: (1) The SSH key pair that you downloaded, and (2) the user name and IP address, which are shown on the Lightsail instance management page.

Testing the SSH Connection

Before trying to use your new instance from Wing Pro, you should first try to connect using ssh or PuTTY's plink.exe on the command line, to make sure those are working. This is important because Wing invokes those command lines to connect to the instance.

OpenSSH

On Linux or macOS using ssh, you need to make your *.pem SSH key pair file readable only by the user running Wing, for example with:

chmod 600 aws.pem

Otherwise, ssh will reject it as potentially compromised.

Once that is done, try connecting as follows, substituting the actual path to your downloaded SSH key pair and your instance's username and IP address or DNS name:

ssh -i /path/to/mykey.pem ubuntu@11.22.33.44

You will be asked to add the instance's identity to your known hosts file, which you should do by typing yes. If this is not done, ssh will fail to connect and Wing will also not be able to connect to the instance.

PuTTY

With PuTTY on Windows, you will need to first convert the SSH key to a format that PuTTY can use. This is done by launching puttygen, pressing the Load button to read the *.pem SSH key file you downloaded from the AWS management site, and then using Save Private Key to write a *.ppk file.

Then you invoke plink.exe to connect to the AWS instance as follows, substituting in the actual path to your downloaded SSH key pair and the correct username and IP address or DNS name for the AWS instance:

plink.exe -i C:\path\to\mykey.ppk ubuntu@11.22.33.44

You will be asked to accept the AWS instance's identity the first time you connect, and this must be done before Wing's remote development support will work with the AWS instance.

Creating a Wing Project

Now you're ready to create a project in Wing Pro. This is done with New Project from the Project menu. Select Create Configuration from the Host dropdown. Then choose AWS as the remote host type and enter an identifier for the remote host (any short string to identify it in Wing's UI), and the user name and IP address or DNS name used to connect to the host:

As in the above example, Python Executable will usually be Use default, which first tries python3 and then python. If Python is not on the PATH on your AWS instance or you want to specify a particular Python executable or activate a virtual environment, you can do this here.

You will also need to point Wing at the SSH key pair file you downloaded from AWS earlier. This is done under the Options tab using the Private Key field as follows:

Pressing OK in the New Remote Host dialog will create your remote configuration and install Wing's remote agent on the AWS instance.

Next, you can continue through the project creation process by selecting or creating a source directory, and then optionally creating a new Python environment to use with the project.

Testing a Hello World

To try out a simple example of editing and debugging code on the remote AWS instance, create a file helloworld.py temporarily on the instance. This is done by right-clicking on one of the files in the Project tool in Wing Pro and selecting Create New File. Enter the file name (in some key bindings this is in the data entry area at the bottom of Wing's window) and type or paste the following into the new file:

import time
print("Hello World! {}".format(time.time()))

After saving the file, set a breakpoint on the second line by clicking on the leftmost margin in the editor:

Then select Starting/Continue from the Debug menu to start debug, or use the green play icon in the toolbar.

There is a slight delay to get the process started, depending on your network distance from the AWS instance, but then you should see Wing stop on the breakpoint:

There's not much to see here, but you can poke around a little in the live runtime state of the paused debug process, using Wing Pro's Debug Console, from the Tools menu:

Once you continue debugging, the process will exit and print to the Debug I/O tool:

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Goto-Definition From the Interactive Shells in Wing

Wed, 11 Mar 2020 01:00:00 GMT

In this Wing Tip we'll take a quick look at a lesser-known but often useful feature in Wing: Jumping from symbols in the integrated Python shells to their point of definition in source code. This makes it a snap to bridge from runtime symbols to the source code where they are actually defined and used.

Debug Console Example

In this example, the debugger is stopped and I'm working in Wing Pro's Debug Console, which is an interactive shell that runs in the context of the currently selected debug stack frame. While trying to determine why handler.exit_status is None, I jump to its point of definition from the right-click context menu:

From here, I could set a breakpoint and restart debug, or right-click on the editor to select Find Points of Use to see all the points of use of exit_status.

Python Shell Example

Similarly, I can import a module in the Python Shell in Wing Pro or Wing Personal and jump to the point of definition of symbols in the module. Here I'm using this technique to bring up the source code for numpy's ndarray:

In this case, I'm pressing F4 to go to the definition, rather than using the right-click context menu.

Traversing Visit History

To get back from the point of definition to the previously displayed code in the editor, use the browser-like forward/back arrow buttons in the top left of the editor:

Pressing Alt-Left or using any other key binding for the command visit-history-previous also goes back in the editor's visit history.

That's it for now! We'll be back soon with more Wing Tips for Wing Python IDE.

As always, please don't hesitate to email support@wingware.com if you run into problems or have any questions.

Wing Tips

Turbo Completion Mode in Wing Pro

Debug Python Code Run by Docker Compose with Wing Pro

Getting Started

Configuration

Working with the Cluster

Using Docker with Wing Pro 8

Prerequisites

Project Configuration

How it Works

Further Reading

Python Package Management in Wing Python IDE

Prerequisites

Viewing Packages

Managing Packages

Updating requirements.txt

Pipenv

Conclusion

Using virtualenv, pipenv, and Anaconda environments with Wing Python IDE

Configuring an Existing Project

Creating a New Project

Creating a New Environment

Using an Existing Environment

Notes

Creating a Project for an Existing Code Base

Selecting Directory and Project Type

Using an Existing Directory

Creating a New Directory

Project Type

Selecting a Python Environment

Creating a Python Environment

Finishing Up

Multiple Selections in Wing Python IDE

Creating Multiple Selections

Editing Selections

Multi-Selecting with the Mouse

Omitting Selections

Configuration Options

Extend Microsoft Excel with Python Using Wing and PyXLL

Install PyXLL

Create a Wing Project

Write an Excel Function With PyXLL

How it Works

Invoke the PyXLL Function

Set up Wing's Debugger

Debugging Python Code Invoked from Excel

Configuring Wing's Python Debugger for Your Code Base

Configuration Options

VirtualEnv, pipenv, and Anaconda Environments

Specific Frameworks and Tools

Multi-threaded and Multi-process Debugging

Conditional Breakpoints Wing Pro's Python Debugger

Use Conditional Breakpoints in Debugging

Use Conditional Breakpoints to Write New Code

Moving the Program Counter in Wing's Python Debugger

Quick Navigation to Project Files in Wing Python IDE

Debug Python Services Running on AWS with Wing Pro

Prerequisites

Setting up Remote Listening

Starting Debug

Notes

Remote Python Development on AWS with Wing Pro

Minimum Requirements

Setting up AWS

Testing the SSH Connection

Creating a Wing Project

Testing a Hello World

Goto-Definition From the Interactive Shells in Wing

Debug Console Example

Python Shell Example

Traversing Visit History