Question

[Solved] Pylint “unresolved import” error in Visual Studio Code

I am using the following setup

  • macOS v10.14 (Mojave)
  • Python 3.7.1
  • Visual Studio Code 1.30
  • Pylint 2.2.2
  • Django 2.1.4

I want to use linting to make my life a bit easier in Visual Studio Code. However, for every import I have states “unresolved import”. Even on default Django imports (i.e. from django.db import models).

I presume it is because it is not seeing the virtual environment Python files.

Everything works just fine, but it’s starting to get annoying.

The interpreter choices I have are all system versions of Python. It does not seem to see my virtual environment Python at all (it is not in the same directory as my workspace, so that part makes sense).

If I set up the python.PythonPath in the settings.json file, it just ignores it and does not list my virtual environment path as an option. I also tried setting it up in my global Python settings, but it also does not show up.

Is there a quick fix to get it working?

Enquirer: jAC

||

Solution #1:

In your workspace settings, you can set your Python path like this:

{
    "python.pythonPath": "/path/to/your/venv/bin/python",
}
Respondent: ruddra

Solution #2:

The accepted answer won’t fix the error when importing own modules.

Use the following setting in your workspace settings .vscode/settings.json:

"python.autoComplete.extraPaths": ["./path-to-your-code"],

Reference: Troubleshooting, Unresolved import warnings

Respondent: Shinebayar G

Solution #3:

Alternative way: use the command interface!

Cmd/Ctrl + Shift + P ? Python: Select Interpreter ? choose the one with the packages you look for:

Enter image description here

Respondent: ted

Solution #4:

This issue has already been opened on GitHub:

Python unresolved import issue #3840

There are two very useful answers, by MagnuesBrzenk and SpenHouet.

The best solution for now is to create a .env file in your project root folder. Then add a PYTHONPATH to it like this:

PYTHONPATH=YOUR/MODULES/PATH

And in your settings.json add:

"python.envFile": ".env"
Respondent: Tomasz Chudzik

Solution #5:

If you have this code in your settings.json file, delete it:

{
    "python.jediEnabled": false
}
Respondent: sps

Solution #6:

When I do > reload window that fixes it.

Reference: Python unresolved import issue #3840, dkavraal‘s comment

Respondent: Full Of Stack

Solution #7:

I was able to resolved this by enabling jedi in .vscodesettings.json

"python.jediEnabled": true

Reference from https://github.com/Microsoft/vscode-python/issues/3840#issuecomment-456017675

Respondent: nairb

Solution #8:

If you are more visual like myself, you can use the Visual Studio Code configurations in menu File ? Preferences ? Settings (Ctrl + ,). Go to Extensions ? Python.

In the section Analysis: Disabled, add the suppression of the following message: unresolved-import:

Visual Studio Code settings

Respondent: David

Solution #9:

You need to select the interpreter associated with the virtual environment.

Enter image description here

Click here (at the bottom status bar):

Enter image description here

And just select the virtual environment you are working with. Done.

Sometimes, even with the interpreter selected, it won’t work. Just repeat the process again and it should solve it.

Enter image description here

Respondent: Evandro Pomatti

Solution #10:

None of the solutions worked except this one. Replacing “Pylance” or “Microsoft” in the settings.json solved mine.

"python.languageServer": "Jedi"
Respondent: hexr

Solution #11:

I wonder how many solutions this problem have (or have not), I tried most of the above, nothing worked, the only solution that worked is to set the python language server to Jedi, instead of Microsoft in the settings.json file:

"python.languageServer": "Jedi"
Respondent: Georges

Solution #12:

None of the previous answers worked for me. Adding both of the lines below to my settings.json file did, however.

"python.analysis.disabled": [
    "unresolved-import"
],
"python.linting.pylintArgs": ["--load-plugin","pylint_protobuf"]

The first line really just hides the linting error. Certainly not a permanent solution, but de-clutters the screen.

This answer gave me the second line: VS Code PyLint Error E0602 (undefined variable) with ProtoBuf compiled Python Structure

Maybe someone who understands Python more than me can explain that one more.

Respondent: dillon.harless

Solution #13:

My solution

This solution is only for the current project.

  1. In the project root, create folder .vscode

  2. Then create the file .vscode/settings.json

  3. In the file setting.json, add the line (this is for Python 3)

    {
        "python.pythonPath": "/usr/local/bin/python3",
    }
    
  4. This is the example for Python 2

    {
        "python.pythonPath": "/usr/local/bin/python",
    }
    
  5. If you don’t know where your Python installation is located, just run the command which python or which python3 on the terminal. It will print the Python location.

  6. This example works for dockerized Python – Django.

Respondent: Rolly

Solution #14:

To me the problem was related with the project that I was working on. It took me a while to figure it out, so I hope this helps:

Original folder structure:

    root/
    __init__.py  # Empty

        folder/
            __init__.py # Empty

            sub_folder_b/
                my_code.py
            sub_folder_c/
                another_code.py

In another_code.py:

from folder.sub_folder_b import my_code.py

This didn’t trigger the intellisense in Visual Studio Code, but it did execute OK.

On the other hand, adding “root” on the import path, did make the intellisense work, but raised ModuleNotFoundError when executing:

from root.folder.sub_folder_b import my_code.py

The solution was to remove the _init_.py file inside the “folder” directory, leaving only the _init_.py located at /root.

Respondent: NicoE

Solution #15:

The solution from Shinebayar G worked, but this other one is a little bit more elegant:

Copied from Python unresolved import issue #3840:

Given the following example project structure:

  • workspaceRootFolder
    • .vscode
  • … other folders
  • codeFolder

What I did to resolve this issue:

  1. Go into the workspace folder (here workspaceRootFolder) and create a .env file
  2. In this empty .env file, add the line PYTHONPATH=codeFolder (replace codeFolder with your folder name)
  3. Add “python.envFile”: “${workspaceFolder}/.env” to the settings.json
  4. Restart Visual Studio Code
Respondent: Lincoln

Solution #16:

None of the answers here solved this error for me. Code would run, but I could not jump directly to function definitions. It was only for certain local packages. For one thing, python.jediEnabled is no longer a valid option. I did two things, but I am not sure the first was necessary:

  1. Download Pylance extension, change python.languageServer to “Pylance”
  2. Add "python.analysis.extraPaths": [ "path_to/src_file" ]

Apparently the root and src will be checked for local packages, but others must be added here.

Respondent: chuck_d

Solution #17:

This works for me:

Open the command palette (Ctrl + Shift + P) and choose “Python: Select Interpreter”.

Doing this, you set the Python interpreter in Visual Studio Code.

Respondent: Evandro Brunassi

Solution #18:

That happens because Visual Studio Code considers your current folder as the main folder, instead of considering the actual main folder.

The quick way to fix is it provide the interpreter path to the main folder.

Press Command + Shift + P (or Ctrl + Shift + P on most other systems).

Type Python interpreter

Select the path where you installed Python in from the options available.

Solution #19:

Changing
Python:Language Server
to ‘Jedi’ worked for me.
It was ‘Windows’ initially.

Respondent: Kirill Kruglov

Solution #20:

I was facing the same problem while importing the project-related(non standard) modules.
Detailed explanation of the problem

Directory structure:

Project_dir:
    .vscode/settings.json
    dir_1
        > a
        > b
        > c
    dir_2
        > x
        > y
        > z

What we want:

Project_dir
    dir_3
        import a
        import y

Here “import a” and “import yfails with following error:

Import "dir_1.a" could not be resolvedPylancereportMissingImports
Import "dir_2.y" could not be resolvedPylancereportMissingImports

What worked for me:

Appending the top directory which contains the modules to be imported.

In above example add the follwoing “Code to append” in “.vscode/settings.json”

Filename:

.vscode/settings.json

Code to append:

"python.analysis.extraPaths": [dir_1, dir_2]
Respondent: Ani

Solution #21:

I have a different solution: my Visual Studio Code instance had picked up the virtualenv stored in .venv, but it was using the wrong Python binary. It was using .venv/bin/python3.7; using the switcher in the blue status bar.

I changed it to use .venv/bin/python and all of my imports were resolved correctly.

I don’t know what Visual Studio Code is doing behind the scenes when I do this, nor do I understand why this was causing my problem, but for me this was a slightly simpler solution than editing my workspace settings.

Respondent: Dawngerpony

Solution #22:

In case of a Pylint error, install the following

pipenv install pylint-django

Then create a file, .pylintrc, in the root folder and write the following

load-plugins=pylint-django

Solution #23:

I have faced this problem in three ways. Although for each of them a solution is available in the answers to this question, I just thought to put it all together.

  1. First I got an “Unresolved Import” while importing some modules and I noticed that my installations were happening in global pip instead of the virtual environment.

    This issue was because of the Python interpreter. You need to select the interpreter in Visual Studio Code using Shift + Ctrl + P and then type Select Python Interpreter. Select your venv interpreter here.

  2. The second issue was: The above change did not resolve my issue completely. This time it was because of file settings.json. If you don’t have the settings.json file in your project directory, create one and add the following line in that:

        {
            "python.pythonPath": "apis/bin/python"
        }
    

    This will basically tell Visual Studio Code to use the Python interpreter that is in your venv.

  3. The third issue was while importing a custom Python module or file in another program. For this you need to understand the folder structure. As Python in venv is inside bin, you’ll need to specify the folder of your module (most of the time the application folder). In my case it was app,

        from app.models import setup_db
    

    Verbally, import setup_db from models.py resides in the app folder.

Respondent: nitin goyal

Solution #24:

If you are using pipenv then you need to specify the path to your virtual environment.in settings.json file.
For example :

{
    "python.pythonPath": 
           "/Users/username/.local/share/virtualenvs/Your-Virual-Env/bin/python"
}

This can help.

Respondent: Devesh

Solution #25:

For me, it worked, if I setup the paths for python, pylint and autopep8 to the local environment paths.

For your workspace add/change this:

"python.pythonPath": "...\your_path\.venv\Scripts\python.exe",
"python.linting.pylintPath": "...\your_path\.venv\Scripts\pylint.exe",
"python.formatting.autopep8Path": "...\your_path\.venv\Scripts\autopep8.exe",

Save and restart VS Code with workspace.
Done!

Respondent: user14430340

Solution #26:

Resolved

First of all open visual studio code settings in json and add following arguments after "[python]":{}

"python.linting.pylintArgs": ["--rep[![enter image description here][1]][1]orts", "12", "--disable", "I0011"],
"python.linting.flake8Args": ["--ignore=E24,W504", "--verbose"]
"python.linting.pydocstyleArgs": ["--ignore=D400", "--ignore=D4"]

This has solved my issue with pylint

Respondent: Otabek Butcher

Solution #27:

I have resolved import error by Ctrl + Shift + P.
Type “Preferences settings” and select the option Preferences Open Settings (JSON)

And add the line "python.pythonPath": "/usr/bin/"

So the JSON content should look like:

{
    "python.pythonPath": "/usr/bin/"
}

Keep other configuration lines if they are present.
This should import all modules that you have installed using PIP for autocomplete.

Respondent: Ashish

Solution #28:

My solution was to open Visual Studio Code in a previous directory.

Respondent: Jeremias Caceres

Solution #29:

In my case I already had a Conda environment activated, but I still wanted local Python modules to be available for autocomplete, peeking definition, etc.

I tried many solutions such as adding a list of Python paths etc., but what finally solved it for me was to create a symbolic link from Conda’s lib/python{your version}/site-packages to my local module.

Respondent: Kerem T

Solution #30:

I have one library which errs out when trying to include it using the Jedi language service and works fine without it (i.e. the C# one).

The library is jsonslicer and it does depend on an external C library I installed into /usr/local/lib. Could that have something to do with it?

I installed the Jedi service and the library in my Conda environment and used that environment within Visual Studio. It works fine at runtime and in my terminal, but not when checking for problems in my source files and it shows up as an error.

Respondent: richtera

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Most Popular

To Top
India and Pakistan’s steroid-soaked rhetoric over Kashmir will come back to haunt them both clenbuterol australia bossier man pleads guilty for leadership role in anabolic steriod distribution conspiracy