required=0, -e commit message for your changes. Lines starting

22 files changed, 610 insertions, 367 deletions

diff --git a/ricky/TODO b/ricky/TODO
new file mode 100644
index 0000000..fe1900d
--- /dev/null
+++ b/ricky/TODO
@@ -0,0 +1 @@
+change MultiSelect to include options
diff --git a/ricky/imbreak/__init__.py b/ricky/imbreak/__init__.py
index 752d977..c2a5a61 100644
--- a/ricky/imbreak/__init__.py
+++ b/ricky/imbreak/__init__.py
@@ -1 +1,12 @@
-from ricky.imbreak.imbreak import ImBreak
+from ricky.im import Im
+from ricky.imbreak.params import ImBreakParams
+from ricky.config import IMBREAK_URL
+
+class ImBreak(Im):
+    def __init__(self):
+        self.url = IMBREAK_URL
+    def params_init(self):
+        new_params = ImBreakParams()
+        #new_params = self.get_from_server()
+        new_params.api = self
+        return new_params
diff --git a/ricky/imbreak/imbreak.py b/ricky/imbreak/imbreak.py
deleted file mode 100644
index c2a5a61..0000000
--- a/ricky/imbreak/imbreak.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from ricky.im import Im
-from ricky.imbreak.params import ImBreakParams
-from ricky.config import IMBREAK_URL
-
-class ImBreak(Im):
-    def __init__(self):
-        self.url = IMBREAK_URL
-    def params_init(self):
-        new_params = ImBreakParams()
-        #new_params = self.get_from_server()
-        new_params.api = self
-        return new_params
diff --git a/ricky/imbreak/params.py b/ricky/imbreak/params.py
index 0c437d6..4cf3af9 100644
--- a/ricky/imbreak/params.py
+++ b/ricky/imbreak/params.py
@@ -1,57 +1,57 @@
-import re, random
 from ricky.params import Params
-from ricky.param.selection import Selection
-from ricky.param.selections import Selections
 from ricky.param.username import Username
 from ricky.param.imageurl import ImageUrl
 from ricky.param.multiselect import MultiSelect
-from ricky.param.numberrange import NumberRange
-from ricky.param.color import Color
-from ricky.config import PATTERN_BASE_URL
+from ricky.param.constrainednumber import ConstrainedNumber
+from ricky.param.bool import Bool
 
 
-breaktype_selections = Selections.from_dict(
-    {"value":"CLASSIC",         "weight": 1},
-    {"value":"REDUX",           "weight": 1},
-    {"value":"BLURRY_BREAK",    "weight": 1},
-    {"value":"BLURRY_BREAK_2",  "weight": 1},
-    {"value":"SWIPE",           "weight": 1},
-    {"value":"RGB_WASH",        "weight": 1},
-    {"value":"RGB_WASH_2",      "weight": 1},
-    {"value":"NOISY_BREAK",     "weight": 1},
-    {"value":"BROKEN_VIGNETTE", "weight": 1},
-    {"value":"FAX_MACHINE",     "weight": 1},
-    {"value":"STRIPES",         "weight": 1},
-    {"value":"PHOTOCOPY",       "weight": 1},
-)
-breakmode_selections = Selections.from_dict(
-    {"value":"extreme",  "weight": 1},
-    {"value":"subtle",  "weight": 1},
-)
-finalformat_selections = Selections.from_dict(
-    {"value":"png",  "weight": 5},
-    {"value":"jpg",  "weight": 2},
-    {"value":"gif",  "weight": 2},
-)
-breakangle_selections = Selections.from_dict(
-    {"value":0,  "weight": 9},
-    {"value":90,  "weight": 2},
-    {"value":-180,  "weight": 2},
-    {"value":180,  "weight": 2},
-)
-expanded_selections = Selections.from_dict(
-    {"value": "" , "weight": 11 },
-    {"value": 1, "weight": 2}
-)
+breaktype_options = [
+    "CLASSIC",
+    "REDUX",
+    "BLURRY_BREAK",
+    "BLURRY_BREAK_2",
+    "SWIPE",
+    "RGB_WASH",
+    "RGB_WASH_2",
+    "NOISY_BREAK",
+    "BROKEN_VIGNETTE",
+    "FAX_MACHINE",
+    "STRIPES",
+    "PHOTOCOPY"
+]
+breakmode_options = [
+    "extreme",
+    "subtle",
+]
+finalformat_options = [
+    "png",
+    "jpg",
+    "gif",
+]
+
 
 class ImBreakParams(Params):
     def __init__(self):
         self._params = [
            Username(name="username", required=0),
            ImageUrl(name="url", required=1),
-           MultiSelect(name="finalformat", required=0, selections=finalformat_selections),
-           MultiSelect(name="breaktype", required=1, selections=breaktype_selections),
-           NumberRange(name="breakangle", required=0, selections=breakangle_selections, min=-180, max=180),
-           MultiSelect(name="breakmode", required=1, selections=breakmode_selections),
-           MultiSelect(name="expanded", required=0, selections=expanded_selections),
+           MultiSelect(
+                       name="finalformat",
+                       required=0,
+                       options=finalformat_options),
+           MultiSelect(
+                       name="breaktype",
+                       required=1,
+                       options=breaktype_options),
+           ConstrainedNumber(
+                       name="breakangle",
+                       required=0,
+                       min=-180,
+                       max=180),
+           MultiSelect(
+                       name="breakmode",
+                       required=1,
+                       options=breakmode_options),
+           Bool(name="expanded", required=0)
         ]
diff --git a/ricky/imbreak/probability.json b/ricky/imbreak/probability.json
new file mode 100644
index 0000000..9c28e6d
--- /dev/null
+++ b/ricky/imbreak/probability.json
@@ -0,0 +1,35 @@
+{
+    "breaktype" :[
+        {"value": "CLASSIC", "weight": 1},
+        {"value": "REDUX", "weight": 1},
+        {"value": "BLURRY_BREAK", "weight": 1},
+        {"value": "BLURRY_BREAK_2", "weight": 1},
+        {"value": "SWIPE", "weight": 1},
+        {"value": "RGB_WASH", "weight": 1},
+        {"value": "RGB_WASH_2", "weight": 1},
+        {"value": "NOISY_BREAK", "weight": 1},
+        {"value": "BROKEN_VIGNETTE", "weight": 1},
+        {"value": "FAX_MACHINE", "weight": 1},
+        {"value": "STRIPES", "weight": 1},
+        {"value": "PHOTOCOPY", "weight": 1}
+    ],
+    "breakmode" :[
+        {"value": "extreme", "weight": 1},
+        {"value": "subtle", "weight": 1}
+    ],
+    "finalformat" :[
+        {"value": "png", "weight": 5},
+        {"value": "jpg", "weight": 2},
+        {"value": "gif", "weight": 2}
+    ],
+    "breakangle" :[
+        {"value": 0, "weight": 9},
+        {"value": 90, "weight": 2},
+        {"value": -180, "weight": 2},
+        {"value": 180, "weight": 2}
+    ],
+    "expanded" :[
+        {"value": "", "weight": 11},
+        {"value": 1, "weight": 2}
+    ]
+}
diff --git a/ricky/imgrid/__init__.py b/ricky/imgrid/__init__.py
index 1ff6788..3b0b128 100644
--- a/ricky/imgrid/__init__.py
+++ b/ricky/imgrid/__init__.py
@@ -1 +1,12 @@
-from imgrid import ImGrid
+from ricky.im import Im
+from ricky.imgrid.params import ImGridParams
+from ricky.config import IMGRID_URL
+
+class ImGrid(Im):
+    def __init__(self):
+        self.url = IMGRID_URL
+    def params_init(self):
+        new_params = ImGridParams()
+        #new_params = self.get_from_server()
+        new_params.api = self
+        return new_params
diff --git a/ricky/imgrid/imgrid.py b/ricky/imgrid/imgrid.py
deleted file mode 100644
index 3b0b128..0000000
--- a/ricky/imgrid/imgrid.py
+++ /dev/null
@@ -1,12 +0,0 @@
-from ricky.im import Im
-from ricky.imgrid.params import ImGridParams
-from ricky.config import IMGRID_URL
-
-class ImGrid(Im):
-    def __init__(self):
-        self.url = IMGRID_URL
-    def params_init(self):
-        new_params = ImGridParams()
-        #new_params = self.get_from_server()
-        new_params.api = self
-        return new_params
diff --git a/ricky/imgrid/selections.py b/ricky/imgrid/options.py
index 7338709..38ba1ee 100755
--- a/ricky/imgrid/selections.py
+++ b/ricky/imgrid/options.py
@@ -1,10 +1,9 @@
-from ricky.param.selections import Selections
-format_selections = Selections.from_dict(
+format_probabilities = Probabilities.from_dict(
   { 'weight': 20, 'value': 'png' },
   { 'weight': 0, 'value': 'gif' },
   { 'weight': 0, 'value': 'jpg' },
 )
-transition_selections = Selections.from_dict(
+transition_probabilities = Probabilities.from_dict(
   { "value" : "background", "weight": 1 },
   { "value" : "dither", "weight": 1 },
   { "value" : "random", "weight": 1 },
@@ -12,52 +11,52 @@ transition_selections = Selections.from_dict(
   { "value" : "edge", "weight": 1 },
 )
 skycolor_colors = \
-  bgcolor_colors = planebgcolor_colors = Selections.from_dict(
+  bgcolor_colors = planebgcolor_colors = Probabilities.from_dict(
   { "value" : "white", "weight" : 1 },
   { "value" : "silver", "weight" : 1 },
   { "value" : None, "weight" : 10 },
 )
 
-linecolor_colors = Selections.from_dict(
+linecolor_colors = Probabilities.from_dict(
   { "value" : "black", "weight" : 1 },
   { "value" : "white", "weight" : 1 },
   { "value" : "silver", "weight" : 1 },
 )
-swing_selections = tilt_selections = roll_selections = Selections.from_dict(
+swing_probabilities = tilt_probabilities = roll_probabilities = Probabilities.from_dict(
    {"value": "",  "weight": 2},
    {"value": 30,   "weight": 1},
    {"value": -30,   "weight": 1},
 )
-width_selections = height_selections = Selections.from_dict(
+width_probabilities = height_probabilities = Probabilities.from_dict(
    { "value" : 400, "weight" : 1 },
    { "value" : 600, "weight" : 1 },
 )
-linethickness_selections = Selections.from_dict(
+linethickness_probabilities = Probabilities.from_dict(
    {"value":1,  "weight": 2},
    {"value":2,  "weight": 1},
 )
-opacity_selections = Selections.from_dict(
+opacity_probabilities = Probabilities.from_dict(
    {"value":1,  "weight": 2},
    {"value":0.5,  "weight": 1},
 )
-spacing_selections = Selections.from_dict(
+spacing_probabilities = Probabilities.from_dict(
    {"value":10,  "weight": 1},
    {"value":15,  "weight": 1},
 )
-vlines_selections = hlines_selections = Selections.from_dict(
+vlines_probabilities = hlines_probabilities = Probabilities.from_dict(
    {"value":"",  "weight": 2},
    {"value":"true",   "weight": 1},
 )
-shadow_selections = Selections.from_dict(
+shadow_probabilities = Probabilities.from_dict(
    {"value":"",  "weight": 1},
    {"value":"true",   "weight": 1},
 )
-zoom_selections = Selections.from_dict(
+zoom_probabilities = Probabilities.from_dict(
     {"value": 0,  "weight": 3},
     {"value": 1.2,  "weight": 1},
     {"value": -1.2,  "weight": 1},
 )
-trim_selections = Selections.from_dict(
+trim_probabilities = Probabilities.from_dict(
    {"value":"",  "weight": 1},
    {"value":"true",   "weight": 1},
 )
diff --git a/ricky/imgrid/params.py b/ricky/imgrid/params.py
index 580c2f2..5740ebc 100644
--- a/ricky/imgrid/params.py
+++ b/ricky/imgrid/params.py
@@ -1,61 +1,92 @@
-import re, random
+import random
 from ricky.params import Params
-from ricky.param import Param
-from ricky.param.selection import Selection
-from ricky.param.selections import Selections
 from ricky.param.username import Username
 from ricky.param.imageurl import ImageUrl
 from ricky.param.multiselect import MultiSelect
-from ricky.param.numberrange import NumberRange
+from ricky.param.constrainednumber import ConstrainedNumber
 from ricky.param.color import Color
+from ricky.param.bool import Bool
 
-from ricky.imgrid.selections import *
+_TRANSITION_OPTIONS = [
+    "background",
+    "dither",
+    "random",
+    "tile",
+    "edge"
+]
 
-class Param_Zoom(NumberRange):
-  def __init__(self, **kwargs):
-    super(Param_Zoom, self).__init__(**kwargs)
-    self.exclusion_range = kwargs['exclusion_range']
-  def test_value(self):
-    return not ((self.value > self.exclusion_range[0]) and (self.value < self.exclusion_range[1]))
-  def randomize(self):
-    weights_total = sum(map(lambda x: x["weight"], self.selections())) + 10
-    choice = random.randint(0, weights_total)
-    position = 0
-    for elem in self.selections():
-       position += elem["weight"]
-       if position >= choice:
-           self.value = elem["value"]
-           return
-    max_tries = 10000
-    while(max_tries):
-      self.value = round(random.uniform(self.range_max, self.range_min), 2)
-      if self.test_value: return
-      max_tries -= 1;
-    raise ValueError
+_FILETYPE_OPTIONS = [
+    "png",
+    "jpg",
+    "gif",
+]
 
-  @property
-  def value(self):
-    return super(MultiSelect, self).value_get()
-  @value.setter
-  def value(self, value):
-    self._value = value
-    if not self._value is None:
-      self.is_ready = 1
-    self.set_by_user = 1
 
-class Param_Opacity(NumberRange):
-  def __init__(self, **kwargs):
-    super(Param_Opacity, self).__init__(**kwargs)
-  def randomize(self):
-    weights_total = sum(map(lambda x: x["weight"], self.selections()) + self.range_max - self.range_min)
-    choice = random.randint(0, weights_total)
-    position = 0
-    for elem in self.selections():
-       position += elem["weight"]
-       if position >= choice:
-           self.value = elem["value"]
-           return
-    self.value = round(random.uniform(self.range_min,range_max), 2),
+class Param_Zoom(ConstrainedNumber):
+    def __init__(self, **kwargs):
+        super(Param_Zoom, self).__init__(**kwargs)
+        self.exclusion_range = kwargs['exclusion_range']
+
+    def test_value(self):
+        return not (
+            (self.value > self.exclusion_range[0]) and
+            (self.value < self.exclusion_range[1])
+        )
+
+    def randomize(self):
+        weights_total = sum(
+            map(lambda x: x["weight"], self.probabilities())
+        ) + 10
+        choice = random.randint(0, weights_total)
+        position = 0
+        for elem in self.probabilities():
+            position += elem["weight"]
+            if position >= choice:
+                self.value = elem["value"]
+                return
+        max_tries = 10000
+        while(max_tries):
+            self.value = round(
+                random.uniform(self.range_max, self.range_min), 2
+            )
+            if self.test_value:
+                return
+            max_tries -= 1
+        raise ValueError
+
+    @property
+    def value(self):
+        return super(MultiSelect, self).value_get()
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+        if self._value is not None:
+            self.is_ready = 1
+        self.set_by_user = 1
+
+
+class Param_Opacity(ConstrainedNumber):
+    def __init__(self, **kwargs):
+        super(Param_Opacity, self).__init__(**kwargs)
+
+    def randomize(self):
+        weights_total = sum(
+            map(
+                lambda x: x["weight"], self.probabilities()
+            ) + self.range_max - self.range_min
+        )
+        choice = random.randint(0, weights_total)
+        position = 0
+        for elem in self.probabilities():
+            position += elem["weight"]
+            if position >= choice:
+                self.value = elem["value"]
+                return
+        self.value = round(
+            random.uniform(self.range_min, self.range_max), 2
+        )
+
 
 class ImGridParams(Params):
     def __init__(self):
@@ -64,48 +95,65 @@ class ImGridParams(Params):
            ImageUrl(name="bgimage", required=0),
            ImageUrl(name="imageinstead", required=0),
            ImageUrl(name="planebgimage", required=0),
-           MultiSelect(name="format", required=0, selections=format_selections),
-           MultiSelect(name="transition", required=1, selections=transition_selections),
-           Color(name="skycolor", required=0, selections=skycolor_colors),
-           Color(name="planebgcolor", required=0, selections=planebgcolor_colors),
-           Color(name="bgcolor", required=0, selections=bgcolor_colors),
-           Color(name="linecolor", required=0, selections=linecolor_colors),
-           NumberRange(name="swing", required=0, selections=swing_selections, min=-170, max=170),
-           NumberRange(name="tilt", required=0, selections=tilt_selections, min=-170, max=170),
-           NumberRange(name="roll", required=0, selections=roll_selections, min=-170, max=170),
-           NumberRange(name="width", required=0, selections=width_selections, min=100, max=800),
-           NumberRange(name="height", required=0, selections=height_selections, min=100, max=800),
-           NumberRange(name="linethickness", required=0, selections=linethickness_selections, min=1, max=30),
-           NumberRange(name="opacity", required=0, selections=opacity_selections, min=0, max=1),
-           NumberRange(name="spacing", required=0, selections=spacing_selections, min=2, max=100),
-           MultiSelect(name="vlines", required=0, selections=vlines_selections),
-           MultiSelect(name="hlines", required=0, selections=hlines_selections),
-           MultiSelect(name="trim", required=0, selections=trim_selections),
-           MultiSelect(name="shadow", required=0, selections=shadow_selections),
-           Param_Zoom(name="zoom", required=0, selections=zoom_selections, min=-12, max=12, exclusion_range=[-1.1, 1.1]),
+           MultiSelect(
+               name="format",
+               required=False,
+               options=_FILETYPE_OPTIONS
+           ),
+           MultiSelect(
+               name="transition",
+               required=1,
+               options=_TRANSITION_OPTIONS
+           ),
+           Color(name="skycolor", required=False),
+           Color(name="planebgcolor", required=False),
+           Color(name="bgcolor", required=False),
+           Color(name="linecolor", required=False),
+           ConstrainedNumber(name="swing", required=False, min=-170, max=170),
+           ConstrainedNumber(name="tilt", required=False, min=-170, max=170),
+           ConstrainedNumber(name="roll", required=False, min=-170, max=170),
+           ConstrainedNumber(name="width", required=False, min=100, max=800),
+           ConstrainedNumber(name="height", required=False, min=100, max=800),
+           ConstrainedNumber(
+               name="linethickness",
+               required=False,
+               min=1,
+               max=30
+           ),
+           ConstrainedNumber(name="opacity", required=False, min=0, max=1),
+           ConstrainedNumber(name="spacing", required=False, min=2, max=100),
+           Bool(name="vlines", required=False),
+           Bool(name="hlines", required=False),
+           Bool(name="trim", required=False),
+           Bool(name="shadow", required=False),
+           Param_Zoom(
+               name="zoom",
+               required=False,
+               min=-12,
+               max=12,
+               exclusion_range=[-1.1, 1.1]
+           )
         ]
+
     def test_values(self):
-        p = self.params
         return not any([
           (self.param('spacing').value > self.param('width').value),
           (self.param('spacing').value > self.param('height').value),
           (self.param('linethickness').value > self.param('width').value),
           (self.param('linethickness').value > self.param('height').value),
         ])
+
     def randomize(self):
         p = self.params
         for el in p:
-          if el in ['spacing', 'linethickness']:
-            continue
-          if el.set_by_user:
-            continue
-          el.randomize()
-        for name in  ['spacing', 'linethickness']:
-          max_tries = 10000
-          while(max_tries):
-            self.param(name).randomize()
-            if self.test_values():
-              return
-            max_tries -= 1
-          raise ValueError
-
+            if el in ['spacing', 'linethickness']:
+                continue
+            el.randomize()
+        for name in ['spacing', 'linethickness']:
+            max_tries = 10000
+            while(max_tries):
+                self.param(name).randomize()
+                if self.test_values():
+                    return
+                max_tries -= 1
+            raise ValueError
diff --git a/ricky/imgrid/probabilities.json b/ricky/imgrid/probabilities.json
new file mode 100644
index 0000000..f9defe8
--- /dev/null
+++ b/ricky/imgrid/probabilities.json
@@ -0,0 +1,87 @@
+{
+    "format" : [
+        { "weight": 20, "value": "png" },
+        { "weight": 0, "value": "gif" },
+        { "weight": 0, "value": "jpg" }
+    ],
+    "transition" : [
+        { "value" : "background", "weight": 1 },
+        { "value" : "dither", "weight": 1 },
+        { "value" : "random", "weight": 1 },
+        { "value" : "tile", "weight": 1 },
+        { "value" : "edge", "weight": 1 }
+    ],
+    "skycolor" : [
+        { "value" : "white", "weight" : 1 },
+        { "value" : "silver", "weight" : 1 },
+        { "value" : null, "weight" : 10 }
+    ],
+    "bgcolor" : [
+        { "value" : "white", "weight" : 1 },
+        { "value" : "silver", "weight" : 1 },
+        { "value" : null, "weight" : 10 }
+    ],
+    "planebgcolor" : [
+        { "value" : "white", "weight" : 1 },
+        { "value" : "silver", "weight" : 1 },
+        { "value" : null, "weight" : 10 }
+    ],
+
+    "linecolor" : [
+        { "value" : "black", "weight" : 1 },
+        { "value" : "white", "weight" : 1 },
+        { "value" : "silver", "weight" : 1 }
+    ],
+    "swing" : [
+        {"value": ",  "weight": 2},
+        {"value": 30,   "weight": 1},
+        {"value": -30,   "weight": 1}
+    ],
+    "tilt" : [
+        {"value": ",  "weight": 2},
+        {"value": 30,   "weight": 1},
+        {"value": -30,   "weight": 1}
+    ],
+    "roll" : [
+        {"value": ",  "weight": 2},
+        {"value": 30,   "weight": 1},
+        {"value": -30,   "weight": 1}
+    ],
+    "width" : "height" : [
+        { "value" : 400, "weight" : 1 },
+        { "value" : 600, "weight" : 1 }
+    ],
+    "linethickness" : [
+        {"value":1,  "weight": 2},
+        {"value":2,  "weight": 1}
+    ],
+    "opacity" : [
+        {"value":1,  "weight": 2},
+        {"value":0.5,  "weight": 1}
+    ],
+    "spacing" : [
+        {"value":10,  "weight": 1},
+        {"value":15,  "weight": 1}
+    ],
+    "vlines" : [
+        {"value":",  "weight": 2},
+        {"value":"true",   "weight": 1}
+    ],
+    "hlines" : [
+        {"value":",  "weight": 2},
+        {"value":"true",   "weight": 1}
+    ],
+    "shadow" : [
+        {"value":",  "weight": 1},
+        {"value":"true",   "weight": 1}
+    ],
+    "zoom" : [
+        {"value": 0,  "weight": 3},
+        {"value": 1.2,  "weight": 1},
+        {"value": -1.2,  "weight": 1}
+    ],
+    "trim" : [
+        {"value":",  "weight": 1},
+        {"value":"true",   "weight": 1}
+    ]
+}
diff --git a/ricky/param/__init__.py b/ricky/param/__init__.py
index 5149889..1bd3c38 100644
--- a/ricky/param/__init__.py
+++ b/ricky/param/__init__.py
@@ -1 +1,37 @@
-from ricky.param.param import Param
+import pprint
+
+
+class Param(object):
+    def __init__(
+                 self,
+                 required=False,
+                 set_by_user=0,
+                 value=None,
+                 name=None,
+                 **kwargs
+                ):
+        self._value_default = None
+        self.name = name
+        self.required = required
+        self._value = value
+        self.set_by_user = set_by_user
+
+    def __str__(self):
+        return pprint.pformat(vars(self))
+
+    def value_get(self):
+        if self.set_by_user == 1:
+            return self._value
+        return self._value_default
+
+    def value_set(self, value):
+        self._value = value
+
+    value = property(value_get, value_set)
+
+    def default(self, value):
+        self._value_default = value
+
+
+    def randomize(self):
+        pass
diff --git a/ricky/param/bool.py b/ricky/param/bool.py
new file mode 100644
index 0000000..b95f1f1
--- /dev/null
+++ b/ricky/param/bool.py
@@ -0,0 +1,35 @@
+from ricky.param import Param
+import re
+import random
+
+
+class Bool(Param):
+    def __init__(self, **kwargs):
+        super(Bool, self).__init__(**kwargs)
+
+    def value_get(self):
+        return super(Bool, self).value_get()
+
+    def value_set(self, value):
+        value = self._bool_correct(value)
+        super(Bool, self).value_set(value)
+
+    value = property(value_get, value_set)
+
+    def _bool_correct(self, value):
+        if any in [
+                   re.match(r'(true|1)', value, re.IGNORECASE),
+                   value == 1,
+                  ]:
+            value = True
+        elif any in [
+                     re.match(r'(false|0)', value, re.IGNORECASE),
+                     value == 0,
+                    ]:
+            value = False
+        else:
+            raise ValueError("Bad Value for Bool %s" % value)
+        return value
+
+    def randomize(self):
+        self.value_set(random.choice([True, False]))
diff --git a/ricky/param/color.py b/ricky/param/color.py
index 4d9f4d5..4d88b90 100644
--- a/ricky/param/color.py
+++ b/ricky/param/color.py
@@ -17,21 +17,8 @@ class Color(Param):
     @value.setter
     def value(self, value):
         self._value = value
-        if self._value is not None:
-            self.is_ready = 1
-        self.set_by_user = 1
 
     def randomize(self):
-        weights_total = sum(
-            map(lambda x: x["weight"], self.selections())
-        ) + (255 * 255 * 255)
-        choice = random.randint(0, weights_total)
-        position = 0
-        for elem in self.selections():
-            position += elem["weight"]
-            if position >= choice:
-                self.value = elem["value"]
-                return
         self.value = "rgb(%s,%s,%s)" % (
             random.randint(0, 255),
             random.randint(0, 255),
diff --git a/ricky/param/constrainednumber.py b/ricky/param/constrainednumber.py
new file mode 100644
index 0000000..214924a
--- /dev/null
+++ b/ricky/param/constrainednumber.py
@@ -0,0 +1,88 @@
+import random
+from ricky.param import Param
+DEFAULT_RAND_MAX = 1000
+DEFAULT_RAND_MIN = -1000
+
+class ConstrainedNumber(Param):
+    def __init__(self, **kwargs):
+        super(ConstrainedNumber, self).__init__(**kwargs)
+        self.range_min = kwargs.get('min')
+        self.range_max = kwargs.get('max')
+        self.forbidden = kwargs.get('forbidden')
+        self.forbidden_range_min = kwargs.get('forbidden_range_min')
+        self.forbidden_range_max = kwargs.get('forbidden_range_max')
+        self.assert_int = kwargs.get('assert_int')
+
+    def randomize(self):
+        val = random.randint(self.range_min, self.range_max)
+        self.value = val
+
+    @property
+    def value(self):
+        return super(ConstrainedNumber, self).value_get()
+
+    @value.setter
+    def value(self, value):
+        if value is not None and (
+                            self._value < self.range_min or
+                            self._value > self.range_max
+                           ):
+            raise ValueError(
+                "Value must be between %s and %s\n" % (
+                    self.range_min, self.range_max
+                )
+            )
+        if value == self.forbidden:
+            raise ValueError(
+                "Value %s is forbidden" % value
+            )
+        if (self.forbidden_range_max or self.forbidden_range_max == 0) and \
+                self.forbidden_range_max >= value:
+                raise ValueError(
+                    "In forbidden range: Value %s is below %s" %
+                    (value, self.forbidden_range_max)
+                )
+        if (self.forbidden_range_min or self.forbidden_range_min == 0) and \
+                self.forbidden_range_min <= value:
+                raise ValueError(
+                    "In forbidden range: Value %s is above %s" %
+                    (value, self.forbidden_range_min)
+                )
+        if self.assert_int and type(value) != int:
+            raise ValueError(
+               "Value %s is not an int" % value
+            )
+        self._value = value
+
+    def __str__(self):
+        value_dict = {
+           'value': self._value,
+        }
+        for attr in (
+            'range_min', 'range_max', 'forbidden', 'forbidden_range_min',
+            'forbidden_range_max', 'enforce_int'
+        ):
+            attr_val = getattr(self, attr)
+            if attr_val or attr_val == 0:
+                value_dict[attr] = attr_val
+        return "Constrained Number Range \"%s\":\n %s" % (self.name, value_dict)
+
+    def _generate_random(self):
+        value = random.uniform(DEFAULT_RAND_MIN, DEFAULT_RAND_MAX)
+        if self.assert_int:
+           value = int(value)
+        self.value = value
+
+    def randomize(self):
+        tries = 0
+        tries_max = 30
+        try:
+           self._generate_random()
+        except ValueError:
+           tries += 1
+           if tries < tries_max:
+               self._generate_random()
+           else:
+               raise ValueError(
+                   "Unable to set random value on %s in %s tries"
+               ) % (self.name, self.tries_max)
diff --git a/ricky/param/multiselect.py b/ricky/param/multiselect.py
index 21eca78..8da5374 100644
--- a/ricky/param/multiselect.py
+++ b/ricky/param/multiselect.py
@@ -5,25 +5,28 @@ from ricky.param import Param
 class MultiSelect(Param):
     def __init__(self, **kwargs):
         super(MultiSelect, self).__init__(**kwargs)
+        self._options = kwargs.get('options') or []
+        if len(self._options):
+            self._validate_options()
+
+    def options(self):
+        return self._options
+
+    def _validate_options(self):
+        try:
+            pass
+        except Exception:
+            raise ValueError('Unable to validate %s\n:' % self.name)
 
     def value_get(self):
         return super(MultiSelect, self).value_get()
 
     def value_set(self, value):
-        if not any([value == i['value'] for i in self._selections]) and \
-            value is not None:
+        if value not in self._options and value is not None:
             raise ValueError
         super(MultiSelect, self).value_set(value)
 
     value = property(value_get, value_set)
 
     def randomize(self):
-        weights_total = sum(map(lambda x: x["weight"], self.selections()))
-        choice = random.randint(0, weights_total)
-        position = 0
-        for elem in self.selections():
-            position += elem["weight"]
-            if position >= choice:
-                self.value = elem["value"]
-                break
-
+        self.value_set(random.choice(self.options))
diff --git a/ricky/param/numberrange.py b/ricky/param/numberrange.py
deleted file mode 100644
index 626d128..0000000
--- a/ricky/param/numberrange.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import random
-from ricky.param import Param
-
-
-class NumberRange(Param):
-    def __init__(self, **kwargs):
-        super(NumberRange, self).__init__(**kwargs)
-        self.range_min = kwargs['min']
-        self.range_max = kwargs['max']
-
-    def randomize(self):
-        weights_total = sum(
-                map(lambda x: x["weight"], self.selections())
-            )# + self.range_max - self.range_min
-        if weights_total < 100:
-            weights_total = 100;
-        choice = random.randint(0, weights_total)
-        import sys
-        sys.stderr.write("choosing %s: random_int: %s, selections: %s\n" % (
-            self.name,
-            choice,
-            self.selections()))
-        position = 0
-        for elem in self.selections():
-            position += elem["weight"]
-            if position >= choice:
-                self.value = elem["value"]
-                return
-        
-        val = random.randint(self.range_min, self.range_max)
-        self.value = val
-        
-    @property
-    def value(self):
-        return super(NumberRange, self).value_get()
-
-    @value.setter
-    def value(self, value):
-        self._value = value
-        import sys
-        sys.stderr.write("%s \n" % self.name)
-        sys.stderr.write("%s \n" % self._value)
-        if self._value < self.range_min:
-            sys.stderr.write("PROBLEM HERE1") 
-        if self._value > self.range_max:
-            sys.stderr.write("%s > %s\n" % (self._value, self.range_max))
-            sys.stderr.write("%s\n" % type(self._value))
-            sys.stderr.write("%s\n" % type(self.range_max))
-            sys.stderr.write("PROBLEM HERE2") 
-        if self._value and \
-            (self._value < self.range_min or self._value > self.range_max):
-            raise ValueError(
-                "Value must be between %s and %s\n" % (
-                    self.range_min, self.range_max
-                )
-            )
-        if self._value is not None:
-            self.is_ready = 1
-        self.set_by_user = 1
diff --git a/ricky/param/option.py b/ricky/param/option.py
new file mode 100644
index 0000000..0cbd505
--- /dev/null
+++ b/ricky/param/option.py
@@ -0,0 +1,16 @@
+"""
+Base option class...essentially a dictionary
+but attributes can be accessed with a dot
+"""
+
+
+class Option(dict):
+    def __init__(self, **kwargs):
+        super(Option, self).__init__(**kwargs)
+
+    def __getattr__(self, attr):
+        return self.get(attr)
+
+    __setattr__ = dict.__setitem__
+
+    __delattr__ = dict.__delitem__
diff --git a/ricky/param/options.py b/ricky/param/options.py
new file mode 100644
index 0000000..dadb8f9
--- /dev/null
+++ b/ricky/param/options.py
@@ -0,0 +1,28 @@
+from ricky.param.option import Option
+
+
+class Options:
+    def __init__(self, *args):
+        self._values = args
+
+    def __iter__(self):
+        return iter(self._values)
+
+    def __len__(self):
+        return len(self._values)
+
+    def __str__(self):
+        return str(self._values)
+
+    def __getitem__(self, i):
+        return self._values[i]
+
+    def search(self, s):
+        for i in self:
+            if str(s) in i.value:
+                return i
+
+    @classmethod
+    def from_dict(cls, *args):
+        options = map(lambda x: Option(**x), args)
+        return cls(*options)
diff --git a/ricky/param/param.py b/ricky/param/param.py
deleted file mode 100644
index 9e7b42e..0000000
--- a/ricky/param/param.py
+++ /dev/null
@@ -1,86 +0,0 @@
-import pprint
-import sys
-
-class Param(object):
-    def __init__(
-            self,
-            required=0,
-            set_by_user=0,
-            value=None,
-            name=None,
-            **kwargs):
-        self._value_default = None
-        self.name = name
-        self.required = required
-        self.is_ready = 0
-        self._value = value
-        self.set_by_user = set_by_user
-        self._selections = kwargs.get('selections') or []
-        if len(self._selections):
-            self._validate_selections()
-            """default value is the selection with the heaviest weight"""
-            self.default(self._choose_heaviest())
-
-    def selections(self):
-        return self._selections
-
-    def _validate_selections(self):
-        try:
-            int(self._selections[0]['weight'])
-            self._selections[0]['value']
-        except Exception:
-            raise ValueError('Unable to validate %s\n:' % self.name)
-
-    def __str__(self):
-        return pprint.pformat(vars(self))
-
-    def value_get(self):
-        if self.set_by_user == 1:
-            return self._value
-        return self._value_default
-
-    def value_set(self, value):
-        self._value = value
-#        sys.stderr.write("trying to set %s - %s: %s \n" %
-#            (
-#                self.__class__.__name__,
-#                self.name,
-#                value
-#            )
-#        )
-        if self._value:
-            self.is_ready = 1
-        self.set_by_user = 1
-
-    value = property(value_get, value_set)
-
-    def default(self, value):
-        self._value_default = value
-
-    @property
-    def is_ready(self):
-        return self._is_ready or not self.required
-
-    @is_ready.setter
-    def is_ready(self, n):
-        self._is_ready = n
-
-    def randomize(self):
-        pass
-
-    def _choose_heaviest(self):
-        heaviest_idx = 0
-        heaviest_weight = 0
-        idx = 0
-        if (len(self.selections())):
-            for elem in self.selections():
-                if elem["weight"] > heaviest_weight:
-                    heaviest_weight = elem["weight"]
-                    heaviest_idx = idx
-                idx += 1
-            return self.selections()[heaviest_idx]["value"]
-        else:
-            self.randomize()
-
-    def heaviest(self):
-        self.value = self._choose_heaviest()
diff --git a/ricky/param/selection.py b/ricky/param/selection.py
deleted file mode 100644
index 93a8388..0000000
--- a/ricky/param/selection.py
+++ /dev/null
@@ -1,9 +0,0 @@
-class Selection(dict):
-  def __init__(self, **kwargs):
-    super(Selection, self).__init__(**kwargs)
-    self.value = kwargs["value"]
-    self.weight = kwargs["weight"]
-  def __getattr__(self, attr):
-       return self.get(attr)
-  __setattr__= dict.__setitem__
-  __delattr__= dict.__delitem__
diff --git a/ricky/param/selections.py b/ricky/param/selections.py
deleted file mode 100644
index 1e2c3b3..0000000
--- a/ricky/param/selections.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from ricky.param.selection import Selection
-import sys
-class Selections:
-  def __init__(self, *args):
-    self._values = args
-  def __iter__(self):
-    return iter(self._values)
-  def __len__(self):
-    return len(self._values)
-  def __str__(self):
-    return str(self._values)
-  def __getitem__(self, i):
-    return self._values[i]
-  def search(self, s):
-    for i in self:
-      if str(s) in i.value:
-        return i
-  @classmethod
-  def from_dict(cls, *args):
-    selections = map(lambda x: Selection(**x), args);
-    return cls(*selections);
diff --git a/ricky/unused/weight.py b/ricky/unused/weight.py
new file mode 100644
index 0000000..4bd4af4
--- /dev/null
+++ b/ricky/unused/weight.py
@@ -0,0 +1,57 @@
+        weights_total = sum(
+            map(lambda x: x["weight"], self.probabilities())
+        ) + (255 * 255 * 255)
+        choice = random.randint(0, weights_total)
+        position = 0
+        for elem in self.probabilities():
+            position += elem["weight"]
+            if position >= choice:
+                self.value = elem["value"]
+                return
+
+        weights_total = sum(
+                map(lambda x: x["weight"], self.probabilities())
+            )# + self.range_max - self.range_min
+        if weights_total < 100:
+            weights_total = 100;
+        choice = random.randint(0, weights_total)
+        import sys
+        sys.stderr.write("choosing %s: random_int: %s, probabilities: %s\n" % (
+            self.name,
+            choice,
+            self.probabilities()))
+        position = 0
+        for elem in self.probabilities():
+            position += elem["weight"]
+            if position >= choice:
+                self.value = elem["value"]
+                return
+
+
+        weights_total = sum(map(lambda x: x["weight"], self.probabilities()))
+        choice = random.randint(0, weights_total)
+        position = 0
+        for elem in self.probabilities():
+            position += elem["weight"]
+            if position >= choice:
+                self.value = elem["value"]
+                break
+    def _choose_heaviest(self):
+        heaviest_idx = 0
+        heaviest_weight = 0
+        idx = 0
+        if (len(self.options())):
+            for elem in self.options():
+                if elem["weight"] > heaviest_weight:
+                    heaviest_weight = elem["weight"]
+                    heaviest_idx = idx
+                idx += 1
+            return self.options()[heaviest_idx]["value"]
+        else:
+            self.randomize()
+
+    def heaviest(self):
+        self.value = self._choose_heaviest()
+
+    """default value is the probability with the heaviest weight"""
+    self.default(self._choose_heaviest())