ScadPy 0.1.0__py3-none-any.whl

scadpy/__init__.py

@@ -0,0 +1,5 @@
+from .color import *  # noqa: F403
+from .core import *  # noqa: F403
+from .d2 import *  # noqa: F403
+from .d3 import *  # noqa: F403
+from .utils import *  # noqa: F403

scadpy/color/__init__.py

@@ -0,0 +1,3 @@
+from .constants import *
+from .type import *
+from .utils import *

scadpy/color/constants/BEIGE.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+BEIGE = [0.96, 0.96, 0.86, DEFAULT_OPACITY]

scadpy/color/constants/BLACK.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+BLACK = [0.05, 0.05, 0.05, DEFAULT_OPACITY]

scadpy/color/constants/BLUE.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+BLUE = [0.1, 0.3, 0.9, DEFAULT_OPACITY]

scadpy/color/constants/BROWN.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+BROWN = [0.65, 0.32, 0.17, DEFAULT_OPACITY]

scadpy/color/constants/DARK_GRAY.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+DARK_GRAY = [0.25, 0.25, 0.25, DEFAULT_OPACITY]

scadpy/color/constants/DEFAULT_COLOR.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.GRAY import GRAY
+
+DEFAULT_COLOR = GRAY

scadpy/color/constants/DEFAULT_OPACITY.py

@@ -0,0 +1 @@
+DEFAULT_OPACITY = 1

scadpy/color/constants/GRAY.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+GRAY = [0.5, 0.5, 0.5, DEFAULT_OPACITY]

scadpy/color/constants/GREEN.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+GREEN = [0.1, 0.9, 0.1, DEFAULT_OPACITY]

scadpy/color/constants/ORANGE.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+ORANGE = [1.0, 0.55, 0.0, DEFAULT_OPACITY]

scadpy/color/constants/RED.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+RED = [0.9, 0.1, 0.1, DEFAULT_OPACITY]

scadpy/color/constants/WHITE.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+WHITE = [0.95, 0.95, 0.95, DEFAULT_OPACITY]

scadpy/color/constants/YELLOW.py

@@ -0,0 +1,3 @@
+from scadpy.color.constants.DEFAULT_OPACITY import DEFAULT_OPACITY
+
+YELLOW = [0.95, 0.95, 0.1, DEFAULT_OPACITY]

scadpy/color/constants/__init__.py

@@ -0,0 +1,29 @@
+__all__ = [
+    "BEIGE",
+    "BLACK",
+    "BLUE",
+    "BROWN",
+    "DEFAULT_COLOR",
+    "DEFAULT_OPACITY",
+    "DARK_GRAY",
+    "GRAY",
+    "GREEN",
+    "ORANGE",
+    "RED",
+    "WHITE",
+    "YELLOW",
+]
+
+from .BEIGE import BEIGE
+from .BLACK import BLACK
+from .BLUE import BLUE
+from .BROWN import BROWN
+from .DEFAULT_COLOR import DEFAULT_COLOR
+from .DARK_GRAY import DARK_GRAY
+from .DEFAULT_OPACITY import DEFAULT_OPACITY
+from .GRAY import GRAY
+from .GREEN import GREEN
+from .ORANGE import ORANGE
+from .RED import RED
+from .WHITE import WHITE
+from .YELLOW import YELLOW

scadpy/color/type/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["Color"]
+
+from .color import Color

scadpy/color/type/color.py

@@ -0,0 +1,3 @@
+from collections.abc import Sequence
+
+Color = Sequence[float]

scadpy/color/utils/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["get_random_color"]
+
+from .get_random_color import get_random_color

scadpy/color/utils/get_random_color.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import random
+from typing import TYPE_CHECKING, cast
+
+from typeguard import typechecked
+
+if TYPE_CHECKING:
+    from scadpy.color import Color
+
+
+@typechecked
+def get_random_color() -> Color:
+    from scadpy import color
+
+    color_names: list[str] = getattr(color.constants, "__all__", [])
+    color_names = [
+        c for c in color_names if c != "DEFAULT_OPACITY" and c != "DEFAULT_COLOR"
+    ]
+
+    if not color_names:
+        raise ValueError("No color constant found.")
+
+    name = random.choice(color_names)
+    color_value = cast(color.Color, getattr(color.constants, name))
+
+    if not isinstance(color_value, (list, tuple)):
+        raise TypeError(f"{name} is not a list or tuple.")
+
+    if len(color_value) != 4:
+        raise TypeError(f"{name} must be RGBA (4 values), got {len(color_value)}.")
+
+    if not all(0.0 <= c <= 1.0 for c in color_value):
+        raise ValueError(f"{name} has values outside [0.0, 1.0] range.")
+
+    return color_value

scadpy/core/__init__.py

@@ -0,0 +1,3 @@
+from .assembly import *  # noqa: F403
+from .component import *  # noqa: F403
+from .part import *  # noqa: F403

scadpy/core/assembly/__init__.py

@@ -0,0 +1,5 @@
+from .combinations import *  # noqa: F403
+from .topologies import *  # noqa: F403
+from .transformations import *  # noqa: F403
+from .types import *  # noqa: F403
+from .utils import *  # noqa: F403

scadpy/core/assembly/combinations/__init__.py

@@ -0,0 +1,13 @@
+__all__ = [
+    "concat_assemblies",
+    "exclude_assemblies",
+    "intersect_assemblies",
+    "subtract_assemblies",
+    "unify_assemblies",
+]
+
+from .concat_assemblies import concat_assemblies
+from .exclude_assemblies import exclude_assemblies
+from .intersect_assemblies import intersect_assemblies
+from .subtract_assemblies import subtract_assemblies
+from .unify_assemblies import unify_assemblies

scadpy/core/assembly/combinations/concat_assemblies.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+
+from typeguard import typechecked
+
+
+@typechecked
+def concat_assemblies[A, P](
+    assemblies: Iterable[A],
+    get_assembly_parts: Callable[[A], Iterable[P]],
+    concat_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Combine multiple assemblies into a single assembly by concatenating all their parts.
+
+    This function uses dependency injection to remain type-agnostic, allowing it
+    to work with any assembly/part domain model by providing appropriate accessor
+    and concatenation functions.
+
+    Parameters
+    ----------
+    assemblies : Iterable[A]
+        Iterable of assembly objects to be combined.
+    get_assembly_parts : Callable[[A], Iterable[P]]
+        Function that extracts parts from an assembly.
+    concat_parts : Callable[[Sequence[P]], A]
+        Function that combines a sequence of parts into a new assembly.
+
+    Returns
+    -------
+    A
+        The assembly object created by combining all parts from all input assemblies.
+
+    Examples
+    --------
+    >>> from scadpy import concat_assemblies
+    >>> assemblies = [
+    ...     ['a', 'b'],
+    ...     ['c'],
+    ...     []
+    ... ]
+    >>> concat_assemblies(
+    ...     assemblies,
+    ...     get_assembly_parts=lambda a: a,
+    ...     concat_parts=lambda parts: ''.join(parts)
+    ... )
+    'abc'
+    """
+    return concat_parts([p for a in assemblies for p in get_assembly_parts(a)])

scadpy/core/assembly/combinations/exclude_assemblies.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def exclude_assemblies[A, P](
+    assemblies: Sequence[A],
+    get_assembly_parts: Callable[[A], Iterable[P]],
+    get_part_bounds: Callable[[P], NDArray[np.float64]],
+    are_parts_intersecting: Callable[[P, P], bool],
+    subtract_parts: Callable[[P, P], A],
+    intersect_parts: Callable[[Sequence[P]], A],
+    unify_parts: Callable[[Sequence[P]], A],
+    concat_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Compute the symmetric difference (exclusive-or) of multiple assemblies.
+
+    This function is fully generic and uses dependency injection for all domain-specific
+    operations, making it suitable for a wide range of applications (2D, 3D, CAD, etc.).
+    The result contains all parts that are present in exactly one assembly, i.e., the union minus all intersections.
+
+    Parameters
+    ----------
+    assemblies : Sequence[A]
+        Sequence of assembly objects to process.
+    get_assembly_parts : Callable[[A], Iterable[P]]
+        Function that extracts parts from an assembly.
+    get_part_bounds : Callable[[P], NDArray[np.float64]]
+        Function to extract the bounding box of a part.
+    are_parts_intersecting : Callable[[P, P], bool]
+        Function to determine if two parts intersect.
+    subtract_parts : Callable[[P, P], A]
+        Function to subtract one part from another, returning an assembly.
+    intersect_parts : Callable[[Sequence[P]], A]
+        Function to compute the intersection of a group of parts.
+    unify_parts : Callable[[Sequence[P]], A]
+        Function to unify (union) overlapping parts within an assembly.
+    concat_parts : Callable[[Sequence[P]], A]
+        Function to concatenate a sequence of parts into a new assembly.
+
+    Returns
+    -------
+    A
+        The assembly object containing the symmetric difference of all input assemblies.
+
+    Examples
+    --------
+    >>> from scadpy import exclude_assemblies
+
+    >>> assemblies = [
+    ...     [{'bounds': [0, 0, 2, 2]}],
+    ...     [{'bounds': [1, 1, 3, 3]}, {'bounds': [5, 5, 6, 6]}]
+    ... ]
+    ...
+    >>> def are_intersecting(p1, p2):
+    ...     b1, b2 = p1['bounds'], p2['bounds']
+    ...     return not (b1[2] <= b2[0] or b2[2] <= b1[0] or
+    ...                 b1[3] <= b2[1] or b2[3] <= b1[1])
+    ...
+    >>> def subtract_geometries(g1, g2):
+    ...     if (g2[0] > g1[0] and g2[2] < g1[2]
+    ...             and g2[1] > g1[1] and g2[3] < g1[3]):
+    ...         return [
+    ...             [g1[0], g1[1], g2[0], g1[3]],  # left
+    ...             [g2[2], g1[1], g1[2], g1[3]],  # right
+    ...             [g2[0], g1[1], g2[2], g2[1]],  # bottom
+    ...             [g2[0], g2[3], g2[2], g1[3]],  # top
+    ...         ]
+    ...     return [g1]
+    ...
+    >>> def subtract_parts(p1, p2):
+    ...     geometries = subtract_geometries(
+    ...         p1['bounds'], p2['bounds']
+    ...     )
+    ...     return [{'bounds': g} for g in geometries]
+    ...
+    >>> result = exclude_assemblies(
+    ...     assemblies,
+    ...     get_assembly_parts=lambda a: a,
+    ...     get_part_bounds=lambda p: p['bounds'],
+    ...     are_parts_intersecting=are_intersecting,
+    ...     subtract_parts=subtract_parts,
+    ...     intersect_parts= lambda parts: parts,
+    ...     unify_parts= lambda parts: parts,
+    ...     concat_parts= lambda parts: parts
+    ... )
+    >>> result == [
+    ...     {'bounds': [0, 0, 2, 2]},
+    ...     {'bounds': [1, 1, 3, 3]},
+    ...     {'bounds': [5, 5, 6, 6]}
+    ... ]
+    True
+    """
+    from scadpy.core.assembly import subtract_assemblies, unify_assemblies
+
+    if len(assemblies) == 0:
+        return concat_parts([])
+
+    result = assemblies[0]
+    for assembly in assemblies[1:]:
+        result = unify_assemblies(
+            assemblies=[
+                subtract_assemblies(
+                    to_be_subtracted=result,
+                    to_subtract=assembly,
+                    get_assembly_parts=get_assembly_parts,
+                    get_part_bounds=get_part_bounds,
+                    are_parts_intersecting=are_parts_intersecting,
+                    subtract_parts=subtract_parts,
+                    intersect_parts=intersect_parts,
+                    unify_parts=unify_parts,
+                    concat_parts=concat_parts,
+                ),
+                subtract_assemblies(
+                    to_be_subtracted=assembly,
+                    to_subtract=result,
+                    get_assembly_parts=get_assembly_parts,
+                    get_part_bounds=get_part_bounds,
+                    are_parts_intersecting=are_parts_intersecting,
+                    subtract_parts=subtract_parts,
+                    intersect_parts=intersect_parts,
+                    unify_parts=unify_parts,
+                    concat_parts=concat_parts,
+                ),
+            ],
+            get_assembly_parts=get_assembly_parts,
+            unify_parts=unify_parts,
+        )
+    return result

scadpy/core/assembly/combinations/intersect_assemblies.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def intersect_assemblies[A, P](
+    assemblies: Sequence[A],
+    get_assembly_parts: Callable[[A], Iterable[P]],
+    get_part_bounds: Callable[[P], NDArray[np.float64]],
+    are_parts_intersecting: Callable[[P, P], bool],
+    intersect_parts: Callable[[Sequence[P]], A],
+    unify_parts: Callable[[Sequence[P]], A],
+    concat_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Compute the intersection of multiple assemblies, keeping only intersections that involve at least one part from each assembly.
+
+    This function is fully generic and uses dependency injection for all domain-specific
+    operations, making it suitable for a wide range of applications (2D, 3D, CAD, etc.).
+    Only groups of parts that include at least one part from each input assembly are intersected and included in the result.
+
+    Parameters
+    ----------
+    assemblies : Sequence[A]
+        Sequence of assembly objects to intersect.
+    get_assembly_parts : Callable[[A], Iterable[P]]
+        Function that extracts parts from an assembly.
+    get_part_bounds : Callable[[P], NDArray[np.float64]]
+        Function to extract the bounding box of a part.
+    are_parts_intersecting : Callable[[P, P], bool]
+        Function to determine if two parts intersect.
+    intersect_parts : Callable[[Sequence[P]], A]
+        Function to compute the intersection of a group of parts.
+    unify_parts : Callable[[Sequence[P]], A]
+        Function to unify (union) overlapping parts within an assembly.
+    concat_parts : Callable[[Sequence[P]], A]
+        Function to concatenate a sequence of parts into a new assembly.
+
+    Returns
+    -------
+    A
+        The assembly object containing all intersections involving at least one part from each input assembly.
+
+    Examples
+    --------
+    >>> from scadpy import intersect_assemblies
+
+    >>> assemblies = [
+    ...     [{'bounds': [0, 0, 2, 2]}],
+    ...     [{'bounds': [1, 1, 3, 3]}, {'bounds': [5, 5, 6, 6]}]
+    ... ]
+    ...
+    >>> def are_intersecting(p1, p2):
+    ...     b1, b2 = p1['bounds'], p2['bounds']
+    ...     return not (b1[2] <= b2[0] or b2[2] <= b1[0] or
+    ...                 b1[3] <= b2[1] or b2[3] <= b1[1])
+    ...
+    >>> def intersect_geometries(geometries):
+    ...     if len(geometries) == 1:
+    ...         return [geometries[0]]
+    ...     minx = max(g[0] for g in geometries)
+    ...     miny = max(g[1] for g in geometries)
+    ...     maxx = min(g[2] for g in geometries)
+    ...     maxy = min(g[3] for g in geometries)
+    ...     if minx < maxx and miny < maxy:
+    ...         return [[minx, miny, maxx, maxy]]
+    ...     return []
+    ...
+    >>> def intersect_parts(parts):
+    ...     geometries = [p['bounds'] for p in parts]
+    ...     for g in intersect_geometries(geometries):
+    ...         return [{'bounds': g}]
+    ...
+    >>> intersect_assemblies(
+    ...     assemblies,
+    ...     get_assembly_parts=lambda a: a,
+    ...     get_part_bounds=lambda p: p['bounds'],
+    ...     are_parts_intersecting=are_intersecting,
+    ...     intersect_parts=intersect_parts,
+    ...     unify_parts=lambda p: p,
+    ...     concat_parts=lambda p: p
+    ... )
+    [{'bounds': [1, 1, 2, 2]}]
+    """
+    from scadpy.core.assembly import concat_assemblies, unify_assemblies
+    from scadpy.core.component import get_intersecting_component_index_groups
+
+    unified_assemblies = [
+        unify_assemblies(
+            [a],
+            get_assembly_parts=get_assembly_parts,
+            unify_parts=unify_parts,
+        )
+        for a in assemblies
+    ]
+    part_with_assembly_index: list[tuple[P, int]] = [
+        (p, i) for i, a in enumerate(unified_assemblies) for p in get_assembly_parts(a)
+    ]
+    parts = [p for p, _ in part_with_assembly_index]
+    assembly_indices = [i for _, i in part_with_assembly_index]
+
+    intersecting_part_index_groups: list[list[int]] = (
+        get_intersecting_component_index_groups(
+            parts,
+            get_component_bounds=get_part_bounds,
+            are_components_intersecting=are_parts_intersecting,
+        )
+    )
+
+    # keep only groups that have at least one part from each assembly
+    num_assemblies = len(assemblies)
+    intersected_assemblies: list[A] = []
+    for group in intersecting_part_index_groups:
+        assembly_ids_in_group = {assembly_indices[idx] for idx in group}
+        if len(assembly_ids_in_group) == num_assemblies:
+            group_parts = [parts[idx] for idx in group]
+            intersected_assemblies.append(intersect_parts(group_parts))
+
+    return concat_assemblies(
+        assemblies=intersected_assemblies,
+        get_assembly_parts=get_assembly_parts,
+        concat_parts=concat_parts,
+    )

scadpy/core/assembly/combinations/subtract_assemblies.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable, Sequence
+
+import numpy as np
+from numpy.typing import NDArray
+from typeguard import typechecked
+
+
+@typechecked
+def subtract_assemblies[A, P](
+    to_be_subtracted: A,
+    to_subtract: A,
+    get_assembly_parts: Callable[[A], Iterable[P]],
+    get_part_bounds: Callable[[P], NDArray[np.float64]],
+    are_parts_intersecting: Callable[[P, P], bool],
+    subtract_parts: Callable[[P, P], A],
+    intersect_parts: Callable[[Sequence[P]], A],
+    unify_parts: Callable[[Sequence[P]], A],
+    concat_parts: Callable[[Sequence[P]], A],
+) -> A:
+    """
+    Subtract the geometry of all parts in one assembly from all parts in another assembly.
+
+    This function is fully generic and uses dependency injection for all domain-specific
+    operations, making it suitable for a wide range of applications (2D, 3D, CAD, etc.).
+    For each part in the first assembly, all intersecting parts from the second assembly are subtracted.
+
+    Parameters
+    ----------
+    to_be_subtracted : A
+        The assembly whose parts will be subtracted from.
+    to_subtract : A
+        The assembly whose parts will be subtracted.
+    get_assembly_parts : Callable[[A], Iterable[P]]
+        Function that extracts parts from an assembly.
+    get_part_bounds : Callable[[P], NDArray[np.float64]]
+        Function to extract the bounding box of a part.
+    are_parts_intersecting : Callable[[P, P], bool]
+        Function to determine if two parts intersect.
+    subtract_parts : Callable[[P, P], A]
+        Function to subtract one part from another, returning an assembly.
+    intersect_parts : Callable[[Sequence[P]], A]
+        Function to compute the intersection of a group of parts.
+    unify_parts : Callable[[Sequence[P]], A]
+        Function to unify (union) overlapping parts within an assembly.
+    concat_parts : Callable[[Sequence[P]], A]
+        Function to concatenate a sequence of parts into a new assembly.
+
+    Returns
+    -------
+    A
+        The assembly object containing all subtracted parts.
+
+    Examples
+    --------
+    >>> from scadpy import subtract_assemblies
+
+    >>> assembly1 = [{'bounds': [0, 0, 3, 3]}]
+    >>> assembly2 = [{'bounds': [1, 1, 2, 2]}]
+    ...
+    >>> def are_intersecting(p1, p2):
+    ...     b1, b2 = p1['bounds'], p2['bounds']
+    ...     return not (b1[2] <= b2[0] or b2[2] <= b1[0] or
+    ...                 b1[3] <= b2[1] or b2[3] <= b1[1])
+    ...
+    >>> def subtract_geometries(g1, g2):
+    ...     if (g2[0] > g1[0] and g2[2] < g1[2]
+    ...             and g2[1] > g1[1] and g2[3] < g1[3]):
+    ...         return [
+    ...             [g1[0], g1[1], g2[0], g1[3]],  # left
+    ...             [g2[2], g1[1], g1[2], g1[3]],  # right
+    ...             [g2[0], g1[1], g2[2], g2[1]],  # bottom
+    ...             [g2[0], g2[3], g2[2], g1[3]],  # top
+    ...         ]
+    ...     return [g1]
+    ...
+    >>> def subtract_parts(p1, p2):
+    ...     geometries = subtract_geometries(
+    ...         p1['bounds'], p2['bounds']
+    ...     )
+    ...     return [{'bounds': g} for g in geometries]
+    ...
+    >>> result = subtract_assemblies(
+    ...     assembly1, assembly2,
+    ...     get_assembly_parts=lambda a: a,
+    ...     get_part_bounds=lambda p: p['bounds'],
+    ...     are_parts_intersecting=are_intersecting,
+    ...     subtract_parts=subtract_parts,
+    ...     intersect_parts=lambda p: p,
+    ...     unify_parts=lambda p: p,
+    ...     concat_parts=lambda p: p
+    ... )
+    >>> result == [
+    ...     {'bounds': [0, 0, 1, 3]},
+    ...     {'bounds': [2, 0, 3, 3]},
+    ...     {'bounds': [1, 0, 2, 1]},
+    ...     {'bounds': [1, 2, 2, 3]}
+    ... ]
+    True
+    """
+
+    from scadpy.core.assembly import (
+        concat_assemblies,
+        intersect_assemblies,
+        unify_assemblies,
+    )
+
+    unified_to_subtract = unify_assemblies(
+        [to_subtract],
+        get_assembly_parts=get_assembly_parts,
+        unify_parts=unify_parts,
+    )
+
+    parts_to_be_subtracted = get_assembly_parts(to_be_subtracted)
+    parts_to_subtract = get_assembly_parts(unified_to_subtract)
+
+    subtracted_assemblies: list[A] = []
+    for part_to_be_subtracted in parts_to_be_subtracted:
+        intersecting_parts_to_subtract = [
+            part
+            for part in parts_to_subtract
+            if are_parts_intersecting(part_to_be_subtracted, part)
+        ]
+        if not intersecting_parts_to_subtract:
+            subtracted_assemblies.append(concat_parts([part_to_be_subtracted]))
+            continue
+
+        partially_subtracted_assemblies: list[A] = []
+        for part_to_subtract in intersecting_parts_to_subtract:
+            partially_subtracted_assemblies.append(
+                subtract_parts(part_to_be_subtracted, part_to_subtract)
+            )
+
+        subtracted_assemblies += [
+            intersect_assemblies(
+                assemblies=partially_subtracted_assemblies,
+                get_assembly_parts=get_assembly_parts,
+                get_part_bounds=get_part_bounds,
+                are_parts_intersecting=are_parts_intersecting,
+                intersect_parts=intersect_parts,
+                unify_parts=unify_parts,
+                concat_parts=concat_parts,
+            )
+        ]
+
+    return concat_assemblies(
+        assemblies=subtracted_assemblies,
+        get_assembly_parts=get_assembly_parts,
+        concat_parts=concat_parts,
+    )