finished the params class, almost done with pb master class

25 files changed, 553 insertions, 237 deletions

diff --git a/Config/__init__.py b/Config/__init__.py
index b849b9e..e834748 100644
--- a/Config/__init__.py
+++ b/Config/__init__.py
@@ -8,7 +8,10 @@ THREEDROTATE = "./bin/3Drotate"
 GRID = "./bin/grid"
 BEVELBORDER = "./bin/bevelborder"
 
+#common parameters
 DEFAULT_FINALFORMAT = "png";
+DEFAULT_HEIGHT = 400
+DEFAULT_WIDTH = 600
 
 
 #mounted on tmpfs
@@ -18,3 +21,5 @@ WORKING_DIR = "/var/www/cache"
 AWS_ACCESS_KEY_ID = 'AKIAIR53VPBXKJMXZIBA'
 AWS_SECRET_ACCESS_KEY = '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'
 BUCKET_NAME = 'i.asdf.us'
+SPECIAL_DOWNLOADERS = [ "ryz pepper RICHARD_GIOVANNI dmgk" ]
+SPECIAL_DOWNLOADERS_MAX_SIZE = 100000
diff --git a/Db/__init__.py b/Db/__init__.py
index c42a7c5..f4ebc57 100644
--- a/Db/__init__.py
+++ b/Db/__init__.py
@@ -35,8 +35,7 @@ class Db(object):
       HOST,
       DATABASE
     ))
-    Session = sessionmaker(bind=engine)
-    self.session = Session()
+    self.Session = sessionmaker(bind=engine)
 
   def insert_cmd (
     self, 
@@ -62,6 +61,7 @@ class Db(object):
 #    sys.stderr.write("dataobj={}".format(str(dataobj)) + "\n")
 #    sys.stderr.write("tag={}".format(str(tag)) + "\n")
     try:
+      session = self.Session()
       entry = ImCmd(
         date=date,
         remote_addr=remote_addr,
@@ -74,8 +74,9 @@ class Db(object):
         dataobj=dataobj,
         tag=tag
       )
-      self.session.add(entry)
-      self.session.commit()
+      session.add(entry)
+      session.commit()
+      #FIXME session.close()....
     except Exception as e:
-      sys.stderr.write("Unable to commit database entry");
+      sys.stderr.write("Unable to commit database entry\n");
       sys.stderr.write(str(e))
diff --git a/Flask_test/blueprint_test.py b/Flask_test/blueprint_test.py
new file mode 100644
index 0000000..2e7c31d
--- /dev/null
+++ b/Flask_test/blueprint_test.py
@@ -0,0 +1,21 @@
+from flask import Blueprint, abort, jsonify
+simple_page = Blueprint('simple_page', __name__)
+@simple_page.route('/homies')
+def show():
+    return "what's up";
+
+@simple_page.route('/nope')
+def nope():
+  return bad_request("oh hell no") 
+
+def bad_request(message):
+    response = jsonify({'message': message})
+    response.status_code = 400
+    return response
+ 
+
+#@simple_page.errorhandler(500)
+#def custom400(error):
+#    response = jsonify({'message': error.description['message']})
+#    # etc.
+
diff --git a/Flask_test/test.py b/Flask_test/test.py
new file mode 100644
index 0000000..b383b0d
--- /dev/null
+++ b/Flask_test/test.py
@@ -0,0 +1,46 @@
+import simplejson as json
+from flask import Flask
+from flask import abort, redirect, url_for
+from blueprint_test import simple_page
+app = Flask(__name__)
+app.register_blueprint(simple_page)
+#app.logger.debug('A value for debugging')
+#app.logger.warning('A warning occurred (%d apples)', 42)
+#app.logger.error('An error occurred')
+
+@app.route("/")
+def hello():
+    return "Hello World!"
+
+if __name__ == "__main__":
+    app.run()
+
+@app.route('/login', methods=['POST', 'GET'])
+def login():
+    error = None
+    if request.method == 'POST':
+        if valid_login(request.form['username'],
+                       request.form['password']):
+            return log_the_user_in(request.form['username'])
+        else:
+            error = 'Invalid username/password'
+    #searchword = request.args.get('key', '')
+    # the code below is executed if the request method
+    # was GET or the credentials were invalid
+    return render_template('login.html', error=error)
+
+
+
+@app.route('/')
+def index():
+    return redirect(url_for('login'))
+
+@app.route('/login')
+def login():
+    abort(401)
+    this_is_never_executed()
+
+
+url_for('static', filename='style.css')
+
+
diff --git a/Flask_test/test2.py b/Flask_test/test2.py
new file mode 100644
index 0000000..0a831b6
--- /dev/null
+++ b/Flask_test/test2.py
@@ -0,0 +1 @@
+print __name__
diff --git a/Params/__init__.py b/Params/__init__.py
new file mode 100644
index 0000000..60a0b58
--- /dev/null
+++ b/Params/__init__.py
@@ -0,0 +1,155 @@
+import re
+import os
+import time
+import sys
+import urllib, urllib2
+from subprocess import Popen, PIPE
+Request = urllib2.Request
+urlencode = urllib.urlencode
+urlopen = urllib2.urlopen
+
+from Config import WORKING_DIR, MAX_SIZE, \
+  SPECIAL_DOWNLOADERS, SPECIAL_DOWNLOADERS_MAX_SIZE, \
+  BIN_IDENTIFY
+
+class BadParamError(Exception):
+  pass
+
+class Params(object):
+    def __init__(self, classname="", **kwargs):
+      self._working_dir = WORKING_DIR
+      self._now = kwargs.get("now", str(int(time.time())));
+      self._classname = classname 
+      for key, value in kwargs.items():
+        setattr(self, key, value)
+    
+    def __iter__(self):
+        for key, value in vars(self).iteritems():
+           yield key, value
+
+    def err_warn(self, s, error=None):
+      self._error_log(s, error=error);
+      raise BadParamError("%s - %s" % (self._classname, s))
+   
+    def __getattr__(self, key):
+      try: 
+        return self.__getattribute__(key);
+      except AttributeError:
+        return None
+
+    def err_fatal(self, s, error=None):
+      self._log(s, error, fatal=True);
+      sys.exit(1);
+
+    def set_val(self, key, value, value_type=None, enum_values=None):
+      try:
+        if value_type == "color":
+          value = self._color_sanitize(value)
+        elif value_type == "float":
+          value = float(value)
+        elif value_type == "int":
+          value = int(value)
+        elif value_type == "bool":
+          value = self._bool_correct(str(value))
+        elif value_type == "string":
+          value = self._sanitize(str(value))
+        elif value_type == "img_url":
+          _filename = self._filename_temporary(key)
+          _path = os.path.join(self._working_dir, _filename)
+          self._image_download(value, _path)
+          _mimetype = self._image_mimetype(_path)
+          value = {
+            'url': value, 
+            'path': _path, 
+            'mimetype' : _mimetype
+          }
+        elif value_type == "enum":
+          if value not in enum_values: 
+            raise ValueError
+        self.__setattr__(key, value) 
+      except Exception as e:
+        self.err_warn("key: %s value: %s" % (key, value), error=str(e))
+
+    def _sanitize (self, s):
+      return re.sub(r'\W+', '', s)
+
+    def _color_sanitize(self, s):
+      if s == "":
+        return "transparent"
+      if re.match('(rgba?\([0-9]+,[0-9]+,[0-9]+\))|([a-zA-Z]+)|(\#[A-Ha-h0-9]+)', s):
+        return s.replace(' ', '');
+      else:
+        sys.stderr.write("Not a color: {}\n".format(s))
+        raise ValueError
+
+    def _bool_correct(self, b):
+         if type(b) == str:
+           if re.match(r'true', b, re.IGNORECASE):
+              return True
+           elif re.match(r'false', b, re.IGNORECASE):
+              return False
+         elif type(b) == bool:
+           return b
+         raise ValueError
+
+    def _filename_temporary(self, s): 
+      return "_tmp-{}-{}_{}".format(self._classname, self._now, s)
+
+    def _error_log(self, s, error=None, fatal=False):
+      message = "ERROR - BAD PARAM"
+      if fatal: message += "- [FATAL] -"
+      sys.stderr.write("{}:{} - {}\n".format(message, self._classname, s))
+      if error:
+        sys.stderr.write("PARAM ERROR: {}\n".format(str(error)))
+
+    def _image_download(self, url, path):
+      max_size = MAX_SIZE
+      if self.username in SPECIAL_DOWNLOADERS:
+        max_size = SPECIAL_DOWNLOADERS_MAX_SIZE
+      try: 
+        self._download(url, path, max_size=max_size)
+      except Exception as e:
+        self.err_warn("Download failed");
+
+    def _browser_request (self, url, data=None):
+        headers = {
+            'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)',
+            'Accept': '*/*',
+        }
+        try:
+            req = Request(url, data, headers)
+            response = urlopen(req)
+        except IOError as e:
+            if hasattr(e, 'code'):
+                sys.stderr.write( 'browser request error: %s - ERROR %s' % (url, e.code) )
+            raise IOError
+        return response
+
+    def _download(self, url, destination, max_size=MAX_SIZE):
+        response = self._browser_request(url, None)
+
+        rawimg = response.read()
+        if len(rawimg) == 0:
+            self.err_warn("got zero-length file")
+        if len(rawimg) > max_size:
+            self.err_warn("file too big: max size {} KB / {} is {} KB".format(
+                str(MAX_SIZE/1024), 
+                destination, 
+                str(len(rawimg)/1024)
+                )
+            )    
+        f = open(destination, "w")
+        f.write(rawimg)
+        f.close()
+
+    def _image_mimetype(self, f):
+        try: 
+            mimetype =  Popen(
+                [BIN_IDENTIFY, f], stdout=PIPE
+            ).communicate()[0].split(" ")[1].lower()
+            return mimetype
+        except Exception as e:
+            sys.stderr.write("couldn't determine mimetype\n")
+            raise e;
+    
+
diff --git a/Pb/Break/.__init__.py.swl b/Pb/Break/.__init__.py.swl
new file mode 100644
index 0000000..e2bd941
--- /dev/null
+++ b/Pb/Break/.__init__.py.swl
diff --git a/Pb/Break/.__init__.py.swm b/Pb/Break/.__init__.py.swm
new file mode 100644
index 0000000..0fcc095
--- /dev/null
+++ b/Pb/Break/.__init__.py.swm
diff --git a/Pb/Break/__init__.py b/Pb/Break/__init__.py
new file mode 100755
index 0000000..db9daaf
--- /dev/null
+++ b/Pb/Break/__init__.py
@@ -0,0 +1,179 @@
+#!/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
+
+class PbBreak(Pb): #FIXME in db gallery
+    def __init__(self,
+        url=None,
+        breaktype=None,
+        finalformat=DEFAULT_FINALFORMAT,
+        breakmode=None,
+        breakangle=None,
+        username=None,
+        expanded=None,
+        ):
+
+        super(PbBreak,self).__init__();
+         
+        self.params.set_val("breaktype", self._get_breaktype(breaktype), value_type="string");
+        self.params.set_val("finalformat", finalformat, value_type="string")
+        self.params.set_val("breakmode", breakmode, value_type="enum", enum_values=["subtle", "extreme", "gradual"])
+        self.params.set_val("breakangle", breakangle, value_type="float")
+        self.params.set_val("expanded", expanded, value_type="bool")
+        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:
+#            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, self.filepath = self._filename_filepath_create(url=self.params.url['url'])
+        self._conversion_file = self._tempfilepath_create()
+
+    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 _choose_frame(self, filepath):
+        _gif_frames = PbBreak.gif_frames(filepath)
+        frame = random.choice(_gif_frames)
+        self._call_cmd([BIN_CONVERT, frame, filepath])
+     
+    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") 
+            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" }
+
+    def _first_conversion(self):
+        if self.params.url['mimetype'] == self.params.breaktype:
+            self.params.url['path'] = self._conversion_file
+            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":
+            self._choose_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, 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 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/Pb/Breaker/__init__.py b/Pb/Break/__init__.py~
index 2d2f573..c1064e2 100755
--- a/Pb/Breaker/__init__.py
+++ b/Pb/Break/__init__.py~
@@ -28,21 +28,28 @@ class Breaker(Pb):
         for arg in _args_vals.args:
           if arg == "self":
             continue
+          sys.stderr.write(str(arg) + "\n")
           try:
             if arg not in ['breaktype', 'url']:
-              self.params.__setattr__(arg, self.bool_correct(str(_args_vals.locals.get(arg))))
+              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.params.url);
+        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)
@@ -64,7 +71,7 @@ class Breaker(Pb):
         self._conversion_file = self.tempname_create(basename=self.basename, fmt=self.params.breaktype); 
 
     def _call_cmd(self, cmd):
-        super(Breaker,self)._call_cmd(cmd)
+        super(Breaker,self)._call_cmd(cmd, error)
         self.commands.append(" ".join(cmd)); 
     
     def _get_breaktype(self, key):
diff --git a/Pb/Generate/__init__.py b/Pb/Generate/__init__.py
index 385591e..191d600 100755
--- a/Pb/Generate/__init__.py
+++ b/Pb/Generate/__init__.py
@@ -22,7 +22,7 @@ DISPOSE_DEFAULT = "None"
 def debuglog(s):
   sys.stderr.write(str(s) + "\n");
 
-class Generate(Pb):
+class Im(Pb):
     def __init__(self, **kwargs):
         self.params = {}
         self._now = self.now()
diff --git a/Pb/Gradient/__init__.py b/Pb/Gradient/__init__.py
index 5120c7d..c384df2 100755
--- a/Pb/Gradient/__init__.py
+++ b/Pb/Gradient/__init__.py
@@ -44,7 +44,7 @@ HALFTONEVALUES = {
     }

 

 

-class Gradient(Pb):

+class Imgradient(Pb):

     def __init__(self, **kwargs):

         self.tag = "imGradient"

         self.directory = WORKING_DIR

diff --git a/Pb/Imgrid/__init__.py b/Pb/Grid/__init__.py
index 52cb748..09718bd 100755
--- a/Pb/Imgrid/__init__.py
+++ b/Pb/Grid/__init__.py
@@ -4,112 +4,73 @@ import re
 import os
 import simplejson as json
 import random
-from Config import *
+from Config import DEFAULT_FINALFORMAT, DEFAULT_HEIGHT, DEFAULT_WIDTH, WORKING_DIR
+from Config import THREEDROTATE, GRID 
 import tempfile
 from Pb import Pb
 
-DEFAULT_HEIGHT = 400
-DEFAULT_WIDTH = 600
-DEFAULT_LINE_COLOR = "silver"
+_default_line_color = "silver"
 
 class Imgrid(Pb):
-    def __init__(self, **kwargs):
-        self.tag = "imGrid"
-        self.files_created = []
-        self.commands = [];
-        self._required_keys = [
-#{{{ required_keys
-            "width",
-            "height",
-            "linethickness",
-            "opacity",
-            "linecolor",
-            "spacing",
-            "vlines",
-            "hlines",
-            "shadow",
-            "bgimage",
-            "bgcolor",
-            "imageinstead",
-            "planebgcolor",
-            "planebgimage",
-            "swing",
-            "tilt",
-            "roll",
-            "zoom",
-            "skycolor",
-            "transition",
-            "trim",
-            "format",
-            "username"
-#}}}
-        ]
-        self._now = self.now()
-        
-        #Work out params ...
-        #note, tmpfile lib is pretty much useless here, given imagemagick's behavior with gifs (it splits them) etc...
-        #instead we're just making our own in /var/www/cache (tmpfs mounted there)
-        self.params = {}
-        for k in self._required_keys:
-            if k in kwargs:
-                if k in [ 'bgimage', 'planebgimage', 'imageinstead' ] and self.bool_correct(kwargs[k]):
-                    self.params[k] = {
-                      'url' : kwargs[k],
-                      'filename' : self._make_tempname(k),
-                      'path' : os.path.join(WORKING_DIR, self._make_tempname(k)) ,
-                    }
-                    try:  
-                        self.download(self.params[k]['url'], self.params[k]['path'])
-                        self.files_created.append(self.params[k]['path'])
-                        self.params[k]['mimetype'] = self.get_mimetype(self.params[k]['path'])
-                        frames = self.gif_frames(self.params[k]['path'])
-                        if len(frames) > 1:
-                            self.params[k]['path'] = random.choice(frames) 
-                            
-                    except Exception:
-                        sys.stderr.write(str(e))
-                        raise Exception ("BAD PARAMS");
-                elif k in [ 'skycolor', 'bgcolor', 'planebgcolor','linecolor' ]:
-                    try:
-                      self.params[k] = self.is_color(kwargs[k])
-                    except Exception:
-                      sys.stderr.write(kwargs[k] + "\n")
-                      raise Exception("Unable to process color for:\n{}".format(k))
-                elif k == 'opacity':
-                    self.params[k] = str(float(kwargs[k]))
-                elif k == 'zoom':
-                    self.params[k] = int(float(kwargs[k]))
-                else:
-                    self.params[k] = self.bool_correct(self.sanitize(kwargs[k]))
-            else:
-                self.params[k] = None;    
+    def __init__(self, 
+          width=None,
+          height=None,
+          linethickness=None,
+          opacity=None,
+          linecolor=None,
+          spacing=None,
+          vlines=None,
+          hlines=None,
+          shadow=None,
+          bgimage=None,
+          bgcolor=None,
+          imageinstead=None,
+          planebgcolor=None,
+          planebgimage=None,
+          swing=None,
+          tilt=None,
+          roll=None,
+          zoom=None,
+          skycolor=None,
+          transition=None,
+          trim=None,
+          finalformat=DEFAULT_FINALFORMAT,
+          username=None
+        ):
+        super(Imgrid,self).__init__();
 
-        self.params = self.make_dotdict(self.params)
+        _frame = inspect.currentframe(); 
+        _args_vals = inspect.getargvalues(_frame);
+        for arg in _args_vals.args:
+          if arg == "self":
+            continue
+          argval = _args_vals.locals.get(arg)
+          try:
+            if arg in [ 'skycolor', 'bgcolor', 'planebgcolor','linecolor' ]:
+              self.params.set_val(arg, argval, value_type="color")
+            elif arg == 'opacity':
+              self.params.set_val(arg, argval, value_type="float")
+            elif arg == 'zoom':
+              self.params.set_val(arg, argval, value_type="int")
+            elif arg in [ 'bgimage', 'planebgimage', 'imageinstead' ]:
+              self.params.set_val(arg, argval, value_type="img_url")
+              if self.params.get_mimetype(arg) == 'gif':
+                self.params.gif_convert_to_still(arg)
+              self.files_created.append(self.params.get_filepath(arg))
+            elif arg in ['finalformat', 'username' ] :
+              self.params.set_val(arg, argval, value_type="string")
+            else:
+              self.params.set_val(arg, argval, value_type="bool")
+  
+          except Exception as e:
+            self.log_err(str(e))
 
+        #FIXME these need to be bumped up to the parent class
         self.basename = self._get_filename();
-
-        if not self.params.finalformat:
-            self.params.finalformat = DEFAULT_FINALFORMAT
         self.filename = "{}.{}".format(self.basename, self.params.finalformat)
         #final filepath is stored in self.filepath
         self.filepath = os.path.join(WORKING_DIR, self.filename) 
 
-    def _get_filename(self):
-        return "{}_{}_{}".format(
-            self.tag,
-            self._now,
-            self.params.username or ""
-        );
-
-    def _call_cmd(self, cmd):
-      try:
-        self.call_cmd(cmd)
-        self.commands.append(" ".join(cmd)); 
-      except Exception:
-        raise Exception("Unable to call cmd {}".format(str(cmd)))
-
-    def _make_tempname(self, s):
-      return "IMGRIDTMP{}{}".format(self._now, s); 
 
 
     #makes a canvas file...step 1 (if not bgimage)
@@ -136,7 +97,7 @@ class Imgrid(Pb):
                 cmd += ["-s", "{},{}".format(height,self.params.spacing)]
             else:
                 cmd += ["-s",self.params.spacing]
-        cmd += [ "-c", self.params.linecolor or DEFAULT_LINE_COLOR]
+        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 ]
diff --git a/Pb/Imlandscape/__init__.py b/Pb/Landscape/__init__.py
index 59212a6..59212a6 100755
--- a/Pb/Imlandscape/__init__.py
+++ b/Pb/Landscape/__init__.py
diff --git a/Pb/Imlandscape/landscape b/Pb/Landscape/landscape
index 10e8ede..10e8ede 100755
--- a/Pb/Imlandscape/landscape
+++ b/Pb/Landscape/landscape
diff --git a/Pb/Params/__init__.py b/Pb/Params/__init__.py
deleted file mode 100644
index 2285e7a..0000000
--- a/Pb/Params/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-class Params(object):
-    def __init__(self, **kwargs):
-      for key, value in kwargs.items():
-        setattr(self, key, value)
-    def __getattr__(self, attr):
-        return self.get(attr, None)
-    def __iter__(self):
-        for key, value in vars(self).iteritems():
-           yield key, value
-
diff --git a/Pb/Pattern/__init__.py b/Pb/Pattern/__init__.py
index 905ddf9..7c53746 100755
--- a/Pb/Pattern/__init__.py
+++ b/Pb/Pattern/__init__.py
@@ -11,9 +11,9 @@ import simplejson as json
 from PIL import Image
 import uuid
 
-FUSE_MODE="Pin_Light"
+_fuse_mode="Pin_Light"
 
-class Pattern(Pb):
+class Impattern(Pb):
     def __init__(self, **kwargs):
         self.params = {}
         self.tag = "imPattern";
@@ -149,7 +149,7 @@ class Pattern(Pb):
         self._call_cmd(cmd)
     
     #third step
-    def _fuse_mask(self, fuse_mode=FUSE_MODE):
+    def _fuse_mask(self, fuse_mode=_fuse_mode):
         cmd = [BIN_CONVERT, "-dispose", "2", self.filepath, "null:", 
             self._downloaded_file, "-matte", "-compose", fuse_mode, "-layers", "composite", 
             self.filepath]
diff --git a/Pb/__init__.py b/Pb/__init__.py
index 909f03b..0212235 100644
--- a/Pb/__init__.py
+++ b/Pb/__init__.py
@@ -7,33 +7,64 @@ import sys
 import os
 import random
 from subprocess import Popen,PIPE,call
-from Pb.Params import Params
+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.params = Params();
+    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=""):
+     if url:
+        _basename = os.path.basename(url)
+        namepart = re.split(r'\.')[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 
+     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):
+     _filename = self._filename_create(url=url, namepart=namepart);
+     _filepath = _filename_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 _call_cmd(self, cmd):
-      try:
-          call(cmd)
-      except Exception as e:
-        self.err_warn("Could not call cmd: {}".format(str(cmd)))
-        self.err_warn(str(e))
+    try:
+      self.call_cmd(cmd)
+      self.commands.append(" ".join(cmd)); 
+    except Exception:
+      raise Exception("Unable to call cmd {}".format(str(cmd)))
 
   @staticmethod
-  def is_color(s):
-    if s == "":
-      return "transparent"
-    if re.match('(rgba?\([0-9]+,[0-9]+,[0-9]+\))|([a-zA-Z]+)|(\#[A-Ha-h0-9]+)', s):
-      return s.replace(' ', '');
-    else:
-      sys.stderr.write("Not a color: {}\n".format(s))
-      raise ValueError
+  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;
 
   @staticmethod
   def dimensions (filepath):
@@ -42,77 +73,6 @@ class Pb(object):
       return ident[2].split("x")
 
   @staticmethod
-  def is_number(s):
-      try:
-          return int(s)
-      except (ValueError, TypeError):
-          return False
-
-  def bool_correct(self, s):
-      try:
-        if re.match(r'^false$', str(s), re.IGNORECASE):
-            return False
-        elif re.match(r'^true$', str(s), re.IGNORECASE):
-            return True
-        else:
-            return s
-      except Exception as e:
-        sys.stderr.write("WHAT THE FUCK")
-
-  @staticmethod
-  def get_mimetype(f):
-      try: 
-          mimetype =  Popen(
-              [BIN_IDENTIFY, f], stdout=PIPE
-          ).communicate()[0].split(" ")[1].lower()
-          return mimetype
-      except Exception as e:
-          sys.stderr.write("couldn't determine mimetype")
-          sys.stderr.write(str(e))
-          raise;
-
-  def sanitize (self, s):
-      return re.sub(r'\W+', '', s)
-
-  @staticmethod
-  def now():
-      return int(time.time())
-
-  @staticmethod
-  def browser_request (url, data=None):
-      headers = {
-          'User-Agent': 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)',
-          'Accept': '*/*',
-      }
-      try:
-          req = Request(url, data, headers)
-          response = urlopen(req)
-      except IOError, e:
-          if hasattr(e, 'code'):
-              sys.stderr.write( '%s - ERROR %s' % (url, e.code) )
-              raise;
-          return None
-      else:   
-          return response
-
-  def download(self, url, destination, max_size=MAX_SIZE):
-      response = self.browser_request(url, None)
-      rawimg = response.read()
-      if len(rawimg) == 0:
-          sys.stderr.write("got zero-length file")
-          raise;
-      if len(rawimg) > max_size:
-          sys.stderr.write("file too big: max size {} KB / {} is {} KB".format(
-              str(MAX_SIZE/1024), 
-              destination, 
-              str(len(rawimg)/1024)
-          ))    
-          raise;
-      f = open(destination, "w")
-      f.write(rawimg)
-      f.close()
-
-  @staticmethod
   def file_size (filepath):
       try:
           return os.stat(filepath)[6]
@@ -121,37 +81,6 @@ class Pb(object):
           sys.stderr.write(str(e)+"\n")
           raise;
 
-  def gif_frames(self, 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:
-          sys.stderr.write("{} couldn't get gif frames".format(self.__class__.__name__))
-          sys.stderr.write(str(e))
-          raise;
-
-  def tempname_create(self, basename=None, fmt="png"):
-    if not basename: basename = self.random_string_create()
-    return os.path.join(self._working_dir, "{}{}.{}".format(self.__class__.__name__, basename, fmt)) # this
-
-  def _get_filename_and_type_from_url (self, url):
-    name = re.sub(r'(?:\s|\?.*|.*/)', '', urllib.unquote(url));
-    try: 
-      basename, ext = map(lambda s: self.sanitize(s), re.search(r'(^.*)\.(.*$)', name).groups());
-    except Exception as e:
-      self.err_warn("Incompatible input file type")
-    if (len(basename) > 20):
-        basename = basename[:-20]
-    return "{}{}_{}_{}".format(self.tag, basename, self._now, self.params.username or ""), ext 
-
-  def random_string_create(self):
-    return "{}".format(random.uniform(0, 100000)); 
-
-  
   def _file_read(self, filepath):
     f = open(filepath, 'r'); 
     data = f.read()
@@ -161,6 +90,10 @@ class Pb(object):
   def err_warn(self, s):
     sys.stderr.write("ERROR:{} - {}\n".format(self.__class__.__name__, s))
   
+  def _cleanup(self):
+      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);
diff --git a/Pb/inspect_objects_example.py b/Pb/inspect_objects_example.py
new file mode 100644
index 0000000..92e28b7
--- /dev/null
+++ b/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();
diff --git a/htmljs/imbreak_main.js b/frontend/htmljs/imbreak_main.js
index c56c9a2..c56c9a2 100644
--- a/htmljs/imbreak_main.js
+++ b/frontend/htmljs/imbreak_main.js
diff --git a/htmljs/imgradient_index.html b/frontend/htmljs/imgradient_index.html
index 275bfec..275bfec 100644
--- a/htmljs/imgradient_index.html
+++ b/frontend/htmljs/imgradient_index.html
diff --git a/htmljs/imgrid_main.js b/frontend/htmljs/imgrid_main.js
index f88e235..f88e235 100644
--- a/htmljs/imgrid_main.js
+++ b/frontend/htmljs/imgrid_main.js
diff --git a/pbserver.py b/pbserver.py
index a1da5d5..530e54f 100755
--- a/pbserver.py
+++ b/pbserver.py
@@ -76,7 +76,7 @@ def format_im_data(im, insert_url="NULL"):
             newfile=im.filename, 
             dataobj=";".join(im.commands),
             cmd=json.dumps(dict(im.params)),
-            tag=im.tag,
+            tag=im.__class__.__name__,
         )
         return json.dumps({
             'url' : "{}/{}".format(BASE_URL, objectname),
diff --git a/test.py b/test.py
new file mode 100644
index 0000000..58c3114
--- /dev/null
+++ b/test.py
@@ -0,0 +1,2 @@
+from Pb.Break import PbBreak
+PbBreak.test()
diff --git a/tests/test_break.py b/tests/test_break.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/tests/test_break.py