class SpacingParser:
def __init__(self, name, drawable, page):
self.name = name
self.parser = ParameterParser(drawable.parameters)
self.drawable = drawable
self.page = page
self.drawable_default = self.realize_parameter(name, None)
self.page_top_default = getattr(page.parameters, self.__get_top_name())
self.page_left_default = getattr(page.parameters,
self.__get_left_name())
def set_property_values(self):
self.__assign_side_attribute_group()
self.__assign_top_bottom_attribute_group()
def realize_parameter(self, parameter_name, default):
value = self.parser.realize_parameter(parameter_name, default)
if self.parser.is_percentage_value(parameter_name):
value *= self.page.parameters.get_column_width()
return value
def __get_top_name(self):
return self.name + "_top_bottom"
def __get_left_name(self):
return self.name + "_left_right"
def __assign_top_bottom_attribute_group(self):
param_name = self.__get_top_name()
default = self.realize_parameter(param_name, self.__get_top_default())
for name in ("top", "bottom"):
self.__assign_attribute(name, default)
def __get_top_default(self):
if self.drawable_default is None:
return self.page_top_default
return self.drawable_default
def __assign_side_attribute_group(self):
param_name = self.__get_left_name()
default = self.realize_parameter(param_name, self.__get_left_default())
for name in ("left", "right"):
self.__assign_attribute(name, default)
def __get_left_default(self):
if self.drawable_default is None:
return self.page_left_default
return self.drawable_default
def __assign_attribute(self, name, default):
param_name = self.name + "_" + name
if self.drawable.primary_element:
value = getattr(self.drawable.primary_element, "_" + param_name)
else:
value = self.realize_parameter(param_name, default)
#value += default
setattr(self.drawable, "_" + param_name, value)
def __init__(self, name, drawable, page):
self.name = name
self.parser = ParameterParser(drawable.parameters)
self.drawable = drawable
self.page = page
self.drawable_default = self.realize_parameter(name, None)
self.page_top_default = getattr(page.parameters, self.__get_top_name())
self.page_left_default = getattr(page.parameters,
self.__get_left_name())
def update_border(self):
border_dict = self.parameters.get("border")
if not border_dict:
return
parser = ParameterParser(border_dict)
if parser.realize_parameter("probability"):
self._border_style = parser.realize_parameter("style", 1)
self._border_width = parser.realize_parameter("width", 1)
def __get_layout_policy(self, parent_bounds):
policy_params = self.parameters.get("layout")
if policy_params:
parser = ParameterParser(policy_params)
class_name = parser.realize_parameter("class")
klass = globals()[class_name]
values = parser.realize_as_dict()
return klass(parent_bounds, self._children, **values)
return VerticalLayout(parent_bounds, self._children)
def __init__(self, parameters, question_number):
self._styles = {}
parser = ParameterParser(parameters)
self._start_number = question_number
self._bold = parser.realize_parameter("probability_bold")
self._circles = parser.realize_parameter("probability_circles")
self._current_level = 0
self._sublevel_numbers = {}
self.scale = (0.75 + (0.5 * random.random()))
self.__create_styles(parameters)
self.reset()
def __create_elements(self, element):
parser = ParameterParser(element)
class_name = parser.realize_parameter("class")
if not class_name:
raise ParameterError("Elements must specify a class")
if self.__skip_element(parser):
return
klass = globals()[class_name]
primary_element = None
for _ in range(self.__number_of_elements_to_create(parser)):
new_element = klass(element)
if primary_element:
new_element.primary_element = primary_element
else:
primary_element = new_element
self._children.append(new_element)
def realize_parameter(self, parameter_name, default=None):
parser = ParameterParser(self.parameters)
return parser.realize_parameter(parameter_name, default)
def setUp(self):
random.seed(42)
self.parser = ParameterParser(test_params)
class ParameterParserTest(unittest.TestCase):
def setUp(self):
random.seed(42)
self.parser = ParameterParser(test_params)
def test_missing_value(self):
value = self.parser.realize_parameter("missing")
self.assertIs(value, None)
value = self.parser.realize_parameter("missing", "default")
self.assertTrue(isinstance(value, str))
self.assertEqual(value, "default")
def test_int_value(self):
value = self.parser.realize_parameter("int")
self.assertTrue(isinstance(value, int))
self.assertEqual(value, test_params["int"])
def test_string_value(self):
value = self.parser.realize_parameter("string")
self.assertTrue(isinstance(value, str))
self.assertEqual(value, test_params["string"])
def test_list_value(self):
value = self.parser.realize_parameter("list")
self.assertTrue(isinstance(value, int))
self.assertEqual(value, 1)
def test_probability_value(self):
did_win = self.parser.realize_parameter("win_probability")
self.assertTrue(isinstance(did_win, bool))
self.assertFalse(did_win)
def test_probability_list_value(self):
value = self.parser.realize_parameter("probability_list")
self.assertTrue(isinstance(value, str))
self.assertEqual(value, test_params["probability_list"][1][1])
def test_min_max_dict_value(self):
value = self.parser.realize_parameter("min_max_dict")
self.assertTrue(isinstance(value, int))
self.assertEqual(value, 82)
def test_min_max_scale_dict_value(self):
value = self.parser.realize_parameter("min_max_scale_dict")
self.assertTrue(isinstance(value, float))
self.assertAlmostEqual(value, 19.24)
def test_percent_value(self):
self.assertFalse(self.parser.is_percentage_value("min_max_scale_dict"))
self.assertTrue(self.parser.is_percentage_value("percent"))
value = self.parser.realize_parameter("percent")
self.assertTrue(isinstance(value, float))
self.assertAlmostEqual(value, 0.1)
def test_percent_list_value(self):
self.assertTrue(self.parser.is_percentage_value("percent_list"))
value = self.parser.realize_parameter("percent_list")
self.assertTrue(isinstance(value, float))
self.assertAlmostEqual(value, 0.15)
def test_percent_dict_value(self):
self.assertTrue(self.parser.is_percentage_value("percent_dict"))
value = self.parser.realize_parameter("percent_dict")
self.assertTrue(isinstance(value, float))
self.assertAlmostEqual(value, 0.20985669)
def test_invalid_dict(self):
with self.assertRaises(NotImplementedError):
self.parser.realize_parameter("invalid_dict")
def __create_styles(self, parameters):
parser = ParameterParser(parameters["style"])
for level in parameters["style"].keys():
self._styles[level] = parser.realize_parameter(level)