How to Create a Managing Multiple Sessions in Python for a Chatbot

As I delved into the world of chatbot development, I encountered a challenge that required me to manage multiple sessions in Python. In this article, I’ll share my experience and the solutions I explored to overcome this hurdle.

Relative Imports and Multiple Applications

Our initial application was a simple FastAPI project with relative imports. However, as we expanded our project, we needed to create another application that built upon the existing one. This led to a more complex directory structure:

project/
  setup.py
  __init__.py
  core/               # The original application
    __init__.py
    src/
      __init__.py
      api/
        __init__.py
        api.py
        routes/
          __init__.py
          router1.py
  core_plus/          # The extending application
    __init__.py
    src/
      api/
        main.py
        api.py

Importing Modules Across Applications

While I could install the core application into core_plus using pip install -e .., importing modules from core into core_plus proved problematic. Specifically, internal imports within core failed to resolve:

# project/core_plus/src/api/api.py
from core.src.api.api import routers

# project/core/src/api/api.py
import routes.router1 as router1

routers = [router1]

Exploring Solutions

I sought a solution that wouldn’t require editing all imports in core and avoided “hackish” approaches like modifying sys.path. Here are the solutions I considered:

Relative Imports

One approach was to use relative imports in core_plus to access modules in core. However, this would require modifying all imports in core, which wasn’t desirable.

Absolute Imports

Another option was to use absolute imports in core_plus by adding the core package to sys.path. However, this could lead to ambiguity if both core and core_plus had files or directories with the same names.

Importlib

I explored using the importlib module to dynamically import modules from core into core_plus. While this approach showed promise, it added complexity to the code and wasn’t the most elegant solution.

Using python -m and __package__

After experimenting with various approaches, I discovered a solution that worked elegantly. By using the python -m command to run the core_plus application and setting the __package__ attribute in the core_plus modules, I could import modules from core without modifying sys.path or using relative imports.

Here’s an example of how I structured my code:

# project/core_plus/src/api/main.py
if __name__ == "__main__":
    import sys
    sys.path.insert(0, '../..')  # Add project root to sys.path
    from core.src.api import api
    # ...

# project/core_plus/src/api/api.py
__package__ = 'core_plus.src.api'
from core.src.api.api import routers
# ...

By using python -m core_plus.src.api.main to run the application, I could ensure that the __package__ attribute was set correctly, allowing me to import modules from core without issues.

Final Thoughts

Managing multiple sessions in Python for a chatbot can be challenging, especially when working with complex directory structures and multiple applications. By exploring different solutions and using a combination of python -m and __package__, I was able to find an elegant solution that worked for my project. I hope that sharing my experience will help others facing similar challenges.