ok all modules working

27 files changed, 273 insertions, 304 deletions

diff --git a/Param/Bool/__init__.py b/Param/Bool/__init__.py
index 38fa7fa..8ccca00 100644
--- a/Param/Bool/__init__.py
+++ b/Param/Bool/__init__.py
@@ -1,10 +1,12 @@
 from Param import Param
-
-def ParamBool(Param):
+import re
+class ParamBool(Param):
   def __init__(self, value, classname=""):
-    self._classname = classname
-    super(ParamBool).__init__()
-    self.value = self._bool_correct(value)
+    super(ParamBool, self).__init__(classname=classname)
+    if value:
+      self.value = self._bool_correct(value)
+    else:
+      self.value = False
   def _bool_correct(self, b):
     if type(b) == str:
       if re.match(r'true', b, re.IGNORECASE):
diff --git a/Param/Color/__init__.py b/Param/Color/__init__.py
index ea7895c..9163338 100644
--- a/Param/Color/__init__.py
+++ b/Param/Color/__init__.py
@@ -1,9 +1,8 @@
 from Param import Param
-
-def ParamColor(Param):
+import re
+class ParamColor(Param):
   def __init__(self, value, classname=""):
-    self._classname = classname
-    super(ParamColor).__init__()
+    super(ParamColor, self).__init__(classname=classname)
     try:
       self.value = self._color_sanitize(value)
     except Exception as e:
diff --git a/Param/Enum/__init__.py b/Param/Enum/__init__.py
index f5aad73..3923a64 100644
--- a/Param/Enum/__init__.py
+++ b/Param/Enum/__init__.py
@@ -1,9 +1,8 @@
 from Param import Param
-
-def ParamEnum(Param):
+import sys
+class ParamEnum(Param):
   def __init__(self, value, enum_values=[], classname=""):
-    self._classname = classname
-    super(ParamEnum).__init__()
+    super(ParamEnum,self).__init__(classname=classname)
     if value not in enum_values:
-      return err_warn("Value %s not in enum values" % str(value))
+      return self.err_warn("Value %s not in enum values" % str(value))
     self.value = value
diff --git a/Param/Float/__init__.py b/Param/Float/__init__.py
index eada7ac..0581815 100644
--- a/Param/Float/__init__.py
+++ b/Param/Float/__init__.py
@@ -1,11 +1,14 @@
 from Param import Param
 
-def ParamFloat(Param):
+class ParamFloat(Param):
   def __init__(self, value, classname=""):
     self._classname = classname
-    super(ParamFloat).__init__()
+    super(ParamFloat, self).__init__(classname=classname)
     try: 
-      self.value = float(value)
+      if value:
+        self.value = float(value)
+      else:
+        self.value = 0.0
     except Exception as e:
       self.err_warn("Not a float: %s" % str(value))
       self.err_warn(str(e))
diff --git a/Param/Img_url/__init__.py b/Param/Img_url/__init__.py
index 176888b..58ed2e0 100644
--- a/Param/Img_url/__init__.py
+++ b/Param/Img_url/__init__.py
@@ -1,7 +1,9 @@
+import os
 from Param import Param
 from Config import *
 import urllib, urllib2
 from subprocess import Popen, PIPE
+import sys
 Request = urllib2.Request
 urlencode = urllib.urlencode
 urlopen = urllib2.urlopen
@@ -9,26 +11,41 @@ Request = urllib2.Request
 urlencode = urllib.urlencode
 urlopen = urllib2.urlopen
 
-
-def ParamImg_url(Param):
+import sys;
+class ParamImg_url(Param):
   def __init__(self, value, key="", classname=""):
-    self._classname = classname
-    super(ParamImg_url).__init__()
-    
+    super(ParamImg_url, self).__init__(classname=classname)
     if value:
       try:
         self.filename = self._filename_temporary(key)
-        self.path = os.path.join(self._working_dir, _filename)
-        self._image_download(value, self._path)
-        self.mimetype = self._image_mimetype(_path)
-        self.value = self.path
+
+        self.path = os.path.join(self._working_dir, self.filename)
+        self._image_download(value, self.path)
+        self.mimetype = self._image_mimetype(self.path)
+        self.url = value
       except Exception as e:
         self.err_warn("Unable to download image: %s" % str(value))
         self.err_warn(str(e))
 
-
   def _filename_temporary(self, s): 
     return "_tmp-{}-{}_{}".format(self._classname, self._now, s)
+   
+  def __dict__(self):
+    return { 
+      'filename' : self.filename, 
+      'path': self.path, 
+      'url': self.url,
+      'mimetype': self.mimetype
+    }
+
+  def __getitem__(self, item):
+    return self.__dict__().__getitem__(item)
+
+  def __str__(self):
+    return str(self.__dict__())
+
+  def __nonzero__(self):
+    return True if self.path and self.mimetype else False 
 
   def _image_download(self, url, path):
     max_size = MAX_SIZE
diff --git a/Param/Int/__init__.py b/Param/Int/__init__.py
index 4d52bdf..0a73cc1 100644
--- a/Param/Int/__init__.py
+++ b/Param/Int/__init__.py
@@ -1,11 +1,13 @@
 from Param import Param
 
-def ParamInt(Param):
+class ParamInt(Param):
   def __init__(self, value, classname=""):
-    self._classname = classname
-    super(ParamInt).__init__()
+    super(ParamInt, self).__init__(classname=classname)
     try: 
-      self.value = int(value)
+      if value:
+        self.value = int(value)
+      else:
+        self.value = 0
     except Exception as e:
       self.err_warn("Not an int: %s" % str(value))
       self.err_warn(str(e))
diff --git a/Param/Json/__init__.py b/Param/Json/__init__.py
index 5e3bbc2..28a7126 100644
--- a/Param/Json/__init__.py
+++ b/Param/Json/__init__.py
@@ -1,8 +1,8 @@
 from Param import Param
 import simplejson as json
 
-def ParamJson(Param):
+class ParamJson(Param):
   def __init__(self, value, classname=""):
-    self._classname = classname
-    super(ParamJson).__init__()
+    super(ParamJson, self).__init__(classname=classname)
     self.value = json.parse(value)
+
diff --git a/Param/Raw/__init__.py b/Param/Raw/__init__.py
index 7eb1a4d..f8adaab 100644
--- a/Param/Raw/__init__.py
+++ b/Param/Raw/__init__.py
@@ -1,7 +1,6 @@
 from Param import Param
 
-def ParamRaw(Param):
+class ParamRaw(Param):
   def __init__(self, value, classname=""):
-    self._classname = classname
-    super(ParamRaw).__init__()
+    super(ParamRaw, self).__init__(classname=classname)
     self.value = value
diff --git a/Param/String/__init__.py b/Param/String/__init__.py
index fe6b6c1..df65c9d 100644
--- a/Param/String/__init__.py
+++ b/Param/String/__init__.py
@@ -1,13 +1,16 @@
 from Param import Param
+import re
 
-def ParamString(Param):
+class ParamString(Param):
   def __init__(self, value, classname=""):
-    self._classname = classname
-    super(ParamString).__init__()
-    try:
-      self.value = self.sanitize(value)
-    except Exception as e:
-      self.err_warn("Unable to sanitize: %s" % str(value))
-      self.err_warn(str(e))
+    super(ParamString, self).__init__(classname=classname)
+    if value:
+      try:
+        self.value = self.sanitize(value)
+      except Exception as e:
+        self.err_warn("Unable to sanitize: %s" % str(value))
+        self.err_warn(str(e))
+    else:
+      self.value = ""
   def sanitize (self, s):
     return re.sub(r'\W+', '', s)
diff --git a/Param/__init__.py b/Param/__init__.py
index 80dcc0e..678b9dc 100644
--- a/Param/__init__.py
+++ b/Param/__init__.py
@@ -3,18 +3,11 @@ import sys
 
 from Config import WORKING_DIR
 
-from Param.Int import ParamInt
-from Param.Raw import ParamRaw
-from Param.Bool import ParamBool
-from Param.Enum import ParamEnum
-from Param.Json import ParamJson
-from Param.Color import ParamColor
-from Param.Float import ParamFloat
-from Param.Img_url import ParamImg_url
-from Param.String import ParamString
+class BadParamError(Exception):
+  pass
 
 
-class Params(object):
+class Param(object):
     def __init__(self, classname="", **kwargs):
       self._working_dir = WORKING_DIR
       self._now = kwargs.get("now", str(int(time.time())));
@@ -28,6 +21,17 @@ class Params(object):
     def __str__(self):
       return str(self.value)
 
+    def __eq__(self, other):
+      return self.value == other
+
+    def __ne__(self, other):
+      return self.value != other
+
+    def set_val(self, value):
+      try:
+        self.value = value
+      except Exception as e:
+        self.err_warn("Unable to set value {}".format(value))
 
     def err_warn(self, s, error=None):
       self._error_log(s, error=error);
@@ -50,3 +54,12 @@ class Params(object):
       if error:
         sys.stderr.write("PARAM ERROR: {}\n".format(str(error)))
 
+from Param.Int import ParamInt
+from Param.Raw import ParamRaw
+from Param.Bool import ParamBool
+from Param.Enum import ParamEnum
+from Param.Json import ParamJson
+from Param.Color import ParamColor
+from Param.Float import ParamFloat
+from Param.Img_url import ParamImg_url
+from Param.String import ParamString
diff --git a/Params/__init__.py b/Params/__init__.py
index 5f098a0..e3ba10b 100644
--- a/Params/__init__.py
+++ b/Params/__init__.py
@@ -32,29 +32,34 @@ class Params(object):
       except AttributeError:
         return None
     
-    def definitions_import(self, d_hash, classname=""):
+    def definitions_import(self, def_dict, classkwargs, classname=""):
       value = None
-      for key in d_hash.keys():
+      for key in def_dict.keys():
         try: 
-          if d_hash[key]['type'] == "bool":
-            instance = ParamBool(d_hash[key], classname=classname)
-          elif d_hash[key]['type'] == "color":
-            instance = ParamColor(d_hash[key], classname=classname)
-          elif d_hash[key]['type'] == "enum":
-            instance = ParamEnum(d_hash[key], enum_values=d_hash[key]['enum_values'], classname=classname)
-          elif d_hash[key]['type'] == "float":
-            instance = ParamFloat(d_hash[key], classname=classname)
-          elif d_hash[key]['type'] == "img_url":
-            instance = ParamImg_url(d_hash[key], classname=classname)
-          elif d_hash[key]['type'] == "int":
-            instance = ParamInt(d_hash[key], classname=classname)
-          elif d_hash[key]['type'] == "json":
-            instance = ParamJson(d_hash[key], classname=classname)
-          elif d_hash[key]['type'] == "raw":
-            instance = ParamRaw(d_hash[key], classname=classname)
-          elif d_hash[key]['type'] == "string":
-            instance = ParamString(d_hash[key], classname=classname)
-          self.__setattr__(key, instance.value) 
+          value = None
+          if key in classkwargs:
+            value = classkwargs[key]
+          elif 'default' in def_dict[key]:
+            value = def_dict[key]['default']
+          if def_dict[key]['type'] == "bool":
+            instance = ParamBool(value, classname=classname)
+          elif def_dict[key]['type'] == "color":
+            instance = ParamColor(value, classname=classname)
+          elif def_dict[key]['type'] == "enum":
+            instance = ParamEnum(value, enum_values=def_dict[key]['enum_values'], classname=classname)
+          elif def_dict[key]['type'] == "float":
+            instance = ParamFloat(value, classname=classname)
+          elif def_dict[key]['type'] == "img_url":
+            instance = ParamImg_url(value, key=key, classname=classname)
+          elif def_dict[key]['type'] == "int":
+            instance = ParamInt(value, classname=classname)
+          elif def_dict[key]['type'] == "json":
+            instance = ParamJson(value, classname=classname)
+          elif def_dict[key]['type'] == "raw":
+            instance = ParamRaw(value, classname=classname)
+          elif def_dict[key]['type'] == "string":
+            instance = ParamString(value, classname=classname)
+          self.__setattr__(key, instance) 
         except Exception as e:
-          self.err_warn("key: %s value: %s" % (key, str(d_hash[key])), error=str(e))
+          self.err_warn("key: %s value: %s" % (key, str(def_dict[key])), error=str(e))
 
diff --git a/Pb/.__init__.py.swk b/Pb/.__init__.py.swk
deleted file mode 100644
index 4a1a4e1..0000000
--- a/Pb/.__init__.py.swk
+++ /dev/null
diff --git a/Pb/.__init__.py.swl b/Pb/.__init__.py.swl
deleted file mode 100644
index 145412b..0000000
--- a/Pb/.__init__.py.swl
+++ /dev/null
diff --git a/Pb/.__init__.py.swm b/Pb/.__init__.py.swm
deleted file mode 100644
index f1649e2..0000000
--- a/Pb/.__init__.py.swm
+++ /dev/null
diff --git a/Pb/.__init__.py.swn b/Pb/.__init__.py.swn
deleted file mode 100644
index 8abdca5..0000000
--- a/Pb/.__init__.py.swn
+++ /dev/null
diff --git a/Pb/Break/.__init__.py.swj b/Pb/Break/.__init__.py.swj
deleted file mode 100644
index 4a38023..0000000
--- a/Pb/Break/.__init__.py.swj
+++ /dev/null
diff --git a/Pb/Break/.__init__.py.swk b/Pb/Break/.__init__.py.swk
deleted file mode 100644
index fd1e760..0000000
--- a/Pb/Break/.__init__.py.swk
+++ /dev/null
diff --git a/Pb/Break/.__init__.py.swl b/Pb/Break/.__init__.py.swl
deleted file mode 100644
index e2bd941..0000000
--- a/Pb/Break/.__init__.py.swl
+++ /dev/null
diff --git a/Pb/Break/.__init__.py.swm b/Pb/Break/.__init__.py.swm
deleted file mode 100644
index 0fcc095..0000000
--- a/Pb/Break/.__init__.py.swm
+++ /dev/null
diff --git a/Pb/Break/.__init__.py.swn b/Pb/Break/.__init__.py.swn
deleted file mode 100644
index 79961cc..0000000
--- a/Pb/Break/.__init__.py.swn
+++ /dev/null
diff --git a/Pb/Break/__init__.py b/Pb/Break/__init__.py
index 3eb9b2a..cf12cc2 100755
--- a/Pb/Break/__init__.py
+++ b/Pb/Break/__init__.py
@@ -29,7 +29,7 @@ class PbBreak(Pb): #FIXME in db gallery
     }
     def __init__(self, **kwargs):
         super(PbBreak,self).__init__();
-        _definitions_hash = {
+        _definitions = {
           'username': { 'type': 'string' },
           'breaktype': { 'type': 'string' },
           'breakmode': {
@@ -40,21 +40,23 @@ class PbBreak(Pb): #FIXME in db gallery
           'breakangle': { 'type': 'float' },
           'expanded': { 'type': 'bool' },
           'url': { 'type': 'img_url' },
+          'finalformat': { 'type': 'enum', 'enum_values' : ['png', 'gif', 'jpg' ] }
         }
-        self._files_created.append(self.params.url['path'])
-        self.params.breaktype = self._get_breaktype(self.params.breaktype)
+        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 finalformat and self.params.url['mimetype'] == "gif":
-          self.params.set_val("finalformat", "gif", value_type="string")
+        if not self.params.finalformat and self.params.url.mimetype == "gif":
+          self.params.finalformat.set_val("gif")
         elif self.params.breaktype == 'miff':
-          self.params.set_val("finalformat", "jpg", value_type="string")
-          self.params.breakmode = "subtle"
-        else:
-          self.params.set_val("finalformat", finalformat or DEFAULT_FINALFORMAT, value_type="string")  
-        self._width_and_height_set(filepath=self.params.url['path'])       
+          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.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):
@@ -79,7 +81,7 @@ class PbBreak(Pb): #FIXME in db gallery
 
 #{{{#########rotatefunctions#######################################  
     def _rotate(self):
-        cmd = [BIN_CONVERT,self.params.url['path'],"-rotate",self.params.breakangle,"+repage",self.params.url['path']]
+        cmd = [BIN_CONVERT,self.params.url.path,"-rotate",self.params.breakangle,"+repage",self.params.url.path]
         self._call_cmd(cmd) 
 
     def _rotate_back(self):
@@ -113,22 +115,22 @@ 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):
+        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._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']
+        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._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": #FIXME and not miami
-            self._choose_gif_frame(self.params.url['path'])
+        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(); 
@@ -150,10 +152,10 @@ class PbBreak(Pb): #FIXME in db gallery
         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 self.params.breaktype == 'psd':
+        if str(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':
+        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:
diff --git a/Pb/Generate/__init__.py b/Pb/Generate/__init__.py
index 0062652..e50e514 100755
--- a/Pb/Generate/__init__.py
+++ b/Pb/Generate/__init__.py
@@ -13,7 +13,6 @@ _compose_params = [ "Over", "ATop", "Dst_Over", "Dst_In", "Dst_Out", "Multiply",
   "Linear_Dodge", "Linear_Burn", "Color_Dodge", "Color_Burn" ]
 _dispose_params = ["None","Previous","Background"]
 _dispose_default = "None"
-
 class PbGenerate(Pb):
     example_params = {
 #{{{ example params
@@ -45,80 +44,49 @@ class PbGenerate(Pb):
      'fuzz': '5'
 #}}}
     }
-    def __init__(self, 
-      #URLS
-      url=None,
-      background=None,
-      #BOOLS
-      coalesce=None,
-      nearest=None,
-      merge_early=None,
-      flip=None,
-      flop=None,
-      tile=None,
-      transparent=None,
-      #COLORS
-      black="black",
-      white="white",
-      subtract="white",
-      #INTS
-      fuzz=None,
-      width=None,
-      height=None,
-      brightness=None,
-      contrast=None,
-      saturation=None,
-      rotate=None,
-      hue=None,
-      #ENUMS
-      compose="Atop",
-      gravity=_gravity_default,
-      format=DEFAULT_FINALFORMAT,
-      dispose="None",
-      #STRINGS
-      name=None,
-      callback=None,
-    ):  
+    def __init__(self, **kwargs):  
       super(PbGenerate,self).__init__();
-      #IMAGES
-      self.params.set_val("url", url, value_type="img_url")
-      self.params.set_val("background", background, value_type="img_url")
-
-      #BOOLS
-      self.params.set_val("coalesce", coalesce, value_type="bool")
-      self.params.set_val("nearest", nearest, value_type="bool")
-      self.params.set_val("merge_early", merge_early, value_type="bool")
-      self.params.set_val("flip", flip, value_type="bool")
-      self.params.set_val("flop", flop, value_type="bool")
-      self.params.set_val("tile", tile, value_type="bool")
-      self.params.set_val("transparent", transparent, value_type="bool")
+      _definitions = { 
+        #IMAGES
+        "url": { 'type': "img_url" },
+        "background": { 'type': "img_url" },
 
-      #COLORS
-      self.params.set_val("black", black, value_type="color")
-      self.params.set_val("white", white, value_type="color")
-      self.params.set_val("subtract", subtract, value_type="color")
+        #BOOLS
+        "coalesce": { 'type': "bool" },
+        "nearest": { 'type': "bool" },
+        "merge_early": { 'type': "bool" },
+        "flip": { 'type': "bool" },
+        "flop": { 'type': "bool" },
+        "tile": { 'type': "bool" },
+        "transparent": { 'type': "bool" },
 
-      #INTS
-      self.params.set_val("fuzz", fuzz or 0, value_type="int")
-      self.params.set_val("width", width or 0, value_type="int")
-      self.params.set_val("height", height or 0, value_type="int")
-      self.params.set_val("brightness", brightness or 0, value_type="int")
-      self.params.set_val("contrast", contrast or 0, value_type="int")
-      self.params.set_val("saturation", saturation or 0, value_type="int")
-      self.params.set_val("rotate", rotate or 0, value_type="int")
-      self.params.set_val("hue", hue or 0, value_type="int")
-      
-      #ENUMS
-      self.params.set_val("compose", compose, value_type="enum", enum_values=_compose_params)
-      self.params.set_val("gravity", gravity, value_type="enum", enum_values=_gravity_params)
-      self.params.set_val("dispose", dispose, value_type="enum", enum_values=_dispose_params)
-      self.params.set_val("format", format, value_type="enum", enum_values=OUTPUT_IMAGE_TYPES)
+        #COLORS
+        "black": { 'type': "color", 'default': 'black' },
+        "white": { 'type': "color", 'default': 'white' },
+        "subtract": { 'type': "color" },
 
-      #STRINGS
-      self.params.set_val("username", name, value_type="string")
-      self.params.set_val("callback", callback, value_type="string")
+        #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
 
diff --git a/Pb/Gradient/__init__.py b/Pb/Gradient/__init__.py
index 2ef8b93..00adbf1 100755
--- a/Pb/Gradient/__init__.py
+++ b/Pb/Gradient/__init__.py
@@ -41,68 +41,50 @@ class PbGradient(Pb):
       "filetype" : "jpg",

       "username" : "whatever"

     }

-    def __init__(self, 

-        width=DEFAULT_WIDTH, height=DEFAULT_HEIGHT, 

-        color1=_default_color_1, color2=_default_color_2, 

-        stripes=False,

-        stripenumber=0, 

-        stripeintensity=0, 

-        blurriness=0, 

-        contrast=100, 

-        brightness=100,

-        saturation=100, 

-        hue=100,

-        halftone=None, 

-        bevel=None, 

-        percentbeveled=_default_bevel_percent,

-        tilt=0, rotate=0, 

-        flip=False, flop=False, 

-        filetype=DEFAULT_FINALFORMAT,

-        gradienttype="default", 

-        username=None,

-    ):

+    def __init__(self, **kwargs):

         super(PbGradient,self).__init__();

-        self.params.set_val("width", width, value_type="int")

-        self.params.set_val("height", height, value_type="int")

-        self.params.set_val("color1", color1, value_type="color")

-        self.params.set_val("color2", color2, value_type="color")

-        self.params.set_val("stripes", stripes, value_type="bool")

-        self.params.set_val("stripenumber", stripenumber, value_type="int")

-        self.params.set_val("stripeintensity", stripeintensity, value_type="int")

-        self.params.set_val("blurriness", blurriness, value_type="int")

-        self.params.set_val("contrast", contrast, value_type="int")

-        self.params.set_val("brightness", brightness, value_type="int")

-        self.params.set_val("saturation", saturation, value_type="int")

-        self.params.set_val("hue", hue, value_type="int")

-

-        self.params.set_val("halftone", halftone, value_type="enum", enum_values=[

-          "checkeredfade", "etchedtransition", "bendaydots",

-          "smallerdots1", "smallerdots2", "flatstripes",

-        ])

-        self.params.set_val("bevel", bevel, value_type="enum", enum_values=[

-          "flatout", "flatinner", "evenlyframed", "biginner",

-          "bigouter", "dramaticflatout", "dramaticflatinner",

-        ])

-        self.params.set_val("percentbeveled", percentbeveled, value_type="int")

-        self.params.set_val("tilt", tilt, value_type="int")

-        self.params.set_val("rotate", rotate, value_type="int")

-        self.params.set_val("flip", flip, value_type="bool")

-        self.params.set_val("flop", flop, value_type="bool")

-        

-        self.params.set_val("filetype", filetype, value_type="enum", enum_values=OUTPUT_IMAGE_TYPES)

-        self.params.set_val("gradienttype", gradienttype, value_type="enum", enum_values=[

-          "default", "canvas", "radial",  "colorspace",  

-          "mirrored",  "plasmawash",  "gradientwash",  "noise"

-        ])

-        self.params.set_val("username", username, value_type="string")

+        _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__, 

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

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

+           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

@@ -147,7 +129,7 @@ class PbGradient(Pb):
             ],

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

             }

-        cmd += _gradients[self.params.gradienttype]

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

             

         if self.params.blurriness: 

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

@@ -158,10 +140,10 @@ class PbGradient(Pb):
                 cmd.append("{},{}".format(self.params.stripenumber,self.params.stripeintensity))

             else:

                 cmd.append(self.params.stripenumber)

-        if self.params.halftone in _halftone_values: 

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

             cmd.extend([

                 "-ordered-dither", 

-                _halftone_values[self.params.halftone]

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

             ])

         cmd += [ 

             '-modulate', 

@@ -188,7 +170,7 @@ class PbGradient(Pb):
             "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"],

-        }[self.params.bevel]

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

 

     def _make_bevel(self):

         cmd = [BEVELBORDER]

diff --git a/Pb/Grid/__init__.py b/Pb/Grid/__init__.py
index 4cc31ee..2f7ae4b 100755
--- a/Pb/Grid/__init__.py
+++ b/Pb/Grid/__init__.py
@@ -21,56 +21,35 @@ class PbGrid(Pb):
       'shadow' : 'true',
       'trim' : 'true'
     }
-    def __init__(self, 
-          width=None,
-          height=None,
-          linethickness=1,
-          opacity=1.0,
-          linecolor="whitesmoke",
-          spacing=10,
-          vlines=False,
-          hlines=False,
-          shadow=False,
-          bgimage=None,
-          bgcolor="transparent",
-          imageinstead=None,
-          planebgcolor="transparent",
-          planebgimage=None,
-          swing=False,
-          tilt=False,
-          roll=False,
-          zoom=0,
-          skycolor="transparent",
-          transition="background",
-          trim=False,
-          finalformat=DEFAULT_FINALFORMAT,
-          username=""
-        ):
+    def __init__(self, **kwargs ):
         super(PbGrid,self).__init__();
-        self.params.set_val("width", width or 0, value_type="int")
-        self.params.set_val("height", height or 0, value_type="int")
-        self.params.set_val("linethickness", linethickness, value_type="int")
-        self.params.set_val("opacity", opacity, value_type="float")
-        self.params.set_val("linecolor", linecolor, value_type="color")
-        self.params.set_val("linethickness", linethickness, value_type="int")
-        self.params.set_val("spacing", spacing, value_type="int")
-        self.params.set_val("vlines", vlines, value_type="bool")
-        self.params.set_val("hlines", hlines, value_type="bool")
-        self.params.set_val("shadow", shadow, value_type="bool")
-        self.params.set_val("bgimage", bgimage, value_type="img_url")
-        self.params.set_val("bgcolor", bgcolor, value_type="color")
-        self.params.set_val("imageinstead", imageinstead, value_type="img_url")
-        self.params.set_val("planebgcolor", planebgcolor, value_type="color")
-        self.params.set_val("planebgimage", planebgimage, value_type="img_url")
-        self.params.set_val("swing", swing, value_type="int")
-        self.params.set_val("tilt", tilt, value_type="int")
-        self.params.set_val("roll", roll, value_type="int")
-        self.params.set_val("zoom", zoom, value_type="int")
-        self.params.set_val("skycolor", skycolor, value_type="color")
-        self.params.set_val("transition", transition, value_type="enum", enum_values=["background", "dither", "edge", "mirror", "random", "tile"]) #FIXME
-        self.params.set_val("trim", trim, value_type="bool")
-        self.params.set_val("finalformat", finalformat, value_type="enum", enum_values=OUTPUT_IMAGE_TYPES)# FIXME
-        self.params.set_val("username", username, value_type="string");
+        _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:
@@ -78,8 +57,6 @@ class PbGrid(Pb):
         else:
           self.filename, self.filepath = self._filename_filepath_create(extension=self.params.finalformat)
 
-#FIXME choose gif frame
-
     #makes a canvas file...step 1 (if not bgimage)
     def _make_canvas(self):
         dimensions = "{}x{}".format(
diff --git a/Pb/Landscape/__init__.py b/Pb/Landscape/__init__.py
index 4df06fd..33eedd6 100755
--- a/Pb/Landscape/__init__.py
+++ b/Pb/Landscape/__init__.py
@@ -2,7 +2,7 @@ from Config import *
 import Pb
 import base64
 from Pb import Pb
-import urlparse
+import urlparse, re
 
 class PbLandscape(Pb):
     example_params = {
@@ -11,22 +11,21 @@ class PbLandscape(Pb):
       'heightmap' : 'http://someurl.biz/someimg.jpg',
       'name' : 'donkey'
     }
-    def __init__(self, 
-      heightmap=None,
-      imgdata=None,
-      texture=None,
-      name="",
-    ):
+    def __init__(self, **kwargs):
       super(PbLandscape,self).__init__();
-      self.params.set_val("heightmap", heightmap, value_type="string");
-      self.params.set_val("imgdata", imgdata, value_type="raw");
-      self.params.set_val("texture", texture, value_type="string");
-      self.params.set_val("username", name, value_type="string");
-      self.filename, self.filepath = self._filename_filepath_create(url=self.params.texture, extension="png")
+      _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(self.params.imgdata)
+        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'
diff --git a/Pb/Pattern/__init__.py b/Pb/Pattern/__init__.py
index 3a094dd..4e4c5a8 100755
--- a/Pb/Pattern/__init__.py
+++ b/Pb/Pattern/__init__.py
@@ -19,19 +19,15 @@ class PbPattern(Pb):
     #    "username" : "garfield",
          "image_url" : "http://i.asdf.us/im/be/PinkHijab_1425078647_reye.gif",
     } 
-    def __init__(self, 
-          pattern_url=None,
-          pattern_data=None,
-          username=None,
-          image_url=None,
-        ):
+    def __init__(self, **kwargs): 
         super(PbPattern,self).__init__();
-
-        self.params.set_val("image_url", image_url, value_type="img_url");
-        self.params.set_val("pattern_url", pattern_url, value_type="img_url");
-        self.params.set_val("pattern_data", pattern_data, value_type="json");
-        self.params.set_val("username", username, value_type="string");
-
+        _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")
 
@@ -45,7 +41,7 @@ class PbPattern(Pb):
                 return (0,0,0,255);
             else:
                 return (255,255,255,255)
-        specs = json.loads(self.params.pattern_data);
+        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")
diff --git a/Pb/__init__.py b/Pb/__init__.py
index ff0a764..4d8a8d4 100644
--- a/Pb/__init__.py
+++ b/Pb/__init__.py
@@ -27,7 +27,7 @@ class Pb(object):
      if url:
         _basename = os.path.basename(url)
         namepart = re.split(r'\.', _basename)[0]
-        namepart = self.params.sanitize(namepart)[0:_max_filename_length]
+        namepart = self._url_sanitize(namepart)[0:_max_filename_length]
      name = ""   
      if namepart: name += "%s-" % namepart 
      name += "%s_%s" % (self.__class__.__name__, self._now)
@@ -47,6 +47,9 @@ class Pb(object):
      _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)