Creating a Python Class Generator for VS Code

Creating a Python Class Generator for VS Code

In this article, let's walk through how I created an extension in Visual Studio Code

In this article, let's walk through how I created an extension in Visual Studio Code

My motto...when you have a problem, do something about. I hated stubbing out Python classes so I created an extension in Visual Studio Code to do it for me. In this article, let's walk through how I created that extension. We will use several techniques to do so.

Table of Contents

  • TLDR
  • Creating the Project
  • Prompt the User for Input
  • Create the Class Content String
  • Creating the Class File
  • Run It
  • Recap
  • Prompting User Input
  • Array Map and Join Functions
  • ES6 Template Literals
  • Writing to the File System

Create a new extension, prompt the user for input, convert the input to a string that represents the new class file, and write out tha

Check out the end result HERE.

Creating the Project

To get started with developing Code extensions, you’ll need two different NPM packages installed, “yo” and “generator-code”. If you’re looking for a little more background on creating VS Code extensions, check out Creating Your First Visual Studio Code Extension!

To generate your project, run the following command.

yo code

This will follow up by asking you several questions about your project. Choose either JavaScript or TypeScript for your extension.

After answering all of the questions, open the newly created project in Code.

You’ll have a several different files created for you, the two most important are the package.json and extension.js files.

Start by opening the extension.js file. Then, rename the extension command name to “createPyClass”.

Then, in the package.json file, rename the activation event and command to match the name of the command.

Update the title as well, which is what the user will type to activate the command.

To run the extension, open the debug panel (looks like a bug) and press play. This will open up a new instance of VS Code. Open the command prompt (Command+Shift+P on Mac and Control+Shift+P on Windows) and type “Create Python Class”.

And you should see the “Hello World” message.

Prompt the User for Input

Here comes the tricky part. We need to prompt the user for input about the class (class name and properties) and convert that input into a string that we can write to the new class file.

Let’s start by ensuring the user has a folder currently open. If not, we don’t have a place to write the new class file to. If the user does not have a folder open, we show an error message and return.

if (!vscode.workspace.workspaceFolders) {
  return vscode.window.showErrorMessage(
    "Please open a directory before creating a class."

Now, we can ask the user for the name of the class he/she wants to create. If the user, for some reason, closes the input prompt (by hitting escape) we return.

const className = await vscode.window.showInputBox({
  prompt: "Class Name?"

if (!className) return;

Now, a bit of a tricky part. We want to let the user input as many properties as he/she wants to. For this we prompt initially for a property, then run a while loop retrieving properties until the user enters ‘done’.

let count = 1;
let property = await vscode.window.showInputBox({
  prompt: `Property #${count}? ('done' when finished)`
const properties = [];
while (property != "done") {
  property = await vscode.window.showInputBox({
    prompt: `Property #${count}? ('done' when finished)`

This might be a good point to rerun you extension, enter in valid inputs, and print the user’s info just to be sure it looks right.

Create the Class Content String

Now, we start to take the users input to generate the content of the class. Let’s start by creating the class definition line as well as the constructor definition.

const classDefinition = `class ${className}:`;
const constructorDefinition = `def __init__(self, ${properties.join(", ")}):`;

Then, we can create the constructor assignments lines. This is where the user will initialize variables on itself, using the values of the constructor parameters. For this, we use map (as we will from now on) to convert each of the property inputs in some way.

const constructorAssignments = properties
  .map(property => `self.${property} = ${property}\n\t\t`)

Now, for each property, we create a getter function. Again, we use map to convert each property into a string that represents its getter.

const classGetters = properties
    property => `\tdef get_${property}(self):\n\t\treturn self.${property}\n\n`

And the last thing we want to create is the string function that will tell Python how to print this object. This one is pretty tricky. Again, we use the map function to convert each property by printing the name of the property and then it’s value.

Notice that in the map return value, we are adding a comma and a plus. This means for the last property, we would be adding unnecessary characters at the end. For this reason, we convert the resulting array to a string and chop of the last 11 characters by using splice.

const dunderStrString = `\tdef __str__():\n \t\treturn ${properties
  .map(property => '"' + property + ': "' + " + " + property + ' + " , " + ')
  .slice(0, -11)}`;

Let’s take this individual pieces and put them all together!

const classString = `${classDefinition}

I would recommend creating a log statement and running this again to make sure your class string looks good!

Creating the Class File

Whew, that was a lot, but it gets easier from here. Now, we need to write that string to a new file. To work with files, we need to import the “fs” and “path” modules from Node at the top of the page.

const fs = require("fs");
const path = require("path");

Then, we need to get the path for the user’s currently open directory. This was a bit tricky for me. You can get a reference to open directories by vscode.workspace.workspaceFolders. Then, we get the first one from the resulting array, grab it’s uri, and convert it to a string. The resulting path string included a prefix, so we strip that out by splitting by a colon and grabbing what comes after the colon.

const folderPath = vscode.workspace.workspaceFolders[0].uri

Now we can use the fs module, the folder path, and the name of the class file, to write the class string to our new file!

fs.writeFile(path.join(folderPath, `${className}.py`), classString, err => {});

We can take it one step further by providing the user some feedback based on whether or not the write file was successful.

fs.writeFile(path.join(folderPath, `${className}.py`), classString, err => {
  if (err) {
    vscode.window.showErrorMessage("Something went wrong");
    return console.log(err);
  vscode.window.showInformationMessage(`${className} Class created.`);

Run It

Either refresh your debugging instance or start again by following the steps above. With the debug instance of VS Code open, run your “Create Python Class” command again. Then, enter the name of the class your want to create. “Person” in this case.

Then enter your properties, “name” first.

Then “age”.

Then “done” to finish.

Hopefully, yours says that the file was successfully created.

Then, double check your file was actually created and it looks good!


Again, if you struggle with something in your development process, work to improve it. In this case I created an extension to solve a specific problem I had. It’s also something that others will benefit from as well. Not to mention, it was a great learning opportunity!

Python in Visual Studio Code

Python in Visual Studio Code

Python in Visual Studio Code

This post was written by Luciana Abud, Program Manager for the Python Extension in Visual Studio Code

We are pleased to announce that the January 2019 release of the Python Extension for Visual Studio Code is now available. You can download the Python extension from the Marketplace, or install it directly from the extension gallery in Visual Studio Code. You can learn more about Python support in Visual Studio Code in the documentation.

In this release we have closed a total of 62 issues, including:

  • IPython console support in the Python Interactive window
  • Support for running an entire file in the Python Interactive window
  • Problems for failed tests when using pytest (thanks Chris NeJame)
  • Much faster outline when using the Python Language Server

Keep on reading to learn more!

IPython console support in the Python Interactive window

The data science experience was first introduced in the last October release, and one of the top feedback requests we’ve heard was to provide the ability to iterate rapidly by experimenting with code in an interactive console environment. In this update, we extended the Python Interactive window with IPython console support by allowing code to be typed in and executed directly in the window. You can now use the enhanced Interactive window standalone as an IPython console, or send code from the editor for execution.

Here’s how to use it in a nutshell:

  • IPython console support in the Python Interactive window
  • Support for running an entire file in the Python Interactive window
  • Problems for failed tests when using pytest (thanks Chris NeJame)
  • Much faster outline when using the Python Language Server

Run an entire file in the Python Interactive window without cells defined

Being able to run code in the Python Interactive window without having to define cells is no doubt one of the most requested features. This update enables running the entire files in the Interactive window without cell definitions.

To run the entire file, simply use the command Run Current File in Python Interactive window in the Command Palette. Your code will be executed with results displayed in the Python Interactive window.

We’ve also heard requests to run the current code selection / line in the editor, and this will be coming next in a future update.

Diagnostics for failed tests with pytest

This release also includes an enhancement to unit tests run with pytest: you can now see failed tests in the problems window. You can also double click lines to navigate to the failed test method and the exact failing line. The correspondent line in the editor will be selected, allowing you to easily identify and edit it.

As before, you can also see failed tests highlighted with pass/fail icons in the editor. You can hover these icons to see the errors navigate to the failing test method/line, just like in the problems window.

We’d like to thank community contributor Chris NeJame for implementing this new feature. Contributions to the Python extension are always welcome! If you’re interested, check our contributing guide to learn more.

Much faster outline view with the Python Language Server

We also made improvements to the outline view when using the Microsoft Python Language Server. The Outline view could often take a long time to load or even time out, and now with the Language Server It now loads consistently fast, and cases where symbols would appear duplicated were fixed.

As a reminder, the Language Server was released as a preview the last July release of the Python extension. To opt-in to the language server, change the python.jediEnabled setting to false in File > Preferences > User Settings. We are working towards making the language server the default in future releases.

Original source:


Thanks for reading :heart: If you liked this post, share it with all of your programming buddies! Follow me on Facebook | Twitter

Learn More

☞ Complete Python Bootcamp: Go from zero to hero in Python 3

☞ Python for Time Series Data Analysis

☞ The complete beginner’s guide to JSON

☞ The Complete Guide to JSON Web Tokens

☞ Python Programming For Beginners From Scratch

☞ Python Network Programming | Network Apps & Hacking Tools

☞ Intro To SQLite Databases for Python Programming

☞ Ethical Hacking With Python, JavaScript and Kali Linux

☞ Beginner’s guide on Python: Learn python from scratch! (New)

☞ Python for Beginners: Complete Python Programming

Visual Studio Code For Python Development

Visual Studio Code For Python Development

This video 'Visual Studio Code For Python Development' will help you understand how you can use the Python extension to write python code in the visual studio code editor.

This video 'Visual Studio Code For Python Development' will help you understand how you can use the Python extension to write python code in the visual studio code editor. Following are the topics discussed in this Visual Studio Code For Python Development tutorial:

  • What is Visual Studio Code?
  • Visual Studio Code Installation
  • Python Extension In VS Code
  • First Python Program In VS Code
  • Linting, Debugging Support
  • Jupyter Notebook Support
  • Python Interactive And Environments

Getting Started with Python in Visual Studio Code

Getting Started with Python in Visual Studio Code

Python is one of the most popular and easy to learn languages, which is why it is often one of the first languages you learn. Let’s see how to work with and run Python inside of Visual Studio Code!

Python is one of the most popular and easy to learn languages, which is why it is often one of the first languages you learn. Let’s see how to work with and run Python inside of Visual Studio Code!

Table of Contents

Install Python on Your Machine

The first thing you’ll need to take care of is installing Python on your machine. To do that, you can head to official Python download page and walk through the install process.

Mac Install Details

If you are using a Mac, you probably already have a version of Python installed, but it is an older version (2.7 for me). If you install the latest version (currently 3.x), you’ll have two different version installed. Applications on your mac are dependent on the older, so you can’t get rid of it.

Because of this, to run your python from the terminal you would need to use the “python3” command. Alternatively, you could set an alias, so that any time you type “python” you’re actually using the “python3” command. To setup this alias, you can type this into your terminal. You can use this post for reference.

alias python = 'python3'

Run Python From the Built in Terminal

A typical workflow for running your Python files will look like this.

To get started I recommend creating a folder on your Desktop (or a directory that you’re comfortable with) to put your Python files in for now. With that directory created and Python installed, now open up Visual Studio Code.

Inside of VS Code, open the folder/directory that you just created by going to File->Open and then choosing that directory. After that, you’ll see your folder open in the explorer window on the left.

With the directory open, you can create your first python file (.py extension) with some code to print “Hello World”.

Now that you have your Hello World code ready, we can run it by using the built-in temrinal in VS Code. If if is not open already, you can open it by going to View->Terminal or use the shortcut, Control+Tilde.

The terminal that you just opened will automatically start in the current directory that you are editing in VS Code. This is exactly why we created and opened a directory before getting started. We can prove this by running the following command (on Mac).


This command will print the path to the current directory. From there, you can verify that your python file is also inside of the current directory by running the following command (on Mac), which will print a list of files in the directory.


Now, you can run your python file with the following command.

python <filename>

After running, you should see “Hello World” printed out in the console.

Install the Python Extension

That process wasn’t so bad, but working with Python gets a lot easier with the Python extension created by Microsoft. To install the extension, open up the extension menu on the left (the icon looks like a square inside of a square) and search Python.

The Python extension provides amazing intellisense, auto-completion, and muchmore!
It will be the first one that pops up, and you can click on it to view the extension details. Should look like this. Go ahead and click install.

After installing, you might need to reload, so go ahead and do that.

After you restart, you can now take advantage of several awesome features of this extension.

To get a sense for intellisense, create an empty array called “list”. Then type “list” followed by a period and notice that a bunch of information pops up. The extension is providing you all the functions and properties of a list that you can use.

If you want to use one of those functions, you can press enter or tab to auto-complete that function name. This means that don’t have to memorize every function in Python because the extension will give you hints as to what is available. Notice also that it shows you a brief description of what the function does and what parameters it takes.

You can also get intellisense when importing modules in Python. Notice that as I type “random”, intellisense pops up to complete the name of the module as well as providing some background info on what it does.

If you then start to use the random module, you’ll continue to get intellisense for functions that you can access with that module!

Lastly, you can hover on existing variables, module imports, etc. for additional information whenever you need it.

Use Shortcuts to Run Python Code

If you want to spice things up a bit in your Python file, here’s a short snippet for the Bubble Sort algorithm. It calls the Bubble Sort function and prints out the result. You can copy this code into your file if you’re interested.

def bubble_sort(list):
    sorted_list = list[:]
    is_sorted = False
    while is_sorted == False:
        swaps = 0
        for i in range(len(list) - 1):
        if sorted_list[i] > sorted_list[i + 1]: # swap
            temp = sorted_list[i]
            sorted_list[i] = sorted_list[i + 1]
            sorted_list[i + 1] = temp
            swaps += 1
        if swaps == 0:
        is_sorted = True
    return sorted_list

print(bubble_sort([2, 1, 3]))

With our fancy new piece of code taken care of, let’s explore a new way to run our python file. The typical first workflow for working with Python files (as we talked about previously) is to save your file and then run that python file in the terminal. With the Python extension, there are a few shortcuts to help with this process.

Inside of any Python file, you can right click in the editor and choose “Run Python File In Terminal”. This command will basically do each of the individual steps that we talked about before.

After using the shortcut, you can see the bubble sort output in your console.

You also have a shortcut to open the Python REPL where you can quickly type Python code directly into your console and see the output. Open the command pallette using the shortcut Command+Shift+P on Mac or Control+Shift+P on Windows and use the “Python Start REPL” command.

After typing in a print command, you will see “Hello World” immediately displayed in the console.


Python is incredibly popular language, and it has some really good support in VS Code. By installing the “Python” extension, you’ll get Python intellisense, auto-completion, and other useful misc. shortcuts.

Curious…Are you using Python? If so, are you using VS Code and the Python extension? Any other tools you’re using that you find useful?

Video from Youtube

Learn More

Complete Python: Go from zero to hero in Python

Python in Visual Studio Code

Computer Vision Using OpenCV

Learn Python 3 Programming for Beginners

An A-Z of useful Python tricks

A Complete Machine Learning Project Walk-Through in Python

Automated Machine Learning on the Cloud in Python

Learning Python: From Zero to Hero

Python Tutorial for Beginners (2019) - Learn Python for Machine Learning and Web Development

Complete Python Bootcamp: Go from zero to hero in Python 3

Machine Learning A-Z™: Hands-On Python & R In Data Science