Fully disable the linting

Here is a link that explain how to do it : Disable Linting on VsCode.

To do so, type Command + Shift + P (or Ctrl + Shift + P on PC) in VsCode. This will open a command prompt at the top of the window. Then type the command Python: Enable Linting, and select off.

Another option is to choose no linter. To do so, open the command prompt with Command + Shift + P (or Ctrl + Shift + P on PC), type Python: Select Linter, and choose the option Disable Linting.

Disable warnings, but keep errors :

If you want to keep the errors, but disable only the warnings, you can also configure pylint directly from VsCode. Go to the menu File -> Preferences -> Settings (Or open directly with Command + , or Ctrl + ,). Then in the search box at the top of the window, search for pylint Args. Click on the button Add item and add the line --disable=W.

1. Find the error-message you want to modify/disable in the Pylance's Diagnostic Severity Rules (in my case "reportMissingImports")
2. Modify settings.json with "reportMissingImports": "none" (see diagnosis reporting levels in Pylance's Settings and Customization)

The entire JSON-code to be inserted into the settings.json is:

"python.analysis.diagnosticSeverityOverrides": {
    "reportMissingImports": "none"
}

As an aside, if you want to be at least informed about unused imports, you can use:

"python.analysis.diagnosticSeverityOverrides": {
    "reportUnusedImport": "information",
    "reportMissingImports": "none"
}

PS: regarding the settings.json - location

Along with the global settings.json there are also local versions in your VS-Code-projects' parent directories. In the following, example paths are provided based on my Windows 10 - OS:

• global: C:\Users\user.name\AppData\Roaming\Code\User\settings.json
• local: .vscode/settings.json

These local project settings override the global ones, if desired.

Found a solution for reference:

In pyproject.toml, add

[tool.pyright]
typeCheckingMode = "off"

Disabling language server works as answered by maxm. This will also disable other features.

Instead, just ignore the warnings and errors of pylance by setting below in settings.json of .vscode.

"python.analysis.ignore": [
        "*"
    ]

The other features will be present with out disabling pylance.

Pylance supports PEP 484

A number of existing or potential use cases for function annotations exist, which are incompatible with type hinting. These may confuse a static type checker. However, since type hinting annotations have no runtime behavior (other than evaluation of the annotation expression and storing annotations in the _annotations_ attribute of the function object), this does not make the program incorrect -- it just may cause a type checker to emit spurious warnings or errors.

To mark portions of the program that should not be covered by type hinting, you can use one or more of the following:

a # type: ignore comment;
a @no_type_check decorator on a class or function;
a custom class or function decorator marked with @no_type_check_decorator.

Alternatively you can create a pyrightconfig.json for Pyright (as that's what Pylance is using underneath) or a pyproject.toml in project's root directory, and specify which types of errors to ignore. You can see the error type in the hover widget where error messages appear.

pyrightconfig.json example:

{
        "reportGeneralTypeIssues": false,
}

pyproject.toml example:

[tool.pyright]
reportGeneralTypeIssues = false

See Type Check Diagnostics Settings for more.

Looks like strict typing is on for linter. Try putting off for python.analysis.typeCheckingMode. You can do it in application or workspace level settings.json. or in GUI by searching the key string.

https://github.com/microsoft/pylance-release

This is currently a bug in the product, but a proposal to fix the behavior exists in the form of a GitHub discussion. You can see that discussion here: https://github.com/microsoft/pylance-release/discussions/2593

As others have said, you can provide a disable argument to disable a specific message. I wanted to elaborate on that.

1. Here is the syntax for disabling multiple messages and for providing multiple arguments, which was not immediately obvious to me from googling it:

   "python.linting.pylintArgs": [
       "--max-line-length=80",
       "--disable=W0142,W0403,W0613,W0232,R0903,R0913,C0103,R0914,C0304,F0401,W0402,E1101,W0614,C0111,C0301"
   ]
   

2. You stated that you started seeing way more errors once you disabled that one message. That actually might make sense according to the documentation:

   Python in Visual Studio code is configured by default to use a set of linting rules that are friendly to the largest number of Python developers:

   • Enable all Error (E) and Fatal (F) messages.
   • Disable all Convention (C) and Refactor (R) messages.
   • Disable all Warning (W) messages except the following:
     • unreachable (W0101): Unreachable code
     • duplicate-key (W0109): Duplicate key %r in dictionary
     • unnecessary-semicolon (W0301): Unnecessary semicolon
     • global-variable-not-assigned (W0602): Using global for %r but no assignment is done
     • unused-variable (W0612): Unused variable %r
     • binary-op-exception (W0711): Exception to catch is the result of a binary "%s" operation
     • bad-format-string (W1302): Invalid format string
     • anomalous-backslash-in-string (W1401): Anomalous backslash in string
     • bad-open-mode (W1501): "%s" is not a valid mode for open

   These rules are applied through the following default arguments passed to Pylint:

   --disable=all
   --enable=F,E,unreachable,duplicate-key,unnecessary-semicolon,global-variable-not-assigned,unused-variable,binary-op-exception,bad-format-string,anomalous-backslash-in-string,bad-open-mode
   

   These arguments are passed whenever the python.linting.pylintUseMinimalCheckers is set to true (the default). If you specify a value in pylintArgs or use a Pylint configuration file (see the next section), then pylintUseMinimalCheckers is implicitly set to false.

   In other words, PyLint is supposedly pretty lax by default in VS Code, only showing you messages for errors and a few hand-picked warnings. But when you manually set pylintArgs to something, pylintUseMinimalCheckers is ignored, opening the floodgates to all messages. That might be why disabling one message resulted in way more messages being shown. Then again, I'm not sure why you were seeing unused-import messages in the first place since it should have been suppressed by default according to the documentation.

3. Actually, this currently doesn't work: python.linting.pylintUseMinimalCheckers": true (for me, at this particular moment in time, but hopefully it works fine for you, future reader). To get the same effect, I had to manually set pylintArgs to the value it was supposed to be setting automatically:

   "python.linting.pylintArgs": [
       "--disable=all",
       "--enable=F,E,unreachable,duplicate-key,unnecessary-semicolon,global-variable-not-assigned,unused-variable,binary-op-exception,bad-format-string,anomalous-backslash-in-string,bad-open-mode"
   ]
   

4. BONUS: Here's an explanation of the list of disabled messages I use, as shown above in point 1. It's mostly taken from here:

   # Disabled messages
   #    Pointless
   #       W0142 = *args and **kwargs support
   #       W0403 = Relative imports
   #       W0613 = Unused argument
   #       W0232 = Class has no __init__ method
   #       R0903 = Too few public methods
   #       R0913 = Too many arguments
   #       C0103 = Invalid name
   #       R0914 = Too many local variables
   #       C0304 = Final newline missing
   #
   #    PyLint's module importation is unreliable
   #       F0401 = Unable to import module
   #       W0402 = Uses of a deprecated module
   #       E1101 = Module x has no y member
   #
   #    Already an error when wildcard imports are used
   #       W0614 = Unused import from wildcard
   #
   #    Stricter messages that can be disabled until everything else has been fixed
   #       C0111 = Missing docstring
   #       C0301 = Line too long