Python namespaces: How to make unique objects accessible in other modules?

Question

I am writing a moderate-sized (a few KLOC) PyQt app. I started out writing it in nice modules for ease of comprehension but I am foundering on the rules of Python namespaces. At several points it is important to instantiate just one object of a class as a resource for other code.

For example: an object that represents Aspell attached as a subprocess, offering a check(word) method. Another example: the app features a single QTextEdit and other code needs to call on methods of this singular object, e.g. "if theEditWidget.document().isEmpty()..."

No matter where I instantiate such an object, it can only be referenced from code in that module and no other. So e.g. the code of the edit widget can't call on the Aspell gateway object unless the Aspell object is created in the same module. Fine except it is also needed from other modules.

In this question the bunch class is offered, but it seems to me a bunch has exactly the same problem: it's a unique object that can only be used in the module where it's created. Or am I completely missing the boat here?

OK suggested elsewhere, this seems like a simple answer to my problem. I just tested the following:

junk_main.py:

import junk_A
singularResource = junk_A.thing()
import junk_B
junk_B.handle = singularResource
print junk_B.look()

junk_A.py:

class thing():
    def __init__(self):
        self.member = 99

junk_B.py:

def look():
    return handle.member

When I run junk_main it prints 99. So the main code can inject names into modules just by assignment. I am trying to think of reasons this is a bad idea.

If one of the answers you received solved your problem, could you accept it by clicking on the checkmark? — andronikus, Sep 09 '11 at 16:29
If one of the answers you got solved your problem, please accept it by clicking on the check mark. — andronikus, Sep 27 '11 at 03:10

score 2 · Answer 1 · answered Sep 05 '11 at 23:16

2

You can access objects in a module with the . operator just like with a function. So, for example:

# Module a.py
a = 3

>>> import a
>>> print a.a
3

This is a trivial example, but you might want to do something like:

# Module EditWidget.py
theEditWidget = EditWidget()
...

# Another module
import EditWidget

if EditWidget.theEditWidget.document().isEmpty():

Or...

import * from EditWidget

if theEditWidget.document().isEmpty():

If you do go the import * from route, you can even define a list named __all__ in your modules with a list of the names (as strings) of all the objects you want your module to export to *. So if you wanted only theEditWidget to be exported, you could do:

# Module EditWidget.py
__all__ = ["theEditWidget"]
theEditWidget = EditWidget()
...

answered Sep 05 '11 at 23:16

andronikus

4,125
2
29
46

I have the impression that import also implies execution, so if in your middle example, more than one module imports EditWidget, doesn't that imply more than one object instantiation? – user405 Sep 05 '11 at 23:40
1

No, only the first import within a run will execute the code; other imports of the same module just create references to the first. – Russell Borogove Sep 05 '11 at 23:54
Exactly. If you've done any C/C++ programming, you normally put some code to ensure that your file only gets `#include`d once (the C equivalent of importing), but Python does that for you automagically. – andronikus Sep 06 '11 at 00:15
1

In particular, `sys.modules` is the dictionary where python stores modules after they have been executed / loaded. Once there, subsequent imports just lookup the object in that dict. – Eli Collins Sep 06 '11 at 04:03

score 2 · Accepted Answer · answered Sep 06 '11 at 18:08

It turns out the answer is simpler than I thought. As I noted in the question, the main module can add names to an imported module. And any code can add members to an object. So the simple way to create an inter-module communication area is to create a very basic object in the main, say IMC (for inter-module communicator) and assign to it as members, anything that should be available to other modules:

IMC.special = A.thingy()
IMC.important_global_constant = 0x0001

etc. After importing any module, just assign IMC to it:

import B
B.IMC = IMC

Now, this is probably not the greatest idea from a software design standpoint. If you just limit IMC to holding named constants, it acts like a C header file. If it's just to give access to singular resources, it's like a link extern. But because of Python's liberal rules, code in any module can modify or add members to IMC. Used in an undisciplined way, "who changed that" could be a debugging issue. If there are multiple processes, race conditions are a danger.

score 1 · Answer 3 · answered Sep 05 '11 at 23:57

At several points it is important to instantiate just one object of a class as a resource for other code.

Instead of trying to create some sort of singleton factory, can you not create the single-use object somewhere between the main point of entry for the program and instantiating the object that needs it? The single-use object can just be passed as a parameter to the other object. Logically, then, you won't create the single-use object more than once.

For example:

def main(...):
    aspell_instance = ...
    myapp = MyAppClass(aspell_instance)

or...

class SomeWidget(...):

    def __init__(self, edit_widget):
        self.edit_widget = edit_widget

    def onSomeEvent(self, ...):
        if self.edit_widget.document().isEmpty():
            ....

I don't know if that's clear enough, or if it's applicable to your situation. But to be honest, the only time I've found I can't do this is in a CherryPy-based webserver, where the points of entry were pretty much everywhere.

Python namespaces: How to make unique objects accessible in other modules?

3 Answers3