I don't really like having one monolithic templatee folder. You end in with a scenario where you have to go digging, in a completely separate path for the template that goes with a given view, and that can be very disrupting when you're in the middle of working on something.
In my current proejct I wanted to use Django's
app_directories loader to try to keep the templates physically close to the views that use them. Then I started working with it and I realized how annoying it'd be to use!
When I create a listing page I generally name the template file
index.html or maybe
listing.html depending on it's usage. Edit pages are normally
edit.html, details pages are normally
details.html and so on. However, the
app_directories's loader class doesn't differentiate in any way between your different modules. This is the root of my issue.
In some magical world it'd use the source of the call to identify what was the most likely module, and then maybe do some guesses for likely fallbacks. But that's not really sane to try to implement, hell I don't even think it's really possible.
The official method is to build subdirectories under the application template folders. This means you'd have
projectname/appname/subappname/templates/appname/subappname/index.html. The other common 'fix' for this is to prefix your filenames so they'd all be
appname-subappname.html and the like.
I don't really care for either. The pathing solution ends up with a lot of redundancy, and you still have to maintain the kinda structure I'm wanting to avoid, and even if the structure is localized it's still annoying to have to go through. The prefixing just seems sloppy, and if you ever do accidentally have a conflicting name, which can happen, you could have a potentially hard to spot bug.
The best idea I've thought of so far to fix this is to have your render methods look like this:
render_to_string(template_app, template_name, dictionary=None, context_instance=None). This way you just pass in the app name when you call it. Now I don't care for the inherent redundancy this would cause either, but it seems to me to be the lesser of the evils.
The idea had me digging into the internals of how Django works with loading templates and what I needed to do to make this really work. What I found wasn't that bad. The Loader api is pretty simple, however, there was a few undocumented and non obvious requirements. Also you can't circumvent the Loader system completely as that breaks other facets of the framework. Some of this would have been extremely painful to figure out if PyCharm didn't have such a great debugger.
It's pretty straight forward to use.
TEMPLATE_LOADERS = (('appname.common.templates.AppSpecificLoader',),) if not DEBUG: TEMPLATE_LOADERS = (('django.template.loaders.cached.Loader', ('appname.common.templates.AppSpecificLoader',)), )
Then you just need to import the render method and use it instead of the default, alternatively there is also a django-annoying inspired decorator that can be used to revent the redundant code many of us have for building the response object.