And I can't use

from robot.py import myActuators

because myActuators is not a module.

But myActuators doesn't need to be a module. You can do exactly that. (Though you'll want to use just robot rather than robot.py)

http://docs.python.org/reference/simple_stmts.html#import

As well:

http://docs.python.org/tutorial/modules.html#more-on-modules

"A module can contain executable statements as well as function definitions. These statements are intended to initialize the module. They are executed only the first time the module is imported somewhere."

So using a script that imports robot and then tilt_head, the executable stuff in robot.py will NOT be run multiple times.

Of course, if robot.py is intended to be the main module of the program, then I'd suggest going with A. Levy's answer.

You should be able to simply use:

from robot import myActuators

You can't say "from robot.py" because the name there is a module name, not a file name.

BTW: I'm not sure why you are doing import actuators as Actuators. Why do you want to change the case? Modules are most commonly lowercase.

As others have been saying, you can actually import myActuators from the robot module. To solve your problem of the code in robot being re-executed, the standard Python approach is to wrap the stand-alone code in an if __name__ == '__main__': so that it will only be executed when the module is used as a standalone app, but not when it is imported.

E.G.

# Things that are defined when robot.py is used as a module
# and when used standalone.
import actuators as Actuators

myActuators = Actuators.AllActuators()

if __name__ == '__main__':
    # Stuff that you only want executed when running robot.py

Then when you want to use robot.py in another module, you should be able to do this:

from robot import myActuators

EDIT:

Actually, as JAB pointed out, I was a little confused in my explanation of conditional execution. your code won't be re-executed if you reload the module. The module loading machinery handles reloading of modules to make sure that they only get loaded and defined one time. All subsequent loads are references to the previously loaded module. If, however, you do have some steps that you only want to happen when you are running the module as a script, then you can place them in the if block and they won't be executed when you load robots from another module.

I guess it doesn't really solve your problem, though it seems like your problem was really an incorrect import syntax.

I would guess that you can access that object as robot.myActuators because it already exists in the process, inside the robot.py namespace.

Many thanks for all the answers and pointers. As it turns out, my problem was a recursive import that ended up trying to create an object more than once. By sorting out the instance creation a little more logically, I was finally able to make the problem go away.