How to use django-compressor to compress form media offline - django

Question

A Django template (containing a form with media) that includes a snippet like the one below would throw an error when using django-compressor with COMPRESS_OFFLINE=True, because form is not available when offline compression is executed:
# Template snippet
{% compress js %}
{{ form.media.js }}
{% endcompress %}
Generally speaking, django-compressor provides the COMPRESS_OFFLINE_CONTEXT setting to handle similar situations. However, if a site contains many such forms or widgets with media, this solution isn't ideal.
For example, currently, I do something like this in settings.py (for each widget's media):
# settings.py
...
from my_app1.widgets import Widget1
from my_app1.widgets import Widget2
from my_app1.widgets import Widget3
...
widgets = {
'my_widget1': Widget1(),
'my_widget2': Widget2(),
'my_widget3': Widget3(),
...
}
for name, widget in widgets.items():
COMPRESS_OFFLINE_CONTEXT['{}_css'.format(name)] = widget.media['css']
COMPRESS_OFFLINE_CONTEXT['{}_js'.format(name)] = widget.media['js']
And then in templates, I do this:
{% compress js %}
{{ my_widget1_js }}
{% endcompress %}
Is there a way to handle this situation in a manner that more closely resembles Django's {{ form.media }} method, or perhaps without needing to enumerate the specific media to every widget or every form (containing media) in the site?

Answer 1

You can simplify your settings by using some custom class with an __getattr__ method. That way if you will pass that object into template and try to call
{{ obj.my_widget1_js }}
logic inside __getattr__ can search for specified widget in your project and return it's media.
Example of class that will auto-discover each widget:
class WidgetImporter(object):
def __getattr__(self, name):
path = name.split('__') # this will split path on double underscore, so you can define submodule here
path = [(node, "".join(part.capitalize() for part in node.split('_'))) for node in path] # this will convert underscore_names to CamelCase names.
# determining for each module if it's name is CamelCased or underscored
real_path = []
for underscored, cameled in path:
try:
__import__(".".join(real_path + [underscored])) # first trying to import umderscored module
except ImportError:
try:
__import__(".".join(real_path + [cameled])) # now try with cameled
except ImportError:
return "" # or raise some exception here if you like
else:
real_path.append(cameled)
else:
real_path.append(underscored)
last_node = real_path[len(real_path) - 1]
return getattr(__import__(".".join(real_path), fromlist=[last_node]), last_node)() # returning actual class instance
That way you can use it inside your settings.py file:
COMPRESS_OFFLINE_CONTEXT = {
'widgets': WidgetImporter(),
}
and use in your template:
{{ widgets.my_app1__widgets__widget1.media.css }}
Class will try to resolve my_app1__widgets__widget1 to actual path to your class and will try to import it. If it succeeds, it's media['css'] will be printed. It's not 100% optimal code and 100% safe (there can be some vulnerabilities if someone has access to your templates), but it will do the job.