ok pretty much done with gradient, moving on to generate

5 files changed, 174 insertions, 193 deletions

diff --git a/Pb/Break/__init__.py b/Pb/Break/__init__.py
index 9f5dba5..eced793 100755
--- a/Pb/Break/__init__.py
+++ b/Pb/Break/__init__.py
@@ -18,7 +18,7 @@ _header_offset = 2000
 _default_breakmode = "subtle"
 
 class PbBreak(Pb): #FIXME in db gallery
-    _test_params = {
+    example_params = {
         "url" : "http://i.asdf.us/im/de/HolyMountain2_1322275112_seamonkey.gif",
         "breaktype" : "RGB_WASH",
         "finalformat" : "png",
diff --git a/Pb/Generate/__init__.py b/Pb/Generate/__init__.py
index 191d600..3aa9c6d 100755
--- a/Pb/Generate/__init__.py
+++ b/Pb/Generate/__init__.py
@@ -1,72 +1,124 @@
 #!/usr/bin/python2.7
 import sys
 import os
-
 from Config import *
 from Pb import Pb
-#FIXME these guys can do stuff wider than 1000
-LIKE_A_BOSS = "ryz pepper seamonkey JAMES".split(" ")
-DEFAULT_FINALFORMAT = "gif"
-DEFAULT_TAG = "im";
 
-GRAVITY_PARAMS = ["NorthWest","North","NorthEast","West","Center","East","SouthWest","South","SouthEast"]
-GRAVITY_DEFAULT = "Center"
-FORMAT_PARAMS = ["jpg", "gif", "png"]
-COMPOSE_PARAMS = [ "Over", "ATop", "Dst_Over", "Dst_In", "Dst_Out", "Multiply", 
+_gravity_params = ["NorthWest","North","NorthEast","West","Center","East","SouthWest","South","SouthEast"]
+_gravity_default = "Center"
+_compose_params = [ "Over", "ATop", "Dst_Over", "Dst_In", "Dst_Out", "Multiply", 
   "Screen", "Divide", "Plus", "Difference", "Exclusion",
   "Lighten", "Darken", "Overlay", "Hard_Light", "Soft_Light", 
   "Linear_Dodge", "Linear_Burn", "Color_Dodge", "Color_Burn" ]
-DISPOSE_PARAMS = ["None","Previous","Background"]
-DISPOSE_DEFAULT = "None"
-
-def debuglog(s):
-  sys.stderr.write(str(s) + "\n");
+_dispose_params = ["None","Previous","Background"]
+_dispose_default = "None"
 
 class Im(Pb):
-    def __init__(self, **kwargs):
-        self.params = {}
-        self._now = self.now()
-        self.files_created = []
-        self.commands = [];
-        self._required_keys = [
+    example_params = {
+     'nearest': 'true',
+  #   'height': None,
+     'compose': 'Soft_Light',
+     'coalesce': 'true',
+     'dispose': 'None',
+     'gravity': 'Center',
+     'width': '200',
+     'black': 'black',
+     'tile': 'true',
+     'white': 'white',
+     'contrast': '100',
+     'hue': '90',
+     'saturation': '100',
+     'merge_early': 'true',
+     'format': 'gif',
+     'background': 'http://i.asdf.us/im/bc/new_1430440747.gif',
+     'subtract': '#EE7AE9',
+     'transparent': 'true',
+  #   'rotate': None,
+     'name': 'yo',
+  #   'brightness': None,
+     'url': 'http://asdf.us/im/new.gif',
+     'flop': 'true',
+     'flip': 'false',
+     'callback': 'jsonp1430442384162',
+     'fuzz': '5'
+    }
+    def __init__(self, 
+      #URLS
+      url=None,
+      background=None,
+
+      #BOOLS
+      coalesce=None,
+      dispose="None",
+      nearest=None,
+      merge_early=None,
+      flip=None,
+      flop=None,
+      tile=None,
+      transparent=None,
+
+      #COLORS
+      black=None,
+      white=None,
+      subtract=None,
+
+      #INTS
+      fuzz=None,
+      width=None,
+      height=None,
+      brightness=None,
+      contrast=None,
+      saturation=None,
+      rotate=None,
+      hue=None,
+      
+      #ENUMS
+      compose=None,
+      gravity=_gravity_default,
+      format=DEFAULT_FINALFORMAT,
+
+      #STRINGS
+      username=None,
+      callback=None,
+    ):  
 #{{{ required_keys
-            #IMAGES
-            "url",
-            "background",
+          #IMAGES
+          "url",
+          "background",
 
-            #BOOLS
-            "coalesce",
-            "dispose",
-            "nearest",
-            "merge_early",
-            "flip",
-            "flop",
-            "tile",
-            "transparent",
+          #BOOLS
+          "coalesce",
+          "dispose",
+          "nearest",
+          "merge_early",
+          "flip",
+          "flop",
+          "tile",
+          "transparent",
 
-            #COLORS
-            "black",
-            "white",
-            "subtract",
+          #COLORS
+          "black",
+          "white",
+          "subtract",
 
-            #INTS
-            "fuzz",
-            "width",
-            "height",
-            "brightness",
-            "contrast",
-            "saturation",
-            "rotate",
-            "hue",
-            
-            #ENUMS
-            "compose",
-            "gravity",
-            "format",
+          #INTS
+          "fuzz",
+          "width",
+          "height",
+          "brightness",
+          "contrast",
+          "saturation",
+          "rotate",
+          "hue",
+          
+          #ENUMS
+          "compose",
+          "gravity",
+          "format",
 
-            #STRINGS
-            "username",
-            "callback",
+          #STRINGS
+          "username",
+          "callback",
 #}}}
         ]
         for k in self._required_keys:
@@ -124,33 +176,6 @@ class Im(Pb):
         self.filename = "{}.{}".format(self.basename, self.params.get('format', DEFAULT_FINALFORMAT))
         self.filepath = os.path.join(WORKING_DIR, self.filename) 
 
-    def _make_tempname(self, s):
-      return "PBTMP{}{}".format(self._now, s); 
-
-    def _test_enum(self, e, arr):
-      if e in arr: return True
-      raise Exception ("Bad value: {}".format(e))
-
-    def _get_filename(self):
-        return "{}_{}_{}".format(
-            self.tag,
-            self._now,
-            self.params.get('username',"")
-        );
-
-    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 _cleanup(self):
-        if not len(self.files_created):
-            pass
-        cmd = ["rm", "-f"] + self.files_created
-        self._call_cmd(cmd)
-
     def _composite (self):
       cmd = [
         BIN_CONVERT, self.params['background']['path'], 
@@ -195,36 +220,3 @@ class Im(Pb):
       if self.params.get('background'):
         self._composite()
       self._cleanup();
-
-if __name__ == "__main__":
-
-  TEST_PARAMS = {
-   'nearest': 'true',
-#   'height': None,
-   'compose': 'Soft_Light',
-   'coalesce': 'true',
-   'dispose': 'None',
-   'gravity': 'Center',
-   'width': '200',
-   'black': 'black',
-   'tile': 'true',
-   'white': 'white',
-   'contrast': '100',
-   'hue': '90',
-   'saturation': '100',
-   'merge_early': 'true',
-   'format': 'gif',
-   'background': 'http://i.asdf.us/im/bc/new_1430440747.gif',
-   'subtract': '#EE7AE9',
-   'transparent': 'true',
-#   'rotate': None,
-   'name': 'yo',
-#   'brightness': None,
-   'url': 'http://asdf.us/im/new.gif',
-   'flop': 'true',
-   'flip': 'false',
-   'callback': 'jsonp1430442384162',
-   'fuzz': '5'
-  }
-  g = Generate(**TEST_PARAMS);
-  g.create() 
diff --git a/Pb/Gradient/__init__.py b/Pb/Gradient/__init__.py
index 6640278..bde42ba 100755
--- a/Pb/Gradient/__init__.py
+++ b/Pb/Gradient/__init__.py
@@ -24,7 +24,7 @@ _halftone_values = {
 }

 

 class PbGradient(Pb):

-    _test_params = {

+    example_params = {

       "width" : "200",

       "color1" : "#ffdead",

       "color2" : "blue",

@@ -44,7 +44,7 @@ class PbGradient(Pb):
     def __init__(self, 

         width=DEFAULT_WIDTH, height=DEFAULT_HEIGHT, 

         color1=_default_color_1, color2=_default_color_2, 

-        stripes=0,

+        stripes=False,

         stripenumber=0, 

         stripeintensity=0, 

         blurriness=0, 

@@ -66,7 +66,7 @@ class PbGradient(Pb):
         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="int")

+        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")

@@ -75,36 +75,30 @@ class PbGradient(Pb):
         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")

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

+        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("height", height, value_type="int")

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

-        for key in PARAM_LIST:

-            if key in kwargs:

-                if key in ['color1', 'color2']:

-                    params[key] = self.is_color(kwargs[key])

-                else:

-                    params[key] = self.sanitize(kwargs[key])

-                    

-                if key in ['rotate','tilt','blurriness','stripenumber','stripeintensity']:

-                    params[key] = params[key] if self.is_number(params[key]) else ""

-                elif key in ['brightness', 'contrast', 'hue']:

-                    if not self.is_number(params[key]) or params[key] == "100": params[key] = ""

-            else:

-                params[key] = ""

-        params['width'] = params['width'] if self.is_number(params['width']) else DEFAULT_WIDTH 

-        params['height'] = params['height'] if self.is_number(params['height']) else DEFAULT_HEIGHT         

-        params["color1"] = params["color1"] or DEFAULT_COLORS["color1"];

-        params["color2"] = params["color2"] or DEFAULT_COLORS["color2"];

-        self.params = params

-        if not self.params['percentbeveled']: self.params['percentbeveled'] = DEFAULT_BEVEL_PERCENT

-        self._bevelvalues = [

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

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

-        ]

+        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=["gif", "png", "jpg"])

+        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")

+

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

 

-    def _filename_create(self):         

+    def _filename_create(self, **kwargs):         

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

            self.__class__.__name__, 

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

@@ -116,75 +110,76 @@ class PbGradient(Pb):
 

 

     def _build_cmd(self):

-        self.cmd = [BIN_CONVERT]

-        self.cmd.extend([

+        cmd = [BIN_CONVERT]

+        cmd.extend([

             '-size',

-            "{}x{}".format(self.params["width"],self.params["height"])

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

         ])

         

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

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

-        if self.params['flip'] == "true": self.cmd.append("-flip")

-        if self.params['flop'] == "true": self.cmd.append("-flop")

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

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

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

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

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

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

         _gradients = {

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

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

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

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

             "radial" : [

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

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

                 ],

             "colorspace" : [

                 "-colorspace",

                 "Gray",

-                "plasma:{}-{}".format(self.params['color1'], self.params['color2'])

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

             ],

             "mirrored" : [

-                "plasma:{}-{}".format(self.params['color1'], self.params['color2']),

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

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

                  "append"

             ],

             "plasmawash" : [

-                "plasma:{}-{}".format(self.params['color1'], self.params['color2']),

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

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

             ],

             "gradientwash" : [

-                "gradient:{}-{}".format(self.params['color1'], self.params['color2']),

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

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

             ],

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

             }

         cmd += _gradients[self.params.gradienttype]

             

-        if self.params['blurriness']: 

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

+        if self.params.blurriness: 

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

         

-        if self.params['stripes'] == "true" and len(self.params['stripenumber']):

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

-            if self.params['stripeintensity']:  

-                self.cmd.append("{},{}".format(self.params['stripenumber'],self.params["stripeintensity"]))

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

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

+            if self.params.stripeintensity:  

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

             else:

-                self.cmd.append(self.params['stripenumber'])

-        if self.params["halftone"] in HALFTONEVALUES: 

-            self.cmd.extend([

+                cmd.append(self.params.stripenumber)

+        if self.params.halftone in _halftone_values: 

+            cmd.extend([

                 "-ordered-dither", 

-                HALFTONEVALUES[self.params["halftone"]]

+                _halftone_values[self.params.halftone]

             ])

-        self.cmd += [ 

+        cmd += [ 

             '-modulate', 

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

-            self.params['brightness'] or "100",

-            self.params['saturation'] or "100",

-            self.params['hue'] or "100")

+            self.params.brightness or "100",

+            self.params.saturation or "100",

+            self.params.hue or "100")

         ]

-        self.cmd.append(os.path.join(self.directory,self.filename));

-        self._call_cmd(self.cmd)

+        cmd.append(self.filepath);

+        self._call_cmd(cmd)

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

 

     def _get_bevelvalue(self):

-        w, h = map(int, (self.params['width'], self.params['height']))

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

         if h >= w:

-            bevpercentval = str(int(self.params['percentbeveled'])*0.005*int(h))

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

         else:

-            bevpercentval = str(int(self.params['percentbeveled'])*0.005*int(w))

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

         return {

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

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

@@ -193,20 +188,14 @@ 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']]

+        }[self.params.bevel]

 

     def _make_bevel(self):

         cmd = [BEVELBORDER]

         cmd += self._get_bevelvalue() 

-        cmd += [ os.path.join(self.directory,self.filename), os.path.join(self.directory, self.filename) ]

+        cmd += [ self.filepath]

         self._call_cmd(cmd)

 

     def create(self):

-        self.filename = self.newfilename() 

-        self.filepath = os.path.join(self.directory, self.filename)

         self._build_cmd()

-#        sys.stderr.write(str(self.cmd))

-

-        if self.params['bevel'] in self._bevelvalues: 

-            self._make_bevel()

 

diff --git a/Pb/__init__.py b/Pb/__init__.py
index af4558f..607362f 100644
--- a/Pb/__init__.py
+++ b/Pb/__init__.py
@@ -108,10 +108,10 @@ class Pb(object):
     sys.exit(1);
   
   @classmethod
-  def test(cls, test_params=None):
-    test_params = test_params or cls._test_params
-    if not test_params:
+  def example_run(cls, params=None):
+    example_params = params or cls.example_params
+    if not example_params:
       raise AttributeError ("Must supply test params to test %s" % cls.__name__)
-    b = cls(**test_params)
+    b = cls(**example_params)
     b.create();
 
diff --git a/test.py b/test.py
index 58c3114..53dd4ed 100644
--- a/test.py
+++ b/test.py
@@ -1,2 +1,2 @@
-from Pb.Break import PbBreak
-PbBreak.test()
+from Pb.Gradient import PbGradient
+PbGradient.example_run()