Define grading strategies...

...and add some entry-level stuff

Author: FranzBangar

src/classy_blocks/grading/autograding/grader.py

@@ -1,14 +1,20 @@
 import abc
+from typing import get_args
 
-from classy_blocks.grading.autograding.params import ChopParams, SimpleChopParams
+from classy_blocks.grading.autograding.params import ChopParams, SimpleChopParams, SimpleHighReChopParams
+from classy_blocks.grading.autograding.probe import Probe
+from classy_blocks.items.block import Block
 from classy_blocks.mesh import Mesh
+from classy_blocks.types import AxisType
 
 
 class GraderBase(abc.ABC):
     def __init__(self, mesh: Mesh, params: ChopParams):
         self.mesh = mesh
         self.params = params
 
+        self.probe = Probe(self.mesh)
+
     @abc.abstractmethod
     def grade(self) -> None:
         pass
@@ -25,3 +31,18 @@ def grade(self):
         for block in self.mesh.blocks:
             for axis in block.axes:
                 axis.chops = chops
+
+
+class SimpleHighReGrader(GraderBase):
+    def __init__(self, mesh: Mesh, params: SimpleHighReChopParams):
+        super().__init__(mesh, params)
+
+    def grade_block(self, block: Block) -> None:
+        raise NotImplementedError("WIP!")
+
+    def grade_axis(self, axis: AxisType) -> None:
+        raise NotImplementedError("WIP!")
+
+    def grade(self):
+        for axis in get_args(AxisType):
+            self.grade_axis(axis)

src/classy_blocks/grading/autograding/probe.py

@@ -1,8 +1,48 @@
+import functools
+from typing import Set, get_args
+
+from classy_blocks.items.block import Block
+from classy_blocks.items.wires.axis import Axis
 from classy_blocks.mesh import Mesh
+from classy_blocks.types import AxisType
+
+
+@functools.lru_cache(maxsize=3000)  # that's for 1000 blocks
+def _get_block_from_axis(mesh: Mesh, axis: Axis) -> Block:
+    for block in mesh.blocks:
+        for index in get_args(AxisType):
+            if block.axes[index] == axis:
+                return block
+
+    raise RuntimeError("Block for Axis not found!")
 
 
 class Probe:
     """Examines the mesh and gathers required data for auto chopping"""
 
     def __init__(self, mesh: Mesh):
         self.mesh = mesh
+
+    def _get_block_from_axis(self, axis: Axis) -> Block:
+        return _get_block_from_axis(self.mesh, axis)
+
+    def get_blocks_on_layer(self, block: Block, axis: AxisType) -> Set[Block]:
+        """Returns all blocks on the same 'layer' as the one in arguments"""
+        # blocks to be returned
+        blocks: Set[Block] = set()
+        # blocks not to check again
+        traversed: Set[Block] = set()
+
+        def check(blk: Block):
+            if blk not in traversed:
+                traversed.add(blk)
+
+                for neighbour_axis in blk.axes[axis].neighbours:
+                    neighbour_block = self._get_block_from_axis(neighbour_axis)
+                    blocks.add(neighbour_block)
+
+                    check(self._get_block_from_axis(neighbour_axis))
+
+        check(block)
+
+        return blocks

src/classy_blocks/items/wires/axis.py

@@ -121,3 +121,6 @@ def is_simple(self) -> bool:
 
     def __str__(self):
         return f"Axis {self.index} (" + "|".join(str(wire) for wire in self.wires.wires) + ")"
+
+    def __hash__(self):
+        return id(self)

tests/test_autograde.py

@@ -0,0 +1,29 @@
+import unittest
+
+from parameterized import parameterized
+
+from classy_blocks.construct.flat.sketches.grid import Grid
+from classy_blocks.construct.stack import ExtrudedStack
+from classy_blocks.grading.autograding.probe import Probe
+from classy_blocks.mesh import Mesh
+
+
+class AutogradeTestsBase(unittest.TestCase):
+    def setUp(self):
+        self.mesh = Mesh()
+
+        # create a simple 3x3 grid for easy navigation
+        base = Grid([0, 0, 0], [1, 1, 0], 3, 3)
+        self.stack = ExtrudedStack(base, 1, 3)
+
+        self.mesh.add(self.stack)
+        self.mesh.assemble()
+
+
+class ProbeTests(AutogradeTestsBase):
+    @parameterized.expand(((0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (2, 2)))
+    def test_get_blocks_on_layer(self, block, axis):
+        probe = Probe(self.mesh)
+
+        blocks = probe.get_blocks_on_layer(self.mesh.blocks[block], axis)
+        self.assertEqual(len(blocks), 9)