Fixed listing
[redakcja.git] / apps / sorl / thumbnail / base.py
1 import os
2 from os.path import isfile, isdir, getmtime, dirname, splitext, getsize
3 from tempfile import mkstemp
4 from shutil import copyfile
5
6 from PIL import Image
7
8 from sorl.thumbnail import defaults
9 from sorl.thumbnail.processors import get_valid_options, dynamic_import
10
11
12 class ThumbnailException(Exception):
13     # Stop Django templates from choking if something goes wrong.
14     silent_variable_failure = True
15
16
17 class Thumbnail(object):
18     imagemagick_file_types = defaults.IMAGEMAGICK_FILE_TYPES
19
20     def __init__(self, source, requested_size, opts=None, quality=85,
21                  dest=None, convert_path=defaults.CONVERT,
22                  wvps_path=defaults.WVPS, processors=None):
23         # Paths to external commands
24         self.convert_path = convert_path
25         self.wvps_path = wvps_path
26         # Absolute paths to files
27         self.source = source
28         self.dest = dest
29
30         # Thumbnail settings
31         try:
32             x, y = [int(v) for v in requested_size]
33         except (TypeError, ValueError):
34             raise TypeError('Thumbnail received invalid value for size '
35                             'argument: %s' % repr(requested_size))
36         else:
37             self.requested_size = (x, y)
38         try:
39             self.quality = int(quality)
40             if not 0 < quality <= 100:
41                 raise ValueError
42         except (TypeError, ValueError):
43             raise TypeError('Thumbnail received invalid value for quality '
44                             'argument: %r' % quality)
45
46         # Processors
47         if processors is None:
48             processors = dynamic_import(defaults.PROCESSORS)
49         self.processors = processors
50
51         # Handle old list format for opts.
52         opts = opts or {}
53         if isinstance(opts, (list, tuple)):
54             opts = dict([(opt, None) for opt in opts])
55
56         # Set Thumbnail opt(ion)s
57         VALID_OPTIONS = get_valid_options(processors)
58         for opt in opts:
59             if not opt in VALID_OPTIONS:
60                 raise TypeError('Thumbnail received an invalid option: %s'
61                                 % opt)
62         self.opts = opts
63
64         if self.dest is not None:
65             self.generate()
66
67     def generate(self):
68         """
69         Generates the thumbnail if it doesn't exist or if the file date of the
70         source file is newer than that of the thumbnail.
71         """
72         # Ensure dest(ination) attribute is set
73         if not self.dest:
74             raise ThumbnailException("No destination filename set.")
75
76         if not isinstance(self.dest, basestring):
77             # We'll assume dest is a file-like instance if it exists but isn't
78             # a string.
79             self._do_generate()
80         elif not isfile(self.dest) or (self.source_exists and
81             getmtime(self.source) > getmtime(self.dest)):
82
83             # Ensure the directory exists
84             directory = dirname(self.dest)
85             if directory and not isdir(directory):
86                 os.makedirs(directory)
87
88             self._do_generate()
89
90     def _check_source_exists(self):
91         """
92         Ensure the source file exists. If source is not a string then it is
93         assumed to be a file-like instance which "exists".
94         """
95         if not hasattr(self, '_source_exists'):
96             self._source_exists = (self.source and
97                                    (not isinstance(self.source, basestring) or
98                                     isfile(self.source)))
99         return self._source_exists
100     source_exists = property(_check_source_exists)
101
102     def _get_source_filetype(self):
103         """
104         Set the source filetype. First it tries to use magic and
105         if import error it will just use the extension
106         """
107         if not hasattr(self, '_source_filetype'):
108             if not isinstance(self.source, basestring):
109                 # Assuming a file-like object - we won't know it's type.
110                 return None
111             try:
112                 import magic
113             except ImportError:
114                 self._source_filetype = splitext(self.source)[1].lower().\
115                    replace('.', '').replace('jpeg', 'jpg')
116             else:
117                 m = magic.open(magic.MAGIC_NONE)
118                 m.load()
119                 ftype = m.file(self.source)
120                 if ftype.find('Microsoft Office Document') != -1:
121                     self._source_filetype = 'doc'
122                 elif ftype.find('PDF document') != -1:
123                     self._source_filetype = 'pdf'
124                 elif ftype.find('JPEG') != -1:
125                     self._source_filetype = 'jpg'
126                 else:
127                     self._source_filetype = ftype
128         return self._source_filetype
129     source_filetype = property(_get_source_filetype)
130
131     # data property is the image data of the (generated) thumbnail
132     def _get_data(self):
133         if not hasattr(self, '_data'):
134             try:
135                 self._data = Image.open(self.dest)
136             except IOError, detail:
137                 raise ThumbnailException(detail)
138         return self._data
139
140     def _set_data(self, im):
141         self._data = im
142     data = property(_get_data, _set_data)
143
144     # source_data property is the image data from the source file
145     def _get_source_data(self):
146         if not hasattr(self, '_source_data'):
147             if not self.source_exists:
148                 raise ThumbnailException("Source file: '%s' does not exist." %
149                                          self.source)
150             if self.source_filetype == 'doc':
151                 self._convert_wvps(self.source)
152             elif self.source_filetype in self.imagemagick_file_types:
153                 self._convert_imagemagick(self.source)
154             else:
155                 self.source_data = self.source
156         return self._source_data
157
158     def _set_source_data(self, image):
159         if isinstance(image, Image.Image):
160             self._source_data = image
161         else:
162             try:
163                 self._source_data = Image.open(image)
164             except IOError, detail:
165                 raise ThumbnailException("%s: %s" % (detail, image))
166             except MemoryError:
167                 raise ThumbnailException("Memory Error: %s" % image)
168     source_data = property(_get_source_data, _set_source_data)
169
170     def _convert_wvps(self, filename):
171         try:
172             import subprocess
173         except ImportError:
174             raise ThumbnailException('wvps requires the Python 2.4 subprocess '
175                                      'package.')
176         tmp = mkstemp('.ps')[1]
177         try:
178             p = subprocess.Popen((self.wvps_path, filename, tmp),
179                                  stdout=subprocess.PIPE)
180             p.wait()
181         except OSError, detail:
182             os.remove(tmp)
183             raise ThumbnailException('wvPS error: %s' % detail)
184         self._convert_imagemagick(tmp)
185         os.remove(tmp)
186
187     def _convert_imagemagick(self, filename):
188         try:
189             import subprocess
190         except ImportError:
191             raise ThumbnailException('imagemagick requires the Python 2.4 '
192                                      'subprocess package.')
193         tmp = mkstemp('.png')[1]
194         if 'crop' in self.opts or 'autocrop' in self.opts:
195             x, y = [d * 3 for d in self.requested_size]
196         else:
197             x, y = self.requested_size
198         try:
199             p = subprocess.Popen((self.convert_path, '-size', '%sx%s' % (x, y),
200                 '-antialias', '-colorspace', 'rgb', '-format', 'PNG24',
201                 '%s[0]' % filename, tmp), stdout=subprocess.PIPE)
202             p.wait()
203         except OSError, detail:
204             os.remove(tmp)
205             raise ThumbnailException('ImageMagick error: %s' % detail)
206         self.source_data = tmp
207         os.remove(tmp)
208
209     def _do_generate(self):
210         """
211         Generates the thumbnail image.
212
213         This a semi-private method so it isn't directly available to template
214         authors if this object is passed to the template context.
215         """
216         im = self.source_data
217
218         for processor in self.processors:
219             im = processor(im, self.requested_size, self.opts)
220
221         self.data = im
222
223         filelike = not isinstance(self.dest, basestring)
224         if not filelike:
225             dest_extension = os.path.splitext(self.dest)[1][1:]
226             format = None
227         else:
228             dest_extension = None
229             format = 'JPEG'
230         if (self.source_filetype and self.source_filetype == dest_extension and
231                 self.source_data == self.data):
232             copyfile(self.source, self.dest)
233         else:
234             try:
235                 im.save(self.dest, format=format, quality=self.quality,
236                         optimize=1)
237             except IOError:
238                 # Try again, without optimization (PIL can't optimize an image
239                 # larger than ImageFile.MAXBLOCK, which is 64k by default)
240                 try:
241                     im.save(self.dest, format=format, quality=self.quality)
242                 except IOError, detail:
243                     raise ThumbnailException(detail)
244
245         if filelike:
246             self.dest.seek(0)
247
248     # Some helpful methods
249
250     def _dimension(self, axis):
251         if self.dest is None:
252             return None
253         return self.data.size[axis]
254
255     def width(self):
256         return self._dimension(0)
257
258     def height(self):
259         return self._dimension(1)
260
261     def _get_filesize(self):
262         if self.dest is None:
263             return None
264         if not hasattr(self, '_filesize'):
265             self._filesize = getsize(self.dest)
266         return self._filesize
267     filesize = property(_get_filesize)
268
269     def _source_dimension(self, axis):
270         if self.source_filetype in ['pdf', 'doc']:
271             return None
272         else:
273             return self.source_data.size[axis]
274
275     def source_width(self):
276         return self._source_dimension(0)
277
278     def source_height(self):
279         return self._source_dimension(1)
280
281     def _get_source_filesize(self):
282         if not hasattr(self, '_source_filesize'):
283             self._source_filesize = getsize(self.source)
284         return self._source_filesize
285     source_filesize = property(_get_source_filesize)