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

11 files changed, 218 insertions, 200 deletions

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);