Merge pull request #41 from mattmanley/add_priority_model

Add priority rule model

Author: mattmanley

docs/index.rst

@@ -17,6 +17,7 @@ Welcome to MapRoulette's documentation!
    usage/models/project
    usage/models/challenge
    usage/models/task
+   usage/models/priority_rule
    usage/exceptions
 
 ---------------

docs/usage/models/priority_rule.rst

@@ -0,0 +1,27 @@
+Priority Rule Model
+=====================================================
+
+.. autoclass:: maproulette.models.priority_rule.PriorityRule
+    :members:
+
+.. autoclass:: maproulette.models.priority_rule.PriorityRuleModel
+    :members:
+
+.. autoclass:: maproulette.models.priority_rule.Conditions
+    :members:
+
+.. autoclass:: maproulette.models.priority_rule.Types
+    :members:
+    :undoc-members:
+
+.. autoclass:: maproulette.models.priority_rule.Conditions
+    :members:
+    :undoc-members:
+
+.. autoclass:: maproulette.models.priority_rule.StringOperators
+    :members:
+    :undoc-members:
+
+.. autoclass:: maproulette.models.priority_rule.NumericOperators
+    :members:
+    :undoc-members:

examples/create_challenge_from_model.py

@@ -16,6 +16,16 @@
 # Adding required instruction
 challenge_data.instruction = "Do something"
 
+# Let's create a basic rule to classify features with tags 'highway' = 'footway' to be high priority
+rule_1 = maproulette.PriorityRule(priority_value='highway.footway',
+                                  priority_type=maproulette.priority_rule.Types.STRING,
+                                  priority_operator=maproulette.priority_rule.StringOperators.EQUAL)
+
+# Create a formal priority rule for the challenge
+challenge_data.high_priority_rule = maproulette.PriorityRuleModel(condition=maproulette.priority_rule.Conditions.OR,
+                                                                  rules=rule_1
+                                                                  ).to_json()
+
 # Adding example overpass QL input for challenge
 challenge_data.overpassQL = open('data/Example_OverpassQL_Query', 'r').read()
 

maproulette/__init__.py

@@ -7,6 +7,8 @@
 from .models.project import ProjectModel
 from .models.challenge import ChallengeModel
 from .models.task import TaskModel
+from .models.priority_rule import PriorityRule, PriorityRuleModel
+from .models import priority_rule
 from .api.project import Project
 from .api.challenge import Challenge
 from .api.task import Task

maproulette/models/__init__.py

@@ -1,3 +1,4 @@
 from .project import ProjectModel
 from .challenge import ChallengeModel
 from .task import TaskModel
+from .priority_rule import PriorityRule, PriorityRuleModel

maproulette/models/challenge.py

@@ -332,7 +332,6 @@ def to_dict(self):
             "id": self._id,
             "name": self._name,
             "description": self._description,
-            "deleted": self.description,
             "parent": self._parent,
             "instruction": self._instruction,
             "difficulty": self._difficulty,

maproulette/models/priority_rule.py

@@ -0,0 +1,192 @@
+"""This module contains the definition of a priority rule object in MapRoulette."""
+
+import json
+from enum import Enum, auto
+
+
+class ExtendedEnum(Enum):
+    def _generate_next_value_(name, start, count, last_values):
+        return name.lower()
+
+    @classmethod
+    def list(cls):
+        return [i.value for i in cls]
+
+
+class Conditions(ExtendedEnum):
+    """An enumeration of valid logical conditions for a priority rule object"""
+    OR = "OR"
+    AND = "AND"
+
+
+class Types(ExtendedEnum):
+    """An enumeration of valid types for a priority rule object"""
+    STRING = auto()
+    INTEGER = auto()
+    DOUBLE = auto()
+    LONG = auto()
+
+
+class StringOperators(ExtendedEnum):
+    """An enumeration of valid string operators for a priority rule object"""
+    EQUAL = auto()
+    NOT_EQUAL = auto()
+    CONTAINS = auto()
+    NOT_CONTAINS = auto()
+    IS_EMPTY = auto()
+    IS_NOT_EMPTY = auto()
+
+
+class NumericOperators(ExtendedEnum):
+    """An enumeration of valid numeric operators for a priority rule object"""
+    EQUAL_TO = "=="
+    NOT_EQUAL_TO = "!="
+    LESS_THAN = "<"
+    LESS_THAN_OR_EQUAL = "<="
+    GREATER_THAN = ">"
+    GREATER_THAN_OR_EQUAL = ">="
+
+
+class PriorityRuleModel:
+    """A model for a priority rule definition in MapRoulette.
+
+    :param condition: the logical condition to use to string together multiple rules. The valid options for conditions
+        are defined by the :class:`~maproulette.models.priority_rule.Conditions` enum.
+    :type condition: Conditions or str
+    :param rules: one or more rules to use for the priority rule definition. Rules should be instances of the
+        :class:`~maproulette.models.priority_rule.PriorityRule` class.
+    :type rules: PriorityRule or list
+    """
+
+    @property
+    def condition(self):
+        """The condition to use to chain together multiple priority rules"""
+        return self._condition
+
+    @condition.setter
+    def condition(self, value):
+        if isinstance(value, Conditions):
+            self._condition = value.value
+        else:
+            if value not in Conditions.list():
+                raise ValueError(f"Priority condition must be one of {Conditions.list()}.")
+            self._condition = value
+
+    @property
+    def rules(self):
+        """The list of priority rules to be used in the priority rule model"""
+        return self._rules
+
+    @rules.setter
+    def rules(self, value):
+        self._rules = value
+
+    def __init__(self, condition, rules):
+        """The constructor for the PriorityRuleModel class"""
+        self.condition = condition
+        self.rules = list()
+        if isinstance(rules, list):
+            if len(rules) > 0:
+                for i in rules:
+                    if isinstance(i, PriorityRule):
+                        self.rules.append(i.to_dict())
+                    else:
+                        raise ValueError("Rules must be PriorityRule instances")
+            else:
+                ValueError("Rule list cannot be empty")
+        elif isinstance(rules, PriorityRule):
+            self.rules.append(rules.to_dict())
+        else:
+            raise ValueError("Rules must be PriorityRule instances")
+
+    def to_dict(self):
+        """Converts all properties of a priority rule model object into a dictionary"""
+        return {
+            "condition": self._condition,
+            "rules": self._rules
+        }
+
+    def to_json(self):
+        """Converts all properties of a priority rule model object into a JSON object"""
+        return json.dumps(self.to_dict())
+
+
+class PriorityRule:
+    """Definition for a single priority rule
+
+    :param priority_type: the data type for the priority rule. The valid options are defined by the
+        :class:`~maproulette.models.priority_rule.Types` enum.
+    :type priority_type: Types or str
+    :param priority_operator: the operator to use for the priority rule. The valid options for string-type priority
+        rules are defined by the :class:`~maproulette.models.priority_rule.StringOperators` enum and the valid options
+        for numeric-type priority rules are defined by the :class:`~maproulette.models.priority_rule.NumericOperators`
+        enum.
+    :type priority_operator: NumericOperators or StringOperators or str
+    :param priority_value: the value to use for the priority rule. This should be formatted like 'highway.footway' to
+        indicate that any task with a 'highway' property equal to 'footway' should be considered for this rule. Multiple
+        values can be specified using commas. Example: 'highway.footway,pedestrian'.
+    :type priority_value: str
+    """
+
+    @property
+    def priority_type(self):
+        """The type for the priority rule"""
+        return self._priority_type
+
+    @priority_type.setter
+    def priority_type(self, value):
+        if isinstance(value, Types):
+            self._priority_type = value.value
+        elif value in Types.list():
+            self._priority_type = value
+        else:
+            raise ValueError(f"Priority types must be one of {Types.list()}.")
+
+    @property
+    def priority_operator(self):
+        """The operator to use for the priority rule"""
+        return self._priority_operator
+
+    @priority_operator.setter
+    def priority_operator(self, value):
+        if self._priority_type == 'string':
+            if isinstance(value, StringOperators):
+                self._priority_operator = value.value
+            elif value in StringOperators.list():
+                self._priority_operator = value
+            else:
+                raise ValueError(f"String type priority operators must be one of {StringOperators.list()}.")
+        else:
+            if isinstance(value, NumericOperators):
+                self._priority_operator = value.value
+            elif value in NumericOperators.list():
+                self._priority_operator = value
+            else:
+                raise ValueError(f"Numeric type priority operators must be one of {NumericOperators.list()}.")
+
+    @property
+    def priority_value(self):
+        """The value for the priority rule"""
+        return self._priority_value
+
+    @priority_value.setter
+    def priority_value(self, value):
+        self._priority_value = value
+
+    def __init__(self, priority_type, priority_operator, priority_value):
+        """The constructor for the PriorityRule class"""
+        self.priority_type = priority_type
+        self.priority_operator = priority_operator
+        self.priority_value = priority_value
+
+    def to_dict(self):
+        """Converts all properties of a priority rule object into a dictionary"""
+        return {
+            "value": self._priority_value,
+            "type": self._priority_type,
+            "operator": self._priority_operator
+        }
+
+    def to_json(self):
+        """Converts all properties of a priority rule object into a JSON object"""
+        return json.dumps(self.to_dict())