change get_queued_filename to get_orig_filename and modified function

[mediagoblin.git] / mediagoblin / media_types / image / processing.py

diff --git a/mediagoblin/media_types/image/processing.py b/mediagoblin/media_types/image/processing.py
index baf2ac7e991a34de360d8b35d66d7df565bf806d..665a2931b3f3c040f2f7e2689cfb1bc416d5f342 100644 (file)
--- a/mediagoblin/media_types/image/processing.py
+++ b/mediagoblin/media_types/image/processing.py
@@ -74,11 +74,16 @@ def resize_image(proc_state, resized, keyname, target_name, new_size,
 
 
 def resize_tool(proc_state, force, keyname, target_name,
-                conversions_subdir, exif_tags):
+                conversions_subdir, exif_tags, new_size=None):
     # filename -- the filename of the original image being resized
-    filename = proc_state.get_queued_filename()
-    max_width = mgg.global_config['media:' + keyname]['max_width']
-    max_height = mgg.global_config['media:' + keyname]['max_height']
+    filename = proc_state.get_orig_filename()
+
+    # Use the default size if new_size was not given
+    if not new_size:
+        max_width = mgg.global_config['media:' + keyname]['max_width']
+        max_height = mgg.global_config['media:' + keyname]['max_height']
+        new_size = (max_width, max_height)
+
     # If the size of the original file exceeds the specified size for the desized
     # file, a target_name file is created and later associated with the media
     # entry.
@@ -88,12 +93,12 @@ def resize_tool(proc_state, force, keyname, target_name,
     except IOError:
         raise BadMediaFail()
     if force \
-        or im.size[0] > max_width \
-        or im.size[1] > max_height \
+        or im.size[0] > new_size[0]\
+        or im.size[1] > new_size[1]\
         or exif_image_needs_rotation(exif_tags):
         resize_image(
             proc_state, im, unicode(keyname), target_name,
-            (max_width, max_height),
+            new_size,
             exif_tags, conversions_subdir)
 
 
@@ -119,54 +124,73 @@ def sniff_handler(media_file, **kw):
     return None
 
 
-def process_image(proc_state):
+def process_image(proc_state, reprocess_info=None):
     """Code to process an image. Will be run by celery.
 
     A Workbench() represents a local tempory dir. It is automatically
     cleaned up when this function exits.
     """
-    entry = proc_state.entry
-    workbench = proc_state.workbench
+    def init(self, proc_state):
+        self.proc_state = proc_state
+        self.entry = proc_state.entry
+        self.workbench = proc_state.workbench
+
+        # Conversions subdirectory to avoid collisions
+        self.conversions_subdir = os.path.join(
+            self.workbench.dir, 'convirsions')
+
+        self.orig_filename = proc_state.get_orig_filename()
+        self.name_builder = FilenameBuilder(self.orig_filename)
+
+        # Exif extraction
+        self.exif_tags = extract_exif(self.orig_filename)
+
+        os.mkdir(self.conversions_subdir)
+
+    def initial_processing(self):
+        # Is there any GPS data
+        gps_data = get_gps_data(self.exif_tags)
 
-    # Conversions subdirectory to avoid collisions
-    conversions_subdir = os.path.join(
-        workbench.dir, 'conversions')
-    os.mkdir(conversions_subdir)
+         # Always create a small thumbnail
+        resize_tool(self.proc_state, True, 'thumb', self.orig_filename,
+                    self.name_builder.fill('{basename}.thumbnail{ext}'),
+                    self.conversions_subdir, self.exif_tags)
 
-    queued_filename = proc_state.get_queued_filename()
-    name_builder = FilenameBuilder(queued_filename)
+        # Possibly create a medium
+        resize_tool(self.proc_state, False, 'medium', self.orig_filename,
+                    self.name_builder.fill('{basename}.medium{ext}'),
+                    self.conversions_subdir, self.exif_tags)
 
-    # EXIF extraction
-    exif_tags = extract_exif(queued_filename)
-    gps_data = get_gps_data(exif_tags)
+        # Copy our queued local workbench to its final destination
+        self.proc_state.copy_original(self.name_builder.fill('{basename}{ext}'))
 
-    # Always create a small thumbnail
-    resize_tool(proc_state, True, 'thumb',
-                name_builder.fill('{basename}.thumbnail{ext}'),
-                conversions_subdir, exif_tags)
+        # Remove queued media file from storage and database
+        self.proc_state.delete_queue_file()
 
-    # Possibly create a medium
-    resize_tool(proc_state, False, 'medium',
-                name_builder.fill('{basename}.medium{ext}'),
-                conversions_subdir, exif_tags)
+        # Insert exif data into database
+        exif_all = clean_exif(self.exif_tags)
 
-    # Copy our queued local workbench to its final destination
-    proc_state.copy_original(name_builder.fill('{basename}{ext}'))
+        if len(exif_all):
+            self.entry.media_data_init(exif_all=exif_all)
 
-    # Remove queued media file from storage and database
-    proc_state.delete_queue_file()
+        if len(gps_data):
+            for key in list(gps_data.keys()):
+                gps_data['gps_' + key] = gps_data.pop(key)
+            self.entry.media_data_init(**gps_data)
 
-    # Insert exif data into database
-    exif_all = clean_exif(exif_tags)
+    def reprocess(self, reprocess_info):
+        new_size = None
 
-    if len(exif_all):
-        entry.media_data_init(exif_all=exif_all)
+        # Did they specify a size?
+        if reprocess_info.get('max_width'):
+            max_width = reprocess_info['max_width']
+            max_height = reprocess_info['max_height']
 
-    if len(gps_data):
-        for key in list(gps_data.keys()):
-            gps_data['gps_' + key] = gps_data.pop(key)
-        entry.media_data_init(**gps_data)
+            new_size = (max_width, max_height)
 
+        resize_tool(self.proc_state, False, reprocess_info['resize'],
+                    self.name_builder.fill('{basename}.medium{ext}'),
+                    self.conversions_subdir, self.exif_tags, new_size)
 
 if __name__ == '__main__':
     import sys