DEV Community

Srinivas for ItsMyCode

Posted on • Originally published at itsmycode.com on

ImportError: attempted relative import with no known parent package

ItsMyCode |

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

Other ways of importing modules in Python

# importing modules a.py
import secondpackage.subpackage.d
import secondpackage.c
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

How to fix ImportError: attempted relative import with no known parent package?

Option 1 – Use absolute imports

For instance, the directory structure may be as follows

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

Enter fullscreen mode Exit fullscreen mode

where setup.py is

from setuptools import setup, find_packages
setup(
    name = 'your_package_name',
    packages = find_packages(),
)
Enter fullscreen mode Exit fullscreen mode

Option 2 – Get rid of from keyword

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

import secondpackage.c
Enter fullscreen mode Exit fullscreen mode

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__ )))

Enter fullscreen mode Exit fullscreen mode

Assuming your package is like this:

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

Enter fullscreen mode Exit fullscreen mode

Now use regular imports in you package, like:

# in module2.py
from module1 import class1
Enter fullscreen mode Exit fullscreen mode

The post ImportError: attempted relative import with no known parent package appeared first on ItsMyCode.

Discussion (0)