Full Code of damogranlabs/classy_blocks for AI

gitextract_gjyxw34u/

├── .editorconfig
├── .github/
│   ├── ISSUE_TEMPLATE.md
│   └── workflows/
│       └── build_ci.yml
├── .gitignore
├── .pre-commit-config.yaml
├── CHANGELOG.md
├── CITATION.cff
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── docs/
│   └── optimization/
│       └── quality-criteria.ods
├── examples/
│   ├── advanced/
│   │   ├── chop_preserve.py
│   │   ├── collapsed.py
│   │   ├── edge_grading.py
│   │   ├── merged.py
│   │   └── project.py
│   ├── assembly/
│   │   ├── l_joint.py
│   │   ├── n_joint.py
│   │   └── t_joint.py
│   ├── bug.py
│   ├── case/
│   │   ├── Allrun.mesh
│   │   ├── case.foam
│   │   ├── constant/
│   │   │   └── geometry/
│   │   │       └── terrain.stl
│   │   └── system/
│   │       ├── collapseDict
│   │       ├── controlDict
│   │       ├── fvSchemes
│   │       └── fvSolution
│   ├── chaining/
│   │   ├── flywheel.py
│   │   ├── helmholtz_nozzle.py
│   │   ├── labyrinth.py
│   │   ├── orifice_plate.py
│   │   ├── tank.py
│   │   ├── test_tube.py
│   │   └── venturi_tube.py
│   ├── complex/
│   │   ├── airfoil/
│   │   │   └── airfoil.py
│   │   ├── cyclone/
│   │   │   ├── README
│   │   │   ├── __init__.py
│   │   │   ├── cyclone.py
│   │   │   ├── geometry.py
│   │   │   ├── parameters.py
│   │   │   └── regions/
│   │   │       ├── __init__.py
│   │   │       ├── body.py
│   │   │       ├── core.py
│   │   │       ├── fillaround.py
│   │   │       ├── inlet.py
│   │   │       ├── inner_ring.py
│   │   │       ├── pipe.py
│   │   │       ├── region.py
│   │   │       └── skirt.py
│   │   ├── gear/
│   │   │   ├── gear.py
│   │   │   ├── involute_gear.py
│   │   │   └── tooth.py
│   │   ├── heater/
│   │   │   ├── heater.py
│   │   │   └── parameters.py
│   │   ├── karman.py
│   │   └── plate/
│   │       ├── parameters.py
│   │       └── plate.py
│   ├── modification/
│   │   └── move_vertex.py
│   ├── operation/
│   │   ├── box.py
│   │   ├── channel.py
│   │   ├── connector.py
│   │   ├── extrude.py
│   │   ├── loft.py
│   │   ├── revolve.py
│   │   └── wedge.py
│   ├── optimization/
│   │   ├── diffuser_free.py
│   │   ├── diffuser_line.py
│   │   ├── duct.py
│   │   └── simple.py
│   ├── shape/
│   │   ├── custom.py
│   │   ├── cylinder.py
│   │   ├── elbow.py
│   │   ├── extruded_ring.py
│   │   ├── frustum.py
│   │   ├── hemisphere.py
│   │   ├── one_core_cylinder.py
│   │   ├── quarter_cylinder.py
│   │   ├── revolved_ring.py
│   │   ├── shell.py
│   │   ├── splined/
│   │   │   ├── combined_example.py
│   │   │   ├── spline_ring.py
│   │   │   ├── spline_ring_whole_half_quarter.py
│   │   │   └── spline_round.py
│   │   ├── torus.py
│   │   └── wrapped_cylinder.py
│   ├── stack/
│   │   ├── cube.py
│   │   └── fusilli.py
│   └── transform/
│       └── mirror.py
├── pyproject.toml
├── src/
│   └── classy_blocks/
│       ├── __init__.py
│       ├── assemble/
│       │   ├── __init__.py
│       │   ├── assembler.py
│       │   ├── depot.py
│       │   ├── dump.py
│       │   └── settings.py
│       ├── base/
│       │   ├── __init__.py
│       │   ├── element.py
│       │   ├── exceptions.py
│       │   └── transforms.py
│       ├── cbtyping.py
│       ├── construct/
│       │   ├── __init__.py
│       │   ├── assemblies/
│       │   │   ├── assembly.py
│       │   │   └── joints.py
│       │   ├── curves/
│       │   │   ├── __init__.py
│       │   │   ├── analytic.py
│       │   │   ├── curve.py
│       │   │   ├── discrete.py
│       │   │   ├── interpolated.py
│       │   │   └── interpolators.py
│       │   ├── edges.py
│       │   ├── flat/
│       │   │   ├── __init__.py
│       │   │   ├── face.py
│       │   │   ├── sketch.py
│       │   │   └── sketches/
│       │   │       ├── __init__.py
│       │   │       ├── annulus.py
│       │   │       ├── disk.py
│       │   │       ├── grid.py
│       │   │       ├── mapped.py
│       │   │       └── spline_round.py
│       │   ├── operations/
│       │   │   ├── __init__.py
│       │   │   ├── box.py
│       │   │   ├── connector.py
│       │   │   ├── extrude.py
│       │   │   ├── loft.py
│       │   │   ├── operation.py
│       │   │   ├── revolve.py
│       │   │   └── wedge.py
│       │   ├── point.py
│       │   ├── series.py
│       │   ├── shape.py
│       │   ├── shapes/
│       │   │   ├── __init__.py
│       │   │   ├── cylinder.py
│       │   │   ├── elbow.py
│       │   │   ├── frustum.py
│       │   │   ├── rings.py
│       │   │   ├── round.py
│       │   │   ├── shell.py
│       │   │   └── sphere.py
│       │   └── stack.py
│       ├── grading/
│       │   ├── __init__.py
│       │   ├── analyze/
│       │   │   ├── __init__.py
│       │   │   ├── catalogue.py
│       │   │   ├── probe.py
│       │   │   └── row.py
│       │   ├── define/
│       │   │   ├── __init__.py
│       │   │   ├── chop.py
│       │   │   ├── collector.py
│       │   │   ├── grading.py
│       │   │   └── relations.py
│       │   └── graders/
│       │       ├── __init__.py
│       │       ├── auto.py
│       │       ├── fixed.py
│       │       ├── inflation.py
│       │       ├── manager.py
│       │       └── simple.py
│       ├── items/
│       │   ├── __init__.py
│       │   ├── block.py
│       │   ├── edges/
│       │   │   ├── __init__.py
│       │   │   ├── arcs/
│       │   │   │   ├── __init__.py
│       │   │   │   ├── angle.py
│       │   │   │   ├── arc.py
│       │   │   │   ├── arc_base.py
│       │   │   │   └── origin.py
│       │   │   ├── curve.py
│       │   │   ├── edge.py
│       │   │   ├── factory.py
│       │   │   ├── line.py
│       │   │   └── project.py
│       │   ├── patch.py
│       │   ├── side.py
│       │   ├── vertex.py
│       │   └── wires/
│       │       ├── __init__.py
│       │       ├── axis.py
│       │       ├── manager.py
│       │       └── wire.py
│       ├── lists/
│       │   ├── __init__.py
│       │   ├── block_list.py
│       │   ├── edge_list.py
│       │   ├── face_list.py
│       │   ├── patch_list.py
│       │   └── vertex_list.py
│       ├── lookup/
│       │   ├── __init__.py
│       │   ├── cell_registry.py
│       │   ├── connection_registry.py
│       │   ├── face_registry.py
│       │   └── point_registry.py
│       ├── mesh.py
│       ├── modify/
│       │   ├── __init__.py
│       │   ├── find/
│       │   │   ├── __init__.py
│       │   │   ├── finder.py
│       │   │   ├── geometric.py
│       │   │   └── shape.py
│       │   └── reorient/
│       │       ├── __init__.py
│       │       └── viewpoint.py
│       ├── optimize/
│       │   ├── __init__.py
│       │   ├── cell.py
│       │   ├── clamps/
│       │   │   ├── __init__.py
│       │   │   ├── clamp.py
│       │   │   ├── curve.py
│       │   │   ├── free.py
│       │   │   └── surface.py
│       │   ├── connection.py
│       │   ├── grid.py
│       │   ├── junction.py
│       │   ├── links.py
│       │   ├── optimizer.py
│       │   ├── quality.py
│       │   ├── record.py
│       │   ├── report.py
│       │   └── smoother.py
│       ├── util/
│       │   ├── __init__.py
│       │   ├── constants.py
│       │   ├── frame.py
│       │   ├── functions.py
│       │   └── tools.py
│       └── write/
│           ├── __init__.py
│           ├── formats.py
│           ├── vtk.py
│           └── writer.py
├── tests/
│   ├── __init__.py
│   ├── fixtures/
│   │   ├── __init__.py
│   │   ├── block.py
│   │   ├── data.py
│   │   └── mesh.py
│   ├── helpers/
│   │   ├── __init__.py
│   │   └── collect_outputs.py
│   ├── test_assemble.py
│   ├── test_bugs/
│   │   ├── __init__.py
│   │   └── test_grading.py
│   ├── test_construct/
│   │   ├── __init__.py
│   │   ├── test_assembly.py
│   │   ├── test_chaining.py
│   │   ├── test_curves/
│   │   │   ├── __init__.py
│   │   │   ├── test_analytic.py
│   │   │   ├── test_discrete.py
│   │   │   ├── test_interpolated.py
│   │   │   └── test_interpolators.py
│   │   ├── test_edge_data.py
│   │   ├── test_flat/
│   │   │   ├── __init__.py
│   │   │   ├── test_annulus.py
│   │   │   ├── test_disk.py
│   │   │   ├── test_face.py
│   │   │   └── test_sketch.py
│   │   ├── test_operation/
│   │   │   ├── __init__.py
│   │   │   ├── test_box.py
│   │   │   ├── test_connector.py
│   │   │   ├── test_extrude.py
│   │   │   ├── test_operation.py
│   │   │   └── test_wedge.py
│   │   ├── test_point.py
│   │   ├── test_shape.py
│   │   ├── test_shell.py
│   │   └── test_stack.py
│   ├── test_grading/
│   │   ├── __init__.py
│   │   ├── test_catalogue.py
│   │   ├── test_collector.py
│   │   ├── test_edge_grading.py
│   │   ├── test_grading.py
│   │   ├── test_inflation.py
│   │   ├── test_layers.py
│   │   ├── test_probe.py
│   │   └── test_relations.py
│   ├── test_items/
│   │   ├── __init__.py
│   │   ├── test_axis.py
│   │   ├── test_block.py
│   │   ├── test_edge.py
│   │   ├── test_patch.py
│   │   ├── test_side.py
│   │   ├── test_vertex.py
│   │   └── test_wire.py
│   ├── test_lists/
│   │   ├── __init__.py
│   │   ├── test_edge_list.py
│   │   ├── test_face_list.py
│   │   └── test_patch_list.py
│   ├── test_mesh.py
│   ├── test_modify/
│   │   ├── __init__.py
│   │   ├── test_finder.py
│   │   └── test_reorient.py
│   ├── test_optimize/
│   │   ├── __init__.py
│   │   ├── optimize_fixtures.py
│   │   ├── test_cell.py
│   │   ├── test_clamps.py
│   │   ├── test_grid.py
│   │   ├── test_links.py
│   │   ├── test_optimizer.py
│   │   ├── test_quality.py
│   │   └── test_smoother.py
│   ├── test_propagation.py
│   └── test_util/
│       ├── __init__.py
│       ├── test_frame.py
│       ├── test_functions.py
│       ├── test_imports.py
│       └── test_tools.py
└── tox.ini

SYMBOL INDEX (2257 symbols across 184 files)

FILE: examples/chaining/flywheel.py
  function double_chop (line 55) | def double_chop(function):

FILE: examples/chaining/venturi_tube.py
  function calculate_fillet (line 9) | def calculate_fillet(r_pipe, r_fillet, a_cone):
  function calculate_cone (line 21) | def calculate_cone(r_start, r_end, a_cone):

FILE: examples/complex/airfoil/airfoil.py
  function get_curve (line 46) | def get_curve(z: float) -> cb.SplineInterpolatedCurve:
  class AirfoilSketch (line 88) | class AirfoilSketch(cb.MappedSketch):
    method __init__ (line 102) | def __init__(self, points):
    method add_edges (line 143) | def add_edges(self):

FILE: examples/complex/cyclone/cyclone.py
  function add_regions (line 25) | def add_regions(regions: list[Region]) -> None:
  function mirror_region (line 139) | def mirror_region(region: Region):

FILE: examples/complex/cyclone/geometry.py
  class Geometry (line 24) | class Geometry:
    method __post_init__ (line 28) | def __post_init__(self):
    method r (line 37) | def r(self) -> dict[str, float]:
    method l (line 48) | def l(self) -> dict["str", "float"]:  # noqa: E743
    method inlet (line 67) | def inlet(self) -> list[NPPointType]:
    method z (line 75) | def z(self) -> dict[str, float]:
    method surfaces (line 86) | def surfaces(self):

FILE: examples/complex/cyclone/regions/body.py
  class ChainSketch (line 16) | class ChainSketch(Sketch):
    method grid (line 20) | def grid(self):
    method _get_faces (line 24) | def _get_faces(ops: Sequence[Operation]) -> list[cb.Face]:
    method _add_arcs (line 46) | def _add_arcs(faces: list[cb.Face]) -> None:
    method __init__ (line 63) | def __init__(self, regions: list[Region]):
    method faces (line 75) | def faces(self):
    method center (line 79) | def center(self):
    method n_segments (line 83) | def n_segments(self):
  class BodyShape (line 87) | class BodyShape(RoundSolidShape):
    method shell (line 89) | def shell(self):
    method core (line 93) | def core(self):
  class UpperBody (line 97) | class UpperBody(Region):
    method __init__ (line 98) | def __init__(self, sketch: ChainSketch, length: float):
    method chop (line 102) | def chop(self):
    method elements (line 106) | def elements(self):
  class LowerBody (line 110) | class LowerBody(UpperBody):
  class Cone (line 114) | class Cone(UpperBody):
    method __init__ (line 115) | def __init__(self, sketch: ChainSketch):

FILE: examples/complex/cyclone/regions/core.py
  class NineCoreDisk (line 15) | class NineCoreDisk(cb.MappedSketch):
    method __init__ (line 46) | def __init__(self, perimeter: PointListType, center_point: PointType):
    method core (line 66) | def core(self) -> list[cb.Face]:
    method shell (line 70) | def shell(self) -> list[cb.Face]:
    method add_edges (line 73) | def add_edges(self):
    method parts (line 78) | def parts(self):
    method center (line 82) | def center(self):
    method grid (line 86) | def grid(self):
    method normal (line 90) | def normal(self) -> NPVectorType:
    method n_segments (line 94) | def n_segments(self):
  class DozenBlockCylinder (line 98) | class DozenBlockCylinder(RoundSolidShape):
    method __init__ (line 101) | def __init__(self, perimeter: PointListType, center_point: PointType, ...
    method chop_radial (line 106) | def chop_radial(self, **kwargs):
  class Core (line 110) | class Core(Region):
    method __init__ (line 111) | def __init__(self, points: PointListType):
    method chop (line 114) | def chop(self):
    method elements (line 119) | def elements(self):
  class Outlet (line 123) | class Outlet(Region):
    method __init__ (line 124) | def __init__(self, core_cylinder: DozenBlockCylinder):
    method chop (line 130) | def chop(self):
    method elements (line 134) | def elements(self):
    method set_patches (line 137) | def set_patches(self):

FILE: examples/complex/cyclone/regions/fillaround.py
  class FillAround (line 7) | class FillAround(Region):
    method __init__ (line 11) | def __init__(self, loft_1: cb.Loft, loft_2: cb.Loft):
    method elements (line 40) | def elements(self):
    method connector_1 (line 44) | def connector_1(self):
    method connector_2 (line 48) | def connector_2(self):
    method project (line 51) | def project(self):

FILE: examples/complex/cyclone/regions/inlet.py
  class InletPipe (line 12) | class InletPipe(Region):
    method __init__ (line 17) | def __init__(self):
    method snap_point (line 20) | def snap_point(self, point: Point) -> None:
    method scale_point (line 29) | def scale_point(self, point: Point) -> None:
    method create_inlet (line 38) | def create_inlet(self):
    method inner_lofts (line 63) | def inner_lofts(self):
    method elements (line 69) | def elements(self):
    method project (line 72) | def project(self):
  class InletExtension (line 77) | class InletExtension(Region):
    method __init__ (line 78) | def __init__(self, inlet: InletPipe):
    method elements (line 87) | def elements(self):
    method set_patches (line 90) | def set_patches(self):

FILE: examples/complex/cyclone/regions/inner_ring.py
  class InnerRing (line 8) | class InnerRing(Region):
    method _move_to_radius (line 13) | def _move_to_radius(self, point):
    method _move_to_angle (line 19) | def _move_to_angle(self, point, angle):
    method _reorient_face (line 25) | def _reorient_face(self, face: cb.Face) -> None:
    method __init__ (line 51) | def __init__(self, lofts: list[cb.Loft]):
    method elements (line 67) | def elements(self):
    method project (line 70) | def project(self):

FILE: examples/complex/cyclone/regions/pipe.py
  class Pipe (line 9) | class Pipe(Region):
    method __init__ (line 10) | def __init__(self, outer: Region):
    method center (line 43) | def center(self) -> NPPointType:
    method elements (line 48) | def elements(self):
    method project (line 51) | def project(self):

FILE: examples/complex/cyclone/regions/region.py
  class Region (line 10) | class Region(abc.ABC):
    method elements (line 22) | def elements(self) -> list[Operation]:
    method get_line_clamps (line 25) | def get_line_clamps(self, mesh):
    method get_free_clamps (line 38) | def get_free_clamps(self, mesh: cb.Mesh) -> set[cb.ClampBase]:
    method get_plane_clamps (line 47) | def get_plane_clamps(self, mesh: cb.Mesh) -> set[cb.ClampBase]:
    method get_radial_clamps (line 57) | def get_radial_clamps(self, mesh: cb.Mesh) -> set[cb.ClampBase]:
    method get_clamps (line 67) | def get_clamps(self, mesh: cb.Mesh) -> set[cb.ClampBase]:
    method project (line 76) | def project(self) -> None:  # noqa: B027
    method set_patches (line 79) | def set_patches(self):  # noqa: B027

FILE: examples/complex/cyclone/regions/skirt.py
  class Skirt (line 6) | class Skirt(Region):
    method __init__ (line 12) | def __init__(self, inlet_shell: list[cb.Loft]):
    method elements (line 29) | def elements(self):
    method project (line 32) | def project(self):

FILE: examples/complex/gear/gear.py
  function frad (line 46) | def frad(t, radius):
  function mirror (line 84) | def mirror(target, source):
  function midpoint (line 103) | def midpoint(target, left, right):

FILE: examples/complex/gear/involute_gear.py
  class DimensionError (line 9) | class DimensionError(Exception):
  function rotation_matrix (line 13) | def rotation_matrix(theta):
  function flip_matrix (line 17) | def flip_matrix(h, v):
  function polar_to_cart (line 21) | def polar_to_cart(*coords):
  function cart_to_polar (line 28) | def cart_to_polar(*coords):
  class InvoluteGear (line 35) | class InvoluteGear:
    method __init__ (line 36) | def __init__(
    method reduce_polyline (line 110) | def reduce_polyline(self, polyline):
    method generate_half_tooth (line 142) | def generate_half_tooth(self):
    method generate_half_root (line 178) | def generate_half_root(self):
    method generate_roots (line 210) | def generate_roots(self):
    method generate_tooth (line 230) | def generate_tooth(self):
    method generate_tooth_and_gap (line 249) | def generate_tooth_and_gap(self):
    method generate_gear (line 260) | def generate_gear(self):
    method get_point_list (line 273) | def get_point_list(self):

FILE: examples/complex/gear/tooth.py
  class ToothSketch (line 6) | class ToothSketch(cb.MappedSketch):
    method __init__ (line 37) | def __init__(self, positions, curve: cb.LinearInterpolatedCurve):
    method add_edges (line 41) | def add_edges(self) -> None:

FILE: examples/complex/heater/heater.py
  function set_cell_zones (line 18) | def set_cell_zones(shape: cb.Shape):
  class NearestSketch (line 66) | class NearestSketch(Sketch):
    method __init__ (line 67) | def __init__(self, operations: List[cb.Operation], far_point):
    method faces (line 72) | def faces(self):
    method grid (line 76) | def grid(self):
    method center (line 80) | def center(self):

FILE: examples/complex/karman.py
  function make_box (line 44) | def make_box(p1, p2, size_axes, patches):

FILE: examples/complex/plate/plate.py
  function make_extrude (line 38) | def make_extrude(indexes):

FILE: examples/shape/custom.py
  class RoundSquare (line 15) | class RoundSquare(cb.MappedSketch):
    method __init__ (line 38) | def __init__(self, center: PointType, side: float, corner_round: float):
    method add_edges (line 56) | def add_edges(self) -> None:

FILE: examples/stack/cube.py
  function move_side (line 39) | def move_side(point, normal, axis, value):

FILE: src/classy_blocks/assemble/assembler.py
  class MeshAssembler (line 16) | class MeshAssembler:
    method __init__ (line 17) | def __init__(self, depot: Depot, settings: Settings, merge_tol=constan...
    method _create_blocks (line 25) | def _create_blocks(self, vertex_list: VertexList) -> BlockList:
    method _create_edges (line 53) | def _create_edges(self, block_list: BlockList) -> EdgeList:
    method _add_geometry (line 79) | def _add_geometry(self):
    method _create_patches (line 84) | def _create_patches(self, block_list: BlockList) -> tuple[PatchList, F...
    method _update_neighbours (line 104) | def _update_neighbours(self, block_list: BlockList) -> None:
    method assemble (line 107) | def assemble(self) -> AssembledDump:

FILE: src/classy_blocks/assemble/depot.py
  class Depot (line 11) | class Depot:
    method __init__ (line 14) | def __init__(self) -> None:
    method add_solid (line 18) | def add_solid(self, solid: AdditiveType) -> None:
    method delete_solid (line 21) | def delete_solid(self, operation: Operation) -> None:
    method operations (line 25) | def operations(self) -> list[Operation]:

FILE: src/classy_blocks/assemble/dump.py
  class DumpBase (line 15) | class DumpBase(abc.ABC):
    method is_assembled (line 18) | def is_assembled(self) -> bool:
    method vertices (line 23) | def vertices(self) -> list[Vertex]:
    method patches (line 28) | def patches(self) -> list[Patch]:
    method blocks (line 33) | def blocks(self) -> list[Block]:
    method edges (line 38) | def edges(self) -> list[Edge]:
  class EmptyDump (line 42) | class EmptyDump(DumpBase):
    method is_assembled (line 44) | def is_assembled(self):
    method vertices (line 48) | def vertices(self):
    method patches (line 52) | def patches(self):
    method blocks (line 56) | def blocks(self):
    method edges (line 60) | def edges(self):
  class AssembledDump (line 64) | class AssembledDump(DumpBase):
    method __init__ (line 65) | def __init__(
    method is_assembled (line 80) | def is_assembled(self):
    method vertices (line 85) | def vertices(self):
    method patches (line 89) | def patches(self):
    method blocks (line 93) | def blocks(self):
    method edges (line 97) | def edges(self):

FILE: src/classy_blocks/assemble/settings.py
  class Settings (line 8) | class Settings:
    method add_geometry (line 26) | def add_geometry(self, geometry: GeometryType) -> None:
    method modify_patch (line 29) | def modify_patch(self, name: str, kind: str, settings: Optional[list[s...
    method slave_patches (line 36) | def slave_patches(self) -> set[str]:

FILE: src/classy_blocks/base/element.py
  class ElementBase (line 12) | class ElementBase(abc.ABC):
    method translate (line 16) | def translate(self: ElementBaseT, displacement: VectorType) -> Element...
    method rotate (line 24) | def rotate(self: ElementBaseT, angle: float, axis: VectorType, origin:...
    method scale (line 35) | def scale(self: ElementBaseT, ratio: float, origin: Optional[PointType...
    method mirror (line 47) | def mirror(self: ElementBaseT, normal: VectorType, origin: Optional[Po...
    method shear (line 58) | def shear(
    method copy (line 66) | def copy(self: ElementBaseT) -> ElementBaseT:
    method parts (line 72) | def parts(self: ElementBaseT) -> list[ElementBaseT]:
    method center (line 81) | def center(self) -> NPPointType:
    method geometry (line 85) | def geometry(self) -> Optional[dict]:
    method transform (line 91) | def transform(self: ElementBaseT, transforms: Sequence[tr.Transformati...

FILE: src/classy_blocks/base/exceptions.py
  class ShapeCreationError (line 5) | class ShapeCreationError(Exception):
    method __init__ (line 9) | def __init__(self, msg: str, details: Optional[str] = None, *args) -> ...
  class PointCreationError (line 20) | class PointCreationError(ShapeCreationError):
  class ArrayCreationError (line 24) | class ArrayCreationError(ShapeCreationError):
  class AnnulusCreationError (line 28) | class AnnulusCreationError(ShapeCreationError):
  class EdgeCreationError (line 32) | class EdgeCreationError(ShapeCreationError):
  class SideCreationError (line 36) | class SideCreationError(ShapeCreationError):
  class FaceCreationError (line 40) | class FaceCreationError(ShapeCreationError):
  class CylinderCreationError (line 44) | class CylinderCreationError(ShapeCreationError):
  class ElbowCreationError (line 48) | class ElbowCreationError(ShapeCreationError):
  class FrustumCreationError (line 52) | class FrustumCreationError(ShapeCreationError):
  class ExtrudedRingCreationError (line 56) | class ExtrudedRingCreationError(ShapeCreationError):
  class GeometryConstraintError (line 60) | class GeometryConstraintError(Exception):
  class DegenerateGeometryError (line 64) | class DegenerateGeometryError(Exception):
  class SharedPointError (line 69) | class SharedPointError(Exception):
  class SharedPointNotFoundError (line 73) | class SharedPointNotFoundError(SharedPointError):
  class PointNotCoincidentError (line 77) | class PointNotCoincidentError(SharedPointError):
  class DisconnectedChopError (line 81) | class DisconnectedChopError(SharedPointError):
  class VertexNotFoundError (line 86) | class VertexNotFoundError(Exception):
  class EdgeNotFoundError (line 90) | class EdgeNotFoundError(Exception):
  class CornerPairError (line 94) | class CornerPairError(Exception):
  class PatchNotFoundError (line 98) | class PatchNotFoundError(Exception):
  class UndefinedGradingsError (line 103) | class UndefinedGradingsError(Exception):
  class InconsistentGradingsError (line 108) | class InconsistentGradingsError(Exception):
  class NoInstructionError (line 112) | class NoInstructionError(Exception):
  class BlockNotFoundError (line 116) | class BlockNotFoundError(Exception):
  class NoClampError (line 121) | class NoClampError(Exception):
  class ClampExistsError (line 125) | class ClampExistsError(Exception):
  class NoCommonSidesError (line 129) | class NoCommonSidesError(Exception):
  class NoJunctionError (line 133) | class NoJunctionError(Exception):
  class InvalidLinkError (line 137) | class InvalidLinkError(Exception):
  class OptimizationError (line 141) | class OptimizationError(Exception):
  class MeshNotAssembledError (line 146) | class MeshNotAssembledError(Exception):

FILE: src/classy_blocks/base/transforms.py
  class Transformation (line 11) | class Transformation:
  class Translation (line 17) | class Translation(Transformation):
  class Rotation (line 24) | class Rotation(Transformation):
  class Scaling (line 33) | class Scaling(Transformation):
  class Mirror (line 41) | class Mirror(Transformation):
  class Shear (line 50) | class Shear(Transformation):

FILE: src/classy_blocks/cbtyping.py
  class ChopArgs (line 43) | class ChopArgs(TypedDict, total=False):

FILE: src/classy_blocks/construct/assemblies/assembly.py
  class Assembly (line 11) | class Assembly(ElementBase, abc.ABC):
    method __init__ (line 12) | def __init__(self, shapes: Sequence[Shape]):
    method parts (line 16) | def parts(self):
    method center (line 20) | def center(self):
    method operations (line 24) | def operations(self) -> list[Operation]:

FILE: src/classy_blocks/construct/assemblies/joints.py
  class CuspSemiCylinder (line 14) | class CuspSemiCylinder(SemiCylinder):
    method __init__ (line 19) | def __init__(
  class CuspCylinder (line 48) | class CuspCylinder(Assembly):
    method __init__ (line 49) | def __init__(
    method shapes (line 66) | def shapes(self):
    method chop_axial (line 69) | def chop_axial(self, **kwargs):
    method chop_radial (line 72) | def chop_radial(self, **kwargs):
    method chop_tangential (line 76) | def chop_tangential(self, **kwargs):
    method set_outer_patch (line 80) | def set_outer_patch(self, patch_name: str) -> None:
    method set_start_patch (line 84) | def set_start_patch(self, patch_name: str) -> None:
  class JointBase (line 89) | class JointBase(Assembly, abc.ABC):
    method __init__ (line 90) | def __init__(self, start_point: PointType, center_point: PointType, ra...
    method _get_angles (line 113) | def _get_angles(self, count: int) -> FloatListType:
    method center (line 117) | def center(self):
    method chop_axial (line 121) | def chop_axial(self, **kwargs):
    method chop_radial (line 125) | def chop_radial(self, **kwargs):
    method chop_tangential (line 128) | def chop_tangential(self, **kwargs):
    method set_outer_patch (line 132) | def set_outer_patch(self, patch_name: str) -> None:
    method set_hole_patch (line 136) | def set_hole_patch(self, hole: int, patch_name: str) -> None:
  class NJoint (line 140) | class NJoint(JointBase):
    method _get_angles (line 141) | def _get_angles(self, count):
  class TJoint (line 145) | class TJoint(JointBase):
    method __init__ (line 146) | def __init__(self, start_point: PointType, center_point: PointType, ra...
    method _get_angles (line 149) | def _get_angles(self, _):
  class LJoint (line 153) | class LJoint(JointBase):
    method __init__ (line 154) | def __init__(self, start_point: PointType, center_point: PointType, ra...
    method _get_angles (line 157) | def _get_angles(self, _):

FILE: src/classy_blocks/construct/curves/analytic.py
  class AnalyticCurve (line 11) | class AnalyticCurve(FunctionCurveBase):
    method __init__ (line 16) | def __init__(self, function: ParamCurveFuncType, bounds: tuple[float, ...
    method parts (line 21) | def parts(self):
    method get_length (line 24) | def get_length(self, param_from: Optional[float] = None, param_to: Opt...
  class LineCurve (line 31) | class LineCurve(AnalyticCurve):
    method __init__ (line 37) | def __init__(self, point_1: PointType, point_2: PointType, bounds: tup...
    method vector (line 44) | def vector(self) -> NPVectorType:
    method parts (line 48) | def parts(self):
    method center (line 52) | def center(self):
  class CircleCurve (line 57) | class CircleCurve(AnalyticCurve):
    method __init__ (line 62) | def __init__(
    method normal (line 77) | def normal(self) -> NPVectorType:
    method center (line 81) | def center(self):
    method parts (line 85) | def parts(self):

FILE: src/classy_blocks/construct/curves/curve.py
  class CurveBase (line 15) | class CurveBase(ElementBase):
    method _check_param (line 20) | def _check_param(self, param: Union[int, float]) -> Union[int, float]:
    method _get_params (line 27) | def _get_params(self, param_from: Optional[float] = None, param_to: Op...
    method get_point (line 40) | def get_point(self, param: float) -> NPPointType:
    method discretize (line 44) | def discretize(
    method get_length (line 52) | def get_length(self, param_from: Optional[float] = None, param_to: Opt...
    method length (line 57) | def length(self) -> float:
    method get_closest_param (line 62) | def get_closest_param(self, point: PointType) -> float:
    method get_closest_point (line 65) | def get_closest_point(self, point: PointType) -> NPPointType:
    method get_param_at_length (line 69) | def get_param_at_length(self, length: float) -> float:
    method _diff (line 73) | def _diff(self, param: float, order: int, delta: float = TOL) -> NPVec...
    method get_tangent (line 86) | def get_tangent(self, param: float, delta: float = TOL) -> NPVectorType:
    method get_normal (line 90) | def get_normal(self, param: float, delta: float = TOL) -> NPVectorType:
    method get_binormal (line 95) | def get_binormal(self, param: float, delta: float = TOL) -> NPVectorType:
  class PointCurveBase (line 101) | class PointCurveBase(CurveBase):
    method _check_param (line 106) | def _check_param(self, param):
    method center (line 110) | def center(self):
  class FunctionCurveBase (line 115) | class FunctionCurveBase(PointCurveBase):
    method discretize (line 120) | def discretize(
    method get_closest_param (line 129) | def get_closest_param(self, point: PointType) -> float:
    method get_point (line 153) | def get_point(self, param: float) -> NPPointType:

FILE: src/classy_blocks/construct/curves/discrete.py
  class DiscreteCurve (line 12) | class DiscreteCurve(PointCurveBase):
    method __init__ (line 22) | def __init__(self, points: PointListType):
    method discretize (line 26) | def discretize(
    method get_length (line 43) | def get_length(self, param_from: Optional[float] = None, param_to: Opt...
    method get_closest_param (line 47) | def get_closest_param(self, point: PointType) -> float:
    method center (line 60) | def center(self):
    method get_point (line 64) | def get_point(self, param: float) -> NPPointType:
    method parts (line 70) | def parts(self):

FILE: src/classy_blocks/construct/curves/interpolated.py
  class InterpolatedCurveBase (line 13) | class InterpolatedCurveBase(FunctionCurveBase, abc.ABC):
    method __init__ (line 28) | def __init__(self, points: PointListType, extrapolate: bool = False, e...
    method segments (line 34) | def segments(self) -> int:
    method parts (line 39) | def parts(self):
    method get_length (line 47) | def get_length(self, param_from: Optional[float] = None, param_to: Opt...
  class LinearInterpolatedCurve (line 64) | class LinearInterpolatedCurve(InterpolatedCurveBase):
  class SplineInterpolatedCurve (line 68) | class SplineInterpolatedCurve(InterpolatedCurveBase):

FILE: src/classy_blocks/construct/curves/interpolators.py
  class InterpolatorBase (line 10) | class InterpolatorBase(abc.ABC):
    method _get_function (line 18) | def _get_function(self) -> ParamCurveFuncType:
    method __init__ (line 21) | def __init__(self, points: Series, extrapolate: bool, equalize: bool =...
    method __call__ (line 29) | def __call__(self, param: float) -> NPPointType:
    method invalidate (line 36) | def invalidate(self) -> None:
    method params (line 40) | def params(self) -> FloatListType:
  class LinearInterpolator (line 53) | class LinearInterpolator(InterpolatorBase):
    method _get_function (line 54) | def _get_function(self):
  class SplineInterpolator (line 73) | class SplineInterpolator(InterpolatorBase):
    method _get_function (line 74) | def _get_function(self):

FILE: src/classy_blocks/construct/edges.py
  class EdgeData (line 12) | class EdgeData(ElementBase):
    method parts (line 18) | def parts(self):
    method center (line 22) | def center(self):
    method representation (line 27) | def representation(self) -> EdgeKindType:
  class Line (line 32) | class Line(EdgeData):
  class Arc (line 38) | class Arc(EdgeData):
    method __init__ (line 44) | def __init__(self, arc_point: PointType):
    method parts (line 48) | def parts(self):
  class Origin (line 52) | class Origin(EdgeData):
    method __init__ (line 66) | def __init__(self, origin: PointType, flatness: float = 1):
    method parts (line 71) | def parts(self):
  class Angle (line 75) | class Angle(EdgeData):
    method __init__ (line 88) | def __init__(self, angle: float, axis: VectorType):
    method translate (line 92) | def translate(self, displacement):
    method scale (line 95) | def scale(self, ratio, origin=None):
    method parts (line 99) | def parts(self):
  class Project (line 103) | class Project(EdgeData):
    method __init__ (line 108) | def __init__(self, label: ProjectToType):
    method convert_label (line 113) | def convert_label(label: ProjectToType) -> list[str]:
    method check_length (line 122) | def check_length(self) -> None:
    method add_label (line 127) | def add_label(self, label: ProjectToType) -> None:
  class OnCurve (line 139) | class OnCurve(EdgeData):
    method __init__ (line 144) | def __init__(self, curve: CurveBase, n_points: int = 10, representatio...
    method parts (line 151) | def parts(self):
    method center (line 155) | def center(self):
    method representation (line 159) | def representation(self) -> EdgeKindType:
    method discretize (line 162) | def discretize(self, param_from: float, param_to: float) -> NPPointLis...
  class Spline (line 166) | class Spline(OnCurve):
    method __init__ (line 171) | def __init__(self, points: PointListType):
    method parts (line 176) | def parts(self):
    method center (line 180) | def center(self):
    method representation (line 184) | def representation(self) -> EdgeKindType:
  class PolyLine (line 188) | class PolyLine(Spline):
    method representation (line 195) | def representation(self) -> EdgeKindType:

FILE: src/classy_blocks/construct/flat/face.py
  class Face (line 16) | class Face(ElementBase):
    method __init__ (line 32) | def __init__(
    method update (line 69) | def update(self, points: PointListType) -> None:
    method add_edge (line 74) | def add_edge(self, corner: int, edge_data: Union[EdgeData, None]) -> N...
    method remove_edges (line 85) | def remove_edges(self, corners: Optional[list[int]] = None) -> None:
    method project_edge (line 95) | def project_edge(self, corner: int, label: ProjectToType) -> None:
    method invert (line 105) | def invert(self) -> "Face":
    method copy (line 113) | def copy(self) -> "Face":
    method point_array (line 118) | def point_array(self) -> NPPointListType:
    method center (line 123) | def center(self) -> NPPointType:
    method normal (line 128) | def normal(self) -> NPVectorType:
    method parts (line 143) | def parts(self):
    method project (line 146) | def project(self, label: str, edges: bool = False, points: bool = Fals...
    method shift (line 172) | def shift(self, count: int) -> "Face":
    method reorient (line 182) | def reorient(self, start_near: PointType) -> "Face":

FILE: src/classy_blocks/construct/flat/sketch.py
  class Sketch (line 12) | class Sketch(ElementBase):
    method faces (line 21) | def faces(self) -> list[Face]:
    method grid (line 26) | def grid(self) -> list[list[Face]]:
    method copy (line 36) | def copy(self: SketchT) -> SketchT:
    method center (line 42) | def center(self) -> NPPointType:
    method normal (line 46) | def normal(self) -> NPVectorType:
    method parts (line 51) | def parts(self):

FILE: src/classy_blocks/construct/flat/sketches/annulus.py
  class Annulus (line 12) | class Annulus(Sketch):
    method __init__ (line 18) | def __init__(
    method faces (line 59) | def faces(self) -> list[Face]:
    method grid (line 63) | def grid(self):
    method center (line 67) | def center(self) -> NPPointType:
    method n_segments (line 81) | def n_segments(self):
    method outer_radius_point (line 86) | def outer_radius_point(self) -> NPPointType:
    method outer_radius (line 91) | def outer_radius(self) -> float:
    method radius (line 96) | def radius(self) -> float:
    method radius_point (line 101) | def radius_point(self) -> NPPointType:
    method inner_radius_point (line 106) | def inner_radius_point(self) -> NPPointType:
    method inner_radius (line 111) | def inner_radius(self) -> float:

FILE: src/classy_blocks/construct/flat/sketches/disk.py
  class FanPattern (line 22) | class FanPattern:
    method __init__ (line 25) | def __init__(self, center_point: PointType, radius_point: PointType, n...
    method get_outer_points (line 32) | def get_outer_points(self, angles) -> NPPointListType:
    method get_inner_points (line 35) | def get_inner_points(self, angles, ratios: list[float]) -> NPPointList...
  class DiskBase (line 47) | class DiskBase(MappedSketch, abc.ABC):
    method __init__ (line 73) | def __init__(self, positions: PointListType, quads: list[IndexType]):
    method origo (line 80) | def origo(self):
    method diagonal_ratio (line 87) | def diagonal_ratio(self) -> float:
    method circular_core_spline (line 90) | def circular_core_spline(
    method add_core_spline_edges (line 130) | def add_core_spline_edges(self) -> None:
    method add_edges (line 146) | def add_edges(self):
    method center (line 153) | def center(self) -> NPPointType:
    method radius_point (line 158) | def radius_point(self) -> NPPointType:
    method radius_vector (line 163) | def radius_vector(self) -> NPVectorType:
    method radius (line 171) | def radius(self) -> float:
    method n_segments (line 176) | def n_segments(self):
    method core (line 180) | def core(self) -> list[Face]:
    method shell (line 184) | def shell(self) -> list[Face]:
    method parts (line 188) | def parts(self):
  class OneCoreDisk (line 192) | class OneCoreDisk(DiskBase):
    method __init__ (line 201) | def __init__(self, center_point: PointType, radius_point: PointType, n...
    method center (line 223) | def center(self):
    method grid (line 227) | def grid(self):
    method add_core_spline_edges (line 230) | def add_core_spline_edges(self):
  class QuarterDisk (line 234) | class QuarterDisk(DiskBase):
    method __init__ (line 242) | def __init__(self, center_point: PointType, radius_point: PointType, n...
    method grid (line 260) | def grid(self):
  class HalfDisk (line 264) | class HalfDisk(DiskBase):
    method __init__ (line 272) | def __init__(self, center_point: PointType, radius_point: PointType, n...
    method grid (line 293) | def grid(self):
  class FourCoreDisk (line 297) | class FourCoreDisk(DiskBase):
    method __init__ (line 303) | def __init__(self, center_point: PointType, radius_point: PointType, n...
    method grid (line 330) | def grid(self):
  class WrappedDisk (line 337) | class WrappedDisk(DiskBase):
    method __init__ (line 346) | def __init__(self, center_point: PointType, corner_point: PointType, r...
    method grid (line 378) | def grid(self):
    method add_edges (line 381) | def add_edges(self):
    method center (line 386) | def center(self):
  class Oval (line 390) | class Oval(DiskBase):
    method __init__ (line 396) | def __init__(self, center_point_1: PointType, center_point_2: PointTyp...
    method center_1 (line 446) | def center_1(self) -> NPPointType:
    method center_2 (line 450) | def center_2(self) -> NPPointType:
    method center (line 454) | def center(self):
    method add_edges (line 457) | def add_edges(self):
    method grid (line 465) | def grid(self):

FILE: src/classy_blocks/construct/flat/sketches/grid.py
  class Grid (line 10) | class Grid(Sketch):
    method __init__ (line 21) | def __init__(self, point_1: PointType, point_2: PointType, count_1: in...
    method faces (line 44) | def faces(self):
    method center (line 48) | def center(self):
    method grid (line 52) | def grid(self):

FILE: src/classy_blocks/construct/flat/sketches/mapped.py
  class MappedSketch (line 13) | class MappedSketch(Sketch):
    method __init__ (line 17) | def __init__(self, positions: PointListType, quads: list[IndexType]):
    method update (line 27) | def update(self, positions: PointListType) -> None:
    method add_edges (line 34) | def add_edges(self) -> None:
    method faces (line 39) | def faces(self):
    method grid (line 44) | def grid(self):
    method center (line 49) | def center(self) -> NPPointType:
    method positions (line 54) | def positions(self) -> NPPointListType:
    method merge (line 63) | def merge(self, other: Union[list["MappedSketch"], "MappedSketch"]):

FILE: src/classy_blocks/construct/flat/sketches/spline_round.py
  class SplineRound (line 12) | class SplineRound(DiskBase):
    method __init__ (line 27) | def __init__(self, side_1: float, side_2: float, **kwargs):
    method remove_core (line 34) | def remove_core(self):
    method oval_core_spline (line 46) | def oval_core_spline(
    method add_core_spline_edges (line 101) | def add_core_spline_edges(self) -> None:
    method outer_spline (line 126) | def outer_spline(
    method add_outer_spline_edges (line 185) | def add_outer_spline_edges(self, center: Optional[NPPointType] = None)...
    method add_inner_spline_edges (line 205) | def add_inner_spline_edges(self, center: Optional[NPPointType] = None)...
    method add_edges (line 224) | def add_edges(self) -> None:
    method radius_1_point (line 240) | def radius_1_point(self) -> NPPointType:
    method radius_1_vector (line 244) | def radius_1_vector(self) -> NPVectorType:
    method radius_1 (line 248) | def radius_1(self) -> float:
    method radius_2_point (line 252) | def radius_2_point(self) -> NPPointType:
    method radius_2_vector (line 256) | def radius_2_vector(self) -> NPVectorType:
    method radius_2 (line 260) | def radius_2(self) -> float:
    method u_0 (line 264) | def u_0(self) -> NPVectorType:
    method normal (line 269) | def normal(self) -> NPVectorType:
    method u_1 (line 273) | def u_1(self) -> NPVectorType:
    method u_1 (line 281) | def u_1(self, vec):
    method u_2 (line 285) | def u_2(self) -> NPVectorType:
    method u_2 (line 293) | def u_2(self, vec):
    method scale (line 296) | def scale(self, ratio: float, origin: Optional[PointType] = None):
  class QuarterSplineDisk (line 304) | class QuarterSplineDisk(SplineRound, QuarterDisk):
    method __init__ (line 307) | def __init__(
    method correct_disk (line 342) | def correct_disk(self, corner_1_point: NPPointType, corner_2_point: NP...
  class HalfSplineDisk (line 368) | class HalfSplineDisk(SplineRound, HalfDisk):
    method __init__ (line 371) | def __init__(
    method correct_disk (line 406) | def correct_disk(self, corner_1_point: NPPointType, corner_2_point: NP...
  class SplineDisk (line 443) | class SplineDisk(SplineRound, FourCoreDisk):
    method __init__ (line 446) | def __init__(
    method correct_disk (line 481) | def correct_disk(self, corner_1_point: NPPointType, corner_2_point: NP...
  class QuarterSplineRing (line 542) | class QuarterSplineRing(QuarterSplineDisk):
    method __init__ (line 550) | def __init__(
    method correct_disk (line 589) | def correct_disk(self, corner_1_point: NPPointType, corner_2_point: NP...
    method add_edges (line 610) | def add_edges(self) -> None:
    method grid (line 641) | def grid(self):
    method core (line 645) | def core(self):
  class HalfSplineRing (line 649) | class HalfSplineRing(HalfSplineDisk, QuarterSplineRing):
    method __init__ (line 657) | def __init__(
    method correct_disk (line 695) | def correct_disk(self, corner_1_point: NPPointType, corner_2_point: NP...
    method add_edges (line 722) | def add_edges(self) -> None:
    method grid (line 753) | def grid(self):
    method core (line 757) | def core(self):
  class SplineRing (line 761) | class SplineRing(SplineDisk, QuarterSplineRing):
    method __init__ (line 769) | def __init__(
    method correct_disk (line 807) | def correct_disk(self, corner_1_point: NPPointType, corner_2_point: NP...
    method grid (line 846) | def grid(self):
    method core (line 850) | def core(self):

FILE: src/classy_blocks/construct/operations/box.py
  class Box (line 8) | class Box(Loft):
    method __init__ (line 23) | def __init__(self, start_point: PointType, diagonal_point: PointType):

FILE: src/classy_blocks/construct/operations/connector.py
  class FacePair (line 9) | class FacePair:
    method __init__ (line 10) | def __init__(self, face_1: Face, face_2: Face):
    method distance (line 15) | def distance(self) -> float:
    method alignment (line 20) | def alignment(self) -> float:
  class Connector (line 27) | class Connector(Operation):
    method __init__ (line 59) | def __init__(self, operation_1: Operation, operation_2: Operation):

FILE: src/classy_blocks/construct/operations/extrude.py
  class Extrude (line 10) | class Extrude(Loft):
    method __init__ (line 15) | def __init__(self, base: Face, amount: Union[float, VectorType]):

FILE: src/classy_blocks/construct/operations/operation.py
  class Operation (line 31) | class Operation(ElementBase):
    method __init__ (line 37) | def __init__(self, bottom_face: Face, top_face: Face):
    method _project_update (line 51) | def _project_update(self, edge: EdgeData, label: ProjectToType):
    method add_side_edge (line 59) | def add_side_edge(self, corner_idx: int, edge_data: EdgeData) -> None:
    method chop (line 70) | def chop(self, axis: DirectionType, **kwargs: Unpack[ChopArgs]) -> None:
    method chop_edge (line 115) | def chop_edge(self, corner_1: int, corner_2: int, **kwargs: Unpack[Cho...
    method unchop (line 118) | def unchop(self, axis: Optional[DirectionType] = None) -> None:
    method project_corner (line 127) | def project_corner(self, corner: int, label: ProjectToType) -> None:
    method project_edge (line 138) | def project_edge(self, corner_1: int, corner_2: int, label: ProjectToT...
    method project_side (line 157) | def project_side(self, side: OrientType, label: str, edges: bool = Fal...
    method set_patch (line 199) | def set_patch(self, sides: Union[OrientType, list[OrientType]], name: ...
    method set_cell_zone (line 228) | def set_cell_zone(self, cell_zone: str) -> None:
    method parts (line 233) | def parts(self):
    method points (line 237) | def points(self) -> list[Point]:
    method point_array (line 242) | def point_array(self) -> NPPointType:
    method center (line 247) | def center(self):
    method get_patches_at_corner (line 250) | def get_patches_at_corner(self, corner: int) -> set:
    method get_face (line 270) | def get_face(self, side: OrientType) -> Face:
    method get_all_faces (line 276) | def get_all_faces(self) -> dict[OrientType, Face]:
    method get_closest_side (line 280) | def get_closest_side(self, point: PointType) -> OrientType:
    method get_closest_face (line 290) | def get_closest_face(self, point: PointType) -> Face:
    method get_normal_face (line 294) | def get_normal_face(self, point: PointType) -> Face:
    method patch_names (line 309) | def patch_names(self) -> dict[OrientType, str]:
    method edges (line 326) | def edges(self) -> Frame[EdgeData]:
    method get_index_from_side (line 342) | def get_index_from_side(side: OrientType) -> int:
    method invert (line 349) | def invert(self) -> "Operation":
    method mirror (line 354) | def mirror(self, normal: VectorType, origin: Optional[PointType] = None):
    method transform (line 365) | def transform(self, transforms):
    method from_series (line 377) | def from_series(cls, faces: list[Face]) -> "Operation":

FILE: src/classy_blocks/construct/operations/revolve.py
  class Revolve (line 7) | class Revolve(Loft):
    method __init__ (line 14) | def __init__(self, base: Face, angle: float, axis: VectorType, origin:...

FILE: src/classy_blocks/construct/operations/wedge.py
  class Wedge (line 8) | class Wedge(Revolve):
    method __init__ (line 31) | def __init__(self, face: Face, angle: Optional[float] = None):
    method set_inner_patch (line 52) | def set_inner_patch(self, name: str) -> None:
    method set_outer_patch (line 56) | def set_outer_patch(self, name: str) -> None:

FILE: src/classy_blocks/construct/point.py
  class Point (line 14) | class Point(ElementBase):
    method __init__ (line 18) | def __init__(self, position: PointType):
    method move_to (line 25) | def move_to(self, position: PointType) -> None:
    method translate (line 31) | def translate(self, displacement):
    method rotate (line 36) | def rotate(self, angle, axis, origin: Optional[PointType] = None):
    method scale (line 44) | def scale(self, ratio, origin: Optional[PointType] = None):
    method mirror (line 52) | def mirror(self, normal: VectorType, origin: Optional[PointType] = None):
    method shear (line 60) | def shear(self, normal: VectorType, origin: PointType, direction: Vect...
    method project (line 75) | def project(self, label: ProjectToType) -> None:
    method parts (line 83) | def parts(self):
    method center (line 87) | def center(self):
    method projected_to (line 91) | def projected_to(self) -> list[str]:
    method __eq__ (line 94) | def __eq__(self, other):
    method __repr__ (line 97) | def __repr__(self):
    method __str__ (line 100) | def __str__(self):
  class Vector (line 104) | class Vector(Point):
    method components (line 108) | def components(self) -> NPVectorType:
    method __repr__ (line 113) | def __repr__(self):

FILE: src/classy_blocks/construct/series.py
  class Series (line 12) | class Series(ElementBase):
    method __init__ (line 13) | def __init__(self, points: PointListType):
    method translate (line 25) | def translate(self, displacement):
    method rotate (line 30) | def rotate(self, angle, axis, origin: Optional[PointType] = None):
    method scale (line 42) | def scale(self, ratio, origin: Optional[PointType] = None):
    method mirror (line 50) | def mirror(self, normal: VectorType, origin: Optional[PointType] = None):
    method shear (line 58) | def shear(self, normal: VectorType, origin: PointType, direction: Vect...
    method center (line 75) | def center(self):
    method parts (line 79) | def parts(self):
    method __len__ (line 82) | def __len__(self):
    method __getitem__ (line 85) | def __getitem__(self, i):

FILE: src/classy_blocks/construct/shape.py
  class Shape (line 20) | class Shape(ElementBase, abc.ABC):
    method operations (line 26) | def operations(self) -> list[Operation]:
    method parts (line 30) | def parts(self):
    method set_cell_zone (line 33) | def set_cell_zone(self, cell_zone: str) -> None:
    method center (line 39) | def center(self) -> NPPointType:
    method grid (line 45) | def grid(self) -> list[list[Operation]]:
  class LoftedShape (line 50) | class LoftedShape(Shape, abc.ABC, Generic[SketchT]):
    method __init__ (line 55) | def __init__(
    method set_start_patch (line 87) | def set_start_patch(self, name: str) -> None:
    method set_end_patch (line 92) | def set_end_patch(self, name: str) -> None:
    method operations (line 98) | def operations(self):
    method grid (line 102) | def grid(self):
    method chop (line 106) | def chop(self, axis: DirectionType, **kwargs) -> None:
  class ExtrudedShape (line 116) | class ExtrudedShape(LoftedShape):
    method __init__ (line 121) | def __init__(self, sketch: Sketch, amount: Union[float, VectorType]):
  class RevolvedShape (line 133) | class RevolvedShape(LoftedShape):
    method __init__ (line 134) | def __init__(self, sketch: Sketch, angle: float, axis: VectorType, ori...

FILE: src/classy_blocks/construct/shapes/cylinder.py
  class SemiCylinder (line 15) | class SemiCylinder(RoundSolidShape):
    method __init__ (line 26) | def __init__(self, axis_point_1: PointType, axis_point_2: PointType, r...
    method set_symmetry_patch (line 41) | def set_symmetry_patch(self, name: str) -> None:
  class QuarterCylinder (line 48) | class QuarterCylinder(RoundSolidShape):
    method __init__ (line 59) | def __init__(self, axis_point_1: PointType, axis_point_2: PointType, r...
    method set_symmetry_patch (line 74) | def set_symmetry_patch(self, name: str) -> None:
  class Cylinder (line 81) | class Cylinder(SemiCylinder):
    method chain (line 85) | def chain(cls, source: RoundSolidShape, length: float, start_face: boo...
    method fill (line 110) | def fill(cls, source: "ExtrudedRing") -> "Cylinder":
    method set_symmetry_patch (line 120) | def set_symmetry_patch(self, _name: str) -> None:

FILE: src/classy_blocks/construct/shapes/elbow.py
  class Elbow (line 11) | class Elbow(RoundSolidShape):
    method __init__ (line 14) | def __init__(
    method chain (line 37) | def chain(

FILE: src/classy_blocks/construct/shapes/frustum.py
  class Frustum (line 14) | class Frustum(RoundSolidShape):
    method __init__ (line 28) | def __init__(
    method chain (line 59) | def chain(

FILE: src/classy_blocks/construct/shapes/rings.py
  class ExtrudedRing (line 16) | class ExtrudedRing(RoundHollowShape):
    method __init__ (line 19) | def __init__(
    method chain (line 36) | def chain(cls, source: "ExtrudedRing", length: float, start_face: bool...
    method expand (line 60) | def expand(cls, source: Union[RoundSolidShape, RoundHollowShape], thic...
    method contract (line 73) | def contract(cls, source: "ExtrudedRing", inner_radius: float) -> "Ext...
  class RevolvedRing (line 94) | class RevolvedRing(ExtrudedRing):
    method __init__ (line 123) | def __init__(self, axis_point_1: PointType, axis_point_2: PointType, c...
    method set_inner_patch (line 137) | def set_inner_patch(self, name: str) -> None:
    method set_start_patch (line 142) | def set_start_patch(self, name: str) -> None:
    method set_end_patch (line 147) | def set_end_patch(self, name: str) -> None:
    method operations (line 154) | def operations(self) -> list[Operation]:
    method chop_axial (line 157) | def chop_axial(self, **kwargs):

FILE: src/classy_blocks/construct/shapes/round.py
  class RoundSolidShape (line 12) | class RoundSolidShape(LoftedShape):
    method __init__ (line 21) | def __init__(
    method chop_axial (line 40) | def chop_axial(self, **kwargs):
    method chop_radial (line 44) | def chop_radial(self, **kwargs):
    method chop_tangential (line 57) | def chop_tangential(self, **kwargs):
    method core (line 62) | def core(self):
    method shell (line 67) | def shell(self):
    method set_outer_patch (line 71) | def set_outer_patch(self, name: str) -> None:
    method remove_inner_edges (line 75) | def remove_inner_edges(self, start: bool = True, end: bool = True) -> ...
  class RoundHollowShape (line 88) | class RoundHollowShape(RoundSolidShape):
    method __init__ (line 89) | def __init__(
    method shell (line 98) | def shell(self) -> list[Loft]:
    method chop_tangential (line 102) | def chop_tangential(self, **kwargs) -> None:
    method chop_radial (line 108) | def chop_radial(self, **kwargs):
    method set_inner_patch (line 112) | def set_inner_patch(self, name: str) -> None:

FILE: src/classy_blocks/construct/shapes/shell.py
  class SharedPoint (line 14) | class SharedPoint:
    method __init__ (line 17) | def __init__(self, point: Point):
    method add (line 23) | def add(self, face: Face, index: int) -> None:
    method normal (line 38) | def normal(self) -> NPVectorType:
    method is_shared (line 45) | def is_shared(self) -> bool:
    method __eq__ (line 50) | def __eq__(self, other):
  class SharedPointStore (line 54) | class SharedPointStore:
    method __init__ (line 57) | def __init__(self) -> None:
    method find_by_point (line 60) | def find_by_point(self, point: Point) -> SharedPoint:
    method add_from_face (line 67) | def add_from_face(self, face: Face, index: int) -> SharedPoint:
  class AwareFace (line 82) | class AwareFace:
    method __init__ (line 85) | def __init__(self, face: Face, shared_points: list[SharedPoint]):
    method get_offset_points (line 89) | def get_offset_points(self, amount: float) -> list[NPPointType]:
    method get_offset_face (line 93) | def get_offset_face(self, amount: float) -> Face:
    method is_solitary (line 97) | def is_solitary(self) -> bool:
  class AwareFaceStore (line 103) | class AwareFaceStore:
    method __init__ (line 107) | def __init__(self, faces: list[Face]):
    method point_store (line 111) | def point_store(self):
    method get_aware_face (line 120) | def get_aware_face(self, face) -> AwareFace:
    method aware_faces (line 125) | def aware_faces(self) -> list[AwareFace]:
    method get_offset_lofts (line 133) | def get_offset_lofts(self, amount: float) -> list[Loft]:
    method is_disconnected (line 139) | def is_disconnected(self) -> bool:
  class Shell (line 149) | class Shell(Shape):
    method __init__ (line 161) | def __init__(self, faces: list[Face], amount: float):
    method operations (line 169) | def operations(self):
    method grid (line 173) | def grid(self):
    method chop (line 176) | def chop(self, **kwargs) -> None:
    method set_outer_patch (line 189) | def set_outer_patch(self, name: str) -> None:

FILE: src/classy_blocks/construct/shapes/sphere.py
  function get_named_points (line 12) | def get_named_points(qdisk: QuarterDisk) -> dict[str, NPPointType]:
  function eighth_sphere_lofts (line 38) | def eighth_sphere_lofts(
  class EighthSphere (line 95) | class EighthSphere(Shape):
    method __init__ (line 100) | def __init__(
    method chop_axial (line 123) | def chop_axial(self, **kwargs):
    method chop_radial (line 127) | def chop_radial(self, **kwargs):
    method chop_tangential (line 131) | def chop_tangential(self, **kwargs):
    method set_start_patch (line 140) | def set_start_patch(self, name: str) -> None:
    method operations (line 151) | def operations(self):
    method core (line 155) | def core(self):
    method shell (line 159) | def shell(self):
    method grid (line 163) | def grid(self):
    method radius_point (line 167) | def radius_point(self) -> NPPointType:
    method center_point (line 171) | def center_point(self) -> NPPointType:
    method normal (line 175) | def normal(self) -> NPVectorType:
    method radius (line 179) | def radius(self) -> float:
    method geometry_label (line 184) | def geometry_label(self) -> str:
    method center (line 189) | def center(self):
    method geometry (line 193) | def geometry(self):
  class QuarterSphere (line 204) | class QuarterSphere(EighthSphere):
  class Hemisphere (line 208) | class Hemisphere(EighthSphere):
    method chain (line 213) | def chain(cls, source, start_face=False):
    method set_outer_patch (line 228) | def set_outer_patch(self, name):

FILE: src/classy_blocks/construct/stack.py
  class Stack (line 15) | class Stack(ElementBase):
    method __init__ (line 19) | def __init__(self) -> None:
    method grid (line 23) | def grid(self):
    method get_slice (line 28) | def get_slice(self, axis: DirectionType, index: int) -> list[Operation]:
    method chop (line 54) | def chop(self, **kwargs) -> None:
    method operations (line 61) | def operations(self) -> list[Operation]:
    method parts (line 65) | def parts(self):
    method center (line 69) | def center(self):
  class TransformedStack (line 73) | class TransformedStack(Stack):
    method __init__ (line 79) | def __init__(
  class ExtrudedStack (line 104) | class ExtrudedStack(TransformedStack):
    method __init__ (line 108) | def __init__(self, base: Sketch, amount: Union[float, VectorType], rep...
  class RevolvedStack (line 117) | class RevolvedStack(TransformedStack):
    method __init__ (line 121) | def __init__(self, base: Sketch, angle: float, axis: VectorType, origi...

FILE: src/classy_blocks/grading/analyze/catalogue.py
  function get_block_from_axis (line 13) | def get_block_from_axis(block_list: BlockList, axis: Axis) -> Block:
  class Instruction (line 21) | class Instruction:
    method __init__ (line 24) | def __init__(self, block: Block):
    method is_defined (line 29) | def is_defined(self):
    method __hash__ (line 32) | def __hash__(self) -> int:
  class RowCatalogue (line 36) | class RowCatalogue:
    method __init__ (line 39) | def __init__(self, block_list: BlockList):
    method _get_undefined_instructions (line 48) | def _get_undefined_instructions(self, direction: DirectionType) -> lis...
    method _find_instruction (line 51) | def _find_instruction(self, block: Block):
    method _add_block_to_row (line 59) | def _add_block_to_row(self, row: Row, instruction: Instruction, direct...
    method _populate (line 75) | def _populate(self, direction: DirectionType) -> None:
    method get_row_blocks (line 85) | def get_row_blocks(self, block: Block, direction: DirectionType) -> li...

FILE: src/classy_blocks/grading/analyze/probe.py
  class WireInfo (line 17) | class WireInfo:
    method length (line 25) | def length(self) -> float:
    method size_after (line 29) | def size_after(self) -> Optional[float]:
    method size_before (line 51) | def size_before(self) -> Optional[float]:
  class WireCatalogue (line 73) | class WireCatalogue:
    method __init__ (line 78) | def __init__(self, dump: AssembledDump, settings: Settings):
    method _fetch (line 92) | def _fetch(self, index_1: int, index_2: int) -> Optional[WireInfo]:
    method _populate (line 98) | def _populate(self) -> None:
    method _get_wire_boundaries (line 114) | def _get_wire_boundaries(self, wire: Wire, block: Block) -> tuple[bool...
    method get_info (line 141) | def get_info(self, wire: Wire) -> WireInfo:
  class Probe (line 150) | class Probe:
    method __init__ (line 153) | def __init__(self, dump: AssembledDump, settings: Settings):
    method get_row_blocks (line 160) | def get_row_blocks(self, block: Block, direction: DirectionType) -> li...
    method get_rows (line 163) | def get_rows(self, direction: DirectionType) -> list[Row]:
    method get_wire_info (line 166) | def get_wire_info(self, wire: Wire) -> WireInfo:

FILE: src/classy_blocks/grading/analyze/row.py
  class Entry (line 11) | class Entry:
    method axis (line 21) | def axis(self) -> Axis:
    method wires (line 25) | def wires(self) -> list[Wire]:
    method neighbours (line 29) | def neighbours(self) -> set[Axis]:
    method lengths (line 33) | def lengths(self) -> list[float]:
  class Row (line 37) | class Row:
    method __init__ (line 45) | def __init__(self) -> None:
    method add_block (line 52) | def add_block(self, block: Block, heading: DirectionType) -> None:
    method get_length (line 75) | def get_length(self, take: ChopTakeType = "avg"):
    method get_axes (line 88) | def get_axes(self) -> list[Axis]:
    method get_wires (line 91) | def get_wires(self) -> list[Wire]:
    method set_count (line 99) | def set_count(self, count: int) -> None:
    method blocks (line 108) | def blocks(self) -> list[Block]:

FILE: src/classy_blocks/grading/define/chop.py
  class ChopRelation (line 10) | class ChopRelation:
    method inputs (line 22) | def inputs(self) -> set[str]:
    method from_function (line 27) | def from_function(cls, function: Callable):
    method get_possible_combinations (line 42) | def get_possible_combinations() -> list["ChopRelation"]:
  class ChopData (line 49) | class ChopData:
    method get_specification (line 61) | def get_specification(self, invert: bool) -> GradingSpecType:
  class Chop (line 69) | class Chop:
    method defined_params (line 84) | def defined_params(self) -> int:
    method __post_init__ (line 88) | def __post_init__(self):
    method check (line 91) | def check(self):
    method calculate (line 102) | def calculate(self, length: float) -> ChopData:

FILE: src/classy_blocks/grading/define/collector.py
  class ChopCollector (line 6) | class ChopCollector:
    method _prepare (line 7) | def _prepare(self) -> None:
    method __init__ (line 13) | def __init__(self) -> None:
    method chop_axis (line 16) | def chop_axis(self, direction: DirectionType, chop: Chop) -> None:
    method chop_edge (line 19) | def chop_edge(self, corner_1: int, corner_2: int, chop: Chop) -> None:
    method clear (line 29) | def clear(self) -> None:
    method is_edge_chopped (line 33) | def is_edge_chopped(self) -> bool:
    method __getitem__ (line 36) | def __getitem__(self, i: DirectionType):

FILE: src/classy_blocks/grading/define/grading.py
  class GradingBase (line 51) | class GradingBase(abc.ABC):
    method add_chop (line 59) | def add_chop(self, chop: Chop) -> None:
    method clear (line 66) | def clear(self) -> None:
    method chop_data (line 71) | def chop_data(self) -> list[ChopData]:
    method get_specification (line 74) | def get_specification(self, inverted: bool) -> list[GradingSpecType]:
    method specification (line 83) | def specification(self) -> list[GradingSpecType]:
    method start_size (line 88) | def start_size(self) -> float:
    method end_size (line 96) | def end_size(self) -> float:
    method copy (line 103) | def copy(self, length: float, invert: bool = False) -> "Grading|Collap...
    method count (line 141) | def count(self) -> int:
    method is_defined (line 146) | def is_defined(self) -> bool:
    method description (line 151) | def description(self) -> str:
  class Grading (line 156) | class Grading(GradingBase):
    method __init__ (line 157) | def __init__(self, length: float) -> None:
    method chop_data (line 171) | def chop_data(self):
    method add_chop (line 181) | def add_chop(self, chop: Chop):
    method count (line 185) | def count(self):
    method is_defined (line 189) | def is_defined(self):
    method clear (line 192) | def clear(self) -> None:
    method description (line 198) | def description(self):
    method __eq__ (line 222) | def __eq__(self, other_grading):
    method __repr__ (line 243) | def __repr__(self) -> str:
  class CollapsedGrading (line 250) | class CollapsedGrading(GradingBase):
    method __init__ (line 251) | def __init__(self) -> None:
    method add_chop (line 257) | def add_chop(self, chop: Chop):
    method chop_data (line 264) | def chop_data(self):
    method count (line 268) | def count(self):
    method is_defined (line 272) | def is_defined(self):
    method clear (line 275) | def clear(self):
    method description (line 279) | def description(self):
    method __eq__ (line 282) | def __eq__(self, other):
    method __repr__ (line 285) | def __repr__(self):

FILE: src/classy_blocks/grading/define/relations.py
  function _validate_length (line 22) | def _validate_length(length) -> None:
  function _validate_count (line 27) | def _validate_count(count: float, condition: str) -> None:
  function _validate_start_end_size (line 53) | def _validate_start_end_size(size, name: str) -> None:
  function _validate_c2c_expansion (line 58) | def _validate_c2c_expansion(c2c_expansion) -> None:
  function _validate_total_expansion (line 63) | def _validate_total_expansion(expansion) -> None:
  function get_start_size__count__c2c_expansion (line 69) | def get_start_size__count__c2c_expansion(length, count, c2c_expansion):
  function get_start_size__end_size__total_expansion (line 80) | def get_start_size__end_size__total_expansion(length, end_size, total_ex...
  function get_end_size__start_size__total_expansion (line 89) | def get_end_size__start_size__total_expansion(length, start_size, total_...
  function get_count__start_size__c2c_expansion (line 97) | def get_count__start_size__c2c_expansion(length, start_size, c2c_expansi...
  function get_count__end_size__c2c_expansion (line 111) | def get_count__end_size__c2c_expansion(length, end_size, c2c_expansion):
  function get_count__total_expansion__c2c_expansion (line 128) | def get_count__total_expansion__c2c_expansion(length, total_expansion, c...
  function get_count__total_expansion__start_size (line 143) | def get_count__total_expansion__start_size(length, total_expansion, star...
  function get_c2c_expansion__count__start_size (line 166) | def get_c2c_expansion__count__start_size(length, count, start_size):
  function get_c2c_expansion__count__end_size (line 195) | def get_c2c_expansion__count__end_size(length, count, end_size):
  function get_c2c_expansion__count__total_expansion (line 220) | def get_c2c_expansion__count__total_expansion(length, count, total_expan...
  function get_total_expansion__count__c2c_expansion (line 232) | def get_total_expansion__count__c2c_expansion(length, count, c2c_expansi...
  function get_total_expansion__start_size__end_size (line 240) | def get_total_expansion__start_size__end_size(length, start_size, end_si...
  function get_calculation_functions (line 249) | def get_calculation_functions() -> dict[str, Callable]:

FILE: src/classy_blocks/grading/graders/auto.py
  class AutoGraderMixin (line 9) | class AutoGraderMixin(abc.ABC):
    method _get_row_length (line 12) | def _get_row_length(self, row: Row) -> float:

FILE: src/classy_blocks/grading/graders/fixed.py
  class FixedAxisGrader (line 11) | class FixedAxisGrader(AxisGrader):
    method __init__ (line 12) | def __init__(self, block: Block, direction: DirectionType, count: int):
    method get_chops (line 16) | def get_chops(self):
  class FixedCountGrader (line 20) | class FixedCountGrader(GradingManager, AutoGraderMixin):
    method __init__ (line 21) | def __init__(self, mesh: Mesh, count: int = 5):
    method _grade_row (line 29) | def _grade_row(self, row: Row):

FILE: src/classy_blocks/grading/graders/inflation.py
  function sum_length (line 19) | def sum_length(first_cell_size: float, count: int, c2c_expansion: float)...
  class InflationParams (line 31) | class InflationParams:
    method bl_thickness (line 42) | def bl_thickness(self) -> float:
    method inflation_count (line 46) | def inflation_count(self) -> int:
    method inflation_end_size (line 51) | def inflation_end_size(self) -> float:
    method buffer_start_size (line 59) | def buffer_start_size(self) -> float:
    method buffer_count (line 64) | def buffer_count(self) -> int:
    method buffer_thickness (line 70) | def buffer_thickness(self) -> float:
  class Layer (line 74) | class Layer(abc.ABC):
    method _construct (line 86) | def _construct(
    method __init__ (line 110) | def __init__(
    method get_chop (line 117) | def get_chop(self):
    method invert (line 127) | def invert(self) -> "Layer":
    method copy (line 134) | def copy(self) -> "Layer":
    method __repr__ (line 137) | def __repr__(self):
  class InflationLayer (line 149) | class InflationLayer(Layer):
    method __init__ (line 150) | def __init__(self, params: InflationParams, remaining_length: float):
  class BufferLayer (line 156) | class BufferLayer(Layer):
    method __init__ (line 157) | def __init__(self, params: InflationParams, remaining_length: float):
  class BulkLayer (line 163) | class BulkLayer(Layer):
    method __init__ (line 164) | def __init__(self, params: InflationParams, remaining_length: float):
    method get_chop (line 169) | def get_chop(self):
  class LayerStack (line 173) | class LayerStack:
    method _normalize_ratios (line 176) | def _normalize_ratios(self):
    method _construct (line 183) | def _construct(self) -> list[Layer]:
    method __init__ (line 206) | def __init__(self, params: InflationParams, total_length: float):
    method invert (line 213) | def invert(self) -> "LayerStack":
    method mirror (line 221) | def mirror(self) -> "LayerStack":
    method count (line 233) | def count(self) -> int:
    method remaining_length (line 237) | def remaining_length(self) -> float:
  class InflationAxisGrader (line 241) | class InflationAxisGrader(AxisGrader):
    method __init__ (line 242) | def __init__(self, block: Block, direction: DirectionType, params: Inf...
    method get_stack (line 247) | def get_stack(self) -> LayerStack:
    method get_chops (line 250) | def get_chops(self) -> list[Chop]:
  class InvertedInflationAxisGrader (line 255) | class InvertedInflationAxisGrader(InflationAxisGrader):
    method get_stack (line 256) | def get_stack(self):
  class DoubleInflationAxisGrader (line 263) | class DoubleInflationAxisGrader(InflationAxisGrader):
    method get_stack (line 264) | def get_stack(self) -> LayerStack:
  class BulkAxisGrader (line 271) | class BulkAxisGrader(FixedAxisGrader):
    method __init__ (line 272) | def __init__(self, block: Block, direction: DirectionType, params: Inf...
  class InflationGrader (line 276) | class InflationGrader(GradingManager, AutoGraderMixin):
    method __init__ (line 307) | def __init__(
    method _get_grader (line 328) | def _get_grader(self, row: Row) -> Union[type[InflationAxisGrader], ty...
    method _grade_row (line 355) | def _grade_row(self, row: Row):

FILE: src/classy_blocks/grading/graders/manager.py
  class WireGrader (line 17) | class WireGrader:
    method __init__ (line 18) | def __init__(self, wire: Wire):
    method copy (line 22) | def copy(from_wire: Wire, to_wire: Wire) -> None:
    method assign (line 30) | def assign(self, grading: GradingBase) -> None:
    method copy_to_coincidents (line 44) | def copy_to_coincidents(self, override: bool = False) -> None:
    method re_chop (line 57) | def re_chop(self, chops: list[Chop]) -> None:
  class AxisGrader (line 97) | class AxisGrader:
    method __init__ (line 98) | def __init__(self, block: Block, direction: DirectionType):
    method axis (line 103) | def axis(self) -> Axis:
    method get_chops (line 106) | def get_chops(self) -> list[Chop]:
    method grade (line 110) | def grade(self) -> int:
  class RowGrader (line 146) | class RowGrader:
    method __init__ (line 147) | def __init__(self, row: Row):
    method grade (line 150) | def grade(self) -> None:
  class GradingDistributor (line 159) | class GradingDistributor:
    method __init__ (line 160) | def __init__(self, row: Row):
    method undefined_axes (line 182) | def undefined_axes(self) -> set[Axis]:
    method is_done (line 186) | def is_done(self) -> bool:
    method _list_ungraded (line 189) | def _list_ungraded(self) -> str:
    method _complete_axis (line 199) | def _complete_axis(self, axis: Axis) -> bool:
    method _propagate_wires (line 216) | def _propagate_wires(self, axis: Axis) -> set[Axis]:
    method distribute (line 231) | def distribute(self) -> None:
  class GradingManager (line 257) | class GradingManager:
    method __init__ (line 261) | def __init__(self, dump: AssembledDump, settings: Settings):
    method _grade_row (line 264) | def _grade_row(self, row: Row) -> None:
    method _grade_edges (line 268) | def _grade_edges(self, row: Row) -> None:
    method _check_consistency (line 283) | def _check_consistency(self, row: Row) -> None:
    method grade (line 306) | def grade(self):

FILE: src/classy_blocks/grading/graders/simple.py
  class SimpleGrader (line 10) | class SimpleGrader(GradingManager, AutoGraderMixin):
    method __init__ (line 11) | def __init__(self, mesh: Mesh, cell_size: float, take: ChopTakeType = ...
    method _get_row_count (line 20) | def _get_row_count(self, row: Row):
    method _grade_row (line 23) | def _grade_row(self, row: Row):

FILE: src/classy_blocks/items/block.py
  class Block (line 13) | class Block:
    method __init__ (line 16) | def __init__(self, index: int, vertices: list[Vertex]):
    method add_edge (line 44) | def add_edge(self, corner_1: int, corner_2: int, edge: Edge):
    method set_chops (line 53) | def set_chops(self, collector: ChopCollector) -> None:
    method get_axis_wires (line 56) | def get_axis_wires(self, direction: DirectionType) -> list[Wire]:
    method get_axis_direction (line 60) | def get_axis_direction(self, axis: Axis) -> DirectionType:
    method add_neighbour (line 68) | def add_neighbour(self, candidate: "Block") -> None:
    method update_wires (line 84) | def update_wires(self) -> None:
    method wire_list (line 90) | def wire_list(self) -> list[Wire]:
    method edge_list (line 96) | def edge_list(self) -> list[Edge]:
    method is_graded (line 107) | def is_graded(self) -> bool:
    method indexes (line 112) | def indexes(self) -> IndexType:
    method get_side_vertices (line 115) | def get_side_vertices(self, orient: OrientType) -> list[Vertex]:
    method __hash__ (line 118) | def __hash__(self) -> int:
    method __repr__ (line 121) | def __repr__(self) -> str:

FILE: src/classy_blocks/items/edges/arcs/angle.py
  function arc_from_theta (line 13) | def arc_from_theta(edge_point_1: PointType, edge_point_2: PointType, ang...
  class AngleEdge (line 45) | class AngleEdge(ArcEdgeBase):
    method third_point (line 51) | def third_point(self):
    method description (line 57) | def description(self):

FILE: src/classy_blocks/items/edges/arcs/arc.py
  class ArcEdge (line 8) | class ArcEdge(ArcEdgeBase):
    method third_point (line 14) | def third_point(self):

FILE: src/classy_blocks/items/edges/arcs/arc_base.py
  class ArcEdgeBase (line 14) | class ArcEdgeBase(Edge, abc.ABC):
    method third_point (line 19) | def third_point(self) -> Point:
    method length (line 23) | def length(self) -> float:
    method description (line 30) | def description(self):
    method is_valid (line 35) | def is_valid(self):

FILE: src/classy_blocks/items/edges/arcs/origin.py
  function arc_from_origin (line 16) | def arc_from_origin(
  class OriginEdge (line 81) | class OriginEdge(ArcEdgeBase):
    method third_point (line 90) | def third_point(self):
    method description (line 107) | def description(self):

FILE: src/classy_blocks/items/edges/curve.py
  class CurveEdgeBase (line 13) | class CurveEdgeBase(Edge, abc.ABC):
    method point_array (line 21) | def point_array(self) -> NPPointListType:
    method param_start (line 25) | def param_start(self) -> float:
    method param_end (line 29) | def param_end(self) -> float:
    method description (line 33) | def description(self):
  class SplineEdge (line 40) | class SplineEdge(CurveEdgeBase):
    method point_array (line 46) | def point_array(self) -> NPPointListType:
    method length (line 50) | def length(self):
  class PolyLineEdge (line 57) | class PolyLineEdge(SplineEdge):
  class OnCurveEdge (line 64) | class OnCurveEdge(CurveEdgeBase):
    method length (line 70) | def length(self):
    method param_start (line 74) | def param_start(self) -> float:
    method param_end (line 79) | def param_end(self) -> float:
    method point_array (line 84) | def point_array(self) -> NPPointListType:
    method representation (line 88) | def representation(self) -> EdgeKindType:

FILE: src/classy_blocks/items/edges/edge.py
  class Edge (line 15) | class Edge(ElementBase):
    method __post_init__ (line 22) | def __post_init__(self):
    method kind (line 30) | def kind(self) -> EdgeKindType:
    method representation (line 35) | def representation(self) -> EdgeKindType:
    method is_valid (line 40) | def is_valid(self) -> bool:
    method length (line 57) | def length(self) -> float:
    method description (line 63) | def description(self) -> str:
    method center (line 71) | def center(self):
    method parts (line 76) | def parts(self):

FILE: src/classy_blocks/items/edges/factory.py
  class EdgeFactory (line 12) | class EdgeFactory:
    method __init__ (line 16) | def __init__(self):
    method register_kind (line 19) | def register_kind(self, kind: EdgeKindType, creator: type[Edge]) -> None:
    method create (line 23) | def create(self, vertex_1, vertex_2, data: EdgeData) -> Edge:

FILE: src/classy_blocks/items/edges/line.py
  class LineEdge (line 8) | class LineEdge(Edge):
    method length (line 14) | def length(self):
    method description (line 19) | def description(self):
    method is_valid (line 24) | def is_valid(self):

FILE: src/classy_blocks/items/edges/project.py
  class ProjectEdge (line 8) | class ProjectEdge(Edge):
    method length (line 14) | def length(self):
    method description (line 19) | def description(self):

FILE: src/classy_blocks/items/patch.py
  class Patch (line 6) | class Patch:
    method __init__ (line 9) | def __init__(self, name: str):
    method add_side (line 19) | def add_side(self, side: Side) -> None:

FILE: src/classy_blocks/items/side.py
  class Side (line 7) | class Side:
    method __init__ (line 11) | def __init__(self, orient: OrientType, vertices: list[Vertex]):
    method __eq__ (line 20) | def __eq__(self, other):
    method __hash__ (line 23) | def __hash__(self):

FILE: src/classy_blocks/items/vertex.py
  class Vertex (line 8) | class Vertex(Point):
    method __init__ (line 12) | def __init__(self, position: PointType, index: int):
    method __eq__ (line 18) | def __eq__(self, other):
    method __hash__ (line 25) | def __hash__(self):
    method __repr__ (line 28) | def __repr__(self):
    method from_point (line 32) | def from_point(cls, point: Point, index: int):

FILE: src/classy_blocks/items/wires/axis.py
  class Axis (line 7) | class Axis:
    method __init__ (line 11) | def __init__(self, direction: DirectionType, wires: list[Wire]):
    method add_neighbour (line 18) | def add_neighbour(self, other: "Axis") -> None:
    method add_inline (line 26) | def add_inline(self, other: "Axis") -> None:
    method is_aligned (line 35) | def is_aligned(self, other: "Axis") -> bool:
    method is_inline (line 46) | def is_inline(self, other: "Axis") -> bool:
    method lengths (line 72) | def lengths(self) -> list[float]:
    method start_vertices (line 76) | def start_vertices(self) -> set[Vertex]:
    method end_vertices (line 80) | def end_vertices(self) -> set[Vertex]:
    method count (line 84) | def count(self) -> int:
    method is_simple (line 88) | def is_simple(self) -> bool:
    method is_graded (line 92) | def is_graded(self):  # TODO: change to is_chopped
    method __str__ (line 95) | def __str__(self):
    method __hash__ (line 98) | def __hash__(self):

FILE: src/classy_blocks/items/wires/manager.py
  class WireManager (line 5) | class WireManager:
    method __init__ (line 6) | def __init__(self, wires: list[Wire]):
    method __getitem__ (line 9) | def __getitem__(self, index) -> Wire:
    method __iter__ (line 12) | def __iter__(self):
    method format_single (line 15) | def format_single(self) -> str:
    method format_all (line 19) | def format_all(self) -> str:
    method length (line 24) | def length(self) -> float:
    method is_simple (line 30) | def is_simple(self) -> bool:
    method count (line 42) | def count(self):

FILE: src/classy_blocks/items/wires/wire.py
  function get_length (line 13) | def get_length(wire: "Wire") -> float:
  class WireJoint (line 18) | class WireJoint:
    method __hash__ (line 25) | def __hash__(self):
  class Wire (line 29) | class Wire:
    method __init__ (line 33) | def __init__(self, vertices: list[Vertex], direction: DirectionType, c...
    method length (line 56) | def length(self) -> float:
    method update (line 59) | def update(self) -> None:
    method is_coincident (line 63) | def is_coincident(self, candidate: "Wire") -> bool:
    method is_aligned (line 68) | def is_aligned(self, candidate: "Wire") -> bool:
    method add_edge (line 76) | def add_edge(self, edge: Edge) -> None:
    method add_coincident (line 79) | def add_coincident(self, candidate: "Wire") -> None:
    method add_inline (line 84) | def add_inline(self, candidate: "Wire") -> None:
    method is_graded (line 103) | def is_graded(self) -> bool:
    method is_collapsed (line 107) | def is_collapsed(self):
    method __repr__ (line 110) | def __repr__(self):

FILE: src/classy_blocks/lists/block_list.py
  class BlockList (line 5) | class BlockList:
    method __init__ (line 8) | def __init__(self) -> None:
    method add (line 11) | def add(self, block: Block) -> None:
    method update_neighbours (line 15) | def update_neighbours(self, registry: HexPointRegistry) -> None:
    method __hash__ (line 23) | def __hash__(self):

FILE: src/classy_blocks/lists/edge_list.py
  function get_location (line 11) | def get_location(vertex_1, vertex_2):
  class EdgeList (line 18) | class EdgeList:
    method __init__ (line 21) | def __init__(self) -> None:
    method find (line 24) | def find(self, vertex_1: Vertex, vertex_2: Vertex) -> Edge:
    method add (line 32) | def add(self, vertex_1: Vertex, vertex_2: Vertex, data: EdgeData) -> E...
    method add_from_operation (line 48) | def add_from_operation(self, vertices: list[Vertex], operation: Operat...

FILE: src/classy_blocks/lists/face_list.py
  class ProjectedFace (line 12) | class ProjectedFace:
    method __eq__ (line 18) | def __eq__(self, other):
  class FaceList (line 22) | class FaceList:
    method __init__ (line 25) | def __init__(self) -> None:
    method find_existing (line 28) | def find_existing(self, side: Side) -> bool:
    method add (line 36) | def add(self, vertices: list[Vertex], operation: Operation) -> None:
    method add_face (line 49) | def add_face(self, vertices: list[Vertex], orient: OrientType, face: F...
    method add_side (line 54) | def add_side(self, side: Side, label: str) -> None:

FILE: src/classy_blocks/lists/patch_list.py
  class PatchList (line 12) | class PatchList:
    method __init__ (line 15) | def __init__(self) -> None:
    method add (line 20) | def add(self, vertices: list[Vertex], operation: Operation) -> None:
    method get (line 25) | def get(self, name: str) -> Patch:
    method find (line 32) | def find(self, vertices: set[Vertex]) -> Patch:
    method add_side (line 41) | def add_side(self, patch_name: str, orient: OrientType, vertices: list...
    method modify (line 45) | def modify(self, name: str, kind: str, settings: Optional[list[str]] =...
    method merge (line 53) | def merge(self, master: str, slave: str) -> None:

FILE: src/classy_blocks/lists/vertex_list.py
  class DuplicatedEntry (line 9) | class DuplicatedEntry:
    method __init__ (line 13) | def __init__(self, vertex: Vertex, patches: set[str]):
    method point (line 18) | def point(self) -> NPPointType:
  class VertexList (line 23) | class VertexList:
    method __init__ (line 26) | def __init__(self, vertices: list[Vertex]) -> None:
    method find_duplicated (line 33) | def find_duplicated(self, position: NPPointType, slave_patches: set[st...
    method add_duplicated (line 43) | def add_duplicated(self, point: Point, slave_patches: set[str]) -> Ver...

FILE: src/classy_blocks/lookup/cell_registry.py
  class CellRegistry (line 5) | class CellRegistry:
    method __init__ (line 7) | def __init__(self, addressing: list[IndexType]):
    method get_near_cells (line 20) | def get_near_cells(self, point_index: int) -> set[int]:

FILE: src/classy_blocks/lookup/connection_registry.py
  function get_key (line 9) | def get_key(index_1: int, index_2: int):
  class Connection (line 13) | class Connection:
    method __init__ (line 16) | def __init__(self, index_1: int, index_2: int):
    method get_other_index (line 19) | def get_other_index(self, index):
    method __repr__ (line 25) | def __repr__(self):
    method __hash__ (line 28) | def __hash__(self):
  class ConnectionRegistryBase (line 32) | class ConnectionRegistryBase:
    method __init__ (line 35) | def __init__(self, points: NPPointListType, addressing: list[IndexType]):
    method get_connected_indexes (line 56) | def get_connected_indexes(self, index: int) -> set[int]:
  class QuadConnectionRegistry (line 60) | class QuadConnectionRegistry(ConnectionRegistryBase):
  class HexConnectionRegistry (line 64) | class HexConnectionRegistry(ConnectionRegistryBase):

FILE: src/classy_blocks/lookup/face_registry.py
  class FaceRegistryBase (line 8) | class FaceRegistryBase(abc.ABC):
    method get_key_from_side (line 11) | def get_key_from_side(self, cell: int, side: OrientType) -> tuple:
    method __init__ (line 18) | def __init__(self, addressing: list[IndexType]):
    method get_cells (line 40) | def get_cells(self, cell: int, side: OrientType) -> set[int]:
  class QuadFaceRegistry (line 44) | class QuadFaceRegistry(FaceRegistryBase):
  class HexFaceRegistry (line 48) | class HexFaceRegistry(FaceRegistryBase):

FILE: src/classy_blocks/lookup/point_registry.py
  class PointRegistryBase (line 16) | class PointRegistryBase:
    method __init__ (line 21) | def __init__(self, flattened_points: NPPointListType, merge_tol: float...
    method _compile_unique (line 38) | def _compile_unique(self) -> NPPointListType:
    method _query_unique (line 53) | def _query_unique(self, positions) -> list[int]:
    method _query_repeated (line 62) | def _query_repeated(self, positions) -> list[int]:
    method find_point_index (line 70) | def find_point_index(self, position: PointType) -> int:
    method find_point_cells (line 78) | def find_point_cells(self, position: PointType) -> list[int]:
    method find_cell_points (line 84) | def find_cell_points(self, cell: int) -> NPPointListType:
    method find_cell_indexes (line 90) | def find_cell_indexes(self, cell: int) -> list[int]:
    method find_cell_neighbours (line 94) | def find_cell_neighbours(self, cell: int) -> list[int]:
    method flatten (line 106) | def flatten(points, length) -> NPPointListType:
    method from_addresses (line 110) | def from_addresses(
    method cell_count (line 120) | def cell_count(self) -> int:
    method point_count (line 124) | def point_count(self) -> int:
  class QuadPointRegistry (line 128) | class QuadPointRegistry(PointRegistryBase):
    method from_sketch (line 134) | def from_sketch(cls: type[PointRegistryType], sketch: Sketch, merge_to...
  class HexPointRegistry (line 140) | class HexPointRegistry(PointRegistryBase):
    method from_operations (line 146) | def from_operations(

FILE: src/classy_blocks/mesh.py
  class Mesh (line 23) | class Mesh:
    method __init__ (line 26) | def __init__(self) -> None:
    method add (line 34) | def add(self, solid: AdditiveType) -> None:
    method merge_patches (line 41) | def merge_patches(self, master: str, slave: str) -> None:
    method set_default_patch (line 47) | def set_default_patch(self, name: str, kind: str) -> None:
    method modify_patch (line 52) | def modify_patch(self, name: str, kind: str, settings: Optional[list[s...
    method add_geometry (line 58) | def add_geometry(self, geometry: GeometryType) -> None:
    method delete (line 65) | def delete(self, operation: Operation) -> None:
    method assemble (line 70) | def assemble(self, merge_tol: float = TOL) -> AssembledDump:
    method clear (line 83) | def clear(self) -> None:
    method backport (line 88) | def backport(self) -> None:
    method grade (line 112) | def grade(self) -> None:
    method write (line 124) | def write(self, output_path: str, debug_path: Optional[str] = None, me...
    method is_assembled (line 143) | def is_assembled(self) -> bool:
    method vertices (line 148) | def vertices(self) -> list[Vertex]:
    method patches (line 152) | def patches(self) -> list[Patch]:
    method operations (line 156) | def operations(self) -> list[Operation]:
    method blocks (line 161) | def blocks(self) -> list[Block]:

FILE: src/classy_blocks/modify/find/finder.py
  class FinderBase (line 12) | class FinderBase:
    method __init__ (line 15) | def __init__(self, mesh: Mesh):
    method _find_by_position (line 18) | def _find_by_position(self, position: PointType, radius: Optional[floa...

FILE: src/classy_blocks/modify/find/geometric.py
  class GeometricFinder (line 9) | class GeometricFinder(FinderBase):
    method find_in_sphere (line 12) | def find_in_sphere(self, position: PointType, radius: Optional[float] ...
    method find_in_box_corners (line 18) | def find_in_box_corners(self, corner_point: PointType, diagonal_point:...
    method find_in_box_center (line 24) | def find_in_box_center(self, center_point: PointType, size_x: float, s...
    method find_on_plane (line 30) | def find_on_plane(self, point: PointType, normal: VectorType):

FILE: src/classy_blocks/modify/find/shape.py
  class RoundSolidFinder (line 10) | class RoundSolidFinder(FinderBase):
    method __init__ (line 14) | def __init__(self, mesh: Mesh, shape: RoundSolidShape):
    method _get_sketch (line 18) | def _get_sketch(self, end_face: bool) -> Disk:
    method _find_from_points (line 24) | def _find_from_points(self, points: list[Point]) -> set[Vertex]:
    method _find_from_faces (line 32) | def _find_from_faces(self, faces: list[Face]) -> set[Vertex]:
    method find_core (line 40) | def find_core(self, end_face: bool = False) -> set[Vertex]:
    method find_shell (line 46) | def find_shell(self, end_face: bool = False) -> set[Vertex]:

FILE: src/classy_blocks/modify/reorient/viewpoint.py
  class Triangle (line 11) | class Triangle:
    method __init__ (line 14) | def __init__(self, points: list[NPPointType]):
    method normal (line 18) | def normal(self) -> NPVectorType:
    method center (line 25) | def center(self) -> NPPointType:
    method flip (line 28) | def flip(self):
    method orient (line 32) | def orient(self, hull_center: NPPointType) -> None:
  class Quadrangle (line 39) | class Quadrangle:
    method __init__ (line 42) | def __init__(self, triangles: list[Triangle]):
    method get_unique_points (line 57) | def get_unique_points(list_1: list[NPPointType], list_2: list[NPPointT...
    method get_common_points (line 76) | def get_common_points(list_1: list[NPPointType], list_2: list[NPPointT...
    method get_common_point (line 87) | def get_common_point(self, quad_1: "Quadrangle", quad_2: "Quadrangle")...
  class ViewpointReorienter (line 98) | class ViewpointReorienter:
    method __init__ (line 110) | def __init__(self, observer: PointType, ceiling: PointType):
    method _make_triangles (line 114) | def _make_triangles(self, points: NPPointListType) -> list[Triangle]:
    method _get_normals (line 130) | def _get_normals(self, center: NPPointType) -> dict[OrientType, NPVect...
    method _get_aligned (line 150) | def _get_aligned(self, triangles: list[Triangle], vector: NPVectorType...
    method reorient (line 153) | def reorient(self, operation: Operation):

FILE: src/classy_blocks/optimize/cell.py
  class CellBase (line 10) | class CellBase(abc.ABC):
    method __init__ (line 15) | def __init__(self, index: int, grid_points: NPPointListType, indexes: ...
    method get_common_indexes (line 23) | def get_common_indexes(self, candidate: "CellBase") -> set[int]:
    method get_corner (line 30) | def get_corner(self, index: int) -> int:
    method get_common_side (line 35) | def get_common_side(self, candidate: "CellBase") -> OrientType:
    method boundary (line 51) | def boundary(self) -> set[int]:
    method __str__ (line 63) | def __str__(self):
    method __repr__ (line 66) | def __repr__(self):
  class QuadCell (line 70) | class QuadCell(CellBase):
  class HexCell (line 77) | class HexCell(CellBase):

FILE: src/classy_blocks/optimize/clamps/clamp.py
  class ClampBase (line 12) | class ClampBase(abc.ABC):
    method __init__ (line 15) | def __init__(
    method initial_guess (line 31) | def initial_guess(self) -> list[float]:
    method get_params (line 34) | def get_params(self) -> list[float]:
    method update_params (line 44) | def update_params(self, params: list[float]):

FILE: src/classy_blocks/optimize/clamps/curve.py
  class CurveClamp (line 11) | class CurveClamp(ClampBase):
    method __init__ (line 20) | def __init__(
    method initial_guess (line 36) | def initial_guess(self):
  class LineClamp (line 40) | class LineClamp(ClampBase):
    method __init__ (line 48) | def __init__(
    method initial_guess (line 64) | def initial_guess(self) -> list[float]:
  class RadialClamp (line 70) | class RadialClamp(ClampBase):
    method __init__ (line 78) | def __init__(
    method initial_guess (line 100) | def initial_guess(self):

FILE: src/classy_blocks/optimize/clamps/free.py
  class FreeClamp (line 7) | class FreeClamp(ClampBase):
    method __init__ (line 8) | def __init__(self, position: PointType):
    method get_params_from_vertex (line 11) | def get_params_from_vertex(self):
    method initial_guess (line 17) | def initial_guess(self):

FILE: src/classy_blocks/optimize/clamps/surface.py
  class PlaneClamp (line 9) | class PlaneClamp(ClampBase):
    method __init__ (line 15) | def __init__(self, position: PointType, point: PointType, normal: Vect...
    method initial_guess (line 31) | def initial_guess(self):
  class ParametricSurfaceClamp (line 35) | class ParametricSurfaceClamp(ClampBase):
    method initial_guess (line 44) | def initial_guess(self):

FILE: src/classy_blocks/optimize/connection.py
  class CellConnection (line 5) | class CellConnection:

FILE: src/classy_blocks/optimize/grid.py
  class GridBase (line 31) | class GridBase:
    method __init__ (line 38) | def __init__(self, points: NPPointListType, addressing: list[IndexType]):
    method _bind_junction_neighbours (line 51) | def _bind_junction_neighbours(self) -> None:
    method _bind_cell_neighbours (line 59) | def _bind_cell_neighbours(self) -> None:
    method _bind_junction_cells (line 71) | def _bind_junction_cells(self) -> None:
    method get_junction_from_clamp (line 79) | def get_junction_from_clamp(self, clamp: ClampBase) -> Junction:
    method add_clamp (line 86) | def add_clamp(self, clamp: ClampBase) -> None:
    method add_link (line 94) | def add_link(self, link: LinkBase) -> None:
    method clamps (line 117) | def clamps(self) -> list[ClampBase]:
    method quality (line 127) | def quality(self) -> float:
    method update (line 133) | def update(self, index: int, position: NPPointType) -> float:
  class QuadGrid (line 157) | class QuadGrid(GridBase):
    method from_sketch (line 163) | def from_sketch(cls, sketch: Sketch, merge_tol: float = TOL) -> "QuadG...
  class HexGrid (line 174) | class HexGrid(GridBase):
    method from_elements (line 180) | def from_elements(
    method from_dump (line 198) | def from_dump(cls, dump: AssembledDump) -> "HexGrid":

FILE: src/classy_blocks/optimize/junction.py
  class LinkTie (line 15) | class LinkTie:
  class Junction (line 20) | class Junction:
    method __init__ (line 24) | def __init__(self, points: NPPointListType, index: int):
    method point (line 36) | def point(self) -> NPPointType:
    method add_clamp (line 39) | def add_clamp(self, clamp: ClampBase) -> None:
    method add_link (line 45) | def add_link(self, link: LinkBase, follower_index: int) -> None:
    method is_boundary (line 49) | def is_boundary(self) -> bool:
    method quality (line 58) | def quality(self) -> float:

FILE: src/classy_blocks/optimize/links.py
  class LinkBase (line 10) | class LinkBase(abc.ABC):
    method __init__ (line 15) | def __init__(self, leader: PointType, follower: PointType):
    method update (line 19) | def update(self) -> None:
    method transform (line 24) | def transform(self) -> NPPointType:
    method __str__ (line 28) | def __str__(self):
  class TranslationLink (line 32) | class TranslationLink(LinkBase):
    method __init__ (line 36) | def __init__(self, leader: PointType, follower: PointType):
    method transform (line 40) | def transform(self) -> NPPointType:
  class RotationLink (line 44) | class RotationLink(LinkBase):
    method __init__ (line 52) | def __init__(self, leader: PointType, follower: PointType, axis: Vecto...
    method transform (line 64) | def transform(self) -> NPPointType:
    method _get_height (line 76) | def _get_height(self, point: NPPointType) -> NPVectorType:
    method _get_radius (line 80) | def _get_radius(self, point: NPPointType) -> NPVectorType:
  class SymmetryLink (line 85) | class SymmetryLink(LinkBase):
    method __init__ (line 88) | def __init__(self, leader: PointType, follower: PointType, normal: Vec...
    method _get_follower (line 94) | def _get_follower(self) -> NPPointType:
    method transform (line 97) | def transform(self) -> NPPointType:

FILE: src/classy_blocks/optimize/optimizer.py
  class OptimizerConfig (line 31) | class OptimizerConfig:
  class OptimizerBase (line 60) | class OptimizerBase(abc.ABC):
    method __init__ (line 65) | def __init__(self, grid: GridBase, report: bool = True):
    method add_clamp (line 76) | def add_clamp(self, clamp: ClampBase) -> None:
    method add_link (line 80) | def add_link(self, link: LinkBase) -> None:
    method _get_sensitivity (line 83) | def _get_sensitivity(self, clamp: ClampBase):
    method _optimize_clamp (line 102) | def _optimize_clamp(self, clamp: ClampBase, relaxation_factor: float) ...
    method _optimize_iteration (line 152) | def _optimize_iteration(self, iteration_no: int) -> IterationRecord:
    method relaxation_factor (line 166) | def relaxation_factor(self, iteration_no: int) -> float:
    method optimize (line 187) | def optimize(
    method _backport (line 235) | def _backport(self) -> None:
  class MeshOptimizer (line 239) | class MeshOptimizer(OptimizerBase):
    method __init__ (line 240) | def __init__(self, mesh: Mesh, report: bool = True, merge_tol: float =...
    method _backport (line 247) | def _backport(self):
  class ShapeOptimizer (line 253) | class ShapeOptimizer(OptimizerBase):
    method __init__ (line 254) | def __init__(self, operations: list[Operation], report: bool = True, m...
    method _backport (line 260) | def _backport(self) -> None:
  class SketchOptimizer (line 269) | class SketchOptimizer(OptimizerBase):
    method __init__ (line 270) | def __init__(self, sketch: Sketch, report: bool = True, merge_tol: flo...
    method _backport (line 277) | def _backport(self):
    method auto_optimize (line 289) | def auto_optimize(

FILE: src/classy_blocks/optimize/quality.py
  function scale_quality (line 12) | def scale_quality(base: float, exponent: float, factor: float, value: fl...
  function scale_aspect (line 17) | def scale_aspect(ratio: float) -> float:
  function take (line 22) | def take(points: NPPointListType, indexes: NPIndexType):
  function get_center_point (line 35) | def get_center_point(points: NPPointListType) -> NPPointType:
  function get_quad_normal (line 40) | def get_quad_normal(points: NPPointListType) -> tuple[NPVectorType, NPVe...
  function scale_angle (line 65) | def scale_angle(angle: float) -> float:
  function get_quad_non_ortho (line 78) | def get_quad_non_ortho(points: NPPointListType, center: NPPointType, nor...
  function get_quad_inner_angle (line 98) | def get_quad_inner_angle(points: NPPointListType, normal: NPVectorType, ...
  function get_quad_quality (line 114) | def get_quad_quality(grid_points: NPPointListType, cell_indexes: NPIndex...
  function get_hex_quality (line 132) | def get_hex_quality(grid_points: NPPointListType, cell_indexes: NPIndexT...

FILE: src/classy_blocks/optimize/record.py
  class OptimizationRecord (line 10) | class OptimizationRecord:
    method abs_improvement (line 18) | def abs_improvement(self) -> float:
    method rel_improvement (line 22) | def rel_improvement(self) -> float:
  class IterationRecord (line 27) | class IterationRecord:
    method abs_improvement (line 34) | def abs_improvement(self) -> float:
    method rel_improvement (line 38) | def rel_improvement(self) -> float:
  class ClampRecord (line 43) | class ClampRecord:
    method improvement (line 52) | def improvement(self) -> float:

FILE: src/classy_blocks/optimize/report.py
  class OptimizationReporterBase (line 7) | class OptimizationReporterBase(abc.ABC):
    method iteration_start (line 9) | def iteration_start(self, iteration_no: int, relaxation: float) -> None:
    method clamp_start (line 13) | def clamp_start(self, crecord: ClampRecord) -> None:
    method clamp_end (line 17) | def clamp_end(self, crecord: ClampRecord) -> None:
    method iteration_end (line 21) | def iteration_end(self, srecord: IterationRecord) -> None:
    method optimization_end (line 25) | def optimization_end(self, orecord: OptimizationRecord) -> None:
  class SilentReporter (line 29) | class SilentReporter(OptimizationReporterBase):
    method iteration_start (line 30) | def iteration_start(self, iteration_no: int, relaxation: float) -> None:
    method clamp_start (line 33) | def clamp_start(self, crecord: ClampRecord) -> None:
    method clamp_end (line 36) | def clamp_end(self, crecord: ClampRecord) -> None:
    method iteration_end (line 39) | def iteration_end(self, srecord: IterationRecord) -> None:
    method optimization_end (line 42) | def optimization_end(self, orecord: OptimizationRecord) -> None:
  class TextReporter (line 46) | class TextReporter(OptimizationReporterBase):
    method iteration_start (line 47) | def iteration_start(self, iteration_no: int, relaxation: float) -> None:
    method clamp_start (line 56) | def clamp_start(self, crecord: ClampRecord) -> None:
    method clamp_end (line 60) | def clamp_end(self, crecord: ClampRecord) -> None:
    method iteration_end (line 69) | def iteration_end(self, srecord: IterationRecord) -> None:
    method optimization_end (line 74) | def optimization_end(self, orecord: OptimizationRecord) -> None:

FILE: src/classy_blocks/optimize/smoother.py
  class SmootherBase (line 15) | class SmootherBase(abc.ABC):
    method __init__ (line 16) | def __init__(self, grid: GridBase):
    method fix_indexes (line 26) | def fix_indexes(self, indexes: Iterable[int]) -> None:
    method fix_points (line 29) | def fix_points(self, points: PointListType):
    method smooth (line 35) | def smooth(self, iterations: int = 5) -> None:
    method backport (line 47) | def backport(self) -> None:
  class MeshSmoother (line 51) | class MeshSmoother(SmootherBase):
    method __init__ (line 52) | def __init__(self, mesh: Mesh, merge_tol: float = TOL):
    method backport (line 57) | def backport(self):
  class SketchSmoother (line 62) | class SketchSmoother(SmootherBase):
    method __init__ (line 63) | def __init__(self, sketch: MappedSketch):
    method backport (line 70) | def backport(self):

FILE: src/classy_blocks/util/constants.py
  function vector_format (line 55) | def vector_format(vector) -> str:

FILE: src/classy_blocks/util/frame.py
  class Frame (line 9) | class Frame(Generic[BeamT]):
    method __init__ (line 27) | def __init__(self) -> None:
    method add_beam (line 35) | def add_beam(self, corner_1: int, corner_2: int, beam: Optional[BeamT]...
    method get_axis_beams (line 46) | def get_axis_beams(self, axis: DirectionType) -> list[BeamT]:
    method get_all_beams (line 58) | def get_all_beams(self) -> list[tuple[int, int, BeamT]]:
    method __getitem__ (line 75) | def __getitem__(self, index):

FILE: src/classy_blocks/util/functions.py
  function vector (line 15) | def vector(x: float, y: float, z: float) -> NPVectorType:
  function deg2rad (line 21) | def deg2rad(deg: float) -> float:
  function rad2deg (line 26) | def rad2deg(rad: float) -> float:
  function norm (line 31) | def norm(matrix: Union[PointType, PointListType]) -> float:
  function unit_vector (line 40) | def unit_vector(vect: VectorType) -> NPVectorType:
  function angle_between (line 46) | def angle_between(vect_1: VectorType, vect_2: VectorType) -> float:
  function _rotation_matrix (line 65) | def _rotation_matrix(axis: NPVectorType, angle: float):
  function rotation_matrix (line 81) | def rotation_matrix(axis: VectorType, angle: float):
  function _rotate (line 91) | def _rotate(point: NPPointType, angle: float, axis: NPVectorType, origin...
  function rotate (line 100) | def rotate(point: PointType, angle: float, axis: VectorType, origin: Poi...
  function scale (line 109) | def scale(point: PointType, ratio: float, origin: Optional[PointType]) -...
  function to_polar (line 118) | def to_polar(point: PointType, axis: Literal["x", "z"] = "z") -> NPVecto...
  function to_cartesian (line 136) | def to_cartesian(point: PointType, direction: Literal[1, -1] = 1, axis: ...
  function lin_map (line 161) | def lin_map(x: float, x_min: float, x_max: float, out_min: float, out_ma...
  function arc_length_3point (line 173) | def arc_length_3point(p_start: NPPointType, p_btw: NPPointType, p_end: N...
  function divide_arc (line 217) | def divide_arc(center: NPPointType, point_1: NPPointType, point_2: NPPoi...
  function arc_mid (line 233) | def arc_mid(center: NPPointType, point_1: NPPointType, point_2: NPPointT...
  function mirror (line 238) | def mirror(points: Union[PointType, PointListType], normal: VectorType, ...
  function point_to_plane_distance (line 274) | def point_to_plane_distance(origin: PointType, normal: VectorType, point...
  function is_point_on_plane (line 286) | def is_point_on_plane(origin: PointType, normal: VectorType, point: Poin...
  function point_to_line_distance (line 291) | def point_to_line_distance(origin: PointType, direction: VectorType, poi...
  function polyline_length (line 300) | def polyline_length(points: NPPointListType) -> float:
  function flatten_2d_list (line 311) | def flatten_2d_list(twodim: list[list]) -> list:

FILE: src/classy_blocks/util/tools.py
  function report (line 12) | def report(text, end=None):
  class EdgeLocation (line 21) | class EdgeLocation:
    method start_corner (line 30) | def start_corner(self) -> int:

FILE: src/classy_blocks/write/formats.py
  function indent (line 9) | def indent(text: str, levels: int) -> str:
  function format_vertex (line 14) | def format_vertex(vertex: Vertex) -> str:
  function format_block (line 25) | def format_block(block: Block) -> str:
  function format_edge (line 56) | def format_edge(edge: Edge) -> str:
  function format_side (line 60) | def format_side(side: Side) -> str:
  function format_patch (line 64) | def format_patch(patch: Patch) -> str:
  function format_face (line 92) | def format_face(face: ProjectedFace) -> str:

FILE: src/classy_blocks/write/vtk.py
  function mesh_to_vtk (line 7) | def mesh_to_vtk(path: str, vertices: list[Vertex], blocks: list[Block]) ...
  function sketch_to_vtk (line 102) | def sketch_to_vtk(sketch: Sketch, filename: str) -> None:

FILE: src/classy_blocks/write/writer.py
  function format_geometry (line 13) | def format_geometry(geometry: GeometryType) -> str:
  function format_list (line 33) | def format_list(name: str, items: list, formatter: Callable) -> str:
  function format_settings (line 44) | def format_settings(settings: Settings):
  class MeshWriter (line 74) | class MeshWriter:
    method __init__ (line 75) | def __init__(self, dump: AssembledDump, settings: Settings):
    method write (line 79) | def write(self, output_path: str):

FILE: tests/fixtures/block.py
  class BlockTestCase (line 13) | class BlockTestCase(DataTestCase):
    method make_vertices (line 16) | def make_vertices(self, index: int) -> list[Vertex]:
    method make_block (line 24) | def make_block(self, index: int) -> Block:
    method make_loft (line 48) | def make_loft(self, index: int) -> Loft:

FILE: tests/fixtures/data.py
  class TestOperationData (line 62) | class TestOperationData:
    method points (line 82) | def points(self):
    method indexes (line 87) | def indexes(self):
  class DataTestCase (line 134) | class DataTestCase(unittest.TestCase):
    method get_single_data (line 138) | def get_single_data(index: int) -> TestOperationData:
    method get_all_data (line 143) | def get_all_data() -> list[TestOperationData]:

FILE: tests/fixtures/mesh.py
  class MeshTestCase (line 9) | class MeshTestCase(DataTestCase):
    method make_box (line 12) | def make_box(self, index):
    method setUp (line 22) | def setUp(self):

FILE: tests/helpers/collect_outputs.py
  function collect_dict (line 18) | def collect_dict(path):

FILE: tests/test_assemble.py
  class RegistryTests (line 14) | class RegistryTests(unittest.TestCase):
    method get_shape (line 15) | def get_shape(self) -> Cylinder:
    method get_hex_point_registry (line 18) | def get_hex_point_registry(self) -> HexPointRegistry:
    method test_find_point_index (line 33) | def test_find_point_index(self, point, index):
    method test_connection (line 39) | def test_connection(self):
    method test_junction (line 52) | def test_junction(self, point_index, neighbour_count):
    method test_face_registry (line 71) | def test_face_registry(self, cell, side, indexes):
    method test_cell_registry (line 89) | def test_cell_registry(self, point, cells) -> None:

FILE: tests/test_bugs/test_grading.py
  class GradingBugTests (line 11) | class GradingBugTests(unittest.TestCase):
    method test_invert_grading (line 12) | def test_invert_grading(self):

FILE: tests/test_construct/test_assembly.py
  class AssemblyTests (line 12) | class AssemblyTests(unittest.TestCase):
    method setUp (line 13) | def setUp(self):
    method fanout (line 18) | def fanout(self, count: int) -> NPPointListType:
    method get_joint_points (line 23) | def get_joint_points(self, joint: JointBase) -> NPPointListType:
    method test_t_joint (line 32) | def test_t_joint(self):
    method test_l_joint (line 40) | def test_l_joint(self):
    method test_n_joint (line 49) | def test_n_joint(self, branches):
    method test_operations (line 57) | def test_operations(self):
    method test_center (line 62) | def test_center(self):
    method test_chop (line 67) | def test_chop(self):
    method test_set_patches (line 82) | def test_set_patches(self):

FILE: tests/test_construct/test_chaining.py
  class ElbowChainingTests (line 21) | class ElbowChainingTests(unittest.TestCase):
    method setUp (line 24) | def setUp(self):
    method check_success (line 37) | def check_success(self, chained_shape, end_center):
    method test_to_elbow_end (line 50) | def test_to_elbow_end(self):
    method test_chain_on_invalid_start_face (line 63) | def test_chain_on_invalid_start_face(self):
    method test_to_elbow_start (line 70) | def test_to_elbow_start(self):
    method test_to_cylinder_start (line 75) | def test_to_cylinder_start(self):
    method test_to_cylinder_end (line 80) | def test_to_cylinder_end(self):
    method test_to_cylinder_negative (line 85) | def test_to_cylinder_negative(self):
    method test_chain_frustum_invalid_length (line 90) | def test_chain_frustum_invalid_length(self):
    method test_to_frustum_start (line 94) | def test_to_frustum_start(self):
    method test_to_frustum_end (line 98) | def test_to_frustum_end(self):
    method test_to_sphere_end (line 102) | def test_to_sphere_end(self):
    method test_to_sphere_start (line 106) | def test_to_sphere_start(self):
  class RingChainingTests (line 111) | class RingChainingTests(unittest.TestCase):
    method setUp (line 114) | def setUp(self):
    method check_success (line 125) | def check_success(self, chained_shape, end_center):
    method test_chain_invalid_length (line 138) | def test_chain_invalid_length(self):
    method test_chain_end (line 142) | def test_chain_end(self):
    method test_chain_start (line 147) | def test_chain_start(self):
  class ExpandContractTests (line 153) | class ExpandContractTests(unittest.TestCase):
    method setUp (line 156) | def setUp(self):
    method check_success (line 159) | def check_success(self, shape_1, shape_2, n_blocks, n_vertices):
    method test_expand_cylinder (line 167) | def test_expand_cylinder(self):
    method test_expand_ring (line 174) | def test_expand_ring(self):
    method test_contract_ring_invalid_radius (line 181) | def test_contract_ring_invalid_radius(self):
    method test_contract_ring_zero_radius (line 186) | def test_contract_ring_zero_radius(self):
    method test_contract_ring (line 191) | def test_contract_ring(self):
    method test_fill_assert (line 197) | def test_fill_assert(self):
    method test_fill (line 202) | def test_fill(self):

FILE: tests/test_construct/test_curves/test_analytic.py
  class AnalyticCurveTests (line 13) | class AnalyticCurveTests(unittest.TestCase):
    method setUp (line 14) | def setUp(self):
    method test_arc_length_halfcircle (line 25) | def test_arc_length_halfcircle(self):
    method test_arc_length_quartercircle (line 29) | def test_arc_length_quartercircle(self):
    method test_length_property (line 32) | def test_length_property(self):
    method test_closest_param (line 42) | def test_closest_param(self, position, param):
    method test_discretize (line 45) | def test_discretize(self):
    method test_transform (line 53) | def test_transform(self):
    method test_tangent (line 65) | def test_tangent(self, param, tangent):
    method test_normal (line 75) | def test_normal(self, param, normal):
    method test_binormal (line 85) | def test_binormal(self, param):
  class LineCurveTests (line 89) | class LineCurveTests(unittest.TestCase):
    method setUp (line 90) | def setUp(self):
    method curve (line 97) | def curve(self) -> LineCurve:
    method test_init (line 100) | def test_init(self):
    method test_values_within_bounds (line 110) | def test_values_within_bounds(self, param, value):
    method test_values_outside_bounds (line 119) | def test_values_outside_bounds(self, param):
    method test_translate (line 123) | def test_translate(self):
    method test_rotate (line 129) | def test_rotate(self):
    method test_scale (line 135) | def test_scale(self):
    method test_scale_nocenter (line 141) | def test_scale_nocenter(self):
    method test_center (line 147) | def test_center(self):
    method test_get_param_at_length (line 150) | def test_get_param_at_length(self):
  class CircleCurveTests (line 154) | class CircleCurveTests(unittest.TestCase):
    method setUp (line 155) | def setUp(self):
    method curve (line 163) | def curve(self) -> CircleCurve:
    method test_circle_points (line 167) | def test_circle_points(self, param, point):
    method test_translate (line 170) | def test_translate(self):
    method test_rotate (line 176) | def test_rotate(self):
    method test_scale (line 182) | def test_scale(self):

FILE: tests/test_construct/test_curves/test_discrete.py
  class DiscreteCurveTests (line 10) | class DiscreteCurveTests(unittest.TestCase):
    method setUp (line 11) | def setUp(self):
    method curve (line 21) | def curve(self) -> DiscreteCurve:
    method test_single_point (line 24) | def test_single_point(self):
    method test_wrong_shape (line 29) | def test_wrong_shape(self):
    method test_discretize_wrong_params (line 35) | def test_discretize_wrong_params(self, param_from, param_to):
    method test_discretize (line 40) | def test_discretize(self):
    method test_discretize_partial (line 44) | def test_discretize_partial(self):
    method test_discretize_inverted (line 48) | def test_discretize_inverted(self):
    method test_length (line 55) | def test_length(self):
    method test_get_length (line 65) | def test_get_length(self, param_from, param_to):
    method test_get_closest_param (line 79) | def test_get_closest_param(self, point, index):
    method test_translate (line 82) | def test_translate(self):
    method test_center (line 89) | def test_center(self):
    method test_scale (line 92) | def test_scale(self):

FILE: tests/test_construct/test_curves/test_interpolated.py
  class LinearInterpolatedCurveTests (line 9) | class LinearInterpolatedCurveTests(unittest.TestCase):
    method setUp (line 10) | def setUp(self):
    method curve (line 21) | def curve(self) -> LinearInterpolatedCurve:
    method test_discretize (line 24) | def test_discretize(self):
    method test_get_length (line 37) | def test_get_length(self, param_from, param_to):
    method test_length (line 41) | def test_length(self):
    method test_get_point (line 44) | def test_get_point(self):
    method test_get_closest_param (line 58) | def test_get_closest_param(self, point, param):
    method test_transform (line 61) | def test_transform(self):
    method test_param_at_length (line 68) | def test_param_at_length(self):
    method test_shear (line 71) | def test_shear(self):
  class SplineInterpolatedCurveTests (line 87) | class SplineInterpolatedCurveTests(unittest.TestCase):
    method setUp (line 88) | def setUp(self):
    method curve (line 101) | def curve(self) -> SplineInterpolatedCurve:
    method test_length (line 104) | def test_length(self):
    method test_through_points (line 118) | def test_through_points(self, param):
    method test_transform (line 123) | def test_transform(self):
    method test_center_warning (line 130) | def test_center_warning(self):
    method test_interpolation_values_line (line 145) | def test_interpolation_values_line(self, param):
    method test_get_param_at (line 156) | def test_get_param_at(self):

FILE: tests/test_construct/test_curves/test_interpolators.py
  class LinearInterpolatorTests (line 10) | class LinearInterpolatorTests(unittest.TestCase):
    method setUp (line 11) | def setUp(self):
    method test_points (line 31) | def test_points(self, param, result):
    method test_extrapolate_exception (line 36) | def test_extrapolate_exception(self):

FILE: tests/test_construct/test_edge_data.py
  class EdgeDataTests (line 12) | class EdgeDataTests(unittest.TestCase):
    method test_line_create (line 15) | def test_line_create(self):
    method test_arc_transform (line 19) | def test_arc_transform(self):
    method test_origin_transform (line 26) | def test_origin_transform(self):
    method test_angle_scale (line 33) | def test_angle_scale(self):
    method test_angle_translate (line 41) | def test_angle_translate(self):
    method test_angle_rotate (line 48) | def test_angle_rotate(self):
    method test_spline_transform (line 55) | def test_spline_transform(self):
    method test_project_create_single (line 64) | def test_project_create_single(self):
    method test_project_create_double (line 70) | def test_project_create_double(self):
    method test_project_create_multiple (line 76) | def test_project_create_multiple(self):
    method test_add_same (line 81) | def test_add_same(self):
    method test_add_different_single (line 88) | def test_add_different_single(self):
    method test_add_different_list (line 95) | def test_add_different_list(self):
    method test_add_too_many (line 102) | def test_add_too_many(self):
    method test_default_transform (line 109) | def test_default_transform(self):
    method test_default_repr (line 117) | def test_default_repr(self):
  class CurveEdgeTests (line 121) | class CurveEdgeTests(unittest.TestCase):
    method points (line 123) | def points(self):
    method curve (line 134) | def curve(self) -> DiscreteCurve:
    method test_on_curve_translate (line 137) | def test_on_curve_translate(self):
    method test_on_curve_rotate (line 143) | def test_on_curve_rotate(self):
    method test_on_curve_rotate_nocenter (line 151) | def test_on_curve_rotate_nocenter(self):
    method test_spline_repr (line 161) | def test_spline_repr(self):
    method test_polyline_repr (line 166) | def test_polyline_repr(self):
    method test_spline_center (line 171) | def test_spline_center(self):

FILE: tests/test_construct/test_flat/test_annulus.py
  class AnnulusTests (line 10) | class AnnulusTests(unittest.TestCase):
    method test_invalid_inner_radius (line 13) | def test_invalid_inner_radius(self):
    method test_coplanar_assert (line 17) | def test_coplanar_assert(self):
    method test_center (line 24) | def test_center(self, n_segments):

FILE: tests/test_construct/test_flat/test_disk.py
  class QuarterDiskTests (line 16) | class QuarterDiskTests(unittest.TestCase):
    method qdisk (line 18) | def qdisk(self):
    method assert_coincident (line 21) | def assert_coincident(self, qdisk: QuarterDisk):
    method test_quarter_translate (line 36) | def test_quarter_translate(self):
    method test_quarter_rotate (line 42) | def test_quarter_rotate(self):
    method test_quarter_scale_origin (line 48) | def test_quarter_scale_origin(self):
    method test_quarter_scale_origin_default (line 55) | def test_quarter_scale_origin_default(self):
    method test_quarter_combined (line 62) | def test_quarter_combined(self):
    method test_face (line 71) | def test_face(self, i_face):
    method test_points_keys (line 81) | def test_points_keys(self):
    method test_point_position (line 98) | def test_point_position(self, key, position):
  class DisksTests (line 106) | class DisksTests(unittest.TestCase):
    method test_one_core_disk (line 107) | def test_one_core_disk(self):
    method test_one_core_disk_origo (line 113) | def test_one_core_disk_origo(self):
    method test_one_core__disk_edges (line 118) | def test_one_core__disk_edges(self):
    method test_half_disk (line 128) | def test_half_disk(self):
    method test_wrapped_disk (line 134) | def test_wrapped_disk(self):
    method test_wrapped_disk_edges (line 141) | def test_wrapped_disk_edges(self):
  class OvalTests (line 152) | class OvalTests(unittest.TestCase):
    method oval (line 154) | def oval(self) -> Oval:
    method test_construct (line 161) | def test_construct(self):
    method test_planar (line 164) | def test_planar(self):
    method test_centers (line 169) | def test_centers(self):
    method test_grid (line 174) | def test_grid(self):
  class ChopTests (line 181) | class ChopTests(unittest.TestCase):
    method setUp (line 182) | def setUp(self):
    method test_one_core_disk (line 185) | def test_one_core_disk(self):

FILE: tests/test_construct/test_flat/test_face.py
  class FaceTests (line 13) | class FaceTests(unittest.TestCase):
    method setUp (line 14) | def setUp(self):
    method test_face_too_few_points (line 17) | def test_face_too_few_points(self):
    method test_face_invalid_points (line 22) | def test_face_invalid_points(self):
    method test_face_center (line 27) | def test_face_center(self):
    method test_reverse (line 31) | def test_reverse(self):
    method test_translate_face (line 40) | def test_translate_face(self):
    method test_rotate_face_center (line 66) | def test_rotate_face_center(self):
    method test_rotate_face_custom_origin (line 84) | def test_rotate_face_custom_origin(self):
    method test_rotate_default_origin (line 102) | def test_rotate_default_origin(self):
    method test_scale_face_center (line 114) | def test_scale_face_center(self):
    method test_scale_face_custom_origin (line 123) | def test_scale_face_custom_origin(self):
    method test_scale_face_edges (line 131) | def test_scale_face_edges(self):
    method test_add_edge (line 138) | def test_add_edge(self):
    method test_replace_edge (line 148) | def test_replace_edge(self):
    method test_reorient_indexes (line 155) | def test_reorient_indexes(self):
    method test_reorient_normal (line 165) | def test_reorient_normal(self):
    method test_update (line 174) | def test_update(self):
    method test_wrong_edge_count (line 182) | def test_wrong_edge_count(self):
    method test_check_coplanar_raise (line 186) | def test_check_coplanar_raise(self):
    method test_remove_edge (line 193) | def test_remove_edge(self):
    method test_remove_edges (line 203) | def test_remove_edges(self):
    method test_shear (line 214) | def test_shear(self):

FILE: tests/test_construct/test_flat/test_sketch.py
  class MappedSketchTests (line 9) | class MappedSketchTests(unittest.TestCase):
    method positions (line 11) | def positions(self):
    method quads (line 25) | def quads(self):
    method sketch (line 34) | def sketch(self):
    method test_faces (line 37) | def test_faces(self):
    method test_grid (line 40) | def test_grid(self):
    method test_update (line 43) | def test_update(self):
    method test_merge (line 52) | def test_merge(self):
  class GridSketchTests (line 68) | class GridSketchTests(unittest.TestCase):
    method test_construct (line 69) | def test_construct(self):
    method test_center (line 74) | def test_center(self):

FILE: tests/test_construct/test_operation/test_box.py
  class BoxTests (line 9) | class BoxTests(unittest.TestCase):
    method test_create_box (line 24) | def test_create_box(self, diagonal_point):

FILE: tests/test_construct/test_operation/test_connector.py
  class ConnectorTests (line 9) | class ConnectorTests(unittest.TestCase):
    method setUp (line 10) | def setUp(self):
    method test_create_normal (line 18) | def test_create_normal(self):
    method test_create_inverted (line 21) | def test_create_inverted(self):
    method test_direction (line 24) | def test_direction(self):
    method test_direction_inverted (line 32) | def test_direction_inverted(self):

FILE: tests/test_construct/test_operation/test_extrude.py
  class ExtrudeTests (line 11) | class ExtrudeTests(unittest.TestCase):
    method setUp (line 12) | def setUp(self):
    method face (line 19) | def face(self) -> Face:
    method extrude (line 23) | def extrude(self) -> Extrude:
    method test_extrude_box (line 26) | def test_extrude_box(self):
    method test_extrude_slanted (line 35) | def test_extrude_slanted(self):
    method test_extrude_edges (line 46) | def test_extrude_edges(self):
    method test_extrude_amount (line 59) | def test_extrude_amount(self):

FILE: tests/test_construct/test_operation/test_operation.py
  class OperationTests (line 16) | class OperationTests(BlockTestCase):
    method setUp (line 19) | def setUp(self):
    method test_add_side_edge_invalid_corner_index (line 22) | def test_add_side_edge_invalid_corner_index(self):
    method test_set_patch_single (line 27) | def test_set_patch_single(self):
    method test_set_patch_multiple (line 33) | def test_set_patch_multiple(self):
    method test_edges (line 50) | def test_edges(self, corner_1, corner_2, edge_data_class):
    method test_faces (line 60) | def test_faces(self, side):
    method test_patch_from_corner_empty (line 64) | def test_patch_from_corner_empty(self):
    method test_patch_from_corner_single (line 68) | def test_patch_from_corner_single(self):
    method test_patch_from_corner_multiple (line 75) | def test_patch_from_corner_multiple(self):
    method test_chop (line 84) | def test_chop(self):
    method test_unchop_single (line 90) | def test_unchop_single(self):
    method test_unchop_all (line 97) | def test_unchop_all(self):
    method test_set_cell_zone (line 106) | def test_set_cell_zone(self):
    method test_center (line 112) | def test_center(self):
    method test_set_patch_name (line 117) | def test_set_patch_name(self, side):
    method test_get_closest_side (line 133) | def test_get_closest_side(self, point, orient):
    method test_get_closest_face (line 146) | def test_get_closest_face(self, point):
    method test_get_normal_face (line 161) | def test_get_normal_face(self, point, orient):
    method test_from_series_error (line 166) | def test_from_series_error(self):
    method test_from_series_2 (line 171) | def test_from_series_2(self):
    method test_from_series_3 (line 177) | def test_from_series_3(self):
    method test_from_series_4 (line 186) | def test_from_series_4(self):
  class OperationProjectionTests (line 201) | class OperationProjectionTests(BlockTestCase):
    method setUp (line 204) | def setUp(self):
    method count_edges (line 207) | def count_edges(self, kind: str) -> int:
    method test_project_side_top (line 218) | def test_project_side_top(self):
    method test_project_side_bottom (line 224) | def test_project_side_bottom(self):
    method test_project_sides (line 231) | def test_project_sides(self, side):
    method test_no_projected_edges (line 238) | def test_no_projected_edges(self):
    method test_project_sides_edges (line 244) | def test_project_sides_edges(self, side):
    method test_project_sides_points (line 251) | def test_project_sides_points(self, side):
    method test_project_side (line 263) | def test_project_side(self):
    method test_project_side_edges (line 269) | def test_project_side_edges(self):
    method test_project_two_sides_bottom (line 277) | def test_project_two_sides_bottom(self):
    method test_project_two_sides_top (line 287) | def test_project_two_sides_top(self):
    method test_project_corner_top (line 297) | def test_project_corner_top(self):
    method test_project_corner_bottom (line 303) | def test_project_corner_bottom(self):
    method test_project_edge (line 337) | def test_project_edge(self, corner_1, corner_2):
    method test_project_edge_twice (line 356) | def test_project_edge_twice(self):
    method test_project_edge_multiple (line 372) | def test_project_edge_multiple(self, first, second, result):
  class OperationTransformTests (line 380) | class OperationTransformTests(unittest.TestCase):
    method setUp (line 384) | def setUp(self):
    method test_construct (line 404) | def test_construct(self):
    method test_translate (line 408) | def test_translate(self):
    method test_rotate (line 423) | def test_rotate(self):
    method test_rotate_default_origin (line 438) | def test_rotate_default_origin(self):
    method test_mirror_bottom (line 452) | def test_mirror_bottom(self):
    method test_mirror_top (line 462) | def test_mirror_top(self):
    method test_index_from_side (line 473) | def test_index_from_side(self):
    method test_mirror (line 477) | def test_mirror(self):
    method test_mirror_transform (line 483) | def test_mirror_transform(self):
    method test_mirror_transform_no_origin (line 489) | def test_mirror_transform_no_origin(self):

FILE: tests/test_construct/test_operation/test_wedge.py
  class WedgeTests (line 7) | class WedgeTests(unittest.TestCase):
    method setUp (line 8) | def setUp(self):
    method base (line 12) | def base(self) -> Face:
    method wedge (line 16) | def wedge(self) -> Wedge:
    method test_wedge_construction_mirror (line 19) | def test_wedge_construction_mirror(self):
    method test_wedge_construction_revolve (line 26) | def test_wedge_construction_revolve(self):
    method test_inner_patch (line 33) | def test_inner_patch(self):
    method test_outer_patch (line 39) | def test_outer_patch(self):
    method test_chop (line 45) | def test_chop(self):

FILE: tests/test_construct/test_point.py
  class PointTests (line 11) | class PointTests(unittest.TestCase):
    method point (line 15) | def point(self) -> Point:
    method test_invalid_creation_parameters (line 25) | def test_invalid_creation_parameters(self, position):
    method test_default_rotate_origin (line 29) | def test_default_rotate_origin(self):
    method test_default_scale_origin (line 33) | def test_default_scale_origin(self):
    method test_center (line 37) | def test_center(self):
    method test_points_equal (line 41) | def test_points_equal(self):
    method test_points_not_equal (line 48) | def test_points_not_equal(self):
    method test_project_double (line 55) | def test_project_double(self):
    method test_project_twice (line 63) | def test_project_twice(self):
    method test_project_twice_mixed (line 72) | def test_project_twice_mixed(self):
    method test_mirror_default_origin (line 80) | def test_mirror_default_origin(self):

FILE: tests/test_construct/test_shape.py
  class ShapeTests (line 19) | class ShapeTests(unittest.TestCase):
    method setUp (line 22) | def setUp(self):
    method test_translate (line 25) | def test_translate(self):
    method test_translate_sketches (line 31) | def test_translate_sketches(self):
    method test_cylinder_center (line 37) | def test_cylinder_center(self):
    method test_set_start_patch (line 41) | def test_set_start_patch(self):
    method test_set_end_patch (line 48) | def test_set_end_patch(self):
    method test_outer_patch (line 55) | def test_outer_patch(self):
    method test_inner_patch_extruded (line 62) | def test_inner_patch_extruded(self):
    method test_inner_patch_revolved (line 70) | def test_inner_patch_revolved(self):
    method test_start_patch_revolved (line 80) | def test_start_patch_revolved(self):
    method test_end_patch_revolved (line 90) | def test_end_patch_revolved(self):
  class ElbowTests (line 101) | class ElbowTests(unittest.TestCase):
    method setUp (line 104) | def setUp(self):
    method radius_1 (line 117) | def radius_1(self) -> float:
    method elbow (line 122) | def elbow(self) -> Elbow:
    method test_radius_1 (line 134) | def test_radius_1(self):
    method test_radius_2 (line 138) | def test_radius_2(self):
    method test_radius_mid_nonuniform (line 142) | def test_radius_mid_nonuniform(self):
    method test_radius_mid_uniform (line 147) | def test_radius_mid_uniform(self):
    method test_sketch_positions (line 153) | def test_sketch_positions(self):
  class RevolvedRingTests (line 163) | class RevolvedRingTests(unittest.TestCase):
    method setUp (line 166) | def setUp(self):
    method test_set_inner_patch (line 174) | def test_set_inner_patch(self):
    method test_set_outer_patch (line 181) | def test_set_outer_patch(self):
    method test_chop_ring_tangential (line 188) | def test_chop_ring_tangential(self):
    method test_transform (line 196) | def test_transform(self):
  class ExtrudedRingTests (line 203) | class ExtrudedRingTests(unittest.TestCase):
    method test_transform (line 204) | def test_transform(self):
  class SphereTests (line 211) | class SphereTests(unittest.TestCase):
    method test_sphere_radii (line 212) | def test_sphere_radii(self):
    method test_start_patch (line 222) | def test_start_patch(self):
    method test_outer_patch (line 234) | def test_outer_patch(self):
    method test_core (line 241) | def test_core(self):
    method test_center (line 246) | def test_center(self):
    method test_geometry (line 251) | def test_geometry(self):
  class FrustumTests (line 259) | class FrustumTests(unittest.TestCase):
    method test_non_perpendicular_axis_radius (line 260) | def test_non_perpendicular_axis_radius(self):
    method test_curved_side (line 264) | def test_curved_side(self):
  class CylinderTests (line 275) | class CylinderTests(unittest.TestCase):
    method setUp (line 276) | def setUp(self):
    method test_non_perpendicular_axis_radius (line 282) | def test_non_perpendicular_axis_radius(self):
    method test_edges (line 286) | def test_edges(self):
    method test_core (line 292) | def test_core(self):
    method test_chop_radial_start_size (line 296) | def test_chop_radial_start_size(self):
    method test_chop_radial_end_size (line 302) | def test_chop_radial_end_size(self):
    method test_mirror (line 308) | def test_mirror(self):
    method _test_mirror_transform (line 316) | def _test_mirror_transform(self):
    method test_remove_inner_edges (line 324) | def test_remove_inner_edges(self):
    method test_symmetry_patches (line 334) | def test_symmetry_patches(self):
  class LoftedShapeTests (line 339) | class LoftedShapeTests(unittest.TestCase):
    method sketch (line 341) | def sketch(self):
    method test_end_sketch_exception (line 344) | def test_end_sketch_exception(self):
    method test_test_mid_sketch_exception (line 351) | def test_test_mid_sketch_exception(self):
    method test_grid (line 359) | def test_grid(self):
    method test_chop_0 (line 365) | def test_chop_0(self):
    method test_chop_2 (line 373) | def test_chop_2(self):
    method test_extruded_shape_scalar (line 379) | def test_extruded_shape_scalar(self):
    method test_extruded_shape_vector (line 384) | def test_extruded_shape_vector(self):
    method test_revolved_shape (line 389) | def test_revolved_shape(self):

FILE: tests/test_construct/test_shell.py
  class ShellTestsBase (line 14) | class ShellTestsBase(DataTestCase):
    method setUp (line 15) | def setUp(self):
    method get_face (line 25) | def get_face(self, orient) -> Face:
    method get_point (line 28) | def get_point(self, orient, index):
  class SharedPointTests (line 32) | class SharedPointTests(ShellTestsBase):
    method get_shared_point (line 33) | def get_shared_point(self, orient: OrientType, index: int):
    method test_equal (line 41) | def test_equal(self):
    method test_add (line 52) | def test_add(self):
    method test_duplicated (line 61) | def test_duplicated(self):
    method test_noncoincident (line 73) | def test_noncoincident(self):
    method test_normal_single (line 80) | def test_normal_single(self):
    method test_normal_multiple (line 88) | def test_normal_multiple(self):
    method test_is_single (line 97) | def test_is_single(self):
    method test_is_shared (line 102) | def test_is_shared(self):
  class SharedpointStoreTests (line 109) | class SharedpointStoreTests(ShellTestsBase):
    method setUp (line 110) | def setUp(self):
    method test_sps_find_by_point_success (line 115) | def test_sps_find_by_point_success(self):
    method test_sps_find_by_point_failure (line 124) | def test_sps_find_by_point_failure(self):
    method test_sps_add_from_face_new (line 134) | def test_sps_add_from_face_new(self):
    method test_sps_add_from_face_duplicate (line 139) | def test_sps_add_from_face_duplicate(self):
  class AwareFaceTests (line 147) | class AwareFaceTests(SharedPointTests):
    method get_aware_face (line 148) | def get_aware_face(self, orient):
    method test_get_offset_points (line 159) | def test_get_offset_points(self):
    method test_get_offset_face (line 170) | def test_get_offset_face(self):
    method test_is_solitary (line 178) | def test_is_solitary(self):
    method test_is_not_solitary (line 183) | def test_is_not_solitary(self):
  class AwareFaceStoreTests (line 190) | class AwareFaceStoreTests(SharedPointTests):
    method get_aws (line 191) | def get_aws(self, orients: list[OrientType]) -> AwareFaceStore:
    method test_get_point_store_single (line 196) | def test_get_point_store_single(self):
    method test_get_point_store_double_separate (line 201) | def test_get_point_store_double_separate(self):
    method test_get_point_store_double_joined (line 206) | def test_get_point_store_double_joined(self):
    method test_get_point_store_cube (line 211) | def test_get_point_store_cube(self):
    method test_get_aware_faces (line 224) | def test_get_aware_faces(self, orients):
  class ShellTests (line 230) | class ShellTests(ShellTestsBase):
    method get_shell_faces (line 231) | def get_shell_faces(self, orients: list[OrientType]):
    method get_shell (line 245) | def get_shell(self, orients: list[OrientType]):
    method test_operations_count (line 255) | def test_operations_count(self, orients):
    method test_chop (line 258) | def test_chop(self):
    method test_set_outer_patch (line 264) | def test_set_outer_patch(self) -> None:
    method test_chop_disconnected (line 272) | def test_chop_disconnected(self):
    method test_grid (line 278) | def test_grid(self):

FILE: tests/test_construct/test_stack.py
  class StackTests (line 9) | class StackTests(unittest.TestCase):
    method round_base (line 11) | def round_base(self) -> cb.OneCoreDisk:
    method square_base (line 15) | def square_base(self) -> cb.Grid:
    method test_construct_extruded_vector (line 18) | def test_construct_extruded_vector(self):
    method test_construct_extruded_amount (line 24) | def test_construct_extruded_amount(self):
    method test_construct_revolved (line 30) | def test_construct_revolved(self):
    method test_construct_transformed (line 33) | def test_construct_transformed(self):
    method test_chop (line 41) | def test_chop(self):
    method test_center (line 49) | def test_center(self):
    method test_stack_transform (line 54) | def test_stack_transform(self):
    method test_grid_square_axis0 (line 61) | def test_grid_square_axis0(self):
    method test_grid_square_axis1 (line 66) | def test_grid_square_axis1(self):
    method test_grid_square_axis2 (line 71) | def test_grid_square_axis2(self):
    method test_grid_round_axis0 (line 76) | def test_grid_round_axis0(self):
    method test_grid_round_axis1 (line 81) | def test_grid_round_axis1(self):
    method test_grid_round_axis2 (line 86) | def test_grid_round_axis2(self):
    method test_get_slice_square (line 109) | def test_get_slice_square(self, axis, index, count):

FILE: tests/test_grading/test_catalogue.py
  class InstructionTests (line 8) | class InstructionTests(BlockTestCase):
    method setUp (line 9) | def setUp(self):
    method test_not_defined (line 12) | def test_not_defined(self):
    method test_defined (line 16) | def test_defined(self):
    method test_hash (line 20) | def test_hash(self):
  class RowCatalogueTests (line 24) | class RowCatalogueTests(BlockTestCase):
    method setUp (line 25) | def setUp(self):
    method test_row_blocks_exception (line 33) | def test_row_blocks_exception(self):
    method test_find_instruction_exception (line 38) | def test_find_instruction_exception(self):

FILE: tests/test_grading/test_collector.py
  class CollectorTests (line 6) | class CollectorTests(unittest.TestCase):
    method test_chop_edge_single (line 7) | def test_chop_edge_single(self):
    method test_chop_edge_multiple (line 18) | def test_chop_edge_multiple(self):
    method test_is_not_edge_chopped (line 30) | def test_is_not_edge_chopped(self):
    method test_is_edge_chopped (line 37) | def test_is_edge_chopped(self):

FILE: tests/test_grading/test_edge_grading.py
  class EdgeGradingExampleTests (line 17) | class EdgeGradingExampleTests(unittest.TestCase):
    method setUp (line 18) | def setUp(self):
    method test_axis_simple_grading (line 51) | def test_axis_simple_grading(self):
    method test_axis_edge_grading (line 58) | def test_axis_edge_grading(self):
    method test_block_grading_simple (line 63) | def test_block_grading_simple(self):
    method test_block_grading_edge (line 69) | def test_block_grading_edge(self):
  class EdgeGradingTests (line 76) | class EdgeGradingTests(unittest.TestCase):
    method setUp (line 79) | def setUp(self):
    method prepare (line 82) | def prepare(self):
    method test_inconsistent_wires (line 86) | def test_inconsistent_wires(self):
    method test_curved_block (line 104) | def test_curved_block(self):
    method test_no_preserve (line 118) | def test_no_preserve(self):
    method test_propagated_count (line 132) | def test_propagated_count(self):
  class BoxEdgeChopTests (line 155) | class BoxEdgeChopTests(unittest.TestCase):
    method setUp (line 158) | def setUp(self):
    method finalize (line 164) | def finalize(self):
    method get_grading (line 168) | def get_grading(self, direction: DirectionType, i_wire: int) -> list[G...
    method test_edge_chop_solo_fail (line 173) | def test_edge_chop_solo_fail(self):
    method test_edge_chop_solo_success (line 180) | def test_edge_chop_solo_success(self):
    method test_edge_chop_multiple (line 192) | def test_edge_chop_multiple(self):
    method test_clear (line 207) | def test_clear(self):

FILE: tests/test_grading/test_grading.py
  class GradingTests (line 12) | class GradingTests(unittest.TestCase):
    method setUp (line 13) | def setUp(self):
    method test_calculator_functions (line 16) | def test_calculator_functions(self):
    method test_calculate (line 59) | def test_calculate(self, keys, count, total_expansion):
    method add_chop (line 65) | def add_chop(self, length_ratio, count, total_expansion):
    method test_output_empty (line 70) | def test_output_empty(self):
    method test_output_single (line 74) | def test_output_single(self):
    method test_output_multi (line 78) | def test_output_multi(self):
    method test_copy_invert_simple (line 87) | def test_copy_invert_simple(self):
    method test_add_division_zero_length (line 95) | def test_add_division_zero_length(self):
    method test_insuficient_data (line 103) | def test_insuficient_data(self):
    method test_over_defined (line 113) | def test_over_defined(self):
    method test_wrong_combination (line 117) | def test_wrong_combination(self):
    method test_add_division_1 (line 125) | def test_add_division_1(self):
    method test_add_division_2 (line 136) | def test_add_division_2(self):
    method test_add_division_3 (line 141) | def test_add_division_3(self):
    method test_add_division_inverted (line 147) | def test_add_division_inverted(self):
    method test_add_wrong_ratio (line 155) | def test_add_wrong_ratio(self, ratio):
    method test_is_defined (line 160) | def test_is_defined(self):
    method test_is_not_defined (line 165) | def test_is_not_defined(self):
    method test_warn_ratio (line 168) | def test_warn_ratio(self):
    method test_invert_empty (line 176) | def test_invert_empty(self):
    method test_equal (line 181) | def test_equal(self):
    method test_not_equal_divisionsn (line 192) | def test_not_equal_divisionsn(self):
    method test_not_equal (line 205) | def test_not_equal(self):
    method test_copy_preserve_none (line 215) | def test_copy_preserve_none(self):
    method test_copy_preserve_start (line 224) | def test_copy_preserve_start(self):
    method test_copy_preserve_end (line 235) | def test_copy_preserve_end(self):
    method test_start_size_exception (line 246) | def test_start_size_exception(self):
    method test_end_size_exception (line 252) | def test_end_size_exception(self):
    method test_grading_description_undefined (line 258) | def test_grading_description_undefined(self):
    method test_grading_description_define (line 263) | def test_grading_description_define(self):
  class CollapsedGradingTests (line 270) | class CollapsedGradingTests(unittest.TestCase):
    method test_add_chop_count (line 271) | def test_add_chop_count(self):
    method test_add_chop_nocount (line 277) | def test_add_chop_nocount(self):
    method test_count_multi (line 284) | def test_count_multi(self):
    method test_clear (line 292) | def test_clear(self):
    method test_description (line 301) | def test_description(self):

FILE: tests/test_grading/test_inflation.py
  class InflationGraderTests (line 10) | class InflationGraderTests(unittest.TestCase):
    method get_grader (line 11) | def get_grader(self, mesh: Mesh) -> InflationGrader:
    method test_flipped_blocks (line 14) | def test_flipped_blocks(self):

FILE: tests/test_grading/test_layers.py
  class ParamsTests (line 13) | class ParamsTests(unittest.TestCase):
    method setUp (line 14) | def setUp(self):
    method test_bl_thickness (line 17) | def test_bl_thickness(self):
    method test_inflation_count (line 20) | def test_inflation_count(self):
    method test_inflation_end_size (line 23) | def test_inflation_end_size(self):
    method test_buffer_start_size (line 26) | def test_buffer_start_size(self):
    method test_buffer_count (line 29) | def test_buffer_count(self):
    method test_sum_length_simple (line 32) | def test_sum_length_simple(self):
    method test_sum_length_graded (line 35) | def test_sum_length_graded(self):
    method test_buffer_thickness (line 38) | def test_buffer_thickness(self):
  class LayerStackTests (line 42) | class LayerStackTests(ParamsTests):
    method test_inflation_layer_count (line 43) | def test_inflation_layer_count(self):
    method test_inflation_layer_size (line 48) | def test_inflation_layer_size(self):
    method test_inflation_layer_size_truncated (line 53) | def test_inflation_layer_size_truncated(self):
    method test_inflation_count_zero (line 58) | def test_inflation_count_zero(self):
    method test_buffer_count (line 63) | def test_buffer_count(self):
    method test_buffer_length_truncated (line 68) | def test_buffer_length_truncated(self):
    method test_buffer_length (line 74) | def test_buffer_length(self):
    method test_bulk_layer (line 79) | def test_bulk_layer(self):
    method test_stack_inflation_short (line 84) | def test_stack_inflation_short(self):
    method test_stack_inflation_exact (line 90) | def test_stack_inflation_exact(self):
    method test_stack_buffer (line 96) | def test_stack_buffer(self):
    method test_stack_bulk (line 101) | def test_stack_bulk(self):
    method test_length_ratios (line 106) | def test_length_ratios(self):

FILE: tests/test_grading/test_probe.py
  class ProbeTests (line 18) | class ProbeTests(unittest.TestCase):
    method get_stack (line 19) | def get_stack(self) -> ExtrudedStack:
    method get_flipped_stack (line 24) | def get_flipped_stack(self) -> ExtrudedStack:
    method get_cylinder (line 32) | def get_cylinder(self) -> Cylinder:
    method get_frustum (line 35) | def get_frustum(self) -> Frustum:
    method get_box (line 38) | def get_box(self) -> Box:
    method setUp (line 41) | def setUp(self):
    method test_block_from_axis_fail (line 44) | def test_block_from_axis_fail(self):
    method test_get_row_length (line 57) | def test_get_row_length(self, take, length):
    method test_get_blocks_on_layer (line 67) | def test_get_blocks_on_layer(self, block, axis):
    method test_block_from_axis (line 77) | def test_block_from_axis(self, index):
    method test_get_layers (line 87) | def test_get_layers(self, axis):
    method test_get_blocks_cylinder (line 107) | def test_get_blocks_cylinder(self, axis, row, blocks):
    method test_get_blocks_inverted (line 128) | def test_get_blocks_inverted(self, axis, row, blocks):
    method test_flipped_simple (line 141) | def test_flipped_simple(self):
    method test_flipped_shape (line 163) | def test_flipped_shape(self, flip_indexes, check_row, check_index):
    method test_wire_boundaries_explicit (line 192) | def test_wire_boundaries_explicit(self, wire_start, wire_end, starts_a...
    method test_wire_boundaries_default (line 222) | def test_wire_boundaries_default(self, wire_start, wire_end, starts_at...
    method test_wire_boundaries_cylinder (line 238) | def test_wire_boundaries_cylinder(self):

FILE: tests/test_grading/test_relations.py
  class TestGradingRelations (line 15) | class TestGradingRelations(unittest.TestCase):
    method assertAlmostEqual (line 18) | def assertAlmostEqual(self, *args, **kwargs):  # noqa: N802
    method test_get_start_size__count__c2c_expansion_valid (line 31) | def test_get_start_size__count__c2c_expansion_valid(self, args, result):
    method test_get_start_size__count__c2c_expansion_zerolen (line 34) | def test_get_start_size__count__c2c_expansion_zerolen(self):
    method test_get_start_size__count__c2c_expansion_contracting (line 38) | def test_get_start_size__count__c2c_expansion_contracting(self):
    method test_get_start_size__end_size__total_expansion_valid (line 42) | def test_get_start_size__end_size__total_expansion_valid(self):
    method test_get_start_size__end_size__total_expansion_zerolen (line 45) | def test_get_start_size__end_size__total_expansion_zerolen(self):
    method test_get_start_size__end_size__total_expansion_zeroexp (line 49) | def test_get_start_size__end_size__total_expansion_zeroexp(self):
    method test_get_end_size__start_size__total_expansion_valid (line 53) | def test_get_end_size__start_size__total_expansion_valid(self):
    method test_get_end_size__start_size__total_expansion_neglen (line 56) | def test_get_end_size__start_size__total_expansion_neglen(self):
    method test_get_count__start__size__c2c_expansion_valid (line 69) | def test_get_count__start__size__c2c_expansion_valid(self, args, result):
    method test_get_count__start__size__c2c_expansion_invalid (line 79) | def test_get_count__start__size__c2c_expansion_invalid(self, args):
    method test_get_count__end_size__c2c_expansion_valid (line 96) | def test_get_count__end_size__c2c_expansion_valid(self, args, result):
    method test_get_count__end_size__c2c_expansion_invalid (line 99) | def test_get_count__end_size__c2c_expansion_invalid(self):
    method test_get_count__total_expansion__c2c_expansion_valid (line 103) | def test_get_count__total_expansion__c2c_expansion_valid(self):
    method test_get_count__total_expansion__c2c_expansion_border (line 106) | def test_get_count__total_expansion__c2c_expansion_border(self):
    method test_get_count__total_expansion__c2c_expansion_invalid (line 115) | def test_get_count__total_expansion__c2c_expansion_invalid(self, args):
    method test_get_count__total_expansion__start_size_valid (line 128) | def test_get_count__total_expansion__start_size_valid(self, args, resu...
    method test_get_c2c_expansion__count__start_size_valid (line 142) | def test_get_c2c_expansion__count__start_size_valid(self, args, result):
    method test_get_c2c_expansion__count__start_size_invalid (line 154) | def test_get_c2c_expansion__count__start_size_invalid(self, args):
    method test_get_c2c_expansion__count__end_size_valid (line 166) | def test_get_c2c_expansion__count__end_size_valid(self, args, result):
    method test_get_c2c_expansion__count__end_size_invalid (line 176) | def test_get_c2c_expansion__count__end_size_invalid(self, args):
    method test_get_c2c_expansion__count__total_expansion_valid (line 187) | def test_get_c2c_expansion__count__total_expansion_valid(self, args, r...
    method test_get_c2c_expansion__count__total_expansion_invalid (line 190) | def test_get_c2c_expansion__count__total_expansion_invalid(self):
    method test_get_total_expansion__count__c2c_expansion_valid (line 195) | def test_get_total_expansion__count__c2c_expansion_valid(self, args, r...
    method test_get_total_expansion__count__c2c_expansion_invalid (line 198) | def test_get_total_expansion__count__c2c_expansion_invalid(self):
    method test_get_total_expansion__start_size__end_size_valid (line 210) | def test_get_total_expansion__start_size__end_size_valid(self, args, r...
    method test_get_total_expansion__start_size__end_size_invalid (line 213) | def test_get_total_expansion__start_size__end_size_invalid(self):
    method test_validate_count_valid (line 229) | def test_validate_count_valid(self, count, condition):
    method test_validate_count_invalid_type (line 232) | def test_validate_count_invalid_type(self):
    method test_validate_count_invalid_operator (line 236) | def test_validate_count_invalid_operator(self):
    method test_validate_count_unknown_operator (line 240) | def test_validate_count_unknown_operator(self):
  class ChopRelationTests (line 245) | class ChopRelationTests(unittest.TestCase):
    method test_from_function_invalid (line 246) | def test_from_function_invalid(self):

FILE: tests/test_items/test_axis.py
  class AxisTests (line 7) | class AxisTests(BlockTestCase):
    method add_blocks (line 10) | def add_blocks(self) -> tuple[Block, Block]:
    method test_length_avg (line 19) | def test_length_avg(self):
    method test_is_aligned_exception (line 27) | def test_is_aligned_exception(self):
    method test_is_aligned (line 38) | def test_is_aligned(self, axis):
    method test_is_not_aligned (line 47) | def test_is_not_aligned(self):
    method test_sequential_before (line 61) | def test_sequential_before(self):
    method test_sequential_after (line 70) | def test_sequential_after(self):
    method test_is_inline (line 78) | def test_is_inline(self):
    method test_is_not_inline (line 83) | def test_is_not_inline(self):

FILE: tests/test_items/test_block.py
  function _mkcollector (line 15) | def _mkcollector(axis: DirectionType, chops: list[Chop]) -> ChopCollector:
  class BlockTests (line 23) | class BlockTests(BlockTestCase):
    method test_add_neighbour_1_wires (line 34) | def test_add_neighbour_1_wires(self, this_corners, nei_corners):
    method test_add_neighbour_1_axes (line 47) | def test_add_neighbour_1_axes(self):
    method test_add_neighbour_2_wires (line 59) | def test_add_neighbour_2_wires(self):
    method test_add_neighbour_2_axes (line 69) | def test_add_neighbour_2_axes(self):
    method test_add_neighbour_3 (line 80) | def test_add_neighbour_3(self):
    method test_add_neighbour_twice (line 91) | def test_add_neighbour_twice(self):
    method test_add_self (line 103) | def test_add_self(self):
    method test_add_neighbour_inverted (line 113) | def test_add_neighbour_inverted(self):
    method test_add_foreign (line 132) | def test_add_foreign(self):
    method test_axis_direction (line 150) | def test_axis_direction(self):
    method test_repr (line 157) | def test_repr(self):
  class WireframeTests (line 161) | class WireframeTests(BlockTestCase):
    method setUp (line 164) | def setUp(self):
    method test_wires_count (line 168) | def test_wires_count(self):
    method test_wire_indexes (line 173) | def test_wire_indexes(self):
    method test_axis_count (line 193) | def test_axis_count(self):
    method test_find_wire_fail (line 199) | def test_find_wire_fail(self, corner_1, corner_2):
    method test_find_wire_success (line 205) | def test_find_wire_success(self, corner_1, corner_2):
    method test_get_axis_wires_length (line 210) | def test_get_axis_wires_length(self, axis):
    method test_edge_list_empty (line 215) | def test_edge_list_empty(self, block_index, edge_count):
    method test_index_exception (line 220) | def test_index_exception(self):

FILE: tests/test_items/test_edge.py
  class EdgeTransformTests (line 20) | class EdgeTransformTests(unittest.TestCase):
    method setUp (line 23) | def setUp(self):
    method test_arc_edge_translate (line 27) | def test_arc_edge_translate(self):
    method test_angle_edge_rotate_1 (line 33) | def test_angle_edge_rotate_1(self):
    method test_angle_edge_rotate_2 (line 42) | def test_angle_edge_rotate_2(self):
    method test_spline_edge_translate (line 51) | def test_spline_edge_translate(self):
    method test_default_origin (line 75) | def test_default_origin(self):
  class EdgeFactoryTests (line 83) | class EdgeFactoryTests(unittest.TestCase):
    method setUp (line 86) | def setUp(self):
    method test_arc (line 90) | def test_arc(self):
    method test_default_origin (line 98) | def test_default_origin(self):
    method test_flat_origin (line 107) | def test_flat_origin(self):
    method test_angle (line 115) | def test_angle(self):
    method test_spline (line 124) | def test_spline(self):
    method test_polyline (line 131) | def test_polyline(self):
    method test_project_edge_single (line 138) | def test_project_edge_single(self):
    method test_project_edge_multi (line 145) | def test_project_edge_multi(self):
  class EdgeValidityTests (line 153) | class EdgeValidityTests(unittest.TestCase):
    method get_edge (line 156) | def get_edge(self, data: edges.EdgeData) -> Edge:
    method test_degenerate (line 160) | def test_degenerate(self):
    method test_line_edge (line 165) | def test_line_edge(self):
    method test_valid_arc (line 171) | def test_valid_arc(self):
    method test_invalid_edge_creation_points (line 175) | def test_invalid_edge_creation_points(self):
    method test_invalid_arc (line 189) | def test_invalid_arc(self):
    method test_invalid_origin (line 193) | def test_invalid_origin(self):
    method test_valid_origin (line 199) | def test_valid_origin(self):
    method test_invalid_angle (line 203) | def test_invalid_angle(self):
    method test_valid_angle (line 209) | def test_valid_angle(self):
    method test_valid_spline (line 213) | def test_valid_spline(self):
    method test_valid_polyline (line 217) | def test_valid_polyline(self):
    method test_valid_project (line 221) | def test_valid_project(self):
  class EdgeLengthTests (line 226) | class EdgeLengthTests(unittest.TestCase):
    method get_edge (line 229) | def get_edge(self, data: edges.EdgeData) -> Edge:
    method test_degenerate_arc (line 233) | def test_degenerate_arc(self):
    method test_arc_edge (line 237) | def test_arc_edge(self):
    method test_origin_edge (line 241) | def test_origin_edge(self):
    method test_spline_edge (line 245) | def test_spline_edge(self):
    method test_poly_edge (line 249) | def test_poly_edge(self):
    method test_project_edge (line 253) | def test_project_edge(self):
    method test_flattened_edge (line 257) | def test_flattened_edge(self):
  class AlternativeArcTests (line 264) | class AlternativeArcTests(unittest.TestCase):
    method test_arc_mid (line 269) | def test_arc_mid(self):
    method test_arc_from_theta (line 276) | def test_arc_from_theta(self):
    method test_arc_from_origin (line 286) | def test_arc_from_origin(self):
    method test_arc_from_origin_warn (line 293) | def test_arc_from_origin_warn(self):
  class EdgeDescriptionTests (line 306) | class EdgeDescriptionTests(unittest.TestCase):
    method get_edge (line 309) | def get_edge(self, data: edges.EdgeData) -> Edge:
    method test_line_description (line 313) | def test_line_description(self):
    method test_arc_description (line 317) | def test_arc_description(self):
    method test_angle_description (line 323) | def test_angle_description(self):
    method test_origin_description (line 328) | def test_origin_description(self):
    method test_spline_description (line 333) | def test_spline_description(self):
    method test_project_description_single (line 339) | def test_project_description_single(self):
    method test_project_description_double (line 343) | def test_project_description_double(self):
  class OnCurveEdgeTests (line 350) | class OnCurveEdgeTests(unittest.TestCase):
    method setUp (line 351) | def setUp(self):
    method edge (line 366) | def edge(self) -> OnCurveEdge:
    method test_length (line 369) | def test_length(self):
    method test_param_start (line 372) | def test_param_start(self):
    method test_param_end (line 375) | def test_param_end(self):
    method test_point_array (line 378) | def test_point_array(self):
    method test_representation (line 381) | def test_representation(self):

FILE: tests/test_items/test_patch.py
  class PatchTests (line 7) | class PatchTests(BlockTestCase):
    method setUp (line 8) | def setUp(self):
    method patch (line 12) | def patch(self) -> Patch:
    method get_side (line 16) | def get_side(self, index: int, orient: OrientType) -> Side:
    method test_add_side (line 20) | def test_add_side(self):
    method test_add_equal_sides (line 27) | def test_add_equal_sides(self):

FILE: tests/test_items/test_side.py
  class SideTests (line 7) | class SideTests(BlockTestCase):
    method test_create_invalid_num_of_vertices (line 8) | def test_create_invalid_num_of_vertices(self):
    method test_create_success (line 13) | def test_create_success(self):
    method test_equal (line 20) | def test_equal(self):

FILE: tests/test_items/test_vertex.py
  class VertexTests (line 11) | class VertexTests(DataTestCase):
    method test_assert_3d (line 14) | def test_assert_3d(self):
    method test_translate_int (line 19) | def test_translate_int(self):
    method test_translate_float (line 25) | def test_translate_float(self):
    method test_rotate (line 32) | def test_rotate(self):
    method test_scale (line 40) | def test_scale(self):
    method test_inequal (line 46) | def test_inequal(self):
    method test_description_plain (line 53) | def test_description_plain(self):
    method test_project_single (line 59) | def test_project_single(self):
    method test_project_multiple (line 68) | def test_project_multiple(self):
    method test_multitransform (line 77) | def test_multitransform(self):

FILE: tests/test_items/test_wire.py
  class WireTests (line 9) | class WireTests(DataTestCase):
    method setUp (line 12) | def setUp(self) -> None:
    method wire (line 22) | def wire(self) -> Wire:
    method test_coincident_aligned (line 26) | def test_coincident_aligned(self):
    method test_coincident_inverted (line 33) | def test_coincident_inverted(self):
    method test_not_coincident (line 43) | def test_not_coincident(self):
    method test_is_aligned_exception (line 54) | def test_is_aligned_exception(self):
    method test_is_aligned (line 68) | def test_is_aligned(self):
    method test_is_inverted (line 75) | def test_is_inverted(self):
    method test_add_inline_duplicate (line 84) | def test_add_inline_duplicate(self):

FILE: tests/test_lists/test_edge_list.py
  class EdgeListTests (line 12) | class EdgeListTests(DataTestCase):
    method setUp (line 13) | def setUp(self):
    method get_vertices (line 18) | def get_vertices(self, index: int) -> list[Vertex]:
    method test_find_existing (line 26) | def test_find_existing(self):
    method test_find_existing_invertex (line 33) | def test_find_existing_invertex(self):
    method test_find_nonexisting (line 40) | def test_find_nonexisting(self):
    method test_add_new (line 48) | def test_add_new(self):
    method test_add_existing (line 55) | def test_add_existing(self):
    method test_add_invalid (line 63) | def test_add_invalid(self):
    method test_vertex_order (line 70) | def test_vertex_order(self):
    method test_add_from_operations (line 86) | def test_add_from_operations(self):

FILE: tests/test_lists/test_face_list.py
  class ProjectedFaceTests (line 9) | class ProjectedFaceTests(BlockTestCase):
    method side_1 (line 11) | def side_1(self) -> Side:
    method side_2 (line 15) | def side_2(self) -> Side:
    method test_equal (line 18) | def test_equal(self):
    method test_not_equal (line 24) | def test_not_equal(self):
  class FaceListTests (line 36) | class FaceListTests(BlockTestCase):
    method setUp (line 37) | def setUp(self):
    method get_side (line 44) | def get_side(self, block: int, orient: OrientType) -> Side:
    method test_find_existing_success (line 47) | def test_find_existing_success(self):
    method test_find_existing_fail (line 54) | def test_find_existing_fail(self):
    method test_capture_sides (line 70) | def test_capture_sides(self, orient):

FILE: tests/test_lists/test_patch_list.py
  class PatchListTests (line 5) | class PatchListTests(BlockTestCase):
    method setUp (line 6) | def setUp(self):
    method test_get_new (line 13) | def test_get_new(self):
    method test_get_existing (line 20) | def test_get_existing(self):
    method test_modify_type (line 26) | def test_modify_type(self):
    method test_add (line 31) | def test_add(self):

FILE: tests/test_mesh.py
  class MeshTests (line 10) | class MeshTests(BlockTestCase):
    method setUp (line 11) | def setUp(self):
    method test_is_not_assembled (line 14) | def test_is_not_assembled(self):
    method test_is_assembled (line 18) | def test_is_assembled(self):
    method test_assemble (line 26) | def test_assemble(self):
    method test_merged_multi (line 35) | def test_merged_multi(self):
    method test_cell_zone_operation (line 78) | def test_cell_zone_operation(self):
    method test_cell_zone_shape (line 89) | def test_cell_zone_shape(self):
    method test_chop_shape_axial (line 100) | def test_chop_shape_axial(self):
    method test_chop_cylinder_tangential (line 114) | def test_chop_cylinder_tangential(self):
    method test_set_default_patch (line 128) | def test_set_default_patch(self):
    method test_modify_patch (line 133) | def test_modify_patch(self):
    method test_operations (line 138) | def test_operations(self):
    method test_with_geometry (line 150) | def test_with_geometry(self):
    method test_backport (line 161) | def test_backport(self):
    method test_backport_empty (line 171) | def test_backport_empty(self):
    method test_delete (line 177) | def test_delete(self):
    method test_assemble_noncoincident (line 194) | def test_assemble_noncoincident(self):

FILE: tests/test_modify/test_finder.py
  class GeometricFinderTests (line 10) | class GeometricFinderTests(BlockTestCase):
    method setUp (line 11) | def setUp(self):
    method test_by_position_close (line 22) | def test_by_position_close(self):
    method test_by_position_close_count (line 28) | def test_by_position_close_count(self):
    method test_by_position_far (line 34) | def test_by_position_far(self):
    method test_by_position_all (line 40) | def test_by_position_all(self):
    method test_on_plane_bottom (line 46) | def test_on_plane_bottom(self):
    method test_on_plane_top (line 51) | def test_on_plane_top(self):
  class RoundSolidShapeFinderTests (line 57) | class RoundSolidShapeFinderTests(BlockTestCase):
    method setUp (line 58) | def setUp(self):
    method test_core_count (line 69) | def test_core_count(self, end_face):
    method test_shell_count (line 76) | def test_shell_count(self, end_face):

FILE: tests/test_modify/test_reorient.py
  class TriangleTests (line 12) | class TriangleTests(unittest.TestCase):
    method setUp (line 13) | def setUp(self):
    method test_normal (line 16) | def test_normal(self):
    method test_center (line 19) | def test_center(self):
    method test_flip (line 22) | def test_flip(self):
    method test_orient_no_change (line 27) | def test_orient_no_change(self):
    method test_orient_change (line 32) | def test_orient_change(self):
  class QuadrangleTests (line 38) | class QuadrangleTests(unittest.TestCase):
    method setUp (line 39) | def setUp(self):
    method test_get_common_points (line 48) | def test_get_common_points(self):
    method test_get_unique_points (line 56) | def test_get_unique_points(self):
    method test_point_count (line 64) | def test_point_count(self):
  class ViewpointReorienterTests (line 70) | class ViewpointReorienterTests(BlockTestCase):
    method setUp (line 71) | def setUp(self):
    method loft (line 75) | def loft(self) -> Loft:
    method test_sort_regular (line 118) | def test_sort_regular(self, axis, angle):
    method test_translated_face (line 135) | def test_translated_face(self):
    method test_rotated_face (line 145) | def test_rotated_face(self):
    method test_moved_point (line 158) | def test_moved_point(self):

FILE: tests/test_optimize/optimize_fixtures.py
  class SketchTestsBase (line 13) | class SketchTestsBase(unittest.TestCase):
    method positions (line 15) | def positions(self):
    method quads (line 31) | def quads(self):
    method grid (line 40) | def grid(self):
  class BoxTestsBase (line 44) | class BoxTestsBase(unittest.TestCase):
    method setUp (line 45) | def setUp(self):
    method get_vertex (line 63) | def get_vertex(self, position):

FILE: tests/test_optimize/test_cell.py
  class CellTests (line 9) | class CellTests(MeshTestCase):
    method setUp (line 10) | def setUp(self):
    method mesh_points (line 14) | def mesh_points(self):
    method get_cell (line 17) | def get_cell(self, index: int) -> HexCell:
    method test_common_vertices (line 28) | def test_common_vertices(self, index_1, index_2, count):
    method test_get_corner (line 35) | def test_get_corner(self, block, vertex, corner):
    method test_get_common_side (line 41) | def test_get_common_side(self, index_1, index_2, orient):
    method test_no_common_sides (line 47) | def test_no_common_sides(self):

FILE: tests/test_optimize/test_clamps.py
  class ClampTestsBase (line 13) | class ClampTestsBase(unittest.TestCase):
    method setUp (line 14) | def setUp(self):
  class FreeClampTests (line 18) | class FreeClampTests(ClampTestsBase):
    method test_free_init (line 19) | def test_free_init(self):
    method test_free_update (line 25) | def test_free_update(self):
  class CurveClampTests (line 33) | class CurveClampTests(ClampTestsBase):
    method setUp (line 34) | def setUp(self):
    method test_line_init (line 42) | def test_line_init(self):
    method test_line_init_far (line 48) | def test_line_init_far(self):
    method test_line_value (line 54) | def test_line_value(self):
    method test_line_bounds_lower (line 61) | def test_line_bounds_lower(self):
    method test_line_bounds_upper (line 67) | def test_line_bounds_upper(self):
    method test_analytic_init (line 73) | def test_analytic_init(self):
    method test_analytic_init_noncoincident (line 78) | def test_analytic_init_noncoincident(self):
    method test_analytic_bounds_lower (line 84) | def test_analytic_bounds_lower(self):
    method test_analytic_bounds_upper (line 90) | def test_analytic_bounds_upper(self):
    method test_radial_init (line 97) | def test_radial_init(self):
    method test_radial_rotate (line 103) | def test_radial_rotate(self):
  class SurfaceClampTests (line 112) | class SurfaceClampTests(ClampTestsBase):
    method setUp (line 113) | def setUp(self):
    method test_plane_clamp (line 125) | def test_plane_clamp(self):
    method test_plane_move_u (line 130) | def test_plane_move_u(self):
    method test_plane_move_v (line 137) | def test_plane_move_v(self):
    method test_plane_move_uv (line 144) | def test_plane_move_uv(self):
    method test_parametric_init (line 151) | def test_parametric_init(self):
    method test_parametric_initial_unbounded (line 156) | def test_parametric_initial_unbounded(self):
    method test_parametric_initial_bounded (line 161) | def test_parametric_initial_bounded(self):
    method test_parametric_move (line 166) | def test_parametric_move(self):
    method test_parametric_bounds_upper (line 173) | def test_parametric_bounds_upper(self):

FILE: tests/test_optimize/test_grid.py
  class HexGridTests (line 14) | class HexGridTests(MeshTestCase):
    method get_grid (line 15) | def get_grid(self, mesh: Mesh) -> HexGrid:
    method setUp (line 21) | def setUp(self):
    method test_cells_quantity (line 25) | def test_cells_quantity(self):
    method test_junctions_quantity (line 28) | def test_junctions_quantity(self):
    method test_junction_boundary (line 31) | def test_junction_boundary(self):
    method test_junction_internal (line 36) | def test_junction_internal(self):
    method test_junction_cells (line 55) | def test_junction_cells(self, index, count):
    method test_cell_neighbours (line 60) | def test_cell_neighbours(self, parent, orient, neighbour):
    method test_neighbours (line 64) | def test_neighbours(self, junction, count):
  class QuadGridTests (line 68) | class QuadGridTests(SketchTestsBase):
    method test_from_sketch (line 69) | def test_from_sketch(self):
    method test_neighbour_cells (line 85) | def test_neighbour_cells(self, i_cell, n_neighbours):
    method test_positions (line 96) | def test_positions(self):
    method test_find_neighbours (line 112) | def test_find_neighbours(self, i_junction, expected_neighbours):
    method test_fixed_points (line 121) | def test_fixed_points(self):

FILE: tests/test_optimize/test_links.py
  class TranslationLinkTests (line 10) | class TranslationLinkTests(unittest.TestCase):
    method test_translate (line 11) | def test_translate(self):
  class RotationLinkTests (line 20) | class RotationLinkTests(unittest.TestCase):
    method setUp (line 21) | def setUp(self):
    method test_radius (line 33) | def test_radius(self, origin):
    method test_rotate (line 41) | def test_rotate(self):
    method test_rotate_negative (line 48) | def test_rotate_negative(self):
    method test_rotate_arbitrary (line 90) | def test_rotate_arbitrary(self, axis, origin, angle):
    method test_coincident (line 99) | def test_coincident(self):
  class SymmetryLinkTests (line 104) | class SymmetryLinkTests(unittest.TestCase):
    method test_move (line 105) | def test_move(self):
    method test_move_displaced_origin (line 113) | def test_move_displaced_origin(self):

FILE: tests/test_optimize/test_optimizer.py
  class MeshOptimizerTests (line 17) | class MeshOptimizerTests(BoxTestsBase):
    method test_relaxation (line 24) | def test_relaxation(self, relaxation, iteration, result):
    method test_add_junction_existing (line 29) | def test_add_junction_existing(self):
    method test_optimize (line 36) | def test_optimize(self):
    method test_optimize_linked (line 50) | def test_optimize_linked(self):
  class SketchOptimizerTests (line 68) | class SketchOptimizerTests(SketchTestsBase):
    method test_optimize_manual (line 69) | def test_optimize_manual(self):
    method test_optimize_auto (line 80) | def test_optimize_auto(self):
    method test_bad_algo (line 88) | def test_bad_algo(self):
    method test_algo_options (line 98) | def test_algo_options(self):
  class ComplexSketchTests (line 116) | class ComplexSketchTests(unittest.TestCase):
    method setUp (line 122) | def setUp(self):
    method test_optimize (line 165) | def test_optimize(self):

FILE: tests/test_optimize/test_quality.py
  class QualityTests (line 9) | class QualityTests(unittest.TestCase):
    method test_quad_inner_angle (line 17) | def test_quad_inner_angle(self, point_2, angle):
    method test_quad_quality (line 26) | def test_quad_quality(self):

FILE: tests/test_optimize/test_smoother.py
  class HexSmootherTests (line 10) | class HexSmootherTests(BoxTestsBase):
    method test_smooth_mesh (line 11) | def test_smooth_mesh(self):
    method test_fix_index (line 20) | def test_fix_index(self):
    method test_fix_point (line 30) | def test_fix_point(self):
  class QuadSmootherTests (line 41) | class QuadSmootherTests(SketchTestsBase):
    method test_smooth_disk (line 42) | def test_smooth_disk(self):
    method test_smooth (line 54) | def test_smooth(self):

FILE: tests/test_propagation.py
  class PropagationTests (line 7) | class PropagationTests(BlockTestCase):
    method setUp (line 8) | def setUp(self):
    method test_propagate_normal (line 11) | def test_propagate_normal(self):
    method test_propagate_upsidedown (line 32) | def test_propagate_upsidedown(self):

FILE: tests/test_util/test_frame.py
  class FrameTests (line 6) | class FrameTests(unittest.TestCase):
    method test_add_beam_invalid (line 7) | def test_add_beam_invalid(self):

FILE: tests/test_util/test_functions.py
  class TestFunctions (line 9) | class TestFunctions(unittest.TestCase):
    method assert_np_equal (line 10) | def assert_np_equal(self, a, b, msg=None):
    method assert_np_almost_equal (line 13) | def assert_np_almost_equal(self, a, b, msg=None):
    method test_deg2rad (line 16) | def test_deg2rad(self):
    method test_rad2deg (line 21) | def test_rad2deg(self):
    method test_unit_vector (line 26) | def test_unit_vector(self):
    method test_norm_vector (line 33) | def test_norm_vector(self):
    method test_angle_between (line 37) | def test_angle_between(self):
    method test_arbitrary_rotation_point (line 49) | def test_arbitrary_rotation_point(self):
    method test_arbitrary_rotation_axis (line 57) | def test_arbitrary_rotation_axis(self):
    method test_to_polar_z_axis (line 65) | def test_to_polar_z_axis(self):
    method test_to_polar_x_axis (line 72) | def test_to_polar_x_axis(self):
    method test_to_polar_invalid_axis (line 79) | def test_to_polar_invalid_axis(self):
    method test_lin_map (line 83) | def test_lin_map(self):
    method test_lin_map_limit (line 87) | def test_lin_map_limit(self):
    method test_to_cartesian_point (line 92) | def test_to_cartesian_point(self):
    method test_polar2cartesian_x_axis (line 105) | def test_polar2cartesian_x_axis(self):
    method test_polar2cartesian_z_axis (line 111) | def test_polar2cartesian_z_axis(self):
    method test_to_cartesian_asserts (line 117) | def test_to_cartesian_asserts(self):
    method test_arc_length_3point_half (line 127) | def test_arc_length_3point_half(self):
    method test_arc_length_3point_quarter (line 133) | def test_arc_length_3point_quarter(self):
    method test_arc_length_3point_3quarter (line 140) | def test_arc_length_3point_3quarter(self):
    method test_arc_length_3point_full (line 147) | def test_arc_length_3point_full(self):
    method test_arc_length_3point_zero (line 155) | def test_arc_length_3point_zero(self):
    method test_mirror_yz (line 163) | def test_mirror_yz(self):
    method test_mirror_yz_origin (line 169) | def test_mirror_yz_origin(self):
    method test_mirror_xz (line 175) | def test_mirror_xz(self):
    method test_mirror_xz_origin (line 181) | def test_mirror_xz_origin(self):
    method test_mirror_xy (line 187) | def test_mirror_xy(self):
    method test_mirror_xy_origin (line 193) | def test_mirror_xy_origin(self):
    method test_mirror_arbitrary (line 199) | def test_mirror_arbitrary(self):
    method test_mirror_arbitrary_inverted (line 205) | def test_mirror_arbitrary_inverted(self):
    method test_mirror_arbitrary_origin (line 211) | def test_mirror_arbitrary_origin(self):
    method test_mirror_array (line 217) | def test_mirror_array(self):
    method test_is_point_on_plane_true (line 232) | def test_is_point_on_plane_true(self, origin, normal, point):
    method test_is_point_on_plane_false (line 244) | def test_is_point_on_plane_false(self, origin, normal, point):
    method test_point_to_line_distance (line 247) | def test_point_to_line_distance(self):
    method test_polyline_1dim (line 254) | def test_polyline_1dim(self):
    method test_polyline_2dim (line 259) | def test_polyline_2dim(self):
    method test_polyline_3dim (line 264) | def test_polyline_3dim(self):
    method test_polyline_singlepoint (line 276) | def test_polyline_singlepoint(self):
    method test_point_to_plane_distance (line 292) | def test_point_to_plane_distance(self, point, normal, origin, distance):

FILE: tests/test_util/test_imports.py
  class ImportsTests (line 6) | class ImportsTests(unittest.TestCase):
    method test_import_transforms (line 9) | def test_import_transforms(self):
    method test_import_curves (line 16) | def test_import_curves(self):
    method test_import_edges (line 25) | def test_import_edges(self):
    method test_import_flat (line 34) | def test_import_flat(self):
    method test_import_operations (line 37) | def test_import_operations(self):
    method test_import_sketches (line 45) | def test_import_sketches(self):
    method test_import_stacks (line 54) | def test_import_stacks(self):
    method test_import_shapes (line 59) | def test_import_shapes(self):
    method test_import_mesh (line 73) | def test_import_mesh(self):
    method test_import_finders (line 76) | def test_import_finders(self):
    method test_import_clamps (line 80) | def test_import_clamps(self):
    method test_import_links (line 87) | def test_import_links(self):
    method test_import_optimizer (line 93) | def test_import_optimizer(self):
    method test_import_assemblies (line 100) | def test_import_assemblies(self):

FILE: tests/test_util/test_tools.py
  class ToolsTests (line 9) | class ToolsTests(unittest.TestCase):
    method test_wrong_edge_location (line 18) | def test_wrong_edge_location(self, corner_1, corner_2):

[
  {
    "path": ".editorconfig",
    "chars": 292,
    "preview": "# http://editorconfig.org\n\nroot = true\n\n[*]\nindent_style = space\nindent_size = 4\ntrim_trailing_whitespace = true\ninsert_"
  },
  {
    "path": ".github/ISSUE_TEMPLATE.md",
    "chars": 324,
    "preview": "* classy_blocks version:\n* Python version:\n* Operating System:\n\n### Description\n\nDescribe what you were trying to get do"
  },
  {
    "path": ".github/workflows/build_ci.yml",
    "chars": 1155,
    "preview": "name: Test and analyze\n\non: [ push ]\n\njobs:\n    pytests:\n        strategy:\n            matrix:\n                python-ve"
  },
  {
    "path": ".gitignore",
    "chars": 2270,
    "preview": "# Why not include workspace and its settings/tasks/cfgs in git so others can benefit?\n#.vscode\n#*.code-workspace\nvenv_*/"
  },
  {
    "path": ".pre-commit-config.yaml",
    "chars": 531,
    "preview": "# See https://pre-commit.com for more information\n# See https://pre-commit.com/hooks.html for more hooks\nrepos:\n-   repo"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 14509,
    "preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Change"
  },
  {
    "path": "CITATION.cff",
    "chars": 546,
    "preview": "cff-version: 1.2.0\nmessage: \"If you use this software, please cite it as below.\"\ntitle: classy_blocks\nabstract: \"A Pytho"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 4258,
    "preview": "# Contributing\n\nContributions are welcome, and they are greatly appreciated! Every\nlittle bit helps, and credit will alw"
  },
  {
    "path": "LICENSE",
    "chars": 1071,
    "preview": "MIT License\n\nCopyright (c) 2022, Nejc Jurkovic\n\nPermission is hereby granted, free of charge, to any person obtaining a "
  },
  {
    "path": "README.md",
    "chars": 19773,
    "preview": "![classy_blocks logo](docs/classy_logo.svg \"classy_blocks logo\")\n\nPython classes for easier creation of OpenFOAM's block"
  },
  {
    "path": "examples/advanced/chop_preserve.py",
    "chars": 984,
    "preview": "\"\"\"demonstrates the 'preserve' keyword to .chop() method\"\"\"\n\nimport os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\nst"
  },
  {
    "path": "examples/advanced/collapsed.py",
    "chars": 652,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\nbottom_face = cb.Face([[0, 0, 0], [1, 0, 0], [0.5, 1, 0], [0.5,"
  },
  {
    "path": "examples/advanced/edge_grading.py",
    "chars": 1466,
    "preview": "\"\"\"A simple cylinder but with custom grading of selected edges\"\"\"\n\nimport os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh"
  },
  {
    "path": "examples/advanced/merged.py",
    "chars": 1152,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\n# two boxes, connected with a geometrically identical\n# but dif"
  },
  {
    "path": "examples/advanced/project.py",
    "chars": 1977,
    "preview": "import os\n\nimport classy_blocks as cb\n\ngeometry = {\n    \"terrain\": [\n        \"type triSurfaceMesh\",\n        \"name terrai"
  },
  {
    "path": "examples/assembly/l_joint.py",
    "chars": 740,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.assemblies.joints import LJoint\nfrom classy_blocks.ut"
  },
  {
    "path": "examples/assembly/n_joint.py",
    "chars": 781,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.assemblies.joints import NJoint\nfrom classy_blocks.ut"
  },
  {
    "path": "examples/assembly/t_joint.py",
    "chars": 778,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.assemblies.joints import TJoint\nfrom classy_blocks.ut"
  },
  {
    "path": "examples/bug.py",
    "chars": 606,
    "preview": "import numpy as np\n\nimport classy_blocks as cb\n\nbox = cb.Box([0, 0, 0], [1, 1, 1])\n\nbase_face = box.bottom_face\nneighbou"
  },
  {
    "path": "examples/case/Allrun.mesh",
    "chars": 282,
    "preview": "#!/bin/bash\ncd \"${0%/*}\" || exit\nsource $WM_PROJECT_DIR/bin/tools/RunFunctions\nsource $WM_PROJECT_DIR/bin/tools/CleanFun"
  },
  {
    "path": "examples/case/case.foam",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "examples/case/constant/geometry/terrain.stl",
    "chars": 23768,
    "preview": "solid terrain\r\nfacet normal -0.024250 -0.041091 -0.998861\r\nouter loop\r\nvertex 0.750000 -0.750000 -1.004215\r\nvertex 1.000"
  },
  {
    "path": "examples/case/system/collapseDict",
    "chars": 3311,
    "preview": "/*--------------------------------*- C++ -*----------------------------------*\\\n| =========                 |           "
  },
  {
    "path": "examples/case/system/controlDict",
    "chars": 1209,
    "preview": "/*--------------------------------*- C++ -*----------------------------------*\\\n| =========                 |           "
  },
  {
    "path": "examples/case/system/fvSchemes",
    "chars": 970,
    "preview": "/*--------------------------------*- C++ -*----------------------------------*\\\n| =========                 |           "
  },
  {
    "path": "examples/case/system/fvSolution",
    "chars": 860,
    "preview": "/*--------------------------------*- C++ -*----------------------------------*\\\n| =========                 |           "
  },
  {
    "path": "examples/chaining/flywheel.py",
    "chars": 2549,
    "preview": "import os\n\nimport classy_blocks as cb\n\n# A mesh for calculation of friction losses of a rotating rotor in a fluid.\n# See"
  },
  {
    "path": "examples/chaining/helmholtz_nozzle.py",
    "chars": 3078,
    "preview": "import os\n\nimport classy_blocks as cb\n\n# A nozzle with a chamber that produces self-induced oscillations.\n# See helmholt"
  },
  {
    "path": "examples/chaining/labyrinth.py",
    "chars": 1211,
    "preview": "import os\nfrom typing import List\n\nimport classy_blocks as cb\nfrom classy_blocks.util import functions as f\n\nmesh = cb.M"
  },
  {
    "path": "examples/chaining/orifice_plate.py",
    "chars": 1873,
    "preview": "import os\n\nimport classy_blocks as cb\n\n# see orifice_plate.svg for sketch\n\nD = 0.1  # [m]\nd_0 = 0.025\nt = 0.005  # thick"
  },
  {
    "path": "examples/chaining/tank.py",
    "chars": 676,
    "preview": "import os\n\nimport classy_blocks as cb\n\n# a cylindrical tank with round end caps\ndiameter = 0.5\nlength = 0.5  # including"
  },
  {
    "path": "examples/chaining/test_tube.py",
    "chars": 2055,
    "preview": "import os\n\nimport classy_blocks as cb\n\n# a test tube as a reactor with a part of atmosphere above and below it\nouter_dia"
  },
  {
    "path": "examples/chaining/venturi_tube.py",
    "chars": 3581,
    "preview": "import os\n\nimport numpy as np\n\nimport classy_blocks as cb\nfrom classy_blocks.util import functions as f\n\n\ndef calculate_"
  },
  {
    "path": "examples/complex/airfoil/airfoil.py",
    "chars": 6139,
    "preview": "from typing import ClassVar\n\nimport numpy as np\n\nimport classy_blocks as cb\nfrom classy_blocks.util import functions as "
  },
  {
    "path": "examples/complex/cyclone/README",
    "chars": 719,
    "preview": "An advanced example with optimization, custom shapes, sketches and regions.\nWork in progress, report bugs promptly!\n\nUsa"
  },
  {
    "path": "examples/complex/cyclone/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "examples/complex/cyclone/cyclone.py",
    "chars": 5594,
    "preview": "#!/usr/bin/env python\nimport os\n\nimport numpy as np\nimport parameters as params\nfrom geometry import geometry\nfrom regio"
  },
  {
    "path": "examples/complex/cyclone/geometry.py",
    "chars": 3827,
    "preview": "import dataclasses\n\nfrom parameters import (\n    D_BODY,\n    D_CONE,\n    D_INLET,\n    D_OUTLET,\n    DIM_SCALE,\n    L_BOD"
  },
  {
    "path": "examples/complex/cyclone/parameters.py",
    "chars": 760,
    "preview": "### Geometry\n# See docs/geometry.svg for a quick sketch\n\n# Diameter and length of inlet pipe [mm]\nD_INLET = 120\nL_INLET "
  },
  {
    "path": "examples/complex/cyclone/regions/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "examples/complex/cyclone/regions/body.py",
    "chars": 3516,
    "preview": "from collections.abc import Sequence\n\nimport parameters as params\nfrom geometry import geometry as geo\nfrom regions.regi"
  },
  {
    "path": "examples/complex/cyclone/regions/core.py",
    "chars": 4193,
    "preview": "from collections.abc import Sequence\nfrom typing import ClassVar\n\nimport numpy as np\nimport parameters as params\nfrom re"
  },
  {
    "path": "examples/complex/cyclone/regions/fillaround.py",
    "chars": 1827,
    "preview": "from regions.region import Region\n\nimport classy_blocks as cb\nfrom classy_blocks.util import functions as f\n\n\nclass Fill"
  },
  {
    "path": "examples/complex/cyclone/regions/inlet.py",
    "chars": 2964,
    "preview": "import numpy as np\nfrom regions.region import Region\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.point impo"
  },
  {
    "path": "examples/complex/cyclone/regions/inner_ring.py",
    "chars": 2133,
    "preview": "import numpy as np\nfrom regions.region import Region\n\nimport classy_blocks as cb\nfrom classy_blocks.util import function"
  },
  {
    "path": "examples/complex/cyclone/regions/pipe.py",
    "chars": 1669,
    "preview": "import numpy as np\nfrom regions.region import Region\n\nimport classy_blocks as cb\nfrom classy_blocks.cbtyping import NPPo"
  },
  {
    "path": "examples/complex/cyclone/regions/region.py",
    "chars": 2437,
    "preview": "import abc\n\nfrom geometry import geometry\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.operations.operation "
  },
  {
    "path": "examples/complex/cyclone/regions/skirt.py",
    "chars": 1145,
    "preview": "from regions.region import Region\n\nimport classy_blocks as cb\n\n\nclass Skirt(Region):\n    \"\"\"A region that connects inlet"
  },
  {
    "path": "examples/complex/gear/gear.py",
    "chars": 5919,
    "preview": "#!/usr/bin/env python\nimport os\nimport time\n\nimport numpy as np\nimport scipy.optimize\nfrom involute_gear import Involute"
  },
  {
    "path": "examples/complex/gear/involute_gear.py",
    "chars": 12129,
    "preview": "\"\"\"A copy of py_gear_gen (https://github.com/heartworm/py_gear_gen),\nslightly modified to fit in classy_blocks for the g"
  },
  {
    "path": "examples/complex/gear/tooth.py",
    "chars": 1613,
    "preview": "from typing import ClassVar\n\nimport classy_blocks as cb\n\n\nclass ToothSketch(cb.MappedSketch):\n    quads: ClassVar = [\n  "
  },
  {
    "path": "examples/complex/heater/heater.py",
    "chars": 4391,
    "preview": "import os\nfrom typing import List\n\nimport numpy as np\nimport parameters as p\n\nimport classy_blocks as cb\nfrom classy_blo"
  },
  {
    "path": "examples/complex/heater/parameters.py",
    "chars": 1022,
    "preview": "from classy_blocks.util import functions as f\n\n# geometry\nheater_diameter = 10\nheater_length = 50\nbend_radius = 3 * heat"
  },
  {
    "path": "examples/complex/karman.py",
    "chars": 2413,
    "preview": "import os\n\nimport classy_blocks as cb\n\ncylinder_diameter = 20e-3  # [m]\nring_thickness = 5e-3  # [m]\n\n# domain size\ndoma"
  },
  {
    "path": "examples/complex/plate/parameters.py",
    "chars": 252,
    "preview": "# plate properties\npl_thickness = 0.3\npl_length = 5\n\n# domain\ndm_upstream = 5\ndm_height = 5\nz = 1\n\n# cell sizing\ncell_si"
  },
  {
    "path": "examples/complex/plate/plate.py",
    "chars": 2068,
    "preview": "#!/usr/bin/env python\nimport os\n\nimport parameters as ps\n\nimport classy_blocks as cb\nfrom classy_blocks.util import func"
  },
  {
    "path": "examples/modification/move_vertex.py",
    "chars": 493,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\ncylinder = cb.Cylinder([0, 0, 0], [1, 0, 0], [0, 1, 0])\ncylinde"
  },
  {
    "path": "examples/operation/box.py",
    "chars": 600,
    "preview": "import os\n\nimport classy_blocks as cb\n\nbox = cb.Box([-1, -2, -4], [4, 2, 1])\n\n# direction of corners 0-1\nbox.chop(0, len"
  },
  {
    "path": "examples/operation/channel.py",
    "chars": 1380,
    "preview": "#!/usr/bin/env python\nimport os\n\nimport numpy as np\n\nimport classy_blocks as cb\n\n# A channel with a 90-degred bend, squa"
  },
  {
    "path": "examples/operation/connector.py",
    "chars": 527,
    "preview": "import os\n\nimport numpy as np\n\nimport classy_blocks as cb\n\nbox_1 = cb.Box([-1, -1, -1], [1, 1, 1])\nbox_2 = box_1.copy()."
  },
  {
    "path": "examples/operation/extrude.py",
    "chars": 837,
    "preview": "import os\n\nimport classy_blocks as cb\n\nbase = cb.Face([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]], [cb.Arc([0.5, -0.2, "
  },
  {
    "path": "examples/operation/loft.py",
    "chars": 1001,
    "preview": "import os\n\nimport classy_blocks as cb\n\n# Example geometry using Loft:\nbottom_face = cb.Face(\n    # 4 points for face cor"
  },
  {
    "path": "examples/operation/revolve.py",
    "chars": 515,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.util import functions as f\n\nbase = cb.Face([[0, 0, 0], [1, 0, 0"
  },
  {
    "path": "examples/operation/wedge.py",
    "chars": 1154,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\n# a face with a single bump;\nbase = cb.Face(\n    # points\n    ["
  },
  {
    "path": "examples/optimization/diffuser_free.py",
    "chars": 1639,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\nsize = 0.1\n\n# Create a rapidly expanding diffuser that will cau"
  },
  {
    "path": "examples/optimization/diffuser_line.py",
    "chars": 1285,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.util import functions as f\n\nmesh = cb.Mesh()\n\nsize = 0.1\n\n# The"
  },
  {
    "path": "examples/optimization/duct.py",
    "chars": 1077,
    "preview": "# An example where a Shape is optimized *before* it is added to mesh, using ShapeOptimizer\nimport os\n\nimport classy_bloc"
  },
  {
    "path": "examples/optimization/simple.py",
    "chars": 1056,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.optimize.clamps.free import FreeClamp\nfrom classy_blocks.optimi"
  },
  {
    "path": "examples/shape/custom.py",
    "chars": 2177,
    "preview": "import os\nfrom typing import ClassVar\n\nimport numpy as np\n\nimport classy_blocks as cb\nfrom classy_blocks.cbtyping import"
  },
  {
    "path": "examples/shape/cylinder.py",
    "chars": 880,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\naxis_point_1 = [0, 0, 0]\naxis_point_2 = [0, 0, 1]\nradius_point_"
  },
  {
    "path": "examples/shape/elbow.py",
    "chars": 813,
    "preview": "import os\n\nimport numpy as np\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\nradius_1 = 1\ncenter_point_1 = [0.0, 0.0, 0."
  },
  {
    "path": "examples/shape/extruded_ring.py",
    "chars": 843,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\npipe_wall = cb.ExtrudedRing(\n    [0, 0, 0],\n    [2, 2, 0],\n    "
  },
  {
    "path": "examples/shape/frustum.py",
    "chars": 1501,
    "preview": "import os\n\nimport numpy as np\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\naxis_point_1 = [0.0, 0.0, 0.0]\naxis_point_2"
  },
  {
    "path": "examples/shape/hemisphere.py",
    "chars": 629,
    "preview": "import os\n\nimport classy_blocks as cb\n\ncenter = [0.0, 0.0, 0.0]\nradius_point = [0.0, 0.0, 1.0]\nnormal = [0.0, 1.0, 0.0]\n"
  },
  {
    "path": "examples/shape/one_core_cylinder.py",
    "chars": 925,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.flat.sketches.disk import OneCoreDisk\nfrom classy_blo"
  },
  {
    "path": "examples/shape/quarter_cylinder.py",
    "chars": 906,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.flat.sketches.disk import QuarterDisk\nfrom classy_blo"
  },
  {
    "path": "examples/shape/revolved_ring.py",
    "chars": 1005,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\n# points that define ring cross-section;\n# must be specified in"
  },
  {
    "path": "examples/shape/shell.py",
    "chars": 936,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\n\n# Create a 7-block sphere by offsetting a box's faces.\nbox = c"
  },
  {
    "path": "examples/shape/splined/combined_example.py",
    "chars": 3725,
    "preview": "import os\n\nimport numpy as np\n\nimport classy_blocks as cb\n\ncenter_point = np.asarray([0, 0, 0])\ndirection = np.asarray(["
  },
  {
    "path": "examples/shape/splined/spline_ring.py",
    "chars": 377,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\n\nsketch = cb.SplineRing([0, 0, 0], [1, 0, 0], [0, 1.2, 0], 0.2,"
  },
  {
    "path": "examples/shape/splined/spline_ring_whole_half_quarter.py",
    "chars": 829,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\nquarter_ring_sketch = cb.QuarterSplineRing([0, 0, 0], [1.0, 0, "
  },
  {
    "path": "examples/shape/splined/spline_round.py",
    "chars": 764,
    "preview": "import os\nimport random\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.flat.sketches.spline_round import Splin"
  },
  {
    "path": "examples/shape/torus.py",
    "chars": 856,
    "preview": "import os\n\nimport numpy as np\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\n# A torus; a simple demonstration of copyin"
  },
  {
    "path": "examples/shape/wrapped_cylinder.py",
    "chars": 844,
    "preview": "import os\n\nimport classy_blocks as cb\nfrom classy_blocks.construct.flat.sketches.disk import WrappedDisk\n\n# A simpler ve"
  },
  {
    "path": "examples/stack/cube.py",
    "chars": 2527,
    "preview": "# a mesh for studying flow over a cube\nimport os\n\nimport classy_blocks as cb\n\n# cube side;\n# it sits in the coordinate s"
  },
  {
    "path": "examples/stack/fusilli.py",
    "chars": 911,
    "preview": "import os\n\nimport numpy as np\n\nimport classy_blocks as cb\nfrom classy_blocks.base.transforms import Rotation, Translatio"
  },
  {
    "path": "examples/transform/mirror.py",
    "chars": 924,
    "preview": "import os\n\nimport classy_blocks as cb\n\nmesh = cb.Mesh()\n\naxis_point_1 = [0.0, 0.0, 0.0]\naxis_point_2 = [2.0, 0.0, 0.0]\nr"
  },
  {
    "path": "pyproject.toml",
    "chars": 1209,
    "preview": "[project]\nname = \"classy_blocks\"\nversion = \"1.10.0\"\ndescription = \"Python classes for easier creation of openFoam's bloc"
  },
  {
    "path": "src/classy_blocks/__init__.py",
    "chars": 4222,
    "preview": "from .base.transforms import Mirror, Rotation, Scaling, Shear, Translation\nfrom .construct.assemblies.assembly import As"
  },
  {
    "path": "src/classy_blocks/assemble/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/assemble/assembler.py",
    "chars": 4841,
    "preview": "from classy_blocks.assemble.depot import Depot\nfrom classy_blocks.assemble.dump import AssembledDump\nfrom classy_blocks."
  },
  {
    "path": "src/classy_blocks/assemble/depot.py",
    "chars": 1016,
    "preview": "from typing import Union\n\nfrom classy_blocks.construct.assemblies.assembly import Assembly\nfrom classy_blocks.construct."
  },
  {
    "path": "src/classy_blocks/assemble/dump.py",
    "chars": 2372,
    "preview": "import abc\n\nfrom classy_blocks.base.exceptions import MeshNotAssembledError\nfrom classy_blocks.items.block import Block\n"
  },
  {
    "path": "src/classy_blocks/assemble/settings.py",
    "chars": 1236,
    "preview": "from dataclasses import dataclass, field\nfrom typing import Optional\n\nfrom classy_blocks.cbtyping import GeometryType\n\n\n"
  },
  {
    "path": "src/classy_blocks/base/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/base/element.py",
    "chars": 4547,
    "preview": "import abc\nimport copy\nfrom collections.abc import Sequence\nfrom typing import Optional, TypeVar\n\nfrom classy_blocks.bas"
  },
  {
    "path": "src/classy_blocks/base/exceptions.py",
    "chars": 3336,
    "preview": "from typing import Optional\n\n\n### Construction\nclass ShapeCreationError(Exception):\n    \"\"\"Base class for shape creation"
  },
  {
    "path": "src/classy_blocks/base/transforms.py",
    "chars": 1248,
    "preview": "\"\"\"Dataclasses for packing combinations of transforms of <anything>\ninto an easily digestable function/method arguments\""
  },
  {
    "path": "src/classy_blocks/cbtyping.py",
    "chars": 2015,
    "preview": "from collections.abc import Sequence\nfrom typing import Any, Callable, Literal, Optional, TypedDict, Union\n\nfrom nptypin"
  },
  {
    "path": "src/classy_blocks/construct/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/construct/assemblies/assembly.py",
    "chars": 726,
    "preview": "import abc\nfrom collections.abc import Sequence\n\nimport numpy as np\n\nfrom classy_blocks.base.element import ElementBase\n"
  },
  {
    "path": "src/classy_blocks/construct/assemblies/joints.py",
    "chars": 5626,
    "preview": "import abc\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import FloatListType, PointType\nfrom classy_blocks.construct"
  },
  {
    "path": "src/classy_blocks/construct/curves/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/construct/curves/analytic.py",
    "chars": 2950,
    "preview": "from typing import Optional\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import NPVectorType, ParamCurveFuncType, Po"
  },
  {
    "path": "src/classy_blocks/construct/curves/curve.py",
    "chars": 6051,
    "preview": "import abc\nimport warnings\nfrom typing import Optional, Union\n\nimport numpy as np\nimport scipy.optimize\n\nfrom classy_blo"
  },
  {
    "path": "src/classy_blocks/construct/curves/discrete.py",
    "chars": 2630,
    "preview": "import warnings\nfrom typing import Optional\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import NPPointListType, NPP"
  },
  {
    "path": "src/classy_blocks/construct/curves/interpolated.py",
    "chars": 2615,
    "preview": "import abc\nfrom typing import Optional\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import PointListType\nfrom classy"
  },
  {
    "path": "src/classy_blocks/construct/curves/interpolators.py",
    "chars": 2543,
    "preview": "import abc\n\nimport numpy as np\nimport scipy.interpolate\n\nfrom classy_blocks.cbtyping import FloatListType, NPPointType, "
  },
  {
    "path": "src/classy_blocks/construct/edges.py",
    "chars": 5710,
    "preview": "import warnings\n\nfrom classy_blocks.base.element import ElementBase\nfrom classy_blocks.base.exceptions import EdgeCreati"
  },
  {
    "path": "src/classy_blocks/construct/flat/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/construct/flat/face.py",
    "chars": 7145,
    "preview": "import collections\nimport copy\nfrom typing import Optional, Union\n\nimport numpy as np\n\nfrom classy_blocks.base.element i"
  },
  {
    "path": "src/classy_blocks/construct/flat/sketch.py",
    "chars": 1601,
    "preview": "import abc\nimport copy\nfrom typing import ClassVar, TypeVar\n\nfrom classy_blocks.base.element import ElementBase\nfrom cla"
  },
  {
    "path": "src/classy_blocks/construct/flat/sketches/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/construct/flat/sketches/annulus.py",
    "chars": 3933,
    "preview": "import numpy as np\n\nfrom classy_blocks.base.exceptions import AnnulusCreationError\nfrom classy_blocks.cbtyping import NP"
  },
  {
    "path": "src/classy_blocks/construct/flat/sketches/disk.py",
    "chars": 14703,
    "preview": "import abc\nfrom typing import ClassVar, Optional\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import (\n    IndexType"
  },
  {
    "path": "src/classy_blocks/construct/flat/sketches/grid.py",
    "chars": 1756,
    "preview": "import numpy as np\n\nfrom classy_blocks.cbtyping import PointType\nfrom classy_blocks.construct.flat.face import Face\nfrom"
  },
  {
    "path": "src/classy_blocks/construct/flat/sketches/mapped.py",
    "chars": 4031,
    "preview": "import warnings\nfrom typing import Union\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import IndexType, NPPointListT"
  },
  {
    "path": "src/classy_blocks/construct/flat/sketches/spline_round.py",
    "chars": 31767,
    "preview": "from typing import ClassVar, Optional\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import NPPointListType, NPPointTy"
  },
  {
    "path": "src/classy_blocks/construct/operations/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/construct/operations/box.py",
    "chars": 1743,
    "preview": "import numpy as np\n\nfrom classy_blocks.cbtyping import PointType\nfrom classy_blocks.construct.flat.face import Face\nfrom"
  },
  {
    "path": "src/classy_blocks/construct/operations/connector.py",
    "chars": 3146,
    "preview": "import numpy as np\n\nfrom classy_blocks.construct.flat.face import Face\nfrom classy_blocks.construct.operations.operation"
  },
  {
    "path": "src/classy_blocks/construct/operations/extrude.py",
    "chars": 728,
    "preview": "from typing import Union\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import VectorType\nfrom classy_blocks.construct"
  },
  {
    "path": "src/classy_blocks/construct/operations/loft.py",
    "chars": 266,
    "preview": "from classy_blocks.construct.operations.operation import Operation\n\n# since any possible block shape can be created with"
  },
  {
    "path": "src/classy_blocks/construct/operations/operation.py",
    "chars": 16120,
    "preview": "import warnings\nfrom typing import Optional, Union, get_args\n\nimport numpy as np\nfrom typing_extensions import Unpack\n\nf"
  },
  {
    "path": "src/classy_blocks/construct/operations/revolve.py",
    "chars": 953,
    "preview": "from classy_blocks.cbtyping import VectorType\nfrom classy_blocks.construct import edges\nfrom classy_blocks.construct.fla"
  },
  {
    "path": "src/classy_blocks/construct/operations/wedge.py",
    "chars": 2098,
    "preview": "from typing import Optional\n\nfrom classy_blocks.construct.flat.face import Face\nfrom classy_blocks.construct.operations."
  },
  {
    "path": "src/classy_blocks/construct/point.py",
    "chars": 3771,
    "preview": "from typing import Optional, TypeVar\n\nimport numpy as np\n\nfrom classy_blocks.base.element import ElementBase\nfrom classy"
  },
  {
    "path": "src/classy_blocks/construct/series.py",
    "chars": 2690,
    "preview": "from typing import Optional\n\nimport numpy as np\n\nfrom classy_blocks.base.element import ElementBase\nfrom classy_blocks.b"
  },
  {
    "path": "src/classy_blocks/construct/shape.py",
    "chars": 5059,
    "preview": "\"\"\"Abstract base classes for different Shape types\"\"\"\n\nimport abc\nfrom typing import Generic, Optional, TypeVar, Union\n\n"
  },
  {
    "path": "src/classy_blocks/construct/shapes/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/construct/shapes/cylinder.py",
    "chars": 4847,
    "preview": "from typing import ClassVar, Union\n\nimport numpy as np\n\nfrom classy_blocks.base import transforms as tr\nfrom classy_bloc"
  },
  {
    "path": "src/classy_blocks/construct/shapes/elbow.py",
    "chars": 2114,
    "preview": "import numpy as np\n\nfrom classy_blocks.base import transforms as tr\nfrom classy_blocks.base.exceptions import ElbowCreat"
  },
  {
    "path": "src/classy_blocks/construct/shapes/frustum.py",
    "chars": 2993,
    "preview": "from typing import Optional\n\nimport numpy as np\n\nfrom classy_blocks.base import transforms as tr\nfrom classy_blocks.base"
  },
  {
    "path": "src/classy_blocks/construct/shapes/rings.py",
    "chars": 5995,
    "preview": "from typing import Union\n\nimport numpy as np\n\nfrom classy_blocks.base import transforms as tr\nfrom classy_blocks.base.ex"
  },
  {
    "path": "src/classy_blocks/construct/shapes/round.py",
    "chars": 4469,
    "preview": "from collections.abc import Sequence\nfrom typing import Optional\n\nfrom classy_blocks.base import transforms as tr\nfrom c"
  },
  {
    "path": "src/classy_blocks/construct/shapes/shell.py",
    "chars": 6311,
    "preview": "import functools\n\nimport numpy as np\n\nfrom classy_blocks.base.exceptions import DisconnectedChopError, PointNotCoinciden"
  },
  {
    "path": "src/classy_blocks/construct/shapes/sphere.py",
    "chars": 6998,
    "preview": "import numpy as np\n\nfrom classy_blocks.cbtyping import NPPointType, NPVectorType, PointType, VectorType\nfrom classy_bloc"
  },
  {
    "path": "src/classy_blocks/construct/stack.py",
    "chars": 4564,
    "preview": "from collections.abc import Sequence\nfrom typing import Optional, Union\n\nimport numpy as np\n\nfrom classy_blocks.base imp"
  },
  {
    "path": "src/classy_blocks/grading/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/grading/analyze/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/grading/analyze/catalogue.py",
    "chars": 3173,
    "preview": "import functools\nfrom typing import get_args\n\nfrom classy_blocks.base.exceptions import BlockNotFoundError, NoInstructio"
  },
  {
    "path": "src/classy_blocks/grading/analyze/probe.py",
    "chars": 5859,
    "preview": "import dataclasses\nfrom typing import Optional\n\nfrom classy_blocks.assemble.dump import AssembledDump\nfrom classy_blocks"
  },
  {
    "path": "src/classy_blocks/grading/analyze/row.py",
    "chars": 3254,
    "preview": "import dataclasses\n\nfrom classy_blocks.base.exceptions import InconsistentGradingsError\nfrom classy_blocks.cbtyping impo"
  },
  {
    "path": "src/classy_blocks/grading/define/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/grading/define/chop.py",
    "chars": 4909,
    "preview": "import dataclasses\nfrom functools import lru_cache\nfrom typing import Callable, Optional, Union\n\nfrom classy_blocks.cbty"
  },
  {
    "path": "src/classy_blocks/grading/define/collector.py",
    "chars": 1147,
    "preview": "from classy_blocks.cbtyping import DirectionType\nfrom classy_blocks.grading.define.chop import Chop\nfrom classy_blocks.u"
  },
  {
    "path": "src/classy_blocks/grading/define/grading.py",
    "chars": 8793,
    "preview": "\"\"\"In theory, combination of three of these 6 values can be specified:\n - Total length\n - Number of cells\n - Total expan"
  },
  {
    "path": "src/classy_blocks/grading/define/relations.py",
    "chars": 9078,
    "preview": "import inspect\nimport sys\nfrom typing import Callable\n\nimport numpy as np\nimport scipy.optimize\n\nfrom classy_blocks.util"
  },
  {
    "path": "src/classy_blocks/grading/graders/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/grading/graders/auto.py",
    "chars": 512,
    "preview": "import abc\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import ChopTakeType\nfrom classy_blocks.grading.analyze.row i"
  },
  {
    "path": "src/classy_blocks/grading/graders/fixed.py",
    "chars": 1186,
    "preview": "from classy_blocks.assemble.dump import AssembledDump\nfrom classy_blocks.cbtyping import DirectionType\nfrom classy_block"
  },
  {
    "path": "src/classy_blocks/grading/graders/inflation.py",
    "chars": 12099,
    "preview": "import abc\nimport copy\nimport dataclasses\nfrom typing import Union\n\nfrom classy_blocks.assemble.dump import AssembledDum"
  },
  {
    "path": "src/classy_blocks/grading/graders/manager.py",
    "chars": 11653,
    "preview": "from typing import get_args\n\nfrom classy_blocks.assemble.dump import AssembledDump\nfrom classy_blocks.assemble.settings "
  },
  {
    "path": "src/classy_blocks/grading/graders/simple.py",
    "chars": 1078,
    "preview": "from classy_blocks.assemble.dump import AssembledDump\nfrom classy_blocks.cbtyping import ChopTakeType\nfrom classy_blocks"
  },
  {
    "path": "src/classy_blocks/items/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/items/block.py",
    "chars": 4189,
    "preview": "from typing import get_args\n\nfrom classy_blocks.cbtyping import DirectionType, IndexType, OrientType\nfrom classy_blocks."
  },
  {
    "path": "src/classy_blocks/items/edges/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/items/edges/arcs/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/items/edges/arcs/angle.py",
    "chars": 2351,
    "preview": "import dataclasses\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import PointType, VectorType\nfrom classy_blocks.cons"
  },
  {
    "path": "src/classy_blocks/items/edges/arcs/arc.py",
    "chars": 319,
    "preview": "import dataclasses\n\nfrom classy_blocks.construct import edges\nfrom classy_blocks.items.edges.arcs.arc_base import ArcEdg"
  },
  {
    "path": "src/classy_blocks/items/edges/arcs/arc_base.py",
    "chars": 1722,
    "preview": "import abc\nimport dataclasses\n\nimport numpy as np\n\nfrom classy_blocks.construct.point import Point\nfrom classy_blocks.it"
  },
  {
    "path": "src/classy_blocks/items/edges/arcs/origin.py",
    "chars": 3793,
    "preview": "import dataclasses\nimport warnings\nfrom typing import ClassVar\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import N"
  },
  {
    "path": "src/classy_blocks/items/edges/curve.py",
    "chars": 2379,
    "preview": "import abc\nimport dataclasses\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import EdgeKindType, NPPointListType\nfrom"
  },
  {
    "path": "src/classy_blocks/items/edges/edge.py",
    "chars": 2543,
    "preview": "import abc\nimport dataclasses\nimport warnings\n\nfrom classy_blocks.base.element import ElementBase\nfrom classy_blocks.bas"
  },
  {
    "path": "src/classy_blocks/items/edges/factory.py",
    "chars": 1463,
    "preview": "from classy_blocks.cbtyping import EdgeKindType\nfrom classy_blocks.construct.edges import EdgeData\nfrom classy_blocks.it"
  },
  {
    "path": "src/classy_blocks/items/edges/line.py",
    "chars": 525,
    "preview": "import dataclasses\n\nfrom classy_blocks.construct import edges\nfrom classy_blocks.items.edges.edge import Edge\n\n\n@datacla"
  },
  {
    "path": "src/classy_blocks/items/edges/project.py",
    "chars": 494,
    "preview": "import dataclasses\n\nfrom classy_blocks.construct import edges\nfrom classy_blocks.items.edges.edge import Edge\n\n\n@datacla"
  },
  {
    "path": "src/classy_blocks/items/patch.py",
    "chars": 647,
    "preview": "import warnings\n\nfrom classy_blocks.items.side import Side\n\n\nclass Patch:\n    \"\"\"Definition of a patch, including type, "
  },
  {
    "path": "src/classy_blocks/items/side.py",
    "chars": 914,
    "preview": "from classy_blocks.base.exceptions import SideCreationError\nfrom classy_blocks.cbtyping import OrientType\nfrom classy_bl"
  },
  {
    "path": "src/classy_blocks/items/vertex.py",
    "chars": 1183,
    "preview": "\"\"\"Defines a numbered vertex in 3D space and all operations\nthat can be applied to it.\"\"\"\n\nfrom classy_blocks.cbtyping i"
  },
  {
    "path": "src/classy_blocks/items/wires/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/items/wires/axis.py",
    "chars": 3329,
    "preview": "from classy_blocks.cbtyping import DirectionType\nfrom classy_blocks.items.vertex import Vertex\nfrom classy_blocks.items."
  },
  {
    "path": "src/classy_blocks/items/wires/manager.py",
    "chars": 1263,
    "preview": "\nfrom classy_blocks.items.wires.wire import Wire\n\n\nclass WireManager:\n    def __init__(self, wires: list[Wire]):\n       "
  },
  {
    "path": "src/classy_blocks/items/wires/wire.py",
    "chars": 3963,
    "preview": "import dataclasses\nimport functools\n\nfrom classy_blocks.cbtyping import DirectionType\nfrom classy_blocks.construct.edges"
  },
  {
    "path": "src/classy_blocks/lists/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/lists/block_list.py",
    "chars": 742,
    "preview": "from classy_blocks.items.block import Block\nfrom classy_blocks.lookup.point_registry import HexPointRegistry\n\n\nclass Blo"
  },
  {
    "path": "src/classy_blocks/lists/edge_list.py",
    "chars": 2084,
    "preview": "from classy_blocks.base.exceptions import EdgeNotFoundError\nfrom classy_blocks.construct.edges import EdgeData\nfrom clas"
  },
  {
    "path": "src/classy_blocks/lists/face_list.py",
    "chars": 1902,
    "preview": "import dataclasses\n\nfrom classy_blocks.cbtyping import OrientType\nfrom classy_blocks.construct.flat.face import Face\nfro"
  },
  {
    "path": "src/classy_blocks/lists/patch_list.py",
    "chars": 2073,
    "preview": "from collections import OrderedDict\nfrom typing import Optional\n\nfrom classy_blocks.base.exceptions import PatchNotFound"
  },
  {
    "path": "src/classy_blocks/lists/vertex_list.py",
    "chars": 2525,
    "preview": "from classy_blocks.base.exceptions import VertexNotFoundError\nfrom classy_blocks.cbtyping import NPPointType\nfrom classy"
  },
  {
    "path": "src/classy_blocks/lookup/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/lookup/cell_registry.py",
    "chars": 753,
    "preview": "from classy_blocks.cbtyping import IndexType\nfrom classy_blocks.util import functions as f\n\n\nclass CellRegistry:\n    # W"
  },
  {
    "path": "src/classy_blocks/lookup/connection_registry.py",
    "chars": 2052,
    "preview": "from typing import ClassVar\n\nfrom classy_blocks.cbtyping import IndexType, NPPointListType\nfrom classy_blocks.util.const"
  },
  {
    "path": "src/classy_blocks/lookup/face_registry.py",
    "chars": 1684,
    "preview": "import abc\nfrom typing import ClassVar\n\nfrom classy_blocks.cbtyping import IndexType, OrientType\nfrom classy_blocks.opti"
  },
  {
    "path": "src/classy_blocks/lookup/point_registry.py",
    "chars": 5668,
    "preview": "from typing import TypeVar\n\nimport numpy as np\nimport scipy.spatial\n\nfrom classy_blocks.base.exceptions import VertexNot"
  },
  {
    "path": "src/classy_blocks/mesh.py",
    "chars": 6888,
    "preview": "from typing import Optional, Union\n\nfrom classy_blocks.assemble.assembler import MeshAssembler\nfrom classy_blocks.assemb"
  },
  {
    "path": "src/classy_blocks/modify/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/modify/find/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/modify/find/finder.py",
    "chars": 1007,
    "preview": "from typing import Optional\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import PointType\nfrom classy_blocks.items.v"
  },
  {
    "path": "src/classy_blocks/modify/find/geometric.py",
    "chars": 1753,
    "preview": "from typing import Optional\n\nfrom classy_blocks.cbtyping import PointType, VectorType\nfrom classy_blocks.items.vertex im"
  },
  {
    "path": "src/classy_blocks/modify/find/shape.py",
    "chars": 1901,
    "preview": "from classy_blocks.construct.flat.face import Face\nfrom classy_blocks.construct.flat.sketches.disk import Disk\nfrom clas"
  },
  {
    "path": "src/classy_blocks/modify/reorient/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/modify/reorient/viewpoint.py",
    "chars": 7243,
    "preview": "import numpy as np\nfrom scipy.spatial import ConvexHull\n\nfrom classy_blocks.base.exceptions import DegenerateGeometryErr"
  },
  {
    "path": "src/classy_blocks/optimize/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/optimize/cell.py",
    "chars": 3315,
    "preview": "import abc\nfrom typing import ClassVar, Optional\n\nfrom classy_blocks.base.exceptions import NoCommonSidesError\nfrom clas"
  },
  {
    "path": "src/classy_blocks/optimize/clamps/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "src/classy_blocks/optimize/clamps/clamp.py",
    "chars": 1428,
    "preview": "import abc\nfrom typing import Callable, Optional\n\nimport numpy as np\nimport scipy.optimize\n\nfrom classy_blocks.cbtyping "
  },
  {
    "path": "src/classy_blocks/optimize/clamps/curve.py",
    "chars": 3341,
    "preview": "from typing import Optional\n\nimport numpy as np\n\nfrom classy_blocks.cbtyping import PointType, VectorType\nfrom classy_bl"
  },
  {
    "path": "src/classy_blocks/optimize/clamps/free.py",
    "chars": 503,
    "preview": "import numpy as np\n\nfrom classy_blocks.cbtyping import PointType\nfrom classy_blocks.optimize.clamps.clamp import ClampBa"
  },
  {
    "path": "src/classy_blocks/optimize/clamps/surface.py",
    "chars": 1595,
    "preview": "import numpy as np\n\nfrom classy_blocks.cbtyping import NPPointType, PointType, VectorType\nfrom classy_blocks.optimize.cl"
  }
]

// ... and 94 more files (download for full content)