Is it possible to hide certain objects from displaying as autocompletion suggestions, preferably only when accessed from another file?

[ItsCubeTime]

Say I have a module foo where its __init__.py contains the following code:

import math

def printPower(val):
    print(math.pow(val))

When writing in this file, I want to get code suggestions for the math module, but when later on importing this module in a separate file main.py of which may look like:

import foo

foo.printPower(3)

I probably dont want to see anything of the math module when typing foo. . How would one solve this?

---

One option would be to change the contents of foo to something like:

import math as _math

def printPower(val):
    print(_math.pow(val))

or

class util():
    import math

def printPower(val):
    print(util.math.pow(val))

or create a separate file foo.py inside the foo folder that contains all the declarations & logic and simply import things as I like into foo/__init__.py (which is probably the most popular solution).
All of which methods would work just fine for organizational purposes even though the first 2 candidates really only obscures the objects without really preventing them from showing at all.

But say if I then have a 3rd file bar.py with some additional code:

import math
def printModulo(op1, op2):
    print(str(math.modf(op1,op2))

and I want to migrate that into the foo module it wont just be as simple as copy-pasting it over from one file to another. All out of a sudden I will have to modify this code to adhere to the candidating practices described above - which will be additional manual work.

So to recap: I dont want intellisense autocompletion to pickup on certain unwanted objects (though, its fine if say foo.math still runs despite that it may be a little strange), preferably only when accessed through an external file (so that I can still see the contents of math when writing inside of the init file of foo in my example). Do you guys know of any techniques that I could use to allow myself to use external libraries and/or declare functions directly inside of module __init__.py files whilst being able to in some way hide them from intellisense autocompletion when the file is accessed by another file without just renaming them or putting these "util" functions in a separate unexposed file?

Ive already discovered that intellisense typically wont pick up on imports done via importlib - which could act as a partial solution, but then I still wont see any autocompletion when working within the module, which is undesired.

Is there perhaps some global variables declared by cpython or pylance that I can make use of to make certain objects not declare in certain autocompletion scenarios? like the following psuedo code:

# Only import math if were invoked by pylance AND were not accessing the file as a module or if were not being invoked
# by pylance at all
if (TYPE_CHECKING and (not IS_FILE_IMPORTED_AS_MODULE) ) or not TYPE_CHECKING:
    import math

Thanks for reading 💝

[parched]

Related: #1875