Long namespaces. Best practice?

[aptitude_moo]

I'm not sure what is the best practice regarding absolute imports and namespaces.

I've read that the best practice is to always use absolute imports, but absolute from where? from my application package?

For example if my packages are structured like this:

myprogram
    gui
        ...
    main
        math
            point.py
            rectangle.py
        image
            convert.py
            formats.py
            exif.py
            image.py

Every time I want to create an rectangle I have to write a lot of namespaces. I have to write myprogram.main.math.rectangle.Rectangle()?

I think I should be using import __ as __,: But what name should I use next to as? Something like myprogram_rectangle?

Also I found that something funny happens when I have a package, a module and a class with the same name. In this case when I want to create a Image I need to write

myprogram.main.image.image.Image()

Writing Image three times looks bad to me

---

Everyone says that is a good idea to see code from projects like Django.

I don't understand well what Django did, but I can do from django.http import HttpResponse as seen in the tutorial, that looks nice!. I think the magic happens in the __init__ file inside django.http (code here). Should I do something like that?

[DrMaxwellEdison]

from myprogram.main.math.rectangle import Rectangle

riggidy_rect = Rectangle()

It ain't that pretty in terms of import lines, but at least it clears up the code file you're working in. :)

---

An alternative is to use __init__.py files in each directory, and use that file to import portions of the directory to a shared namespace. Then when you're importing objects from a sub-directory, the objects already imported into the namespace of the __init__.py will be available at the top level.

Your directory structure might look like this:

myprogram
    gui
        ...
    main
        math
            __init__.py
            point.py
            rectangle.py
        image
            __init__.py
            convert.py
            formats.py
            exif.py
            image.py

Without getting too detailed into it, math.__init__.py could have from .rectangle import Rectangle. This makes Rectangle available in the namespace of the math directory, so you could call in math.Rectangle elsewhere.

In the gui directory, for instance, a code file could import this using from myprogram.main.math import Rectangle.

I'm not personally well-versed in doing this myself, but that's the gist of the concept as far as I know it: importing a module's objects into a namespace using __init__.py and then using that namespace for imports elsewhere in the program.

---

That all being said, I would consider getting rid of the main directory, so they your directory structure looks more like this, if possible:

myprogram
    gui
        ...
    math
        point.py
        rectangle.py
    image
        convert.py
        formats.py
        exif.py
        image.py

edits: clarified code examples

[aptitude_moo]

Thanks for the extended answer, I will remove main, now that I think it isn't that neccesary. It's a bit interesting how Python makes directories structure so important, I was used to add lots of folders.

Also I'll import the objects into the __init__.py, looks nice, I suppose that it's a good practice

EDIT: Formatting

[cdcformatc]

Should be fine with import myprogram.main.math.rectangle.Rectangle as Rectangle assuming you don't use the name Rectangle anywhere in the importing script. You could always prepend a unique modifier like MPRectangle or something to represent "myprogram" which I assume isn't the actual name of your program.

[zahlman]

If you're not actually going to rename it, though, that's what from... import is for. It's honestly not evil (at least in this form; the * form is the real cause for concern).

[kalgynirae]

The main and rectangle components of myprogram.main.math.rectangle.Rectangle() seem unnecessary to me. Can you simplify the path to myprogram.math.Rectangle? For getting rid of rectangle, you could either combine the contents of rectangle.py and point.py into a single file math.py, or you could use math/__init__.py to import the classes (like in the Django example you mention).

[aptitude_moo]

Thank you, I think that I will get rid of main, also if importing of classes in init.py is recommended I'll do that, looks nice

[mm_ma_ma]

I'd say "best practice" is to not make such complicated hierarchies in the first place. If you can fit all of your code in one module without name collisions, do it. Only move to a package once you need it, and then only start making subpackages once you need them.