almost working

3 files changed, 45 insertions, 36 deletions

diff --git a/Params/__init__.py b/Params/__init__.py
index 60a0b58..2c94460 100644
--- a/Params/__init__.py
+++ b/Params/__init__.py
@@ -52,7 +52,7 @@ class Params(object):
         elif value_type == "bool":
           value = self._bool_correct(str(value))
         elif value_type == "string":
-          value = self._sanitize(str(value))
+          value = self.sanitize(str(value))
         elif value_type == "img_url":
           _filename = self._filename_temporary(key)
           _path = os.path.join(self._working_dir, _filename)
@@ -70,7 +70,7 @@ class Params(object):
       except Exception as e:
         self.err_warn("key: %s value: %s" % (key, value), error=str(e))
 
-    def _sanitize (self, s):
+    def sanitize (self, s):
       return re.sub(r'\W+', '', s)
 
     def _color_sanitize(self, s):
diff --git a/Pb/Break/__init__.py b/Pb/Break/__init__.py
index db9daaf..ed02f60 100755
--- a/Pb/Break/__init__.py
+++ b/Pb/Break/__init__.py
@@ -37,14 +37,17 @@ class PbBreak(Pb): #FIXME in db gallery
         self.params.set_val("url", url, value_type="img_url");
         self._files_created.append(self.params.url['path'])
         
-#        if not self.params.finalformat and self._gif_frames:
+#       if not self.params.finalformat and self._gif_frames:
 #            self.params.finalformat = 'gif'
-#        if self.params.breaktype == 'miff':
+#        if self.params.breaktypte == 'miff':
 #            self.params.finalformat = 'jpg'
 #            self.params.breakmode = 'subtle'
         #final filepath is stored in self.filepath
+        self._width_and_height_set(filepath=self.params.url['path'])       
+
         self.filename, self.filepath = self._filename_filepath_create(url=self.params.url['url'])
-        self._conversion_file = self._tempfilepath_create()
+        self._conversion_file = self._tempfilepath_create(namepart="conversion")
+        #maybe touch here, since files aren't actually created yet
 
     def _get_breaktype(self, key):
         #{{{ conversion table
@@ -83,22 +86,22 @@ class PbBreak(Pb): #FIXME in db gallery
 
     def _subtle_break(self):
         #assume the header is no longer than _header_offset bytes
-        breakpoint = random.randint(_header_offset, len(self.file_data))
-        newfile = self.file_data[0:breakpoint] \
+        breakpoint = random.randint(_header_offset, len(self._file_data))
+        newfile = self._file_data[0:breakpoint] \
           + _subtle_break_mark \
-          + self.file_data[breakpoint:]
-        self.file_data = newfile[0:len(self.file_data)]
+          + self._file_data[breakpoint:]
+        self._file_data = newfile[0:len(self._file_data)]
 
     def _extreme_break(self):
-        increment = len(self.file_data)/10;
+        increment = len(self._file_data)/10;
         i = 0
         newfile = "";
-        for b in self.file_data:
+        for b in self._file_data:
             if i > _header_offset and not (i % increment):
                 b += _extreme_break_mark
             newfile += b
             i += 1
-        self.file_data = newfile[0:len(self.file_data)]
+        self._file_data = newfile[0:len(self._file_data)]
 
     def _choose_frame(self, filepath):
         _gif_frames = PbBreak.gif_frames(filepath)
@@ -107,21 +110,17 @@ class PbBreak(Pb): #FIXME in db gallery
      
     def _enforce_jpg(self):
         if self.params.breaktype in [ "exr", "bmp", "miff" ] and not re.match(r'jpe?g$', self.params.url['mimetype'], re.IGNORECASE):
-            jpg_file = self.tempname_create(basename=self.basename, fmt="jpg") 
+            jpg_file = self._tempfilepath_create(extension="jpg")
             self._call_cmd([BIN_CONVERT,self.params.url['path'], jpg_file])
-            self._call_cmd(["rm",self.params.url['path']])
-            #FIXME create logical separation between params and files created by the module
-            #FIXME add appropriate methods to the master class, to create temporary filenames, 
-            #to create appropriate output names
-            #FIXME add flask methods when you can
-            self.params.url = { 'path': jpg_file, 'mimetype': "jpg" }
+            self._files_created.append(jpg_file)
+            self._conversion_file = jpg_file
 
     def _first_conversion(self):
         if self.params.url['mimetype'] == self.params.breaktype:
-            self.params.url['path'] = self._conversion_file
+            self._conversion_file = self.params.url['path']
             return
         self._call_cmd([BIN_CONVERT, self.params.url['path'], self._conversion_file])
-        self.files_created.append(self._conversion_file)
+        self._files_created.append(self._conversion_file)
 
     def _prepare_filedata(self):
         if self.params.url['mimetype'] == "gif":
@@ -130,8 +129,8 @@ class PbBreak(Pb): #FIXME in db gallery
             self._rotate()
         self._enforce_jpg(); 
         self._first_conversion();
-        self.file_data = self._file_read(self._conversion_file)
-        if not self.file_data:
+        self._file_data = self._file_read(self._conversion_file)
+        if not self._file_data:
           self.err_warn("Unable to get file data");
    
     def _add_false_data(self, breakmode):
@@ -140,19 +139,19 @@ class PbBreak(Pb): #FIXME in db gallery
         elif breakmode == "extreme":
             self._extreme_break()
         f = open(self._conversion_file, 'w')
-        f.write(self.file_data)
+        f.write(self._file_data)
         f.close();
 
     def _final_conversion(self):
         self._call_cmd( [BIN_CONVERT, self._conversion_file, self.filepath])
         def psd_psbfilepath(num):
-            return os.path.join(self._working_dir, "{}-{}.{}".format(self.basename, num, self.params.finalformat))
+            return os.path.join(self._working_dir, "{}-{}-{}.{}".format(self.__class__.__name__, self._now, num, self.params.finalformat))
         if self.params.breaktype == 'psd':
             self._call_cmd(['mv', psd_psbfilepath(1), self.filepath])
-            self.files_created.append(psd_psbfilepath(0))
+            self._files_created.append(psd_psbfilepath(0))
         if self.params.breaktype == 'psb':
             self._call_cmd(['mv', psd_psbfilepath(0), self.filepath])
-            self.files_created.append(psd_psbfilepath(1))
+            self._files_created.append(psd_psbfilepath(1))
         if self.params.breakangle:
             self._rotate_back()
 
@@ -177,3 +176,4 @@ class PbBreak(Pb): #FIXME in db gallery
       b = cls(**TEST_PARAMS)
       b.create();
       print b.filepath
+      print b.params.finalformat
diff --git a/Pb/__init__.py b/Pb/__init__.py
index 0212235..edb7e1f 100644
--- a/Pb/__init__.py
+++ b/Pb/__init__.py
@@ -23,15 +23,16 @@ class Pb(object):
     self.commands = [];
     self._working_dir = WORKING_DIR
 
-  def _filename_create(self, url=None, namepart=""):
+  def _filename_create(self, url=None, namepart="", extension=""):
      if url:
         _basename = os.path.basename(url)
-        namepart = re.split(r'\.')[0]
-        namepart = self.params.sanitize(_namepart)[0:_max_filename_length]
+        namepart = re.split(r'\.', _basename)[0]
+        namepart = self.params.sanitize(namepart)[0:_max_filename_length]
      name = ""   
      if namepart: name += "%s-" % namepart 
      name += "%s_%s" % (self.__class__.__name__, self._now)
      if self.params.username : name += "_%s" % self.params.username 
+     if extension: name += ".%s" % extension
      return name
      
   def _filepath_create(self, filename, directory=WORKING_DIR):
@@ -39,16 +40,17 @@ class Pb(object):
 
   def _filename_filepath_create(self, url=None, namepart="", directory=WORKING_DIR):
      _filename = self._filename_create(url=url, namepart=namepart);
-     _filepath = _filename_create(_filename, directory=directory);
+     _filepath = self._filepath_create(_filename, directory=directory);
      return _filename, _filepath
 
-  def _tempfilepath_create(self, namepart="temp", directory=WORKING_DIR):
-     _filename = self._filename_create(namepart=namepart)
-     return _filepath_create(_filename, directory=directory)
+  def _tempfilepath_create(self, namepart="temp", directory=WORKING_DIR, extension=""):
+     _filename = self._filename_create(namepart=namepart, extension=extension)
+     return self._filepath_create(_filename, directory=directory)
 
-  def _call_cmd(self, cmd):
+  def _call_cmd(self, cmd):    
     try:
-      self.call_cmd(cmd)
+      cmd = map(lambda i: str(i), cmd)
+      call(cmd)
       self.commands.append(" ".join(cmd)); 
     except Exception:
       raise Exception("Unable to call cmd {}".format(str(cmd)))
@@ -72,6 +74,13 @@ class Pb(object):
       ident = (Popen([BIN_IDENTIFY, filepath], stdout=PIPE).communicate()[0]).split(" ")
       return ident[2].split("x")
 
+  def _width_and_height_set(self, filepath=None, width=DEFAULT_WIDTH, height=DEFAULT_HEIGHT):
+    if filepath:
+      self.width, self.height = Pb.dimensions(filepath)
+      return
+    self.width = width
+    self.height = height
+
   @staticmethod
   def file_size (filepath):
       try: