That is a Pylance error.

You can create a pyrightconfig.json file at the root of your workspace and define the files to be exclude-d from analysis or completely ignore-d:

{
    "ignore": [
        "**/*.ipynb",
    ],
}

You can even list up specific filenames:

{
    "ignore": [
        "notimportant.ipynb",
        "test.ipynb",
    ],
}

Historical Notes:

It initially didn't work for Jupyter Notebooks (.ipynb):
https://github.com/microsoft/pylance-release/issues/2135

This happens because pyright doesn't see the file as a "*.ipynb". The file is being preprocessed (to combine all of the cells) in the notebook by the VS Code Python extension, and the resulting combined file is then passed to pyright for analysis.

The pylance team is actively working on changing the way this works. I'm going to transfer this bug to the pylance-release repo so it gets the attention it deserves.

That Github issue has since been resolved the fix was deployed as part of pylance 2022.8.51: https://github.com/microsoft/pylance-release/blob/main/CHANGELOG.md#2022851-31-august-2022-prerelease

Notable changes:

• ...
• Bug Fix: Ignoring *.ipynb files does not work (pylance-release#2135)

If it somehow still does not work, check the version of pylance on your VS Code.

Pylance's static type checker sees arg.lower() where arg is typed as Union[str, list[str]]. Since list[str] doesn't have a .lower() method, Pylance flags this as an attribute access error, even though you're handling it with try-except.

However, even if your runtime logic is correct Pylance's static type checker sees arg.lower() where arg is typed as Union[str, list[str]]. Since list[str] doesn't have a .lower() method, Pylance flags this as an attribute access error, even though you're handling it with try-except.
Simply add # type: ignore[attr-defined] to the line like this

return arg.lower()  # type: ignore[attr-defined]

That's it! This tells Pylance "I know this attribute might not exist for all possible types, but I'm handling it properly, so ignore this specific type warning." For your static type checking this will solve your problem.

By default, pyright (the type checker upon which pylance is built) does not report the use of Unknown types. It does this only if you've enabled "strict mode". These strict-mode checks are designed for people who want to know about any potential "holes" in their type checking. If you're importing types from libraries that have incomplete types, you will naturally have holes in your type checking, so using these strict mode checks doesn't make sense in this case. Your options are: 1) disable the reportUnknown... family of diagnostic checks (you can manually enable other strict-mode checks if you'd like), or 2) augment the type information for the libraries you're consuming via type stubs so the type information is complete.

You can add the following settings in settings.json configuration file:

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

Or you can search for python.analysis.diagnosticSeverityOverrides in the settings, click Add Item button to select "reportUndefinedVariable", "none":

Result:

There are many ways of forcing a type-checker to accept this.

1. Use assert:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       assert var is not None
       var.foo()
   

   
   

2. Raise some other exception:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       if var is None:
           raise RuntimeError("NO")
       var.foo()
   

   
   

3. Use an if statement:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       if var is not None:
           var.foo()
   

   
   

4. Use typing.cast, a function that does nothing at runtime but forces a type-checker to accept that a variable is of a certain type:

   from typing import Union, cast
   
   def do_something(var: Union[T, None]):
       var = cast(T, var)
       var.foo()
   

   
   

5. Switch off the type-checker for that line:

   from typing import Union
   
   def do_something(var: Union[T, None]):
       var.foo()  # type: ignore
   

   
   

Note also that, while it makes no difference to how your type annotation is interpreted by a type-checker (the two are semantically identical), you can also write typing.Union[T, None] as typing.Optional[T], which is arguably slightly nicer syntax. In Python >=3.10 (or earlier if you have from __future__ import annotations at the top of your code), you can even write Union types with the | operator, i.e. T | None.

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.

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.