From 8e53c5bc5db462f6e39404c73ac96ec0cbb6a6c7 Mon Sep 17 00:00:00 2001
From: Simon Law <simon.law@ecometrica.com>
Date: Tue, 24 Jul 2012 14:57:06 -0400
Subject: PDFTemplateResponse and PDFTemplateView now match Django's
 implementations

PDFTemplateResponse is like TemplateResponse in that it does dynamic
rendering of a template on the fly.

PDFTemplateView has a much smaller implementation, relying on
PDFTemplateResponse to do the rendering for it. It also knows about
the standard TemplateResponse when it needs to render the HTML version.
---
 wkhtmltopdf/utils.py | 55 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

(limited to 'wkhtmltopdf/utils.py')

diff --git a/wkhtmltopdf/utils.py b/wkhtmltopdf/utils.py
index fb8f0aa..d0475c4 100644
--- a/wkhtmltopdf/utils.py
+++ b/wkhtmltopdf/utils.py
@@ -5,6 +5,7 @@ from itertools import chain
 from os import fdopen
 import sys
 from tempfile import mkstemp
+import warnings
 
 from django.conf import settings
 from django.template import loader
@@ -76,6 +77,8 @@ def template_to_temp_file(template_name, dictionary=None, context_instance=None)
     """
     Renders a template to a temp file, and returns the path of the file.
     """
+    warnings.warn('template_to_temp_file is deprecated in favour of PDFResponse. It will be removed in version 1.',
+                  PendingDeprecationWarning, 2)
     file_descriptor, tempfile_path = mkstemp(suffix='.html')
     with fdopen(file_descriptor, 'wt') as f:
         f.write(smart_str(loader.render_to_string(template_name, dictionary=dictionary, context_instance=context_instance)))
@@ -111,3 +114,55 @@ def http_quote(string):
             string = string.encode('ascii', 'replace')
     # Wrap in double-quotes for ; , and the like
     return '"{!s}"'.format(string.replace('\\', '\\\\').replace('"', '\\"'))
+
+
+try:
+    # From Django 1.4
+    from django.conf import override_settings
+except ImportError:
+    class override_settings(object):
+        """
+        Acts as either a decorator, or a context manager. If it's a decorator it
+        takes a function and returns a wrapped function. If it's a contextmanager
+        it's used with the ``with`` statement. In either event entering/exiting
+        are called before and after, respectively, the function/block is executed.
+        """
+        def __init__(self, **kwargs):
+            self.options = kwargs
+            self.wrapped = settings._wrapped
+
+        def __enter__(self):
+            self.enable()
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            self.disable()
+
+        def __call__(self, test_func):
+            from django.test import TransactionTestCase
+            if isinstance(test_func, type) and issubclass(test_func, TransactionTestCase):
+                original_pre_setup = test_func._pre_setup
+                original_post_teardown = test_func._post_teardown
+                def _pre_setup(innerself):
+                    self.enable()
+                    original_pre_setup(innerself)
+                def _post_teardown(innerself):
+                    original_post_teardown(innerself)
+                    self.disable()
+                test_func._pre_setup = _pre_setup
+                test_func._post_teardown = _post_teardown
+                return test_func
+            else:
+                @wraps(test_func)
+                def inner(*args, **kwargs):
+                    with self:
+                        return test_func(*args, **kwargs)
+            return inner
+
+        def enable(self):
+            override = copy(settings._wrapped)
+            for key, new_value in self.options.items():
+                setattr(override, key, new_value)
+            settings._wrapped = override
+
+        def disable(self):
+            settings._wrapped = self.wrapped
-- 
cgit v1.2.3