11 files changed, 1295 insertions, 0 deletions

diff --git a/lib/Pb/Break/__init__.py b/lib/Pb/Break/__init__.py
new file mode 100755
index 0000000..cf12cc2
--- /dev/null
+++ b/lib/Pb/Break/__init__.py
@@ -0,0 +1,169 @@
+#!/usr/bin/python2.7
+import os
+import sys
+import random
+import re
+import urllib
+import inspect
+from Config import *
+from Pb import Pb
+from Params import Params
+
+DEFAULT_FINALFORMAT = "png";
+
+_subtle_break_mark = 'pron'
+_extreme_break_mark = 'sugar'
+
+_header_offset = 2000
+_default_breakmode = "subtle"
+
+class PbBreak(Pb): #FIXME in db gallery
+    example_params = {
+        "url" : "http://i.asdf.us/im/de/HolyMountain2_1322275112_seamonkey.gif",
+        "breaktype" : "RGB_WASH",
+        "finalformat" : "png",
+        "breakmode" : "extreme",
+        "breakangle" : "10",
+        "username" : "donkey",
+        "expanded" : "false"
+    }
+    def __init__(self, **kwargs):
+        super(PbBreak,self).__init__();
+        _definitions = {
+          'username': { 'type': 'string' },
+          'breaktype': { 'type': 'string' },
+          'breakmode': {
+            'type': 'enum',
+            'enum_values' : ['subtle', 'extreme', 'gradual'] ,
+            'default' : _default_breakmode 
+           },
+          'breakangle': { 'type': 'float' },
+          'expanded': { 'type': 'bool' },
+          'url': { 'type': 'img_url' },
+          'finalformat': { 'type': 'enum', 'enum_values' : ['png', 'gif', 'jpg' ] }
+        }
+        self.params.definitions_import(_definitions, kwargs, classname=self.__class__.__name__);
+        self._files_created.append(self.params.url.path)
+        self.params.breaktype.set_val(self._get_breaktype(str(self.params.breaktype)))
+        
+        #psd returns an animation
+        if not self.params.finalformat and self.params.url.mimetype == "gif":
+          self.params.finalformat.set_val("gif")
+        elif self.params.breaktype == 'miff':
+          self.params.finalformat.set_val("jpg")
+          self.params.breakmode.set_val("subtle")
+        elif not self.params.finalformat:
+          self.params.finalformat.set_val(DEFAULT_FINALFORMAT)  
+        self._width_and_height_set(filepath=self.params.url.path)       
+
+        self.filename, self.filepath = self._filename_filepath_create(url=self.params.url.url, extension=self.params.finalformat)
+        self._conversion_file = self._tempfilepath_create(namepart="conversion", extension=self.params.breaktype)
+
+    def _get_breaktype(self, key):
+        #{{{ conversion table
+        breaktypeTranslate = {
+            'CLASSIC':'jpg',
+            'REDUX':'pcds',
+            'BLURRY_BREAK':'viff',
+            'BLURRY_BREAK_2':'mat',
+            'SWIPE':'miff',
+            'RGB_WASH':'psd',
+            'RGB_WASH_2':'psb',
+            'NOISY_BREAK':'palm',
+            'NOISY_BREAK_2':'fig',
+            'BROKEN_VIGNETTE':'pbm',
+            'FAX_MACHINE':'cals',
+            'STRIPES':'exr',
+            'PHOTOCOPY':'art',
+        }
+        #}}}
+        return breaktypeTranslate[key]
+
+#{{{#########rotatefunctions#######################################  
+    def _rotate(self):
+        cmd = [BIN_CONVERT,self.params.url.path,"-rotate",self.params.breakangle,"+repage",self.params.url.path]
+        self._call_cmd(cmd) 
+
+    def _rotate_back(self):
+        angle = str(360-int(self.params.breakangle))
+        cmd = [BIN_CONVERT,self.filepath,"-rotate",angle,"+repage",self.filepath]
+        self._call_cmd(cmd) 
+        if not self.params.expanded:
+            cmd = [BIN_CONVERT,self.filepath,"-gravity","Center","-crop","{}x{}+0+0".format(
+                self.width, self.height),"+repage",self.filepath]
+            self._call_cmd(cmd) 
+#}}}
+
+    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] \
+          + _subtle_break_mark \
+          + self._file_data[breakpoint:]
+        self._file_data = newfile[0:len(self._file_data)]
+
+    def _extreme_break(self):
+        increment = len(self._file_data)/10;
+        i = 0
+        newfile = "";
+        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)]
+
+     
+    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._tempfilepath_create(extension="jpg")
+            self._call_cmd([BIN_CONVERT,self.params.url.path, jpg_file])
+            self._files_created.append(jpg_file)
+            self._conversion_file = jpg_file
+
+    def _first_conversion(self):
+        if self.params.url.mimetype == self.params.breaktype:
+            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)
+
+    def _prepare_filedata(self):
+        if self.params.url.mimetype == "gif" and self.params.breaktype not in [ 'mat', 'psd' ]: 
+            self._choose_gif_frame(self.params.url.path)
+        if self.params.breakangle:
+            self._rotate()
+        self._enforce_jpg(); 
+        self._first_conversion();
+        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):
+        if self.params.breakmode == "subtle":
+            self._subtle_break()
+        elif self.params.breakmode == "extreme":
+            self._extreme_break()
+        f = open(self._conversion_file, 'w')
+        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(re.sub(r'\.', "-%s." % num, self.filepath))
+        if str(self.params.breaktype) == 'psd':
+            self._call_cmd(['mv', psd_psbfilepath(1), self.filepath])
+            self._files_created.append(psd_psbfilepath(0))
+        if str(self.params.breaktype) == 'psb':
+            self._call_cmd(['mv', psd_psbfilepath(0), self.filepath])
+            self._files_created.append(psd_psbfilepath(1))
+        if self.params.breakangle:
+            self._rotate_back()
+
+    def create(self):
+        self._prepare_filedata();
+        self._add_false_data();
+        self._final_conversion() 
+        self._cleanup()
+
diff --git a/lib/Pb/Break/__init__.py~ b/lib/Pb/Break/__init__.py~
new file mode 100755
index 0000000..c1064e2
--- /dev/null
+++ b/lib/Pb/Break/__init__.py~
@@ -0,0 +1,205 @@
+#!/usr/bin/python2.7
+import os
+import sys
+import random
+import re
+import urllib
+import inspect
+from Config import *
+from Pb import Pb
+from Pb.Params import Params
+
+DEFAULT_FINALFORMAT = "png";
+SUBTLE_BREAK_MARK = 'pron'
+EXTREME_BREAK_MARK = 'sugar'
+
+HEADER_OFFSET = 2000
+
+class Breaker(Pb):
+    def __init__(self, url=None, breaktype=None, finalformat=DEFAULT_FINALFORMAT, 
+        breakmode=None, breakangle=None, username=None, expanded=None, firsttime=None):
+        super(Breaker,self).__init__();
+         
+        self.params.breaktype = self._get_breaktype(breaktype);
+        self.params.url = url
+        
+        _frame = inspect.currentframe(); 
+        _args_vals = inspect.getargvalues(_frame);
+        for arg in _args_vals.args:
+          if arg == "self":
+            continue
+          sys.stderr.write(str(arg) + "\n")
+          try:
+            if arg not in ['breaktype', 'url']:
+              sys.stderr.write("Yoooo"); 
+              sys.stderr.write(arg)
+              strarg = str(_args_vals.locals.get(arg))
+              django self.bool_correct(strarg)
+              self.params.__setattr__("dingo", django)
+#              self.params.__setattr__(arg, self.bool_correct(_args_vals.locals.get(arg)))
+          except Exception as e:
+            sys.stderr.write("\n"+str(e)+"\n") 
+        sys.exit(1);
+        self.params = Params(**self.params);
+ 
+        self.tag = "imBreak"
+        self.commands = [];
+        self._now = self.now()
+        self.files_created = []
+
+        self.basename, self._first_format = self._get_filename_and_type_from_url();
+        self._downloaded_file = self.tempname_create(basename=self.basename, fmt=self._first_format) 
+
+        try:
+            self.download(self.params.url, self._downloaded_file)
+            self.files_created.append(self._downloaded_file)
+        except Exception as e:
+            self.err_warn(str(e))
+
+        self._gif_frames = self.gif_frames(self._downloaded_file)
+        self._gif_frames = self._gif_frames if len(self._gif_frames) > 1 else False
+        self.width, self.height = self.dimensions(self._downloaded_file) # same here
+        
+        if not self.params.finalformat and self._gif_frames:
+            self.params.finalformat = 'gif'
+        if self.params.breaktype == 'miff':
+            self.params.finalformat = 'jpg'
+            self.params.breakmode = 'subtle'
+        #final filepath is stored in self.filepath
+        self.filename = "{}.{}".format(self.basename, self.params.finalformat)
+        self.filepath = os.path.join(self._working_dir, self.filename) 
+        self._conversion_file = self.tempname_create(basename=self.basename, fmt=self.params.breaktype); 
+
+    def _call_cmd(self, cmd):
+        super(Breaker,self)._call_cmd(cmd, error)
+        self.commands.append(" ".join(cmd)); 
+    
+    def _get_breaktype(self, key):
+        #{{{ conversion table
+        breaktypeTranslate = {
+            'CLASSIC':'jpg',
+            'REDUX':'pcds',
+            'BLURRY_BREAK':'viff',
+            'BLURRY_BREAK_2':'mat',
+            'SWIPE':'miff',
+            'RGB_WASH':'psd',
+            'RGB_WASH_2':'psb',
+            'NOISY_BREAK':'palm',
+            'NOISY_BREAK_2':'fig',
+            'BROKEN_VIGNETTE':'pbm',
+            'FAX_MACHINE':'cals',
+            'STRIPES':'exr',
+            'PHOTOCOPY':'art',
+        }
+        #}}}
+        return breaktypeTranslate[key]
+
+#{{{#########rotatefunctions#######################################  
+    def _rotate(self):
+        cmd = [BIN_CONVERT,self._downloaded_file,"-rotate",self.params.breakangle,"+repage",self._downloaded_file]
+        self._call_cmd(cmd) 
+
+    def _rotate_back(self):
+        angle = str(360-int(self.params.breakangle))
+        cmd = [BIN_CONVERT,self.filepath,"-rotate",angle,"+repage",self.filepath]
+        self._call_cmd(cmd) 
+        if not self.params.expanded:
+            cmd = [BIN_CONVERT,self.filepath,"-gravity","Center","-crop","{}x{}+0+0".format(
+                self.width, self.height),"+repage",self.filepath]
+            self._call_cmd(cmd) 
+#}}}
+    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] \
+          + SUBTLE_BREAK_MARK \
+          + self.file_data[breakpoint:]
+        self.file_data = newfile[0:len(self.file_data)]
+
+    def _extreme_break(self):
+        increment = len(self.file_data)/10;
+        i = 0
+        newfile = "";
+        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)]
+
+    def _choose_frame(self):
+       frame = random.choice(self._gif_frames)
+       self._call_cmd([BIN_CONVERT, frame, self._downloaded_file])
+            
+    def _enforce_jpg(self):
+        if self.params.breaktype in [ "exr", "bmp", "miff" ] and not re.match(r'jpe?g$', self._first_format, re.IGNORECASE):
+            jpg_file = self.tempname_create(basename=self.basename, fmt="jpg") 
+            self._call_cmd([BIN_CONVERT,self._downloaded_file,jpg_file])
+            self._call_cmd(["rm",self._downloaded_file])
+            self._downloaded_file = jpg_file
+
+    def _first_conversion(self):
+        if self._first_format == self.params.breaktype:
+            self._downloaded_file = self._conversion_file
+            return
+        self._call_cmd([BIN_CONVERT, self._downloaded_file, self._conversion_file])
+        self.files_created.append(self._conversion_file)
+
+    def _prepare_filedata(self):
+        if self._gif_frames:
+            self._choose_frame()
+        if self.params.breakangle:
+            self._rotate()
+        self._enforce_jpg(); 
+        self._first_conversion();
+        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):
+        if breakmode == "subtle":
+            self._subtle_break()
+        elif breakmode == "extreme":
+            self._extreme_break()
+        f = open(self._conversion_file, 'w')
+        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))
+        if self.params.breaktype == 'psd':
+            self._call_cmd(['mv', psd_psbfilepath(1), self.filepath])
+            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))
+        if self.params.breakangle:
+            self._rotate_back()
+
+    def _cleanup(self):
+        cmd = ["rm"]+self.files_created
+        self._call_cmd(cmd)
+
+    def create(self, breakmode=""):
+        if not breakmode: breakmode = self.params.breakmode
+        self._prepare_filedata();
+        self._add_false_data(breakmode);
+        self._final_conversion() 
+        self._cleanup()
+
+    @classmethod
+    def test(cls):
+      TEST_PARAMS = {
+          "url" : "http://i.asdf.us/im/27/1424816234661dumpfmpfifferkinggr_1424816412_pfifferking.gif" ,
+          "breaktype" : "RGB_WASH",
+          "finalformat" : "png",
+          "breakmode" : "extreme",
+          "breakangle" : "10",
+          "username" : "donkey",
+          "expanded" : "false"
+      }
+      b = cls(**TEST_PARAMS)
+      b.create();
+      print b.filepath
diff --git a/lib/Pb/Generate/__init__.py b/lib/Pb/Generate/__init__.py
new file mode 100755
index 0000000..e50e514
--- /dev/null
+++ b/lib/Pb/Generate/__init__.py
@@ -0,0 +1,138 @@
+#!/usr/bin/python2.7
+import sys
+import os
+from Config import *
+from Pb import Pb
+_default_tag = "im"
+
+_gravity_params = ["NorthWest","North","NorthEast","West","Center","East","SouthWest","South","SouthEast"]
+_gravity_default = "Center"
+_compose_params = [ "Over", "ATop", "Dst_Over", "Dst_In", "Dst_Out", "Multiply", 
+  "Screen", "Divide", "Plus", "Difference", "Exclusion",
+  "Lighten", "Darken", "Overlay", "Hard_Light", "Soft_Light", 
+  "Linear_Dodge", "Linear_Burn", "Color_Dodge", "Color_Burn" ]
+_dispose_params = ["None","Previous","Background"]
+_dispose_default = "None"
+class PbGenerate(Pb):
+    example_params = {
+#{{{ example params
+     'nearest': 'true',
+  #   'height': None,
+     'compose': 'Soft_Light',
+     'coalesce': 'true',
+     'dispose': 'None',
+     'gravity': 'Center',
+     'width': '200',
+     'black': 'black',
+     'tile': 'true',
+     'white': 'white',
+     'contrast': '100',
+     'hue': '90',
+     'saturation': '100',
+     'merge_early': 'true',
+     'format': 'gif',
+     'background': 'http://i.asdf.us/im/bc/new_1430440747.gif',
+     'subtract': '#EE7AE9',
+     'transparent': 'true',
+  #   'rotate': None,
+     'name': 'yo',
+  #   'brightness': None,
+     'url': 'http://asdf.us/im/new.gif',
+     'flop': 'true',
+     'flip': 'false',
+     'callback': 'jsonp1430442384162',
+     'fuzz': '5'
+#}}}
+    }
+    def __init__(self, **kwargs):  
+      super(PbGenerate,self).__init__();
+      _definitions = { 
+        #IMAGES
+        "url": { 'type': "img_url" },
+        "background": { 'type': "img_url" },
+
+        #BOOLS
+        "coalesce": { 'type': "bool" },
+        "nearest": { 'type': "bool" },
+        "merge_early": { 'type': "bool" },
+        "flip": { 'type': "bool" },
+        "flop": { 'type': "bool" },
+        "tile": { 'type': "bool" },
+        "transparent": { 'type': "bool" },
+
+        #COLORS
+        "black": { 'type': "color", 'default': 'black' },
+        "white": { 'type': "color", 'default': 'white' },
+        "subtract": { 'type': "color" },
+
+        #INTS
+        "fuzz": { 'type': "int" },
+        "width": { 'type': "int" },
+        "height": { 'type': "int" },
+        "brightness": { 'type': "int" },
+        "contrast": { 'type': "int" },
+        "saturation": { 'type': "int" },
+        "rotate": { 'type': "int" },
+        "hue": { 'type': "int" },
+        
+        #ENUMS
+        "compose": { 'type': "enum", 'enum_values': _compose_params, 'default': "Atop" },
+        "gravity": { 'type': "enum", 'enum_values': _gravity_params, 'default': _gravity_default },
+        "dispose": { 'type': "enum", 'enum_values': _dispose_params, 'default': "None" },
+        "format": { 'type': "enum", 'enum_values': OUTPUT_IMAGE_TYPES, 'default': DEFAULT_FINALFORMAT },
+
+        #STRINGS
+        "username": { 'type': "string" },
+        "callback": { 'type': "string" },
+      }
+      self.tag = _default_tag
+      self.params.definitions_import(_definitions, kwargs, classname=self.__class__.__name__);
+      if self.params.background: self.tag = self.params.compose 
+      if self.params.transparent: self.tag = self.params.transparent
+
+      self.filename, self.filepath = self._filename_filepath_create(url=self.params.url['url'], extension=self.params.format)
+
+    def _composite (self):
+      cmd = [
+        BIN_CONVERT, self.params.background['path'], 
+        "null:", self.filepath, "-matte",
+        "-dispose", self.params.dispose,
+        "-gravity", self.params.gravity,
+        "-compose", self.params.compose, "-layers", "composite",
+        self.filepath ]
+      self._call_cmd(cmd);
+
+    def _convert(self):
+      cmd = [BIN_CONVERT, self.params.url['path'] ]
+      if self.params.rotate: cmd += ["-rotate", self.params.rotate ]
+      if self.params.flip: cmd += ["-flip"]    
+      if self.params.flop: cmd += ["-flop"]    
+      if self.params.transparent: 
+        if self.params.fuzz: 
+          cmd += ["-fuzz", "{}%".format(self.params.fuzz) ]
+        cmd += [ "-transparent", self.params.subtract ] 
+      if self.params.width or self.params.height:
+        if self.params.nearest and self.params.format == "gif":
+            cmd += [ "-coalesce","+map","-interpolate","Nearest","-interpolative-resize" ]
+        else:
+          cmd.append("-resize")
+        cmd += [ "{}x{}".format(self.params.width or "", self.params.height or "") ]
+      if self.params.black != "black" or self.params.white != 'white':
+         cmd += [ "+level-colors" , "{},{}".format(self.params.black, self.params.white) ] 
+      if self.params.contrast: cmd += [ '-contrast-stretch', self.params.contrast ] 
+      if self.params.brightness or self.params.saturation or self.params.hue:
+         cmd += [ 
+           "-modulate", "{},{},{}".format( 
+             (self.params.brightness or 100),
+             (self.params.contrast or 100),
+             (self.params.hue or 100)
+           )] 
+      cmd.append("-coalesce"); #why? #FIXME
+      cmd += [ self.filepath ];
+      self._call_cmd(cmd);
+    
+    def create(self):
+      self._convert()
+      if self.params.background:
+        self._composite()
+      self._cleanup();
diff --git a/lib/Pb/Gradient/__init__.py b/lib/Pb/Gradient/__init__.py
new file mode 100755
index 0000000..00adbf1
--- /dev/null
+++ b/lib/Pb/Gradient/__init__.py
@@ -0,0 +1,183 @@
+#!/usr/bin/python2.7

+import re

+import time

+from subprocess import call 

+import simplejson as json

+import sys

+import os

+import sha

+from Config import *

+from Pb import Pb

+

+_default_color_1 = "white"

+_default_color_2 = "black"

+

+_default_bevel_percent = "12";

+

+_halftone_values = {

+    "checkeredfade": "h6x6a",

+    "etchedtransition": "o8x8",

+    "bendaydots": "h16x16o",

+    "smallerdots1": "h8x8o",

+    "smallerdots2": "c7x7w",

+    "flatstripes": "o2x2",

+}

+

+class PbGradient(Pb):

+    example_params = {

+      "width" : "200",

+      "color1" : "#ffdead",

+      "color2" : "blue",

+      "stripes" : "true",

+      "stripenumber" : "20",

+      "gradienttype" : "radial",

+      "stripeintensity" : "20",

+      "halftone" : "checkeredfade",

+      "percentbeveled" : "30",

+      "flip" : "true",

+      "bevel" : "flatinner",

+      "rotate" : "20",

+      "height" : "200",

+      "filetype" : "jpg",

+      "username" : "whatever"

+    }

+    def __init__(self, **kwargs):

+        super(PbGradient,self).__init__();

+        _definitions = {

+          'width': { 'type':'int', 'default': DEFAULT_WIDTH },

+          'height': { 'type':'int', 'default' : DEFAULT_HEIGHT },

+          'color1': { 'type':'color', 'default': _default_color_1 },

+          'color2': { 'type':'color', 'default': _default_color_2 },

+          'stripes': { 'type':'bool' },

+          'stripenumber': { 'type':'int', 'default': 0 },

+          'stripeintensity': { 'type':'int', 'default': 0 },

+          'blurriness': { 'type':'int', 'default': 0 },

+          'contrast': { 'type':'int', 'default': 100 },

+          'brightness': { 'type':'int', 'default': 100 },

+          'saturation': { 'type':'int', 'default': 100 },

+          'hue': { 'type':'int', 'default': 100 },

+          'halftone': { 'type':'enum', 'enum_values' : [

+            'checkeredfade', 'etchedtransition', 'bendaydots',

+            'smallerdots1', 'smallerdots2', 'flatstripes',

+          ] },

+          'bevel': { 'type':'enum', 'enum_values' : [

+            'flatout', 'flatinner', 'evenlyframed', 'biginner',

+            'bigouter', 'dramaticflatout', 'dramaticflatinner',

+          ] },

+          'percentbeveled': { 'type':'int', 'default': _default_bevel_percent },

+          'tilt': { 'type':'int' },

+          'rotate': { 'type':'int' },

+          'flip': { 'type':'bool' },

+          'flop': { 'type':'bool' },

+          'filetype': { 'type':'enum', 'enum_values' : OUTPUT_IMAGE_TYPES, 'default': DEFAULT_FINALFORMAT },

+          'gradienttype': { 'type':'enum', 'enum_values' : [

+            'default', 'canvas', 'radial',  'colorspace',  

+            'mirrored',  'plasmawash',  'gradientwash',  'noise'

+          ], 'default': 'default' },

+          'username': { 'type':'string' }

+        }

+        self.params.definitions_import(_definitions, kwargs, classname=self.__class__.__name__);

+

+        self.filename, self.filepath = self._filename_filepath_create()

+

+    def _filename_create(self, **kwargs):         

+        _base = "{}{}-{}_{}".format(

+           self.__class__.__name__, 

+           str(self.params.color1).replace('#','').replace('(','-').replace(')','-'),

+           str(self.params.color2).replace('#','').replace('(','-').replace(')','-'),

+           self._now,                                         

+        )

+        if self.params.username: _base += "_%s" % self.params.username

+        return _base + ".%s" % self.params.filetype

+

+

+    def _build_cmd(self):

+        cmd = [BIN_CONVERT]

+        cmd.extend([

+            '-size',

+            "{}x{}".format(self.params.width,self.params.height)

+        ])

+        

+        if self.params.rotate: cmd.extend(["-rotate", self.params.rotate])         

+        if self.params.tilt: cmd.extend(["-distort","SRT",self.params.tilt])

+        if self.params.flip == "true": cmd.append("-flip")

+        if self.params.flop == "true": cmd.append("-flop")

+        if self.params.contrast: cmd.extend(["-contrast-stretch", self.params.contrast])

+        _gradients = {

+            "default" : "gradient:{}-{}".format(self.params.color1, self.params.color2),

+            "canvas" : ["canvas:{}".format(self.params.color1)],

+            "radial" : [

+                "radial-gradient:{}-{}".format( self.params.color1, self.params.color2)

+                ],

+            "colorspace" : [

+                "-colorspace",

+                "Gray",

+                "plasma:{}-{}".format(self.params.color1, self.params.color2)

+            ],

+            "mirrored" : [

+                "plasma:{}-{}".format(self.params.color1, self.params.color2),

+                 "\(","+clone","-flop","\)",

+                 "append"

+            ],

+            "plasmawash" : [

+                "plasma:{}-{}".format(self.params.color1, self.params.color2),

+                "-set","colorspace","HSB"

+            ],

+            "gradientwash" : [

+                "gradient:{}-{}".format(self.params.color1, self.params.color2),

+                "-set","colorspace","HSB"

+            ],

+            "noise" : ["xc:","+noise","Random","-virtual-pixel","tile"]

+            }

+        cmd += _gradients[str(self.params.gradienttype)]

+            

+        if self.params.blurriness: 

+            cmd.extend(["-blur","0x{}".format(self.params.blurriness),"-auto-level"])

+        

+        if self.params.stripes == "true" and len(self.params.stripenumber):

+            cmd.extend(["-function","Sinusoid"])

+            if self.params.stripeintensity:  

+                cmd.append("{},{}".format(self.params.stripenumber,self.params.stripeintensity))

+            else:

+                cmd.append(self.params.stripenumber)

+        if str(self.params.halftone) in _halftone_values: 

+            cmd.extend([

+                "-ordered-dither", 

+                _halftone_values[str(self.params.halftone)]

+            ])

+        cmd += [ 

+            '-modulate', 

+            "{},{},{}".format(

+            self.params.brightness or "100",

+            self.params.saturation or "100",

+            self.params.hue or "100")

+        ]

+        cmd.append(self.filepath);

+        self._call_cmd(cmd)

+        if self.params.bevel: self._make_bevel()

+

+    def _get_bevelvalue(self):

+        w, h = map(int, (self.params.width, self.params.height))

+        if h >= w:

+            bevpercentval = str(int(self.params.percentbeveled)*0.005*int(h))

+        else:

+            bevpercentval = str(int(self.params.percentbeveled)*0.005*int(w))

+        return {

+            "flatout": ["-s",bevpercentval,"-m","outer"],

+            "flatinner": ["-s",bevpercentval,"-m","inner"],

+            "evenlyframed": ["-s ",bevpercentval,"-m", "split"],

+            "biginner": ["-s",bevpercentval,"-m","outer","-c","50","-b","red","-a","25"],

+            "bigouter": ["-s",bevpercentval,"-m","split","-c","50","-b","red","-a","25"],

+            "dramaticflatout": ["-s",bevpercentval,"-m","outer","-a","25","-b","blue"],

+            "dramaticflatinner": ["-s",bevpercentval,"-m","outer","-a","25","-b","blue"],

+        }[str(self.params.bevel)]

+

+    def _make_bevel(self):

+        cmd = [BEVELBORDER]

+        cmd += self._get_bevelvalue() 

+        cmd += [ self.filepath, self.filepath]

+        self._call_cmd(cmd)

+

+    def create(self):

+        self._build_cmd()

+

diff --git a/lib/Pb/Grid/__init__.py b/lib/Pb/Grid/__init__.py
new file mode 100755
index 0000000..2f7ae4b
--- /dev/null
+++ b/lib/Pb/Grid/__init__.py
@@ -0,0 +1,159 @@
+import sys
+import re
+import os
+import simplejson as json
+import random
+from Config import DEFAULT_FINALFORMAT, DEFAULT_HEIGHT, DEFAULT_WIDTH, WORKING_DIR, OUTPUT_IMAGE_TYPES
+from Config import THREEDROTATE, GRID, BIN_CONVERT, BIN_COMPOSITE
+import tempfile
+from Pb import Pb
+
+_default_line_color = "silver"
+
+class PbGrid(Pb):
+    example_params = {
+      'bgimage' : 'http://i.asdf.us/im/1a/imBreak_1424909483_xx_abridged___.gif',
+      'planebgimage' : 'http://i.imgur.com/FICZtph.png',
+      'tilt' : '30',
+      'spacing' : '30',
+      'hlines' : 'true',
+      'roll' : '30',
+      'shadow' : 'true',
+      'trim' : 'true'
+    }
+    def __init__(self, **kwargs ):
+        super(PbGrid,self).__init__();
+        _definitions = { 
+          'width': { 'type':'int' },
+          'height': { 'type':'int' },
+          'linethickness': { 'type':'int', 'default': 1 },
+          'opacity': { 'type':'float', "default": 1.0 },
+          'linecolor': { 'type':'color', 'default': 'whitesmoke' },
+          'linethickness': { 'type':'int' },
+          'spacing': { 'type':'int', 'default': 10 },
+          'vlines': { 'type':'bool' },
+          'hlines': { 'type':'bool' },
+          'shadow': { 'type':'bool' },
+          'bgimage': { 'type':'img_url' },
+          'bgcolor': { 'type':'color', 'default': 'transparent' },
+          'imageinstead': { 'type':'img_url' },
+          'planebgcolor': { 'type':'color', 'default': 'transparent' },
+          'planebgimage': { 'type':'img_url' },
+          'swing': { 'type':'int' },
+          'tilt': { 'type':'int' },
+          'roll': { 'type':'int' },
+          'zoom': { 'type':'int' },
+          'skycolor': { 'type':'color', 'default': 'transparent' },
+          'transition': { 'type':'enum', 'enum_values' : ['background', 'dither', 'edge', 'mirror', 'random', 'tile'], 'default': 'background' },
+          'trim': { 'type':'bool' },
+          'finalformat': { 'type':'enum', 'enum_values' : OUTPUT_IMAGE_TYPES, 'default': DEFAULT_FINALFORMAT },
+          'username': { 'type':'string' },
+        }
+        self.params.definitions_import(_definitions, kwargs, classname=self.__class__.__name__);
+        if self.params.imageinstead:
+          self.filename, self.filepath = self._filename_filepath_create(url=self.params.imageinstead['url'], extension=self.params.finalformat)
+        elif self.params.planebgimage:
+          self.filename, self.filepath = self._filename_filepath_create(url=self.params.planebgimage['url'], extension=self.params.finalformat)
+        else:
+          self.filename, self.filepath = self._filename_filepath_create(extension=self.params.finalformat)
+
+    #makes a canvas file...step 1 (if not bgimage)
+    def _make_canvas(self):
+        dimensions = "{}x{}".format(
+            self.params.width or DEFAULT_WIDTH, 
+            self.params.height or DEFAULT_HEIGHT
+        )
+        if self.params.bgimage:
+            return 
+        bgcolor = "xc:{}".format(self.params.bgcolor or 'transparent')
+        cmd = [ BIN_CONVERT, "-size", dimensions, bgcolor, self.filepath ]
+        self._call_cmd(cmd)
+
+    #2nd step-- run grid
+    def _grid_command(self):
+        cmd = [GRID]
+        if self.params.spacing:
+            if self.params.vlines:
+                width = 2 * int(self.params.width or DEFAULT_WIDTH)
+                cmd += ["-s","{},{}".format(self.params.spacing,width)]
+            elif self.params.hlines:
+                height = 2 * int(self.params.height or DEFAULT_HEIGHT)
+                cmd += ["-s", "{},{}".format(height,self.params.spacing)]
+            else:
+                cmd += ["-s",self.params.spacing]
+        cmd += [ "-c", self.params.linecolor or _default_line_color]
+        if self.params.linethickness: cmd += ['-t',self.params.linethickness]
+        if self.params.opacity: cmd += ['-o',self.params.opacity]
+        cmd += [ self.filepath, self.filepath ]
+        self._call_cmd(cmd)
+    
+    def _shadow_cmd(self):
+    #convert 1.png \( +clone -background black -shadow 110x1+9+9 \) +swap -background none -layers merge +repage 2.png
+        cmd = [
+            BIN_CONVERT,
+            self.filepath,
+            "(","+clone","-background","black","-shadow","100x2+20+10",")",
+            "+swap","-background","none","-layers","merge","+repage" ,
+            self.filepath
+        ]
+        self._call_cmd(cmd)
+            
+    
+    def _threed_rotate_cmd (self):
+    #3rd step--run 3Drotate
+        cmd = [THREEDROTATE]
+        if self.params.swing: cmd += ["pan={}".format(self.params.swing)]
+        if self.params.tilt: cmd += ["tilt={}".format(self.params.tilt)]
+        if self.params.roll: cmd += ["roll={}".format(self.params.roll)]
+        if self.params.zoom: 
+            cmd += ["zoom={}".format(self.params.zoom)]
+        if cmd == [THREEDROTATE]: #if nothing has been added
+            return
+        if self.params.planebgcolor and not self.params.planebgimage:
+            cmd += ["bgcolor={}".format(self.params.planebgcolor)]
+        else:
+            cmd += ["bgcolor=none"]
+        cmd += ["skycolor={}".format(self.params.skycolor or 'none')]
+        if self.params.transition: cmd += ["vp={}".format(self.params.transition)]
+        cmd += [ self.filepath, self.filepath ]
+        self._call_cmd(cmd)
+
+
+    def _trim_cmd (self):
+        cmd = [BIN_CONVERT, self.filepath, "-trim", "+repage", self.filepath]
+        self._call_cmd(cmd)
+    
+    def _prepare_gridimage(self, image):
+        if image['mimetype'] == 'gif':
+          _frame = self._choose_gif_frame(image['path'])
+        if image['mimetype'] != 'png':
+            cmd = [BIN_CONVERT, image['path'], self.filepath]
+        else:
+            cmd = ['cp', image['path'], self.filepath]
+        self._call_cmd(cmd)
+
+    
+    def _overlay_planebgimage(self):
+        cmd = [ 
+            BIN_COMPOSITE,
+            "-compose", "Dst_Over", "-gravity", "center", 
+            self.params.planebgimage["path"], 
+            self.filepath,
+            self.filepath
+        ]
+        self._call_cmd(cmd)
+             
+    def create(self):
+        if self.params.bgimage:
+            self._prepare_gridimage(self.params.bgimage)
+            self._grid_command()
+        elif self.params.imageinstead:
+            self._prepare_gridimage(self.params.imageinstead)
+        else:
+            self._make_canvas()
+            self._grid_command()
+        if self.params.shadow: self._shadow_cmd()
+        self._threed_rotate_cmd()
+        if self.params.planebgimage: self._overlay_planebgimage()
+        if self.params.trim: self._trim_cmd() 
+        self._cleanup()
diff --git a/lib/Pb/Landscape/__init__.py b/lib/Pb/Landscape/__init__.py
new file mode 100755
index 0000000..33eedd6
--- /dev/null
+++ b/lib/Pb/Landscape/__init__.py
@@ -0,0 +1,48 @@
+from Config import *
+import Pb
+import base64
+from Pb import Pb
+import urlparse, re
+
+class PbLandscape(Pb):
+    example_params = {
+      'imgdata' : open('Pb/Landscape/_base64img', 'rb').read(),
+      'texture' : 'http://someurl.biz/someimg.jpg',
+      'heightmap' : 'http://someurl.biz/someimg.jpg',
+      'name' : 'donkey'
+    }
+    def __init__(self, **kwargs):
+      super(PbLandscape,self).__init__();
+      _definitions = {
+        'heightmap': {'type': 'string'} ,
+        'imgdata': {'type': 'raw' } ,
+        'texture': {'type': 'string' } ,
+        'username': {'type': 'string'} ,
+      }
+      self.params.definitions_import(_definitions, kwargs, classname=self.__class__.__name__);
+      _namepart = re.sub(r'https?:?/?/?', '', str(self.params.texture))
+      self.filename, self.filepath = self._filename_filepath_create(url=_namepart, extension="png")
+
+    def _saveImgData(self):
+      try:
+        up = urlparse.urlparse(str(self.params.imgdata))
+        head, data = up.path.split(',', 1)
+        bits = head.split(';')
+        mime_type = bits[0] if bits[0] else 'text/plain'
+        charset, b64 = 'ASCII', False
+        for bit in bits[1]:
+            if bit.startswith('charset='):
+                charset = bit[8:]
+            elif bit == 'base64':
+                b64 = True
+
+        # Do something smart with charset and b64 instead of assuming
+        plaindata = base64.b64decode(data)
+
+        with open(self.filepath, 'wb') as f:
+            f.write(plaindata)
+      except Exception as e:
+        self.err_warn(str(e));
+
+    def create(self, breakmode=""):
+        self._saveImgData();
diff --git a/lib/Pb/Landscape/_base64img b/lib/Pb/Landscape/_base64img
new file mode 100644
index 0000000..bb7e093
--- /dev/null
+++ b/lib/Pb/Landscape/_base64img
@@ -0,0 +1 @@
+data:image/png;base64,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
\ No newline at end of file
diff --git a/lib/Pb/Landscape/landscape b/lib/Pb/Landscape/landscape
new file mode 100755
index 0000000..10e8ede
--- /dev/null
+++ b/lib/Pb/Landscape/landscape
@@ -0,0 +1,163 @@
+#!/usr/bin/python2.7
+import cgi
+import sys
+import os
+import re
+import time
+import string
+import urllib
+from subprocess import Popen, PIPE
+import sha
+import simplejson as json
+
+import mimetypes
+import s3
+
+import db
+DB = db.db ()
+
+import base64
+import urlparse
+
+
+AWS_ACCESS_KEY_ID = 'AKIAIR53VPBXKJMXZIBA'
+AWS_SECRET_ACCESS_KEY = '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'
+BUCKET_NAME = 'i.asdf.us'
+BASE_PATH = "/var/www/asdf.us/httpdocs/imlandscape"
+BASE_URL = "http://i.asdf.us/" 
+PARAM_LIST = "heightmap texture name imgdata filename"
+BIN_IDENTIFY = "/usr/bin/identify"
+
+print "Content-type: text/plain"
+print ""
+def insert_cmd (dir, newfile, name, texture, dataobj):
+  if texture == "":
+    texture = "NULL"
+  try:
+    sql = "INSERT INTO im_cmd (date,remote_addr,name,url,dir,oldfile,newfile,cmd, dataobj, tag) VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s, %s)"
+    
+    args = (now(), "NULL", name, texture, dir, "NULL", newfile, "NULL", dataobj, "imlandscape")
+    DB.execute(sql, args)
+  except ():
+    return
+
+def hash_dir (s):
+  return sha.new(s).hexdigest()[:2]
+
+def bin_identify (filename):
+  ident = Popen([BIN_IDENTIFY, filename], stdout=PIPE).communicate()[0]
+  partz = ident.split(" ")
+  width,height = partz[2].split("x")
+  return width, height
+
+def get_params (paramlist):
+  paramkeys = paramlist.split()
+  form = cgi.FieldStorage()
+  params = {}
+  for key in paramkeys:
+    if key in form:
+      if key == 'heightmap':
+        params[key] = form[key].value
+      elif key == 'imgdata':
+        params[key] = form[key].value
+      elif key == 'texture':
+        params[key] = form[key].value
+      else:
+        params[key] = sanitize(form[key].value)
+    else:
+      params[key] = None
+  return params
+
+def error (e):
+  print "#@imlandscape"
+  print "ERROR\t"+e
+  sys.exit()
+
+def now ():
+  return int(time.mktime(time.localtime()))
+
+def sanitize (str):
+  return re.sub(r'\W+', '', str)
+
+def filename_from_url (url, name=""):
+  if "?" in url:
+    url = url.split("?")[0]
+  if "/" in url:
+    url = urllib.unquote(url).replace(" ","")
+    filename = url.split("/")[-1]
+    filetype = "png" 
+    filename = sanitize(filename[:-4])
+  else:
+    filename = "" 
+  if name != "":
+    name = name+"_"
+  return "{}_{}{}_{}.{}".format("imlandscape", name, filename,now(), "png")
+
+def saveImgData(url, filename):
+  try:
+    up = urlparse.urlparse(url)
+    head, data = up.path.split(',', 1)
+    bits = head.split(';')
+    mime_type = bits[0] if bits[0] else 'text/plain'
+    charset, b64 = 'ASCII', False
+    for bit in bits[1]:
+        if bit.startswith('charset='):
+            charset = bit[8:]
+        elif bit == 'base64':
+            b64 = True
+
+    # Do something smart with charset and b64 instead of assuming
+    plaindata = base64.b64decode(data)
+
+    with open(filename, 'wb') as f:
+        f.write(plaindata)
+  except Exception as e:
+    error(str(e));
+
+def file_size (file):
+  return os.stat(file)[6]
+
+def moveToS3(filename,objectname):
+  conn = s3.AWSAuthConnection(AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
+  sys.stderr.write( "Uploading %s" % filename)
+  filedata = open(filename, 'rb').read()
+  content_type = mimetypes.guess_type(filename)[0]
+  if not content_type:
+    content_type = 'text/plain'
+  conn.put(BUCKET_NAME, objectname, s3.S3Object(filedata),
+    {'x-amz-acl': 'public-read', 'Content-Type': content_type, 'x-amz-storage-class': 'REDUCED_REDUNDANCY'})
+
+param = get_params(PARAM_LIST)
+if param['imgdata'] is None:
+  error("no imgdata")
+url = param['imgdata']
+if param['texture'] is None:
+  param['texture'] = "";
+if param['heightmap'] is None:
+  param['heightmap'] = "";
+if param['name'] is None:
+  param['name'] = "";
+
+dataobj = json.dumps({
+  'texture' : param['texture'],
+  'heightmap' : param['heightmap'],
+  'name' : param['name']
+})
+
+dir = hash_dir(param['imgdata']);
+
+filename = filename_from_url(param['texture'], param['name']);
+
+tag = "imlandscape"
+objectname = "im/"+dir+"/"+filename
+
+saveImgData(param['imgdata'], filename);
+
+print "#@imlandscape"
+#print ", ".join([k+"="+str(v) for k,v in param.iteritems()])
+print file_size (filename)
+print bin_identify (filename)
+print BASE_URL+objectname
+insert_cmd(dir, filename, param['name'], param['texture'], dataobj);
+moveToS3(filename, objectname);
+os.remove(filename);
diff --git a/lib/Pb/Pattern/__init__.py b/lib/Pb/Pattern/__init__.py
new file mode 100755
index 0000000..4e4c5a8
--- /dev/null
+++ b/lib/Pb/Pattern/__init__.py
@@ -0,0 +1,84 @@
+import os
+import sys
+import random
+import re
+import urllib
+from Config import *
+from Pb import Pb
+
+import simplejson as json
+from PIL import Image
+import uuid
+
+_fuse_mode="Pin_Light"
+
+class PbPattern(Pb):
+    example_params = {
+    #    "pattern_url" : "http://asdf.us/impattern/patterns/1.png",
+         "pattern_data" : '{"matrix":[["0","0","0","0","0","1","0","0","0","0"],["0","0","0","0","1","1","1","0","0","0"],["0","0","1","1","1","0","1","0","0","0"],["0","1","1","0","0","0","0","0","0","0"],["0","1","0","0","1","0","0","0","0","0"],["0","1","0","0","1","0","0","0","1","0"],["0","1","0","0","1","1","0","0","1","0"],["0","1","0","0","0","1","1","1","1","0"],["0","1","1","1","1","0","0","0","0","0"],["0","0","0","0","1","0","0","0","0","0"]],"width":"10","height":"10"}',
+    #    "username" : "garfield",
+         "image_url" : "http://i.asdf.us/im/be/PinkHijab_1425078647_reye.gif",
+    } 
+    def __init__(self, **kwargs): 
+        super(PbPattern,self).__init__();
+        _definitions = {
+          'image_url': { 'type':'img_url' },
+          'pattern_url': { 'type':'img_url' },
+          'pattern_data': { 'type':'raw' },
+          'username': { 'type':'string' },
+        }
+        self.params.definitions_import(_definitions, kwargs, classname=self.__class__.__name__);
+        self.filename, self.filepath = self._filename_filepath_create(url=self.params.image_url['url'], extension=self.params.image_url['mimetype'])
+        _pattern_filename, self._pattern_filepath = self._filename_filepath_create(namepart="pattern")
+
+        if self.params.pattern_data: self._from_pattern_data()
+        elif not self.params.pattern_url:
+            self.err_warn("pattern must be supplied as json array or as a png url")
+
+    def _from_pattern_data(self):
+        def boolToColor(boolean):
+            if boolean:
+                return (0,0,0,255);
+            else:
+                return (255,255,255,255)
+        specs = json.loads(str(self.params.pattern_data));
+        if int(specs['width']) > 100 or int(specs['height']) > 100:
+            raise ValueError
+            sys.stderr.write("height and width need to be less than 100 px")
+        img = Image.new('RGBA', (int(specs['width']), int(specs['height'])));
+        pixels = img.load();
+        for i in range(0, len(specs['matrix'])):
+            for j in range(0, len(specs['matrix'][i])):
+              pixels[j,i] = boolToColor(int(specs['matrix'][i][j]));
+
+        img.save(self._pattern_filepath, "PNG")
+        
+    #first step
+    def _make_canvas(self):
+        _width, _height = self.dimensions(self.params.image_url['path']) # same here
+        cmd = [BIN_CONVERT, "-size", _width + "x" + _height, "canvas:transparent", self.filepath]
+        self._call_cmd(cmd)
+
+    #second step use the Canvas as a background
+    def _make_mask(self):
+        #tile the pattern pattern on the canvas
+        cmd = [BIN_COMPOSITE,"-tile", self._pattern_filepath, self.filepath, self.filepath];
+        self._call_cmd(cmd)
+        #fuse the tiled file to create a mask
+        #convert thebg.gif -compose Dst_In null: thefile.gif -matte -layers composite new.gif
+        cmd = [BIN_CONVERT, self.filepath, "-compose", "Dst_In", "null:", 
+            self.params.image_url['path'], "-matte", "-layers", "composite", self.filepath]
+        self._call_cmd(cmd)
+    
+    #third step
+    def _fuse_mask(self, fuse_mode=_fuse_mode):
+        cmd = [BIN_CONVERT, "-dispose", "2", self.filepath, "null:", 
+            self.params.image_url['path'], "-matte", "-compose", fuse_mode, "-layers", "composite", 
+            self.filepath]
+        self._call_cmd(cmd)
+
+    def create(self):
+        self._make_canvas();
+        self._make_mask()
+        self._fuse_mask();
+
diff --git a/lib/Pb/__init__.py b/lib/Pb/__init__.py
new file mode 100644
index 0000000..4d8a8d4
--- /dev/null
+++ b/lib/Pb/__init__.py
@@ -0,0 +1,130 @@
+import re
+from Config import *
+import time 
+import urllib
+import urllib2
+import sys
+import os
+import random
+from subprocess import Popen,PIPE,call
+from Params import Params
+import time
+Request = urllib2.Request
+urlencode = urllib.urlencode
+urlopen = urllib2.urlopen
+
+_max_filename_length = 20;
+
+class Pb(object):
+  def __init__(self):
+    self._now = str(int(time.time()));
+    self.params = Params(classname=self.__class__.__name__, now=self._now);
+    self._files_created = []
+    self.commands = [];
+    self._working_dir = WORKING_DIR
+
+  def _filename_create(self, url=None, namepart="", extension=""):
+     if url:
+        _basename = os.path.basename(url)
+        namepart = re.split(r'\.', _basename)[0]
+        namepart = self._url_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):
+     return os.path.join(directory, filename)
+
+  def _filename_filepath_create(self, url=None, namepart="", directory=WORKING_DIR, extension=""):
+     _filename = self._filename_create(url=url, namepart=namepart, extension=extension);
+     _filepath = self._filepath_create(_filename, directory=directory);
+     return _filename, _filepath
+
+  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 _url_sanitize (self, s):
+    return re.sub(r'\W+', '', s)
+
+  def _call_cmd(self, cmd):    
+    try:
+      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)))
+
+
+  @staticmethod
+  def dimensions (filepath):
+      #works in lieu of a mimetype check (it reads the header as well)
+      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:
+          return os.stat(filepath)[6]
+      except Exception as e:
+          sys.stderr.write("Couldn't determine filesize\n")
+          sys.stderr.write(str(e)+"\n")
+          raise;
+
+  def _file_read(self, filepath):
+    f = open(filepath, 'r'); 
+    data = f.read()
+    f.close()
+    return data        
+
+  def err_warn(self, s):
+    sys.stderr.write("ERROR:{} - {}\n".format(self.__class__.__name__, s))
+  
+  def _cleanup(self):
+      if not self._files_created: return
+      cmd = ["rm"]+self._files_created
+      self._call_cmd(cmd)
+
+  def err_fatal(self, s):
+    sys.stderr.write("ERROR[FATAL]:{} - {}\n".format(self.__class__.__name__, s))
+    sys.exit(1);
+  
+  @classmethod
+  def example_run(cls, params=None, verbose=True):
+    example_params = params or cls.example_params
+    if not example_params:
+      raise AttributeError ("Must supply test params to test %s" % cls.__name__)
+    b = cls(**example_params)
+    b.create();
+    if verbose:
+      sys.stderr.write("generated %s\n" % b.filepath)
+      sys.stderr.write("files created %s\n" % b._files_created)
+      sys.stderr.write("commands %s" % " ".join(b.commands))
+
+  @staticmethod
+  def gif_frames(filepath):
+      try:
+          info = Popen([BIN_IDENTIFY,filepath], stdout=PIPE).communicate()[0]
+          frames = filter((lambda x: x), map(  
+              (lambda x: x.split(" ")[0]), 
+              (info).split('\n')
+          ))
+          return frames
+      except Exception as e:
+          self.err_warn("couldn't get gif frames")
+          raise e;
+
+  def _choose_gif_frame(self, filepath):
+      _gif_frames = Pb.gif_frames(filepath)
+      frame = random.choice(_gif_frames)
+      self._call_cmd([BIN_CONVERT, frame, filepath])
diff --git a/lib/Pb/inspect_objects_example.py b/lib/Pb/inspect_objects_example.py
new file mode 100644
index 0000000..92e28b7
--- /dev/null
+++ b/lib/Pb/inspect_objects_example.py
@@ -0,0 +1,15 @@
+class Test(object):
+  def __init__(self, one="la", two="di"):
+    self._test_args(inspect.getargvalues(inspect.currentframe()));
+
+  def _test_args(self, _args_vals):
+    for arg in _args_vals.args:
+      if arg == "self":
+        continue
+      try:
+        sys.stdout.write("%s\n" % arg)
+        sys.stdout.write("\t%s\n" % _args_vals.locals.get(arg))
+      except Exception as e:
+        sys.stderr.write("%s\n" % e );
+ 
+t = Test();