init - Structure and Rule classes with tests

Author: MikeSchutzman

.gitignore

@@ -0,0 +1,2 @@
+__pycache__/
+.venv

constants.py

@@ -0,0 +1,14 @@
+# colors
+RED = "RED"
+BLUE = "BLUE"
+YELLOW = "YELLOW"
+
+# quantities
+EXACTLY = "EXACTLY"
+AT_LEAST = "AT_LEAST"
+
+# shapes
+PYRAMIDS = "PYRAMIDS"
+WEDGES = "WEDGES"
+BLOCKS = "BLOCKS"
+

requirements.txt

@@ -0,0 +1,2 @@
+pytest==5.4.1
+pytest-xdist==1.31.0

rule.py

@@ -0,0 +1,108 @@
+"""
+Class to represent a zendo rules. Specifications can be found here:
+https://www.looneylabs.com/sites/default/files/literature/Zendo%20Rules%20Book%201.pdf
+"""
+
+from structure import Structure
+from constants import (
+    RED, BLUE, YELLOW, EXACTLY, AT_LEAST, PYRAMIDS, WEDGES, BLOCKS
+)
+
+class Rule:
+    """
+    Rules can be compromised of color, quantity, and shape.
+    Rules must be in all caps, space separated, and follow the spelling conventions found in constants.py
+    """
+
+    def __init__(self, rule: str) -> None:
+        """
+        :param rule: a string rule. Must be in format "quantity color and/or shape"
+
+        Examples:
+        EXACTLY 2 RED BLOCKS
+        EXACTLY 0 YELLOW
+        AT_LEAST 3 PYRAMIDS
+        """
+        self._is_exactly = False
+        self._is_at_least = False
+        self._quantity = None
+        self._color = None
+        self._shape = None
+
+        try:
+            rule_list = rule.upper().split(" ")
+
+            # parse quantity
+            if rule_list[0] not in [EXACTLY, AT_LEAST]:
+                raise ValueError("Rules must begin with a quantity")
+            if rule_list[0] == EXACTLY: self._is_exactly = True
+            elif rule_list[0] == AT_LEAST: self._is_at_least = True
+            self._quantity = int(rule_list[1])
+
+            # parse the color and shape
+            if rule_list[2] in [RED, BLUE, YELLOW]:
+                self._color = rule_list[2]
+                if len(rule_list) == 4:
+                    self._shape = rule_list[3]
+            elif rule_list[2] in [PYRAMIDS, WEDGES, BLOCKS]:
+                self._shape = rule_list[2]
+        except Exception:
+            raise ValueError("Invalid rule")
+
+    @property
+    def is_exactly(self):
+        return self._is_exactly
+
+    @property
+    def is_at_least(self):
+        return self._is_at_least
+
+    @property
+    def quantity(self):
+        return self._quantity
+
+    @property
+    def color(self):
+        return self._color
+
+    @property
+    def shape(self):
+        return self._shape
+
+    def does_structure_fit_rule(self, structure: Structure) -> bool:
+        """
+        Returns a boolean whether a structure matches the rule
+        """
+        structure_qty = 0
+
+        # only specifies a color
+        if self._color and not self._shape:
+            if self._color == RED: structure_qty = structure.num_red
+            elif self._color == BLUE: structure_qty = structure.num_blue
+            elif self._color == YELLOW: structure_qty = structure.num_yellow
+
+        # only specifies a shape
+        elif self._shape and not self._color:
+            if self._shape == PYRAMIDS: structure_qty = structure.num_pyramids
+            elif self._shape == WEDGES: structure_qty = structure.num_wedges
+            elif self._shape == BLOCKS: structure_qty = structure.num_blocks
+
+        # both color and shape are given
+        else:
+            if self._shape == PYRAMIDS:
+                if self._color == RED: structure_qty = structure.num_red_pyramids
+                elif self._color == BLUE: structure_qty = structure.num_blue_pyramids
+                elif self._color == YELLOW: structure_qty = structure.num_yellow_pyramids
+            elif self._shape == WEDGES:
+                if self._color == RED: structure_qty = structure.num_red_wedges
+                elif self._color == BLUE: structure_qty = structure.num_blue_wedges
+                elif self._color == YELLOW: structure_qty = structure.num_yellow_wedges
+            elif self._shape == BLOCKS:
+                if self._color == RED: structure_qty = structure.num_red_blocks
+                elif self._color == BLUE: structure_qty = structure.num_blue_blocks
+                elif self._color == YELLOW: structure_qty = structure.num_yellow_blocks
+
+        # validate quantity
+        if (self._is_exactly and structure_qty != self._quantity) or \
+            (self._is_at_least and structure_qty < self._quantity): return False
+        return True

structure.py

@@ -0,0 +1,102 @@
+"""
+Class to represent a zendo structure. Specifications can be found here:
+https://www.looneylabs.com/sites/default/files/literature/Zendo%20Rules%20Book%201.pdf
+"""
+
+class Structure:
+    """
+    Pieces: 27 pyramids, 27 wedges, 27 blocks (9 per color). Possible colors are: red, blue, yellow.
+    """
+
+    def __init__(
+        self,
+        num_red_pyramids: int = 0,
+        num_red_wedges: int = 0,
+        num_red_blocks: int = 0,
+        num_blue_pyramids: int = 0,
+        num_blue_wedges: int = 0,
+        num_blue_blocks: int = 0,
+        num_yellow_pyramids: int = 0,
+        num_yellow_wedges: int = 0,
+        num_yellow_blocks: int = 0,
+    ) -> None:
+
+        self._num_red_pyramids = num_red_pyramids
+        self._num_red_wedges = num_red_wedges
+        self._num_red_blocks = num_red_blocks
+
+        self._num_blue_pyramids = num_blue_pyramids
+        self._num_blue_wedges = num_blue_wedges
+        self._num_blue_blocks = num_blue_blocks
+
+        self._num_yellow_pyramids = num_yellow_pyramids
+        self._num_yellow_wedges = num_yellow_wedges
+        self._num_yellow_blocks = num_yellow_blocks
+
+        self._num_red = self._num_red_pyramids + self._num_red_wedges + self._num_red_blocks
+        self._num_blue = self._num_blue_pyramids + self._num_blue_wedges + self._num_blue_blocks
+        self._num_yellow = self._num_yellow_pyramids + self._num_yellow_wedges + self._num_yellow_blocks
+
+        self._num_pyramids = self._num_red_pyramids + self._num_blue_pyramids + self._num_yellow_pyramids
+        self._num_wedges = self._num_red_wedges + self._num_blue_wedges + self._num_yellow_wedges
+        self._num_blocks = self._num_red_blocks + self._num_blue_blocks + self._num_yellow_blocks
+    
+    @property
+    def num_red_pyramids(self):
+        return self._num_red_pyramids
+
+    @property
+    def num_red_wedges(self):
+        return self._num_red_wedges
+
+    @property
+    def num_red_blocks(self):
+        return self._num_red_blocks
+
+    @property
+    def num_blue_pyramids(self):
+        return self._num_blue_pyramids
+
+    @property
+    def num_blue_wedges(self):
+        return self._num_blue_wedges
+
+    @property
+    def num_blue_blocks(self):
+        return self._num_blue_blocks
+
+    @property
+    def num_yellow_pyramids(self):
+        return self._num_yellow_pyramids
+
+    @property
+    def num_yellow_wedges(self):
+        return self._num_yellow_wedges
+
+    @property
+    def num_yellow_blocks(self):
+        return self._num_yellow_blocks
+
+    @property
+    def num_red(self):
+        return self._num_red
+
+    @property
+    def num_blue(self):
+        return self._num_blue
+
+    @property
+    def num_yellow(self):
+        return self._num_yellow
+
+    @property
+    def num_pyramids(self):
+        return self._num_pyramids
+
+    @property
+    def num_wedges(self):
+        return self._num_wedges
+
+    @property
+    def num_blocks(self):
+        return self._num_blocks

unittests.py

@@ -0,0 +1,122 @@
+"""
+Unittests for zendo project
+"""
+from constants import BLOCKS, PYRAMIDS, RED, YELLOW
+import unittest
+
+from structure import Structure
+from rule import Rule
+
+
+class TestStructure(unittest.TestCase):
+
+    def test_creating_structures(self):
+        """
+        Tests creating a structure with various parameters
+        """
+        structure = Structure(
+            num_red_pyramids=1,
+            num_red_wedges=2,
+            num_red_blocks=3,
+            num_blue_pyramids=4,
+            num_blue_wedges=5,
+            num_blue_blocks=6,
+            num_yellow_pyramids=7,
+            num_yellow_wedges=8,
+            num_yellow_blocks=9,
+        )
+        self.assertEqual(structure.num_red_pyramids, 1)
+        self.assertEqual(structure.num_red_wedges, 2)
+        self.assertEqual(structure.num_red_blocks, 3)
+        self.assertEqual(structure.num_blue_pyramids, 4)
+        self.assertEqual(structure.num_blue_wedges, 5)
+        self.assertEqual(structure.num_blue_blocks, 6)
+        self.assertEqual(structure.num_yellow_pyramids, 7)
+        self.assertEqual(structure.num_yellow_wedges, 8)
+        self.assertEqual(structure.num_yellow_blocks, 9)
+        self.assertEqual(structure.num_red, 6)
+        self.assertEqual(structure.num_blue, 15)
+        self.assertEqual(structure.num_yellow, 24)
+        self.assertEqual(structure.num_pyramids, 12)
+        self.assertEqual(structure.num_wedges, 15)
+        self.assertEqual(structure.num_blocks, 18)
+
+
+class TestRule(unittest.TestCase):
+
+    def test_creating_rules(self):
+        """
+        Test creating valid rules
+        """
+        rule1 = Rule(rule="EXACTLY 2 RED BLOCKS")
+        rule2 = Rule(rule="EXACTLY 0 YELLOW")
+        rule3 = Rule(rule="AT_LEAST 3 PYRAMIDS")
+
+        self.assertEqual(rule1.is_exactly, True)
+        self.assertEqual(rule2.is_exactly, True)
+        self.assertEqual(rule3.is_exactly, False)
+
+        self.assertEqual(rule1.is_at_least, False)
+        self.assertEqual(rule2.is_at_least, False)
+        self.assertEqual(rule3.is_at_least, True)
+
+        self.assertEqual(rule1.quantity, 2)
+        self.assertEqual(rule2.quantity, 0)
+        self.assertEqual(rule3.quantity, 3)
+
+        self.assertEqual(rule1.color, RED)
+        self.assertEqual(rule2.color, YELLOW)
+        self.assertEqual(rule3.color, None)
+
+        self.assertEqual(rule1.shape, BLOCKS)
+        self.assertEqual(rule2.shape, None)
+        self.assertEqual(rule3.shape, PYRAMIDS)
+
+    def test_creating_invalid_rules(self):
+        """
+        Test creating invalid rules
+        """
+        with self.assertRaises(ValueError):
+            Rule(rule="EXACTLY TWO RED BLOCKS")
+
+        with self.assertRaises(ValueError):
+            Rule(rule="INVALID 2 RED BLOCKS")
+
+    def test_does_structure_fit_rule(self):
+        """
+        Test if structures match a rule
+        """
+        rule1 = Rule("AT_LEAST 2 BLOCKS")
+        structure1 = Structure(
+            num_red_blocks=0,
+            num_blue_blocks=1,
+            num_yellow_blocks=1,
+        )
+        structure2 = Structure(
+            num_red_pyramids=5,
+            num_red_blocks=1
+        )
+        self.assertTrue(rule1.does_structure_fit_rule(structure1))
+        self.assertFalse(rule1.does_structure_fit_rule(structure2))
+
+        rule2 = Rule("EXACTLY 4 BLUE")
+        structure3 = Structure(
+            num_blue_pyramids=3,
+            num_blue_wedges=1,
+            num_blue_blocks=0,
+        )
+        structure4 = Structure(
+            num_blue_blocks=5,
+        )
+        self.assertTrue(rule2.does_structure_fit_rule(structure3))
+        self.assertFalse(rule2.does_structure_fit_rule(structure4))
+
+        rule3 = Rule("EXACTLY 1 RED PYRAMIDS")
+        structure5 = Structure(
+            num_red_pyramids=1,
+            num_red_blocks=5,
+            num_blue_pyramids=3,
+        )
+        structure6 = Structure()
+        self.assertTrue(rule3.does_structure_fit_rule(structure5))
+        self.assertFalse(rule3.does_structure_fit_rule(structure6))