You can do this how Django does it: define a variable to the Project Root from a file that is in the top-level of the project. For example, if this is what your project structure looks like:

project/

    configuration.conf

    definitions.py

    main.py

    utils.py

In definitions.py you can define (this requires import os):

ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) # This is your Project Root

Thus, with the Project Root known, you can create a variable that points to the location of the configuration (this can be defined anywhere, but a logical place would be to put it in a location where constants are defined - e.g. definitions.py):

CONFIG_PATH = os.path.join(ROOT_DIR, 'configuration.conf')  # requires `import os`

Then, you can easily access the constant (in any of the other files) with the import statement (e.g. in utils.py): from definitions import CONFIG_PATH.

To get the path of the "root" module, you can use:

import os

import sys

os.path.dirname(sys.modules['__main__'].__file__)

But more interestingly if you have an config "object" in your top-most module you could -read- from it like so:

app = sys.modules['__main__']

stuff = app.config.somefunc()

Other answers advice to use file in top-level of the project. This is not necessary if you use pathlib.Path and parent. Consider the following directory structure where all files except README.md and utils.py have been omitted.

project

│   README.md

|

└───src

│   │   utils.py

|   |   ...

|   ...

In utils.py we define the following function.

from pathlib import Path



def get_project_root() -> Path:

    """Returns project root folder."""

    return Path(__file__).parent.parent

In any module in the project we can now get the project root as follows.

from src.utils import get_project_root



root = get_project_root()

Benefits: Any module which calls get_project_root can be moved without changing program behavior. Only when the module utils.py is moved we have to update get_project_root and the imports (use IDE refactoring to automate this).

A standard way to achieve this would be to use the pkg_resources module which is part of the setuptools package. setuptools is used to create an install-able python package.

You can use pkg_resources to return the contents of your desired file as a string and you can use pkg_resources to get the actual path of the desired file on your system.

Let's say that you have a package called stackoverflow.

stackoverflow/

|-- app

|   `-- __init__.py

`-- resources

    |-- bands

    |   |-- Dream Theater

    |   |-- __init__.py

    |   |-- King's X

    |   |-- Megadeth

    |   `-- Rush

    `-- __init__.py



3 directories, 7 files

Now let's say that you want to access the file Rush from a module app.run. Use pkg_resources.resouces_filename to get the path to Rush and pkg_resources.resource_string to get the contents of Rush; thusly:

import pkg_resources



if __name__ == "__main__":

    print pkg_resources.resource_filename('resources.bands', 'Rush')

    print pkg_resources.resource_string('resources.bands', 'Rush')

The output:

/home/sri/workspace/stackoverflow/resources/bands/Rush

Base: Geddy Lee

Vocals: Geddy Lee

Guitar: Alex Lifeson

Drums: Neil Peart

This works for all packages in your python path. So if you want to know where lxml.etree exists on your system:

import pkg_resources



if __name__ == "__main__":

    print pkg_resources.resource_filename('lxml', 'etree')

output:

/usr/lib64/python2.7/site-packages/lxml/etree

The point is that you can use this standard method to access files that are installed on your system (e.g pip install xxx or yum -y install python-xxx) and files that are within the module that you're currently working on.

All the previous solutions seem to be overly complicated for what I think you need, and often didn't work for me. The following one-line command does what you want:

import os

ROOT_DIR = os.path.abspath(os.curdir)

This worked for me using a standard PyCharm project with my virtual environment (venv) under the project root directory.

Code below isnt the prettiest, but consistently gets the project root. It returns the full directory path to venv from the VIRTUAL_ENV environment variable e.g. /Users/NAME/documents/PROJECT/venv

It then splits the path at the last /, giving an array with two elements. The first element will be the project path e.g. /Users/NAME/documents/PROJECT

import os



print(os.path.split(os.environ['VIRTUAL_ENV'])[0])

I've recently been trying to do something similar and I have found these answers inadequate for my use cases (a distributed library that needs to detect project root). Mainly I've been battling different environments and platforms, and still haven't found something perfectly universal.

Code local to project

I've seen this example mentioned and used in a few places, Django, etc.

import os

print(os.path.dirname(os.path.abspath(__file__)))

Simple as this is, it only works when the file that the snippet is in is actually part of the project. We do not retrieve the project directory, but instead the snippet's directory

Similarly, the sys.modules approach breaks down when called from outside the entrypoint of the application, specifically I've observed a child thread cannot determine this without relation back to the 'main' module. I've explicitly put the import inside a function to demonstrate an import from a child thread, moving it to top level of app.py would fix it.

app/

|-- config

|   `-- __init__.py

|   `-- settings.py

`-- app.py

app.py

#!/usr/bin/env python

import threading





def background_setup():

    # Explicitly importing this from the context of the child thread

    from config import settings

    print(settings.ROOT_DIR)





# Spawn a thread to background preparation tasks

t = threading.Thread(target=background_setup)

t.start()



# Do other things during initialization



t.join()



# Ready to take traffic

settings.py

import os

import sys





ROOT_DIR = None





def setup():

    global ROOT_DIR

    ROOT_DIR = os.path.dirname(sys.modules['__main__'].__file__)

    # Do something slow

Running this program produces an attribute error:

>>> import main

>>> Exception in thread Thread-1:

Traceback (most recent call last):

  File "C:Python2714libthreading.py", line 801, in __bootstrap_inner

    self.run()

  File "C:Python2714libthreading.py", line 754, in run

    self.__target(*self.__args, **self.__kwargs)

  File "main.py", line 6, in background_setup

    from config import settings

  File "configsettings.py", line 34, in <module>

    ROOT_DIR = get_root()

  File "configsettings.py", line 31, in get_root

    return os.path.dirname(sys.modules['__main__'].__file__)

AttributeError: 'module' object has no attribute '__file__'

...hence a threading-based solution

Location independent

Using the same application structure as before but modifying settings.py

import os

import sys

import inspect

import platform

import threading





ROOT_DIR = None





def setup():

    main_id = None

    for t in threading.enumerate():

        if t.name == 'MainThread':

            main_id = t.ident

            break



    if not main_id:

        raise RuntimeError("Main thread exited before execution")



    current_main_frame = sys._current_frames()[main_id]

    base_frame = inspect.getouterframes(current_main_frame)[-1]



    if platform.system() == 'Windows':

        filename = base_frame.filename

    else:

        filename = base_frame[0].f_code.co_filename



    global ROOT_DIR

    ROOT_DIR = os.path.dirname(os.path.abspath(filename))

Breaking this down:
First we want to accurately find the thread ID of the main thread. In Python3.4+ the threading library has threading.main_thread() however, everybody doesn't use 3.4+ so we search through all threads looking for the main thread save it's ID. If the main thread has already exited, it won't be listed in the threading.enumerate(). We raise a RuntimeError() in this case until I find a better solution.

main_id = None

for t in threading.enumerate():

    if t.name == 'MainThread':

        main_id = t.ident

        break



if not main_id:

    raise RuntimeError("Main thread exited before execution")

Next we find the very first stack frame of the main thread. Using the cPython specific function sys._current_frames() we get a dictionary of every thread's current stack frame. Then utilizing inspect.getouterframes() we can retrieve the entire stack for the main thread and the very first frame.
current_main_frame = sys._current_frames()[main_id]
base_frame = inspect.getouterframes(current_main_frame)[-1]
Finally, the differences between Windows and Linux implementations of inspect.getouterframes() need to be handled. Using the cleaned up filename, os.path.abspath() and os.path.dirname() clean things up.

if platform.system() == 'Windows':

    filename = base_frame.filename

else:

    filename = base_frame[0].f_code.co_filename



global ROOT_DIR

ROOT_DIR = os.path.dirname(os.path.abspath(filename))

So far I've tested this on Python2.7 and 3.6 on Windows as well as Python3.4 on WSL

Try:

ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))