To get to the module object from the body of the module itself, the usual trick is to import it from itself, as in:

x.py:
import x
do_stuff_with(x)

This fails strangely if x is in a package:

package/x.py:
import package.x
do_stuff_with(package.x)

The last line triggers an AttributeError: 'module' object has no attribute 'x'.  In other words, the import succeeds but the expression 'package.x' still isn't valid after it.

Logged In: YES 
user_id=595483

The error seems to be due to the calling sequence of
add_submodule and loadmodule in import.c:import_submodule.
If load_module(..) is called after add_submodule(...) gets
called, the above does not trigger Attribute Error.
I made a patch that does it, but there is a problem... 
Currently, when import produces errors, sys.modules have the
damaged module, but the patch does not. (That's why it
cannot pass the  test_pkgimport.py unittest, I think.) 
Someone who knows more about import.c could fix the patch to
behave like that.

The patch is in
http://seojiwon.dnip.net:8000/~jiwon/tmp/import.diff

Logged In: YES 
user_id=595483

The behavior is definitely due to the calling sequence of
add_submodule and load_module in import_submodule. (like
following)

...
m = load_module(fullname, fp, buf, fdp->type, loader);
Py_XDECREF(loader);
if (fp)
    fclose(fp);
if (!add_submodule(mod, m, fullname, subname, modules)) {
    Py_XDECREF(m);
    m = NULL;
}
...

For "importing package.x;do_something(package.x)" from
within package.x to be possible,  add_submodule should be
done before load_module, since in load_module,  not only the
module is load, but also executed by PyImport_ExecCodeModuleEx.
So, if we make a module and call add_submodule before
load_module, import ing package.x and using it is possible.
(like following)

m = PyImport_AddModule(fullname);
if (!m) {
        return NULL;
}

if (!add_submodule(mod, m, fullname, subname, modules)) {
        Py_XDECREF(m);
        return NULL;
}

m = load_module(mod, fullname, fp, buf, fdp->type, loader);
Py_XDECREF(loader);

but above would make test_importhook fail because in
IMP_HOOK case, module object is created by
PyObject_CallMethod(... "load_module"..), not by calling
PyImport_AddModule. So, we cannot know about the module
before that  method calling is returned. Thus, in IMP_HOOK
case, load_module would not use the already-created module
by PyImport_AddModule, but would make a new one, which is
not added as submodule to its parent.

Anyway, adding another add_submodule after load_module would
make import-hook test code to be passed, but it's a lame
patch since in IMP_HOOK case, import package.x in
package/x.py cannot be done.

So, for the behavior to be possible, I think load_module
should be explicitly separated into two function -
load_module, execute_module. And then we'll load_module,
add_submodule itself to its parent and then execute_module.
There does not seem to be any hack that touches only limited
places, so I think this bug(?) will stay open for quite long
time. =)