meerk40t 0.9.7030__py2.py3-none-any.whl → 0.9.7040__py2.py3-none-any.whl

meerk40t/core/elements/tree_commands.py

@@ -2,7 +2,6 @@
 This is a giant list of console commands that deal with and often implement the elements system in the program.
 """
 
-
 from meerk40t.kernel import CommandSyntaxError
 
 from .element_types import *
@@ -39,9 +38,10 @@ def init_commands(kernel):
             for i, n in enumerate(node.children):
                 p = list(path)
                 p.append(str(i))
-                channel(
-                    f"{'.'.join(p).ljust(10)}: {str(n._bounds)} - {str(n._bounds_dirty)} {str(n.type)} - {str(str(n)[:16])}"
-                )
+                if hasattr(n, "_bounds"):
+                    channel(
+                        f"{'.'.join(p).ljust(10)}: {str(n._bounds)} - {str(n._bounds_dirty)} {str(n.type)} - {str(str(n)[:16])}"
+                    )
                 b_list(p, n)
 
         for d in data:
@@ -49,7 +49,12 @@ def init_commands(kernel):
             if d.type == "root":
                 channel(_("Tree:"))
             else:
-                channel(f"{str(d)}:")
+                if hasattr(d, "_bounds"):
+                    channel(
+                        f"{str(d)}: {str(d._bounds)} - {str(d._bounds_dirty)} {str(d.type)} - {str(str(d)[:16])}"
+                    )
+                else:
+                    channel(f"{str(d)}:")
             b_list([], d)
             channel("----------")
 

meerk40t/core/node/elem_ellipse.py

@@ -3,8 +3,8 @@ from math import cos, sin, sqrt, tau
 
 from meerk40t.core.node.mixins import (
     FunctionalParameter,
-    Stroked,
     LabelDisplay,
+    Stroked,
     Suppressable,
 )
 from meerk40t.core.node.node import Fillrule, Node
@@ -171,12 +171,16 @@ class EllipseNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable
         tablen = self.mktablength
         numtabs = self.mktabpositions
         if tablen and numtabs:
-            path = Geomstr.wobble_tab(path, tablen, resolution, numtabs, unit_factor=unit_factor)
+            path = Geomstr.wobble_tab(
+                path, tablen, resolution, numtabs, unit_factor=unit_factor
+            )
         # Is there a dash/dot pattern to apply?
         dashlen = self.stroke_dash
         irrelevant = 50
         if dashlen:
-            path = Geomstr.wobble_dash(path, dashlen, resolution, irrelevant, unit_factor=unit_factor)
+            path = Geomstr.wobble_dash(
+                path, dashlen, resolution, irrelevant, unit_factor=unit_factor
+            )
 
         return path
 
@@ -261,19 +265,25 @@ class EllipseNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/elem_image.py

@@ -27,19 +27,21 @@ Methods:
     bbox(transformed=True, with_stroke=False): Returns the bounding box of the image.
 """
 
-import numpy as np
 import threading
 import time
 from copy import copy
 from math import ceil, floor
 
-from meerk40t.core.node.node import Node
+import numpy as np
+
 from meerk40t.core.node.mixins import LabelDisplay, Suppressable
+from meerk40t.core.node.node import Node
 from meerk40t.core.units import UNITS_PER_INCH, UNITS_PER_MM
 from meerk40t.image.imagetools import RasterScripts
 from meerk40t.svgelements import Matrix, Path, Polygon
 from meerk40t.tools.geomstr import Geomstr
 
+
 class ImageNode(Node, LabelDisplay, Suppressable):
     """
     ImageNode is the bootstrapped node type for the 'elem image' type.
@@ -153,7 +155,12 @@ class ImageNode(Node, LabelDisplay, Suppressable):
         self._process_image_failed = False
 
         self.message = None
-        if (self.operations or self.dither or self.prevent_crop or self.keyhole_reference) and startup:
+        if (
+            self.operations
+            or self.dither
+            or self.prevent_crop
+            or self.keyhole_reference
+        ) and startup:
             step = self._default_units / self.dpi
             step_x = step
             step_y = step
@@ -186,7 +193,6 @@ class ImageNode(Node, LabelDisplay, Suppressable):
             time.sleep(0.05)
             counter += 1
         if self._processed_image is None:
-
             step = self._default_units / self.dpi
             step_x = step
             step_y = step
@@ -320,18 +326,24 @@ class ImageNode(Node, LabelDisplay, Suppressable):
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            drag_node.type in ("op image", "op raster", "file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("op image", "op raster", "file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True
@@ -418,12 +430,18 @@ class ImageNode(Node, LabelDisplay, Suppressable):
                 # Unset cache.
                 self._cache = None
             else:
-                if self._keyhole_reference is not None and self._keyhole_geometry is None:
+                if (
+                    self._keyhole_reference is not None
+                    and self._keyhole_geometry is None
+                ):
                     get_keyhole_geometry()
 
                 # We need to have a thread per image, so we need to provide a node specific thread_name!
                 self._update_thread = context.threaded(
-                    self._process_image_thread, result=clear, daemon=True, thread_name=f"image_update_{self.id}_{str(time.perf_counter())}"
+                    self._process_image_thread,
+                    result=clear,
+                    daemon=True,
+                    thread_name=f"image_update_{self.id}_{str(time.perf_counter())}",
                 )
 
     def _process_image_thread(self):
@@ -460,6 +478,7 @@ class ImageNode(Node, LabelDisplay, Suppressable):
         """
 
         from PIL import Image, ImageDraw
+
         while self._processing:
             time.sleep(0.05)
 
@@ -491,6 +510,7 @@ class ImageNode(Node, LabelDisplay, Suppressable):
     @property
     def opaque_image(self):
         from PIL import Image
+
         img = self.image
         if img is not None and img.mode == "RGBA":
             r, g, b, a = img.split()
@@ -503,6 +523,7 @@ class ImageNode(Node, LabelDisplay, Suppressable):
         # Convert image to L type.
         if image.mode == "I":
             from PIL import Image
+
             # Load the 32-bit signed grayscale image
             img = np.array(image, dtype=np.int32)
 
@@ -510,7 +531,9 @@ class ImageNode(Node, LabelDisplay, Suppressable):
             # img = img.reshape((image.width, image.height))
 
             # Normalize the image to the range 0-255
-            img_normalized = ((img - img.min()) / (img.max() - img.min()) * 255).astype(np.uint8)
+            img_normalized = ((img - img.min()) / (img.max() - img.min()) * 255).astype(
+                np.uint8
+            )
 
             # Convert the NumPy array to a Pillow Image
             img_pil = Image.fromarray(img_normalized)
@@ -684,7 +707,9 @@ class ImageNode(Node, LabelDisplay, Suppressable):
                     pass
             elif name == "contrast":
                 try:
-                    if op["enable"] and (op["contrast"] is not None and op["brightness"] is not None):
+                    if op["enable"] and (
+                        op["contrast"] is not None and op["brightness"] is not None
+                    ):
                         contrast = ImageEnhance.Contrast(image)
                         c = (op["contrast"] + 128.0) / 128.0
                         image = contrast.enhance(c)
@@ -924,7 +949,9 @@ class ImageNode(Node, LabelDisplay, Suppressable):
             try:
                 image = ImageOps.invert(image)
             except OSError as e:
-                print (f"Image inversion crashed: {e}\nMode: {image.mode}, {image.width}x{image.height} pixel")
+                print(
+                    f"Image inversion crashed: {e}\nMode: {image.mode}, {image.width}x{image.height} pixel"
+                )
 
         # Find rejection mask of white pixels. (already inverted)
         reject_mask = image.point(lambda e: 0 if e == 255 else 255)
@@ -950,7 +977,10 @@ class ImageNode(Node, LabelDisplay, Suppressable):
             image = self.image
         if self._keyhole_geometry is not None:
             # Let's check whether the keyhole dimensions match
-            if self._keyhole_image is not None and (self._keyhole_image.width != image.width or self._keyhole_image.height != image.height):
+            if self._keyhole_image is not None and (
+                self._keyhole_image.width != image.width
+                or self._keyhole_image.height != image.height
+            ):
                 self._keyhole_image = None
             if self._keyhole_image is None:
                 actualized_matrix = self._actualized_matrix
@@ -973,19 +1003,21 @@ class ImageNode(Node, LabelDisplay, Suppressable):
                     # Let's simplify things, if we don't have any overlap then we don't need to do something
                     # if x0 > bounds[2] or x2 < bounds [0] or y0 > bounds[3] or y2 < bounds[1]:
                     #     continue
-                    geom_points = list(geom.as_interpolated_points(int(UNITS_PER_MM/10)))
+                    geom_points = list(
+                        geom.as_interpolated_points(int(UNITS_PER_MM / 10))
+                    )
                     points = list()
                     for pt in geom_points:
                         if pt is None:
                             continue
                         gx = pt.real
                         gy = pt.imag
-                        x = int(maskimage.width * (gx - x0) / i_wd )
-                        y = int(maskimage.height * (gy - y0) / i_ht )
-                        points.append( (x, y) )
+                        x = int(maskimage.width * (gx - x0) / i_wd)
+                        y = int(maskimage.height * (gy - y0) / i_ht)
+                        points.append((x, y))
 
                     # print (points)
-                    draw.polygon( points, fill="white", outline="white")
+                    draw.polygon(points, fill="white", outline="white")
                 self._keyhole_image = maskimage
                 # For debug purposes...
                 # maskimage.save("C:\\temp\\maskimage.png")

meerk40t/core/node/elem_line.py

@@ -2,8 +2,8 @@ from copy import copy
 
 from meerk40t.core.node.mixins import (
     FunctionalParameter,
-    Stroked,
     LabelDisplay,
+    Stroked,
     Suppressable,
 )
 from meerk40t.core.node.node import Fillrule, Linecap, Linejoin, Node
@@ -150,12 +150,16 @@ class LineNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
         numtabs = 4
         numtabs = 0
         if tablen and numtabs:
-            path = Geomstr.wobble_tab(path, tablen, resolution, numtabs, unit_factor=unit_factor)
+            path = Geomstr.wobble_tab(
+                path, tablen, resolution, numtabs, unit_factor=unit_factor
+            )
         # Is there a dash/dot pattern to apply?
         dashlen = self.stroke_dash
         irrelevant = 50
         if dashlen:
-            path = Geomstr.wobble_dash(path, dashlen, resolution, irrelevant, unit_factor=unit_factor)
+            path = Geomstr.wobble_dash(
+                path, dashlen, resolution, irrelevant, unit_factor=unit_factor
+            )
         return path
 
     def scaled(self, sx, sy, ox, oy, interim=False):
@@ -235,19 +239,25 @@ class LineNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/elem_path.py

@@ -2,8 +2,8 @@ from copy import copy
 
 from meerk40t.core.node.mixins import (
     FunctionalParameter,
-    Stroked,
     LabelDisplay,
+    Stroked,
     Suppressable,
 )
 from meerk40t.core.node.node import Fillrule, Linecap, Linejoin, Node
@@ -122,12 +122,16 @@ class PathNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
         tablen = self.mktablength
         numtabs = self.mktabpositions
         if tablen and numtabs:
-            path = Geomstr.wobble_tab(path, tablen, resolution, numtabs, unit_factor=unit_factor)
+            path = Geomstr.wobble_tab(
+                path, tablen, resolution, numtabs, unit_factor=unit_factor
+            )
         # Is there a dash/dot pattern to apply?
         dashlen = self.stroke_dash
         irrelevant = 50
         if dashlen:
-            path = Geomstr.wobble_dash(path, dashlen, resolution, irrelevant, unit_factor=unit_factor)
+            path = Geomstr.wobble_dash(
+                path, dashlen, resolution, irrelevant, unit_factor=unit_factor
+            )
         return path
 
     def scaled(self, sx, sy, ox, oy, interim=False):
@@ -201,19 +205,25 @@ class PathNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/elem_point.py

@@ -85,18 +85,24 @@ class PointNode(Node, FunctionalParameter, LabelDisplay, Suppressable):
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            drag_node.type in ("op dots", "file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("op dots", "file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/elem_polyline.py

@@ -2,8 +2,8 @@ from copy import copy
 
 from meerk40t.core.node.mixins import (
     FunctionalParameter,
-    Stroked,
     LabelDisplay,
+    Stroked,
     Suppressable,
 )
 from meerk40t.core.node.node import Fillrule, Linecap, Linejoin, Node
@@ -18,9 +18,7 @@ from meerk40t.svgelements import (
 from meerk40t.tools.geomstr import Geomstr
 
 
-class PolylineNode(
-    Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable
-):
+class PolylineNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
     """
     PolylineNode is the bootstrapped node type for the 'elem polyline' type.
     """
@@ -152,12 +150,16 @@ class PolylineNode(
         tablen = self.mktablength
         numtabs = self.mktabpositions
         if tablen and numtabs:
-            path = Geomstr.wobble_tab(path, tablen, resolution, numtabs, unit_factor=unit_factor)
+            path = Geomstr.wobble_tab(
+                path, tablen, resolution, numtabs, unit_factor=unit_factor
+            )
         # Is there a dash/dot pattern to apply?
         dashlen = self.stroke_dash
         irrelevant = 50
         if dashlen:
-            path = Geomstr.wobble_dash(path, dashlen, resolution, irrelevant, unit_factor=unit_factor)
+            path = Geomstr.wobble_dash(
+                path, dashlen, resolution, irrelevant, unit_factor=unit_factor
+            )
         return path
 
     def scaled(self, sx, sy, ox, oy, interim=False):
@@ -232,19 +234,25 @@ class PolylineNode(
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/elem_rect.py

@@ -2,8 +2,8 @@ from copy import copy
 
 from meerk40t.core.node.mixins import (
     FunctionalParameter,
-    Stroked,
     LabelDisplay,
+    Stroked,
     Suppressable,
 )
 from meerk40t.core.node.node import Fillrule, Linejoin, Node
@@ -157,12 +157,16 @@ class RectNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
         tablen = self.mktablength
         numtabs = self.mktabpositions
         if tablen and numtabs:
-            path = Geomstr.wobble_tab(path, tablen, resolution, numtabs, unit_factor=unit_factor)
+            path = Geomstr.wobble_tab(
+                path, tablen, resolution, numtabs, unit_factor=unit_factor
+            )
         # Is there a dash/dot pattern to apply?
         dashlen = self.stroke_dash
         irrelevant = 50
         if dashlen:
-            path = Geomstr.wobble_dash(path, dashlen, resolution, irrelevant, unit_factor=unit_factor)
+            path = Geomstr.wobble_dash(
+                path, dashlen, resolution, irrelevant, unit_factor=unit_factor
+            )
         return path
 
     def scaled(self, sx, sy, ox, oy, interim=False):
@@ -241,18 +245,24 @@ class RectNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
 
     def can_drop(self, drag_node):
         # Dragging element into element.
+        if self.is_a_child_of(drag_node):
+            return False
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            (drag_node.type.startswith("op ") and drag_node.type != "op dots") or
-            drag_node.type in ("file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or (drag_node.type.startswith("op ") and drag_node.type != "op dots")
+            or drag_node.type in ("file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/elem_text.py

@@ -4,8 +4,8 @@ from math import tau
 
 from meerk40t.core.node.mixins import (
     FunctionalParameter,
-    Stroked,
     LabelDisplay,
+    Stroked,
     Suppressable,
 )
 from meerk40t.core.node.node import Node
@@ -196,18 +196,24 @@ class TextNode(Node, Stroked, FunctionalParameter, LabelDisplay, Suppressable):
         return default_map
 
     def can_drop(self, drag_node):
+        if self.is_a_child_of(drag_node):
+            return False
         # Dragging element into element.
         return bool(
-            hasattr(drag_node, "as_geometry") or
-            hasattr(drag_node, "as_image") or
-            drag_node.type in ("op raster", "file", "group")
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("op raster", "file", "group")
         )
 
     def drop(self, drag_node, modify=True, flag=False):
         # Dragging element into element.
         if not self.can_drop(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type in ("file", "group"):
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type in ("file", "group")
+        ):
             if modify:
                 self.insert_sibling(drag_node)
             return True

meerk40t/core/node/filenode.py

@@ -25,21 +25,15 @@ class FileNode(Node):
         default_map["filename"] = s
         return default_map
 
-    def is_a_child_of(self, node):
-        candidate = self
-        while candidate is not None:
-            if candidate is node:
-                return True
-            candidate = candidate.parent
         return False
-    
+
     def can_drop(self, drag_node):
         if self.is_a_child_of(drag_node):
             return False
         if drag_node.type == "group":
             return True
         return False
-    
+
     def drop(self, drag_node, modify=True, flag=False):
         # Do not allow dragging onto children
         if not self.can_drop(drag_node):

meerk40t/core/node/groupnode.py

@@ -1,5 +1,5 @@
-from meerk40t.core.node.node import Node
 from meerk40t.core.node.mixins import LabelDisplay
+from meerk40t.core.node.node import Node
 
 
 class GroupNode(Node, LabelDisplay):
@@ -76,18 +76,14 @@ class GroupNode(Node, LabelDisplay):
         default_map["id"] = str(self.id)
         return default_map
 
-    def is_a_child_of(self, node):
-        candidate = self
-        while candidate is not None:
-            if candidate is node:
-                return True
-            candidate = candidate.parent
-        return False
-
     def can_drop(self, drag_node):
         if self.is_a_child_of(drag_node):
             return False
-        if hasattr(drag_node, "as_geometry") or hasattr(drag_node, "as_image") or drag_node.type == "group":
+        if (
+            hasattr(drag_node, "as_geometry")
+            or hasattr(drag_node, "as_image")
+            or drag_node.type == "group"
+        ):
             # Move a group
             return True
         elif drag_node.type.startswith("op"):
@@ -121,7 +117,11 @@ class GroupNode(Node, LabelDisplay):
             if result and modify:
                 # changed = []
                 for e in self.flat():
-                    if hasattr(drag_node, "color") and drag_node.color is not None and hasattr(e, "stroke"):
+                    if (
+                        hasattr(drag_node, "color")
+                        and drag_node.color is not None
+                        and hasattr(e, "stroke")
+                    ):
                         e.stroke = drag_node.color
                         # changed.append(e)
                 for ref in old_references: