Import helpers¶
There are three helpers under cwf.splitter.imports
that you can use:
- cwf.splitter.imports.steal
This lets you inject variables from several files into your current file without relying on magic “from somewhere import *”.
- cwf.splitter.imports.inject
This lets you inject some object into import space.
- cwf.splitter.imports.install_failed_import_handler
This provides a wrapper around the default __import__ logic that makes autoreload logic for development servers reload modules that never import properly.
steal¶
A django settings file tends to get very large and a bit unweildy.
You can use this to split your settings.py
into many files that you combine
together.
For example, let’s say you have the following folder structure:
settings.py
settings_files/
inclusions.py
logging.py
cache.py
other.py
Then you can have the following in your settings.py
:
from cwf.splitter.imports import steal
this_dir = os.path.dirname(__file__)
settings_dir = os.path.abspath(os.path.join(this_dir, 'settings_files'))
steal('inclusions', 'logging', 'cache', 'other'
, folder=settings_dir, globals=globals(), locals=locals()
)
steal
will use execfile
to insert the variables from those files into the globals
and locals
that your provide.
inject¶
Inject is a special beast that will create a finder object that gets placed into sys.meta_path
What this means is that you can write something like:
from cwf.splitter.imports import inject
try:
import blah
assert False, "Blah shouldn't exist"
except ImportError:
assert True
obj = {"one":1, "two":2}
inject(obj, "blah")
try:
import blah
assert blah.one == 1
assert blah.two == 2
print "successfully injected blah"
except ImportError:
assert False, "Blah should have been injected"
Note
There is a limitation to this in that all packages leading up your new import path must already exist and be folders.
(The limitation is an implementation detail that I haven’t found the time to rectify yet)
So if you inject into “blah.things”, then “blah” must already exist in your
PYTHONPATH and be a folder with an __init__.py
for this to work.
install_failed_import_handler¶
When you start a development server that auto reloads for you (for example, the
werkzeug powered one provided then files will only be
reloaded if they are inside sys.modules
.
It so happens that if a module fails to import, then it won’t end up in
sys.modules
and so when you edit such a file to not fail on import, the
reloader won’t see that it has changed and ignore it.
To get around this, CWF provides
cwf.splitter.imports.install_failed_import_handler
that will wrap the default __import__
such that any module that fails to
import will get a fake module put into sys.modules
in it’s place so that
the reloader knows to check that file.
Installation is as simple as:
from cwf.splitter.imports import install_failed_import_handler
install_failed_import_handler()
It will consider either a SyntaxError
or ImportError
as conditions for
when a fake version of it should go into sys.modules
. Regardless of what
exception is raised, if any, it will always be reraised so that you are aware
when this happens.