Add validation between parameter in ParameterContainer.

Makefile

@@ -1,3 +1,6 @@
+PROJECT_NAME = PARAMETERS
+BUILD_DIRECTORY = ../build_$(PROJECT_NAME)
+
 # Run pep8 style checking
 #http://pypi.python.org/pypi/pep8
 pep8:
@@ -14,3 +17,14 @@ test_suite:
 	@echo "Regression Test Suite"
 	@echo "---------------------"
 	@export PYTHONPATH=`pwd`:$(PYTHONPATH);nosetests -v --with-id --with-coverage --cover-package=. 3>&1 1>&2 2>&3 3>&- || true
+
+# zip
+package:
+	@echo
+	@echo "---------------------"
+	@echo "Creating a package for $(PROJECT_NAME) project"
+	@echo "---------------------"
+	rm -rf $(BUILD_DIRECTORY)
+	cp -rf . $(BUILD_DIRECTORY)
+	find $(BUILD_DIRECTORY) -name "*.pyc" -exec rm -rf {} \;
+	find $(BUILD_DIRECTORY) -name "test_" -exec rm -rf {} \;

parameter_exceptions.py

@@ -20,3 +20,15 @@ class ValueOutOfBounds(Exception):
 class CollectionLengthError(Exception):
     """Error raised when a collection is too long or too short."""
     pass
+
+
+class RequiredException(Exception):
+    """Exception raised when a parameter is required but not assigned.
+    """
+    pass
+
+
+class InvalidValidationException(Exception):
+    """Exception raised when there is validation breaker in ParameterContainer.
+    """
+    pass

qt_widgets/parameter_container.py

@@ -16,14 +16,15 @@
     QColor,
     QLabel)
 from qt_widgets.qt4_parameter_factory import Qt4ParameterFactory
+from parameter_exceptions import RequiredException, InvalidValidationException
 
 
 class ParameterContainer(QWidget, object):
     """Container to hold Parameter Widgets."""
 
     def __init__(
             self,
-            parameters=[],
+            parameters=None,
             description_text='',
             extra_parameters=None,
             parent=None):
@@ -41,10 +42,15 @@ def __init__(
         """
         QWidget.__init__(self, parent)
 
-        self.parameters = parameters
+        # attributes
+        if not parameters:
+            self.parameters = []
+        else:
+            self.parameters = parameters
         self.description_text = description_text
         self.extra_parameters = extra_parameters
         self.parent = parent
+        self.validators = []
 
         # UI
         self.vertical_layout = QVBoxLayout()
@@ -77,12 +83,18 @@ def __init__(
     #     if parameter.__name__ in self.dict_widget.keys():
     #         self.dict_widget.pop(parameter.__name__)
 
-    def get_parameters(self):
+    def get_parameters(self, validate=True):
         """Return list of parameters from the current state of widget.
 
+        :param validate: If true, run validator, else no.
+        :type validate: bool
+
         :returns: List of parameter
         :rtype: list
         """
+        if validate:
+            if not self.validate():
+                return
 
         parameter_widgets = (self.vertical_layout.itemAt(i) for i in range(
             self.vertical_layout.count()))
@@ -183,3 +195,40 @@ def set_empty_parameters(self):
         new_description += '\n'
         new_description += 'But, currently there is no parameters available.'
         self.description_label.setText(new_description)
+
+    def add_validator(self, validator):
+        """Add validator for this parameter container.
+
+        :param validator: validator function for this parameter container.
+        :type validator: function
+        """
+        validator.parent = self
+        self.validators.append(validator)
+
+    def validate(self):
+        """Validate of all rule for all parameter in this container.
+
+        :return: True if all valid, False
+        :rtype: bool
+        """
+        for validator in self.validators:
+            validation_result = validator(self)
+            if not validation_result['valid']:
+                raise InvalidValidationException(validation_result['message'])
+
+        return True
+
+    def get_parameter_by_guid(self, parameter_guid):
+        """Return a parameter based on its uuid
+
+        :param parameter_guid: The parameter uuid
+        :type parameter_guid: str
+
+        :returns: The parameter or None if not exist
+        :rtype: GenericParameter, None
+        """
+        parameters = self.get_parameters(validate=False)
+        for parameter in parameters:
+            if parameter.guid == parameter_guid:
+                return parameter
+        return None

qt_widgets/test/main.py

@@ -8,6 +8,7 @@
 __doc__ = ''
 
 import sys
+from functools import partial
 
 from PyQt4.QtGui import (QApplication, QWidget, QGridLayout, QPushButton)
 from metadata import unit_feet_depth, unit_metres_depth
@@ -27,6 +28,34 @@ def main():
     """Main function"""
     app = QApplication([])
 
+    def validate_min_max(parent_container):
+        """
+        :param parent_container: The container that use this validator.
+        :type parent_container: ParameterContainer
+        :return:
+        """
+        min_value_parameter = parent_container.get_parameter_by_guid(
+            min_integer_parameter.guid)
+        max_value_parameter = parent_container.get_parameter_by_guid(
+            max_integer_parameter.guid)
+
+        min_value = min_value_parameter.value
+        max_value = max_value_parameter.value
+
+        print 'min', min_value
+        print 'max', max_value
+
+        if min_value > max_value:
+            print 'Not valid'
+            return {
+                'valid': False,
+                'message': (
+                    'Your minimum value (%d) should be less than your maximum '
+                    'value (%d)' % (min_value, max_value))
+            }
+        print 'Valid'
+        return {'valid': True, 'message': ''}
+
     unit_feet = Unit('130790')
     unit_feet.load_dictionary(unit_feet_depth)
 
@@ -97,6 +126,30 @@ def main():
     point_parameter.description = 'Long description for parameter.'
     point_parameter.value = (0, 1)
 
+    min_integer_parameter = IntegerParameter()
+    min_integer_parameter.name = 'Minimal Stick Length'
+    min_integer_parameter.is_required = True
+    min_integer_parameter.minimum_allowed_value = 1
+    min_integer_parameter.maximum_allowed_value = 50
+    min_integer_parameter.help_text = 'Minimum length of a stick'
+    min_integer_parameter.description = (
+        'Minimum length of a stick that are allowed')
+    min_integer_parameter.unit = unit_metres
+    min_integer_parameter.allowed_units = [unit_metres]
+    min_integer_parameter.value = 3
+
+    max_integer_parameter = IntegerParameter()
+    max_integer_parameter.name = 'Maximum Stick Length'
+    max_integer_parameter.is_required = True
+    max_integer_parameter.minimum_allowed_value = 1
+    max_integer_parameter.maximum_allowed_value = 50
+    max_integer_parameter.help_text = 'Maximum length of a stick'
+    max_integer_parameter.description = (
+        'Maximum length of a stick that are allowed')
+    max_integer_parameter.unit = unit_metres
+    max_integer_parameter.allowed_units = [unit_metres]
+    max_integer_parameter.value = 4
+
     parameters = [
         string_parameter,
         integer_parameter,
@@ -110,6 +163,7 @@ def main():
     extra_parameters = [
         (PointParameter, PointParameterWidget)
     ]
+    min_max_parameters = [min_integer_parameter, max_integer_parameter]
 
     description_text = (
         'These parameters are merely created for showing example only')
@@ -122,34 +176,50 @@ def main():
 
     parameter_container2 = ParameterContainer(
         extra_parameters=extra_parameters,
-        description_text=description_text)
+        description_text='Empty Parameter Container Description')
     parameter_container2.setup_ui()
 
+    parameter_container3 = ParameterContainer(
+        parameters=min_max_parameters,
+        extra_parameters=extra_parameters,
+        description_text='Minimum Maximum Parameter')
+    parameter_container3.add_validator(validate_min_max)
+    parameter_container3.setup_ui()
+
+    def show_parameter(the_parameter_container):
+        """Print the value of parameter.
+
+        :param the_parameter_container: A parameter container
+        :type the_parameter_container: ParameterContainer
+        """
+        temps = the_parameter_container.get_parameters()
+        if temps:
+            for temp in temps:
+                print temp.guid, temp.name, temp.value
+
+    button = QPushButton('Show parameters')
+    # noinspection PyUnresolvedReferences
+    button.clicked.connect(
+        partial(show_parameter, the_parameter_container=parameter_container))
+
+    validate_button = QPushButton('Validate parameters')
+    # noinspection PyUnresolvedReferences
+    validate_button.clicked.connect(
+        partial(show_parameter, the_parameter_container=parameter_container3))
+
     widget = QWidget()
     layout = QGridLayout()
     layout.addWidget(parameter_container)
+    layout.addWidget(button)
     layout.addWidget(parameter_container2)
+    layout.addWidget(parameter_container3)
+    layout.addWidget(validate_button)
 
-    def show_parameter():
-        """Show help."""
-        temps = parameter_container.get_parameters()
-        for temp in temps:
-            print temp.name, temp.value
-
-    button = QPushButton('Press me')
-    # noinspection PyUnresolvedReferences
-    button.clicked.connect(show_parameter)
-
-    layout.addWidget(button)
     widget.setLayout(layout)
     widget.setGeometry(0, 0, 500, 500)
 
     widget.show()
 
-    new_parameters = parameter_container.get_parameters()
-    for new_parameter in new_parameters:
-        print new_parameter.name, new_parameter.value
-
     sys.exit(app.exec_())
 
 if __name__ == '__main__':