ok all modules working

16 files changed, 154 insertions, 227 deletions

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)