import – complex or complicated?

In Python, life is really easy when all your .py files are in one directory. The moment you want to organize your code into folders there’s a wall of challenges you have to climb. I believe this is an issue that can be alleviated with one small fix.

Here’s a comparison of how a developer shares code across a project in C/C++ and Python:

	C/C++	Python
Forms	#include <from_env_dirs_first> #include “from_local_dir_first” #include “abs_or_rel_file_system_path”	import module import module as alias from module import var from module import * from ..package_relative_path import module from package.absolute_path import module try:     import one_thing except ImportError:     import another as one_thing
Namespacing	Public toilet – everything included is global.	“Namespaces are one honking great idea — let’s do more of those!” Seriously, module encapsulation is fantastic.
Helpful extra knowledge	Makefiles/vcproj configurations of paths #ifdef	sys.path __all__ __path__
Mandatory extra knowledge (“Gotchas”)	#pragma once (or the equivalent #ifdef) certain things aren’t allowed in .h files please don’t use absolute paths	__init__.py syntax for intra-package imports modules intended for use as the main module of a Python application must always use absolute imports.

Now this isn’t an exhaustive list as I want to discuss just a small subset from the above table. Also note that I didn’t go into “ctypes”, “#pragma comment(lib…)”, etc. as we’re talking about sharing code, not binaries.

For the 6 years of keyboard tapping I’ve done in C and Python, I never once was confused as to how to access code between directories in C; Python on the other hand has gotten me quite a few times and I always need to rertfm. And I consider myself far more interested and fluent in Python than in C/C++. This may be just a problem with my head, but I’d like to vent either way.

Blah, blah, what’s the problem?

Skip this section if you’ve already had experience with said problem, I’m sure it’s as painful to read as it was to write.

Python has this really elegant solution for one-folder-mode, “import x” just gives you what you expected, either from the standard library (sys.path, etc) or your local directory. If you have “os.py” in that local directory then you shadow out the standard “import os”. Once you mix directories in there, python is suddenly afraid of shadowing and you can’t import things from a folder named “os” unless it has an “__init__.py”. So shadowing here is allowed and there not. If you want to access modules from the outside (dot dot and beyond), then you have to be in a package, use sys.path, os.chdir or maybe implement file-system-imports on your own.

Personally, I find myself doing this design pattern a lot:

1. The App directory
1. main_app_entry.py
2. framework
1. general_useful_things.py
2. more_frameworkey_goodness.py
3. components
1. this_solves_a_problem.py
2. another_tool.py

I usually have an “if __name__ == ‘__main__’:” in my modules and there I have some sort of test, utility function, or a train of code-thought not yet organized.

How can another_tool.py access general_useful_things.py? First things first – __init__.py everywhere! After trying a few ways to do the import – here are a few results.

So what’s needed for another_tool to import general_useful_things:

• “from framework import general_useful_things” works in another_tool.py if we only use main_app_entry.py, it does not work if we run another_tool.py directly. Does this mean __name__ == “__main__” is a useless feature I should ignore?
• Here’s the rest of the list of failed attempts:

  #from app.framework import general_useful_things
  #from .app.framework import general_useful_things
  #from ..framework import general_useful_things
  #from .framework import general_useful_things
  #from . import framework
  #from .. import framework

• And this little recipe works in most cases:

  SRC_DIR = os.path.dirname(os.path.abspath(__file__))
  os.sys.path.append(os.path.join(SRC_DIR, '..', 'framework'))
  import general_useful_things

If you want to tinker around with that example directory structure here you go: http://dl.dropbox.com/u/440522/importing%20is%20hard.zip

Python doesn’t have file-system imports

To summarize my rant – python has this mantra that your import lines should be concise and thus a complex searching import mechanism was built to avoid filesystem-path-like imports. The price we pay for that searching import mechanism is that you really need to learn how to use its implicit kinks and even then it’s not that fun to use.

The theoretical ideal solution

“import x” always imports from sys.path etc, if you want to import something local you use “import ./local_dir_module”, the forward slash signals the parser and the developer that a file-system import is taking place. “local_dir_module.py” needs to be in the current folder for the above example to work. Just in case it isn’t clear, the module “local_dir_module” will be accessed as usual, without the “.py”, dots or slashes. The import statement is the only place where slashes are allowed and the result of the import is a module in the stater’s namespace.

That’s as explicit, simple, concise and useful as it gets.

The practical solution

I don’t mind if “import x” still works as it does today, the main point is that now you can do things like “import ../../that_module_from_far_away”. So you can actually keep python 100% backwards compatible and still add this feature.

Concerning the backslash/forwardslash debate – I’m a windows guy and I don’t mind using the forward slash for Python, Windows doesn’t mind it either (“/” only fails in a few specific scenarios like cmd autocomplete). Another fun fact is you can avoid littering your app with __init__.py if you aren’t going to be accessed using that big old search-import-package mechanism.

I realize this whole fiasco might raise the question of absolute path imports, in my opinion these shouldn’t be allowed. Absolue includes in C/C++ destroy portability, impose annoying folder structure constraints and they’re ever-so tempting at late hours where you don’t really want to calculate the amount of “..” needed. For the special cases that might still need this, the instrumentation existing in python and e.g. import_file are enough.

The good things about __init__.py

Many packages use __init__.py as a way to organize their API’s to the outside world. Your package folder can have tons of scripts and only what you included in __init__.py is exposed when your folder is imported directly (eg json in the std-library). So don’t take this as an attack on __init__.py, it’s just that the import mechanism seems incomplete in my eyes. Just to be a bit specific – package maintainers don’t need to do stuff like “import os as _os” to avoid littering their module namespace when they use __init__.py as their API, that’s a nice thing to have.

Also, I’d like to hear other justifications as I’m sure more than a few exist.

The drawbacks of slashes and file-system-imports

1. From a compatibility viewpoint, old packages aren’t affected as we’re introducing the “forward slash” in whatever future python version. Whoever uses this feature won’t be compatible with older python versions.
2. Windows users and *nix users might argue over whether or not to allow backslashes, I think it’s not that important. Though the internet has forward slashes, so that makes it 2 platforms against 1.
3. It’s uglier (though today’s relative imports are just as ugly and harder to learn).
4. People might ask for absolute imports.
5. Dividing the community and its packages into “file-system-importers” and “package-search-importers”.
6. *reserved for complaints in the comments*

Summary

I’ve tried to do packages the existing python way and I think we can do better. The __init__.py based search mechanism works great for whatever is in sys.path, though I believe its pains outweigh its gains for organizing code. Here’s to hoping there’s a chance for relative-file-system imports in standard python.

References

http://www.python.org/dev/peps/pep-0328/

http://en.cppreference.com/w/cpp/preprocessor/include

http://effbot.org/zone/import-confusion.htm – January 07, 1999 – “There are Many Ways to Import a Module” – “The import and from-import statements are a constant cause of serious confusion for newcomers to Python”

http://stackoverflow.com/questions/448271/what-is-init-py-for

http://stackoverflow.com/questions/1260792/python-import-a-file-from-a-subdirectory 

http://docs.python.org/tutorial/modules.html

http://www.slideshare.net/stuartmitchell/python-relative-imports-just-let-me-use-the-file-system-please

A new module – import_file

So I had this python web server and I wanted to write a script that does some maintenance. The problem was, if the maintenance script isn’t part of the “__init__.py” package tree, it couldn’t use any of the web server modules. A hacky way to get around this is to add the target module’s directory to the path:

    import sys
    sys.path.append('/usr/wherever_that_module_is')
    import your_module

Another trick is using os.chdir. Even when importing modules from the same package things can become confusing as can be learned from PEP 328, PEP 366, an abundance of stackoverflow questions on the subject and many more. I’d like to quote The Zen of Python:

    Simple is better than complex.
    There should be one-- and preferably only one --obvious way to do it.
    If the implementation is hard to explain, it's a bad idea.

I don’t believe any of these can be said about python imports, at least not for anything past the trivial case of one-folder-with-all-the-modules. The moment you want to organize your project in folders it becomes complex if not complicated and unnatural.

“import math” just works and that’s great, I just wished there was an equivalent to the banal:

#include "path/to/module"

From those inferior languages. So I wrote import_file which can be used like this:

    >>>from import_file import import_file
    >>>mylib = import_file('c:\\mylib.py')
    >>>another = import_file('relative_subdir/another.py')

It’s very similar to the imp module syntax, except the function requires one argument less. This is the way it should be imo. Enjoy import_file at google code, from the cheese shop, “easy_install import_file” or pip, etc.

What python lacks

I do like python a lot, but I feel some things are still missing. Correct me if I’m wrong.

* How do I know what can I import? I can use help(os) but how do I know that ‘os’ exists (from within the interpreter). I want a command like dir that can search through the default import directories. “mdir” (like module dir) or “pdir” (package dir).
* Tkinter sucks, why isn’t wx or anything else included?
* The php documentation really makes me jealous because the user contributed comments are VERY useful. Why doesn’t python docs have some web 2.0 in it? Like digg’s comment system.
* So many crappy IDE’s, I can’t find one that’s good for everything. At first I liked Wing but nowadays it’s way too slow and heavy so I switched to SPE which is great except it can crash for no reason.
* The GIL needs to be taken more seriously with a dedicated page explaining why it’s in place, how to escape it’s suckiness, and a roadmap to minimize the damage. Alot of people care about performance more than idiot-proof concurrency.

And I think i have a few more rants to go on about this, I’ll post ’em when I recall.