Ошибка attempted relative import with no known parent package

Module imports sometimes can cause too much frustration if you are a Python beginner. This tutorial will learn how imports work and the solution for ImportError: attempted relative import with no known parent package.

Before getting into the solution, let’s first understand few basic terminologies in Python.

Python Module: A module is a file in Python containing definitions and statements. A module can contain executable statements as well as function definitions. In simple terms, think as a single .py file with some functionality.

Python Package: A Python package consists of one or more modules, and it contains one file named __init__.py that tells Python that this directory is a package. The init file may be empty, or it may include code to be executed upon package initialization.

imports: Imports in Python are essential for structuring your code effectively, and by using the import keyword, you can import any module and reuse it effectively. There are two types of import, Relative and Absolute, which will look in-depth.

Let’s consider a simple example. 

└── myproject
    ├── firstpackage
    │   ├── a.py
    └── secondpackage
        ├── b.py
        ├── c.py
        └── subpackage
            └── d.py

The above project has two packages named firstpackage and secondpackage. Each of these contains some modules, and the secondpackage also has a subpackage that includes its own module. Typically the project structure goes something like this, and it may grow pretty complex.

How does module import work in Python?

Now, let’s say if you import module b in one of your files using the import statement as shown below.

import b

Python will perform the following operations to import the module:

• Locate, load, and initialize (if required) the requested module
• Define necessary names in the local namespace and corresponding scope

Now Python interpreter is going to follow the following steps in an attempt to resolve module b .

Step 1: sys.modules lookup

Python will try to look at the module first in the sys.modules, which is a dictionary that has a mapping of key-value pairs of modules. If it finds, then the module is resolved and loaded.

Step 2: Python Standard Library lookup

Python Standard Library contains built-in modules (written in C) that provide access to system functionality such as file I/O that would otherwise be inaccessible to Python programmers. Modules are written in Python that provides standardized solutions for many problems that occur in everyday programming. Some of these modules are explicitly designed to encourage and enhance the portability of Python programs by abstracting away platform-specifics into platform-neutral APIs.

If the name is not found in the sys.modules, it will search in the standard library. If it cannot find over there, then it goes to the next step.

Step 3: sys.path lookup

Python will look into the sys.path as the last step to resolve the module. This is where things can go wrong, and you will get ModuleNotFoundError: No module named ‘b’

Absolute vs. Relative imports

In absolute imports, you need to specify the explicit path from the project’s root directory.

Example – If we have to import module b then we can use the following way to import

import secondpackage.b

Other ways of importing modules in Python

# importing modules a.py
import secondpackage.subpackage.d
import secondpackage.c

In case of relative imports, we need to specify the module’s path relative to the current module’s location.

Example –

# in module a.py
from ..secondpackage import b
from ..secondpackage.b import another_function

# in module b
from . import c
from .c import my_function

Option 1 – Use absolute imports

For instance, the directory structure may be as follows

.
├── project
│   ├── package
│   │   ├── __init__.py
│   │   ├── module.py
│   │   └── standalone.py
│   └── setup.py

where setup.py is

from setuptools import setup, find_packages
setup(
    name = 'your_package_name',
    packages = find_packages(),
)

Option 2 – Get rid of from keyword

Remove the from keyword and use the standard way of import as shown below.

import secondpackage.c

Option 3 – Import inside package init file

Put this inside your package’s __init__.py file:

# For relative imports to work in Python 3.6
import os, sys; sys.path.append(os.path.dirname(os.path.realpath(__file__)))

Assuming your package is like this:

├── project
│   ├── package
│   │   ├── __init__.py
│   │   ├── module1.py
│   │   └── module2.py
│   └── setup.py

Now use regular imports in you package, like:

# in module2.py
from module1 import class1

This article will discuss the error – ImportError: Attempted Relative Import With No Known Parent Package. The primary reason for this error is that the specified module does not exist within the Python library.

In Python, the failure to import a module, module member, or other python files results in ImportError.

What Causes This Error?

Let’s take the following file structure as an example to better understand the reasons for this error.

->ProjectDirectory
|
|
|
---->myPackage1
      - __init__.py
      - runCode.py
|
|
|
---->myPackage2
      - __init__.py
      - function.py

ProjectDirectory Consists of 2 folders : myPackage1(runCode.py) and myPackage2(function.py).

runCode.py

from .myPackage2 import runFunction
print("Running Code")
function.runFunction()

function.py

def runFunction():
     print("Running Function")

Note that the runCode.py program makes use of the function from function.py by importing.

Now, let’s discuss what’s relative importing.

In runCode.py, note that a dot(.) is used in the import statement. This usage of the dot indicates a relative import. As we call a function from a different package(directory), the caller program (runCode.py) has to call one level above. Multiple directory levels require multiple dots. This is the concept of relative importing. Its counter-technique. Absolute importing requires the complete path.

Let’s look at the actual error produced by runCode.py

C:UsersSampleFolderPythonProgramsProjectDirectorymyPackage > python runCode.py
Traceback (most recent call last):
     File "C:UsersSampleFolderPythonProgramsProjectDirectorymyPackagerunCode.py", line 1m in <module>
     from myPackage2 import runFunction
ImportError: attempted relative import with no parent package

This is due to the fact that a parent package doesn’t exist.

How To Solve This Error?

The most straightforward approach is to make the particular package global using a setup.py file. Let’s look at the following steps to achieve the same.

Creating a Setup File

Create a Setup file using the setuptools module from Python. The setup file defines the package to be made global.

from setuptools import setup, find_packages

setup(name = "myPackage2", packages = find_packages())

The above lines import the module from myPackage2.

Running the Setup File

Access your project directory and run the following command in your command terminal.

python setup.py install

Changing the Caller Program (runCode.py)

Remove the dot from the import statement now that the package is global.

from myPackage2 import function

print("Running Code")
function.runFunction()

Output

C:UsersSampleFolderPythonProgramsProjectDirectorymyPackage > python runCode.py
Running Code
Running Function

Let’s look at the following program that deals with unit testing.

import unittest
from ..programUtil import util

class TestUrlUtilities(unittest.SampleTestCase):
    def test_simple(self):
        result = name_from_link("https://pythonpool.com")
        self.assertEqual(result, "Python")

if __name__ == "__main__":
    unittest.main()

Output

ERROR: program_utilities(unittest.loader._FailedTest)
ImportError: Failed to import test module: program_utilities
Traceback (most recent call last):
     File "C:Python37libunittestloader.py", line 13, in loadTestsFromName
         module = __import__(module_name)

ImportError: attempted relative import with no known parent package

What do we do in this situation? As the error says, the test folder doesn’t contain a parent package. This means using double dots (..) to import relatively will not work.

Go to the project source directory and run the following command:

python -m unittest

This creates a src folder for our project path. Now that our module is in the path, there is no need for a relative import (..).

ImportError: Attempted Relative Import With No Known Parent Package Django

When you import a function into your Django project, you may receive the ImportError. This is due to the fact that you cannot import relatively from a direct run script. Relative imports work only if the package has been imported completely as a module.

For example, if a code is passed through /user/stdin, there isn’t a reference for the file’s location.

Use relative imports when running .py programs. If a relative import is a must, convert the program file as a __main__.py file within the package directory while passing the Python -m command to run the module.

ImportError: Attempted Relative Import With No Known Parent Package IntelliJ (PyCharm IDE)

In this scenario, the program files may run without error. However, the unit test can fail and produce relative import errors when run from the program file’s directory.

To solve this problem, set the working directory as the top-level project directory. After this, any unit tests or relative imports will run properly. In summary, resetting the working directory should fix the relative import errors.

Attempted Relative Import Beyond Top Level Package Error

Let’s take the following file structure as an example

myModule/
   __init__.py
   P/
      __init__.py
      program.py
   testProgram_P/
      __init__.py
      testCode.py

testCode.py

from ..P import program

To run tests, you may pass the following command within the myModule directory

python -m testProgram_P.testCode

This can result in the following error:

"ValueError: attempted relative import beyond top-level package"

However, within the parent folder of myModule, testProgram_P.testCode will run perfectly.

Why does this error occur?

This is due to the fact that Python doesn’t keep track of the package location. Therefore, upon running python -m testProgram_P.testCodePython doesn’t take into account that the file is located in myModule. This means writing from ..P import program is basically trying to fetch information that does not exist anymore.

FAQs

Conclusion

In this article, we have looked at the exception: ImportError: Attempted Relative Import With No Known Parent Package. This error shows us how much the structure of a working directory matters in Python. We have learned that Python does not consider the current working directory to be a package itself, therefore hindering relative imports.

This article will discuss the error – ImportError: Attempted Relative Import With No Known Parent Package. The primary reason for this error is that the specified module does not exist within the Python library.

In Python, the failure to import a module, module member, or other python files results in ImportError.

What Causes This Error?

Let’s take the following file structure as an example to better understand the reasons for this error.

->ProjectDirectory
|
|
|
---->myPackage1
      - __init__.py
      - runCode.py
|
|
|
---->myPackage2
      - __init__.py
      - function.py

ProjectDirectory Consists of 2 folders : myPackage1(runCode.py) and myPackage2(function.py).

runCode.py

from .myPackage2 import runFunction
print("Running Code")
function.runFunction()

function.py

def runFunction():
     print("Running Function")

Note that the runCode.py program makes use of the function from function.py by importing.

Now, let’s discuss what’s relative importing.

In runCode.py, note that a dot(.) is used in the import statement. This usage of the dot indicates a relative import. As we call a function from a different package(directory), the caller program (runCode.py) has to call one level above. Multiple directory levels require multiple dots. This is the concept of relative importing. Its counter-technique. Absolute importing requires the complete path.

Let’s look at the actual error produced by runCode.py

C:UsersSampleFolderPythonProgramsProjectDirectorymyPackage > python runCode.py
Traceback (most recent call last):
     File "C:UsersSampleFolderPythonProgramsProjectDirectorymyPackagerunCode.py", line 1m in <module>
     from myPackage2 import runFunction
ImportError: attempted relative import with no parent package

This is due to the fact that a parent package doesn’t exist.

How To Solve This Error?

The most straightforward approach is to make the particular package global using a setup.py file. Let’s look at the following steps to achieve the same.

Creating a Setup File

Create a Setup file using the setuptools module from Python. The setup file defines the package to be made global.

from setuptools import setup, find_packages

setup(name = "myPackage2", packages = find_packages())

The above lines import the module from myPackage2.

Running the Setup File

Access your project directory and run the following command in your command terminal.

python setup.py install

Changing the Caller Program (runCode.py)

Remove the dot from the import statement now that the package is global.

from myPackage2 import function

print("Running Code")
function.runFunction()

Output

C:UsersSampleFolderPythonProgramsProjectDirectorymyPackage > python runCode.py
Running Code
Running Function

Let’s look at the following program that deals with unit testing.

import unittest
from ..programUtil import util

class TestUrlUtilities(unittest.SampleTestCase):
    def test_simple(self):
        result = name_from_link("https://pythonpool.com")
        self.assertEqual(result, "Python")

if __name__ == "__main__":
    unittest.main()

Output

ERROR: program_utilities(unittest.loader._FailedTest)
ImportError: Failed to import test module: program_utilities
Traceback (most recent call last):
     File "C:Python37libunittestloader.py", line 13, in loadTestsFromName
         module = __import__(module_name)

ImportError: attempted relative import with no known parent package

What do we do in this situation? As the error says, the test folder doesn’t contain a parent package. This means using double dots (..) to import relatively will not work.

Go to the project source directory and run the following command:

python -m unittest

This creates a src folder for our project path. Now that our module is in the path, there is no need for a relative import (..).

ImportError: Attempted Relative Import With No Known Parent Package Django

When you import a function into your Django project, you may receive the ImportError. This is due to the fact that you cannot import relatively from a direct run script. Relative imports work only if the package has been imported completely as a module.

For example, if a code is passed through /user/stdin, there isn’t a reference for the file’s location.

Use relative imports when running .py programs. If a relative import is a must, convert the program file as a __main__.py file within the package directory while passing the Python -m command to run the module.

ImportError: Attempted Relative Import With No Known Parent Package IntelliJ (PyCharm IDE)

In this scenario, the program files may run without error. However, the unit test can fail and produce relative import errors when run from the program file’s directory.

To solve this problem, set the working directory as the top-level project directory. After this, any unit tests or relative imports will run properly. In summary, resetting the working directory should fix the relative import errors.

Attempted Relative Import Beyond Top Level Package Error

Let’s take the following file structure as an example

myModule/
   __init__.py
   P/
      __init__.py
      program.py
   testProgram_P/
      __init__.py
      testCode.py

testCode.py

from ..P import program

To run tests, you may pass the following command within the myModule directory

python -m testProgram_P.testCode

This can result in the following error:

"ValueError: attempted relative import beyond top-level package"

However, within the parent folder of myModule, testProgram_P.testCode will run perfectly.

Why does this error occur?

This is due to the fact that Python doesn’t keep track of the package location. Therefore, upon running python -m testProgram_P.testCodePython doesn’t take into account that the file is located in myModule. This means writing from ..P import program is basically trying to fetch information that does not exist anymore.

FAQs

Conclusion

In this article, we have looked at the exception: ImportError: Attempted Relative Import With No Known Parent Package. This error shows us how much the structure of a working directory matters in Python. We have learned that Python does not consider the current working directory to be a package itself, therefore hindering relative imports.