Reorganize the whole grading toolbox (savegame; not working)

Author: FranzBangar

examples/shape/cylinder.py

@@ -39,9 +39,4 @@
 mesh.add(cylinder)
 mesh.modify_patch("walls", "wall")
 
-from classy_blocks.grading.graders.manual import ManualGrader
-
-grader = ManualGrader(mesh)
-grader.grade()
-
 mesh.write(os.path.join("..", "case", "system", "blockMeshDict"), debug_path="debug.vtk")

src/classy_blocks/assemble/assembler.py

@@ -1,4 +1,3 @@
-
 from classy_blocks.assemble.depot import Depot
 from classy_blocks.assemble.dump import AssembledDump
 from classy_blocks.assemble.settings import Settings
@@ -20,10 +19,7 @@ def __init__(self, depot: Depot, settings: Settings, merge_tol=constants.TOL):
         self.settings = settings
         self.merge_tol = merge_tol
 
-        # once the mesh is assembled, adding new stuff to depot will break things;
-        # better (and faster) is to cache status quo
         self._operations = self.depot.operations
-
         self._points = HexPointRegistry.from_operations(self._operations, self.merge_tol)
 
     def _create_blocks(self, vertex_list: VertexList) -> BlockList:

src/classy_blocks/construct/operations/operation.py

@@ -19,8 +19,8 @@
 from classy_blocks.construct.edges import Arc, EdgeData, Line, Project, Spline
 from classy_blocks.construct.flat.face import Face
 from classy_blocks.construct.point import Point
-from classy_blocks.grading.chop import Chop
-from classy_blocks.grading.collector import ChopCollector
+from classy_blocks.grading.define.chop import Chop
+from classy_blocks.grading.define.collector import ChopCollector
 from classy_blocks.util import constants
 from classy_blocks.util import functions as f
 from classy_blocks.util.constants import SIDES_MAP

src/classy_blocks/grading/analyze/__init__.py

@@ -3,15 +3,15 @@
 
 from classy_blocks.base.exceptions import BlockNotFoundError, NoInstructionError
 from classy_blocks.cbtyping import DirectionType
-from classy_blocks.grading.graders.row import Row
+from classy_blocks.grading.analyze.row import Row
 from classy_blocks.items.block import Block
 from classy_blocks.items.wires.axis import Axis
-from classy_blocks.mesh import Mesh
+from classy_blocks.lists.block_list import BlockList
 
 
-@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:
+@functools.lru_cache(maxsize=9000)  # that's for 3000 blocks
+def get_block_from_axis(block_list: BlockList, axis: Axis) -> Block:
+    for block in block_list.blocks:
         if axis in block.axes:
             return block
 
@@ -36,11 +36,11 @@ def __hash__(self) -> int:
 class RowCatalogue:
     """A collection of rows on a specified axis"""
 
-    def __init__(self, mesh: Mesh):
-        self.mesh = mesh
+    def __init__(self, block_list: BlockList):
+        self.block_list = block_list
 
         self.rows: dict[DirectionType, list[Row]] = {0: [], 1: [], 2: []}
-        self.instructions = [Instruction(block) for block in mesh.blocks]
+        self.instructions = [Instruction(block) for block in block_list.blocks]
 
         for i in get_args(DirectionType):
             self._populate(i)
@@ -63,7 +63,7 @@ def _add_block_to_row(self, row: Row, instruction: Instruction, direction: Direc
         block = instruction.block
 
         for neighbour_axis in block.axes[direction].neighbours:
-            neighbour_block = get_block_from_axis(self.mesh, neighbour_axis)
+            neighbour_block = get_block_from_axis(self.block_list, neighbour_axis)
 
             if neighbour_block in row.blocks:
                 continue

…assy_blocks/grading/graders/catalogue.py …assy_blocks/grading/analyze/catalogue.pysrc/classy_blocks/grading/graders/catalogue.py renamed to src/classy_blocks/grading/analyze/catalogue.py src/classy_blocks/grading/graders/catalogue.py renamed to src/classy_blocks/grading/analyze/catalogue.py

@@ -2,13 +2,13 @@
 from typing import Optional
 
 from classy_blocks.assemble.dump import AssembledDump
+from classy_blocks.assemble.settings import Settings
 from classy_blocks.base.exceptions import PatchNotFoundError
 from classy_blocks.cbtyping import DirectionType, OrientType
-from classy_blocks.grading.graders.catalogue import RowCatalogue
-from classy_blocks.grading.graders.row import Row
+from classy_blocks.grading.analyze.catalogue import RowCatalogue
+from classy_blocks.grading.analyze.row import Row
 from classy_blocks.items.block import Block
 from classy_blocks.items.wires.wire import Wire
-from classy_blocks.mesh import Mesh
 from classy_blocks.optimize.grid import HexGrid
 from classy_blocks.util.constants import DIRECTION_MAP
 
@@ -75,13 +75,12 @@ class WireCatalogue:
     many wires can be located at the same spot and only some of them can be
     on 'walls'; gather data first so that wall-bounded wires aren't ignored"""
 
-    def __init__(self, mesh: Mesh):
-        self.mesh = mesh
-        assert isinstance(self.mesh.dump, AssembledDump)
-        self.dump = self.mesh.dump
+    def __init__(self, dump: AssembledDump, settings: Settings):
+        self.dump = dump
+        self.settings = settings
 
         # finds blocks' neighbours
-        self.grid = HexGrid.from_mesh(self.mesh)
+        self.grid = HexGrid.from_dump(dump)
 
         # WireInfo is stored at indexes [vertex_1][vertex_2];
         # if a coincident wire is inverted, it will reside at
@@ -97,7 +96,7 @@ def _fetch(self, index_1: int, index_2: int) -> Optional[WireInfo]:
         return self.data[index_1].get(index_2)
 
     def _populate(self) -> None:
-        for block in self.mesh.blocks:
+        for block in self.dump.blocks:
             for wire in block.wire_list:
                 start_index, end_index = wire.vertices[0].index, wire.vertices[1].index
 
@@ -116,7 +115,7 @@ def _get_wire_boundaries(self, wire: Wire, block: Block) -> tuple[bool, bool]:
         """Finds out whether a Wire starts or ends on a wall patch"""
         start_orient = DIRECTION_MAP[wire.direction][0]
         end_orient = DIRECTION_MAP[wire.direction][1]
-        block_index = self.mesh.blocks.index(block)
+        block_index = self.dump.blocks.index(block)
 
         def find_patch(orient: OrientType) -> bool:
             # search for external faces;
@@ -132,7 +131,7 @@ def find_patch(orient: OrientType) -> bool:
                 if patch.kind == "wall":
                     return True
             except PatchNotFoundError:
-                if self.mesh.settings.default_patch.get("kind") == "wall":
+                if self.settings.default_patch.get("kind") == "wall":
                     return True
 
             return False
@@ -151,14 +150,12 @@ def get_info(self, wire: Wire) -> WireInfo:
 class Probe:
     """Examines the mesh and gathers required data for auto chopping"""
 
-    def __init__(self, mesh: Mesh):
-        self.mesh = mesh
-
+    def __init__(self, dump: AssembledDump, settings: Settings):
         # maps blocks to rows
-        self.rows = RowCatalogue(self.mesh)
+        self.rows = RowCatalogue(dump.block_list)
 
         # build a wire database
-        self.wires = WireCatalogue(self.mesh)
+        self.wires = WireCatalogue(dump, settings)
 
     def get_row_blocks(self, block: Block, direction: DirectionType) -> list[Block]:
         return self.rows.get_row_blocks(block, direction)

…c/classy_blocks/grading/graders/probe.py …c/classy_blocks/grading/analyze/probe.pysrc/classy_blocks/grading/graders/probe.py renamed to src/classy_blocks/grading/analyze/probe.py src/classy_blocks/grading/graders/probe.py renamed to src/classy_blocks/grading/analyze/probe.py

@@ -3,7 +3,7 @@
 from typing import Callable, Optional, Union
 
 from classy_blocks.cbtyping import ChopPreserveType, ChopTakeType, GradingSpecType
-from classy_blocks.grading import relations as rel
+from classy_blocks.grading.define import relations as rel
 
 
 @dataclasses.dataclass

src/classy_blocks/grading/graders/row.py src/classy_blocks/grading/analyze/row.pysrc/classy_blocks/grading/graders/row.py renamed to src/classy_blocks/grading/analyze/row.py

@@ -1,5 +1,5 @@
 from classy_blocks.cbtyping import DirectionType
-from classy_blocks.grading.chop import Chop
+from classy_blocks.grading.define.chop import Chop
 from classy_blocks.util.frame import Frame