5 Easy Ways To Check If Module Exists In Python Environment

Check If Module Exists By Importing The Module

Well, the straightforward answer is importing the specific module. If the module does not exist in the python environment, an exception may be raised (ModuleNotFoundError or ImportError based on your python version), and the script terminates.

import blabla                         # ==> A1
print("The blabla module exists !!!") # ==> A2

If the blabla module does not exist, an exception will be raised. Since the exception is not handled, the python interrupter prints the exception’s traceback and terminates the script at A1.

$ python main.py
Traceback (most recent call last):                                                                                                                                                                                 File "/projects/s1/main.py", line 1, in <module>
  import blabla
    ModuleNotFoundError: No module named 'blabla' 

If the blabla module exist, the python interrupter will execute the print statement at A2

$ python main.py
The blabla module exists !!!

Check If Module Exists By Enclosing Import In Try-Except

The user can not run the script with the system’s standard python environment anymore. However, The ModuleNotFoundError or ImportError message and the displayed traceback might not be obvious to your users. They may find that the issue is a bug in your script. Therefore, You should provide a proper error message explaining the problem; that is, explain to the user that he can run this python script only in your custom environment as it requires specific modules.

To do this, Let’s enclose the import statement in a try-except construct and handle the ModuleNotFoundError or ImportError that will be raised when the module does not exist in the python environment.

import sys
try:
    import blabla
except ImportError or ModuleNotFoundError:
    # The blabla module does not exist, display proper error message and exit
    print('This script can only be run in blabla environment', file=sys.stderr)
    sys.exit(1)

Now, if the blabla module does not exist, a clear message error will be displayed, and the script will terminate.

$ python main.py
This script can only be run in blabla environment

Check If Module Exists With Function

While the above solution works, It may become tedious, especially if there are many such scripts or you need to check the availability of many modules. Of course, you can repeat the try/except for each module. You can add the check_enviroment function that tries to import all the specific modules:

Now, you can safely import the modules. If the user runs the script outside the custom environment, he will see a clear message that he can is not in the right environment.

def ensure_enviroment():
    try:
        import sys
        import math        
        import blabla1
        import blabla2
    except ModuleNotFoundError or ImportError as ee:
        print('This script can only be run in blabla environment : {0}'.format(ee.msg), file=sys.stderr)
        exit(1)

ensure_enviroment()

import sys
import math        
import blabla1
import blabla2

The first problem with this approach is the need to duplicate all the import statements inside the ensure_enviromnet function and write them in the main script after calling it. It can be tedious and error-prone. However, we must do it since imported modules in the ensure_enviromnet function are not available in the main script.

The second problem is apparent when you have several scripts you want to ensure your custom environment is active. In this case, you must duplicate this function in each script. Furthermore, some python linters may complain that we call a function before the import statements.

Check If Module Exists With Module

Let’s fix the second problem by writing the function in a separate module and importing this module before the import statements.

import ensure_environment

import math        
import blabla1
import blabla2

import sys

def ensure_environment():
    try:
        import math        
        import blabla1
        import blabla2
    except ModuleNotFoundError or ImportError as ee:
        print('This script can only be run in blabla environment : {0}'.format(ee.msg), file=sys.stderr)
        exit(1)

ensure_environment()

We successfully fix the second problem,

However the first problem was not resolved. In the above solution, we duplicated all the import statements inside the ensure_enviromnet function of the ensure_enviromnet module and wrote them in the main script after importing it. As said, It can be tedious and error-prone. However, we must do it since the imported modules in the ensure_enviromnet are not available in the main script. Let’s Fix it.

Check If Module Exists With Exception Hook

The sys module provides a hook called sys.exceptionhook. Python interrupter calls this hook when an exception is raised. We can replace this hook with our customized function:

In this function, We will check if the exceptionType is ModuleNotFoundError or ImportError. If it is, we print a clear message to the user and terminates the script; otherwise, for other exceptions, we call the original hook.

import ensure_environment

import math        
import blabla1
import blabla2

import sys

old_excepthook =  sys.excepthook
def ensure_enviroment_excepthook(exceptionType, exception, traceback):    
    if exceptionType == ModuleNotFoundError or exceptionType == ImportError:
        print('This script can only be run in blabla environment : {0}'.format(exception.msg), file=sys.stderr)
        exit(1)
    return old_excepthook(exceptionType , exception ,traceback)

sys.excepthook = ensure_enviroment_excepthook