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

meerk40t/core/elements/element_treeops.py

@@ -112,7 +112,18 @@ from meerk40t.kernel import CommandSyntaxError
 from meerk40t.svgelements import Matrix, Point
 from meerk40t.tools.geomstr import Geomstr
 
-from .element_types import *
+from .element_types import (
+    effect_nodes,
+    elem_group_nodes,
+    elem_nodes,
+    elem_ref_nodes,
+    non_structural_nodes,
+    op_burnable_nodes,
+    op_image_nodes,
+    op_nodes,
+    op_parent_nodes,
+    op_vector_nodes,
+)
 
 
 def plugin(kernel, lifecycle=None):
@@ -158,7 +169,10 @@ def init_tree(kernel):
     ## @tree_separator_after()
     @tree_conditional(lambda node: len(list(self.ops(selected=True))) == 1)
     @tree_operation(
-        _("Operation properties"), node_type=op_nodes, help=_("Open property window for operation"), grouping="00PROPS"
+        _("Operation properties"),
+        node_type=op_nodes,
+        help=_("Open property window for operation"),
+        grouping="00PROPS",
     )
     def operation_property(node, **kwargs):
         activate = self.kernel.lookup("function/open_property_window_for_node")
@@ -166,7 +180,12 @@ def init_tree(kernel):
             activate(node)
 
     ## @tree_separator_after()
-    @tree_operation(_("Edit"), node_type="util console", help=_("Modify console command"), grouping="00PROPS")
+    @tree_operation(
+        _("Edit"),
+        node_type="util console",
+        help=_("Modify console command"),
+        grouping="00PROPS",
+    )
     def edit_console_command(node, **kwargs):
         activate = self.kernel.lookup("function/open_property_window_for_node")
         if activate is not None:
@@ -286,7 +305,10 @@ def init_tree(kernel):
     """
 
     @tree_operation(
-        _("Remove effect"), node_type=effect_nodes, help=_("Remove hatch/wobble"), grouping="10_ELEM_DELETION"
+        _("Remove effect"),
+        node_type=effect_nodes,
+        help=_("Remove hatch/wobble"),
+        grouping="10_ELEM_DELETION",
     )
     def remove_effect(node, **kwargs):
         with self.undoscope("Remove effect"):
@@ -300,7 +322,10 @@ def init_tree(kernel):
 
     @tree_conditional(lambda node: is_hatched(node))
     @tree_operation(
-        _("Remove effect"), node_type=elem_nodes, help=_("Remove surrounding hatch/wobble"), grouping="10_ELEM_DELETION"
+        _("Remove effect"),
+        node_type=elem_nodes,
+        help=_("Remove surrounding hatch/wobble"),
+        grouping="10_ELEM_DELETION",
     )
     def unhatch_elements(node, **kwargs):
         # Language hint: _("Remove effect")
@@ -367,7 +392,9 @@ def init_tree(kernel):
     def ungroup_elements(node, **kwargs):
         with self.undoscope("Ungroup elements"):
             to_treat = []
-            for gnode in self.flat(selected=True, cascade=False, types=("group", "file")):
+            for gnode in self.flat(
+                selected=True, cascade=False, types=("group", "file")
+            ):
                 enode = gnode
                 while True:
                     if enode.parent is None or enode.parent is self.elem_branch:
@@ -449,9 +476,9 @@ def init_tree(kernel):
         for e in dataset:
             if not hasattr(e, "hidden"):
                 continue
-            if mode==0:
+            if mode == 0:
                 e.hidden = True
-            elif mode==1:
+            elif mode == 1:
                 e.hidden = False
             else:
                 e.hidden = not e.hidden
@@ -706,7 +733,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Burning sequence"))
     @tree_operation(
-        _("Burn first"), node_type=op_parent_nodes, help=_("Establish the sequence of operations during burntime"), grouping="OPS_40_SEQUENCE"
+        _("Burn first"),
+        node_type=op_parent_nodes,
+        help=_("Establish the sequence of operations during burntime"),
+        grouping="OPS_40_SEQUENCE",
     )
     def burn_first(node, **kwargs):
         move_op(node, "top")
@@ -723,14 +753,20 @@ def init_tree(kernel):
 
     @tree_submenu(_("Burning sequence"))
     @tree_operation(
-        _("Burn later"), node_type=op_parent_nodes, help=_("Establish the sequence of operations during burntime"), grouping="OPS_40_SEQUENCE"
+        _("Burn later"),
+        node_type=op_parent_nodes,
+        help=_("Establish the sequence of operations during burntime"),
+        grouping="OPS_40_SEQUENCE",
     )
     def burn_later(node, **kwargs):
         move_op(node, "down")
 
     @tree_submenu(_("Burning sequence"))
     @tree_operation(
-        _("Burn last"), node_type=op_parent_nodes, help=_("Establish the sequence of operations during burntime"), grouping="OPS_40_SEQUENCE"
+        _("Burn last"),
+        node_type=op_parent_nodes,
+        help=_("Establish the sequence of operations during burntime"),
+        grouping="OPS_40_SEQUENCE",
     )
     def burn_last(node, **kwargs):
         move_op(node, "bottom")
@@ -739,7 +775,9 @@ def init_tree(kernel):
     @tree_operation(
         _("Convert to Image"),
         node_type=op_parent_nodes,
-        help=_("Convert an operation to a different type maintaining properties and assigned elements"),
+        help=_(
+            "Convert an operation to a different type maintaining properties and assigned elements"
+        ),
         grouping="OPS_60_CONVERSION",
     )
     def convert_operation_image(node, **kwargs):
@@ -748,6 +786,8 @@ def init_tree(kernel):
             return
         with self.undoscope("Convert to Image"):
             for n in data:
+                if n.type not in op_parent_nodes:
+                    continue
                 new_settings = dict(n.settings)
                 new_settings["type"] = "op image"
                 n.replace_node(keep_children=True, **new_settings)
@@ -757,7 +797,9 @@ def init_tree(kernel):
     @tree_operation(
         _("Convert to Raster"),
         node_type=op_parent_nodes,
-        help=_("Convert an operation to a different type maintaining properties and assigned elements"),
+        help=_(
+            "Convert an operation to a different type maintaining properties and assigned elements"
+        ),
         grouping="OPS_60_CONVERSION",
     )
     def convert_operation_raster(node, **kwargs):
@@ -766,6 +808,8 @@ def init_tree(kernel):
             return
         with self.undoscope("Convert to Raster"):
             for n in data:
+                if n.type not in op_parent_nodes:
+                    continue
                 new_settings = dict(n.settings)
                 new_settings["type"] = "op raster"
                 n.replace_node(keep_children=True, **new_settings)
@@ -775,7 +819,9 @@ def init_tree(kernel):
     @tree_operation(
         _("Convert to Engrave"),
         node_type=op_parent_nodes,
-        help=_("Convert an operation to a different type maintaining properties and assigned elements"),
+        help=_(
+            "Convert an operation to a different type maintaining properties and assigned elements"
+        ),
         grouping="OPS_60_CONVERSION",
     )
     def convert_operation_engrave(node, **kwargs):
@@ -784,6 +830,8 @@ def init_tree(kernel):
             return
         with self.undoscope("Convert to Engrave"):
             for n in data:
+                if n.type not in op_parent_nodes:
+                    continue
                 new_settings = dict(n.settings)
                 new_settings["type"] = "op engrave"
                 n.replace_node(keep_children=True, **new_settings)
@@ -793,7 +841,9 @@ def init_tree(kernel):
     @tree_operation(
         _("Convert to Cut"),
         node_type=op_parent_nodes,
-        help=_("Convert an operation to a different type maintaining properties and assigned elements"),
+        help=_(
+            "Convert an operation to a different type maintaining properties and assigned elements"
+        ),
         grouping="OPS_60_CONVERSION",
     )
     def convert_operation_cut(node, **kwargs):
@@ -802,6 +852,8 @@ def init_tree(kernel):
             return
         with self.undoscope("Convert to Cut"):
             for n in data:
+                if n.type not in op_parent_nodes:
+                    continue
                 new_settings = dict(n.settings)
                 new_settings["type"] = "op cut"
                 n.replace_node(keep_children=True, **new_settings)
@@ -811,7 +863,9 @@ def init_tree(kernel):
     @tree_operation(
         _("Convert to Dots"),
         node_type=op_parent_nodes,
-        help=_("Convert an operation to a different type maintaining properties and assigned elements"),
+        help=_(
+            "Convert an operation to a different type maintaining properties and assigned elements"
+        ),
         grouping="OPS_60_CONVERSION",
     )
     def convert_operation_dots(node, **kwargs):
@@ -820,6 +874,8 @@ def init_tree(kernel):
             return
         with self.undoscope("Convert to Dots"):
             for n in data:
+                if n.type not in op_parent_nodes:
+                    continue
                 new_settings = dict(n.settings)
                 new_settings["type"] = "op dots"
                 n.replace_node(keep_children=True, **new_settings)
@@ -827,7 +883,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Raster-Wizard"))
     @tree_operation(
-        _("Set to None"), node_type="elem image", help=_("Remove stored image operations"), grouping="70_ELEM_IMAGES"
+        _("Set to None"),
+        node_type="elem image",
+        help=_("Remove stored image operations"),
+        grouping="70_ELEM_IMAGES",
     )
     def image_rasterwizard_apply_none(node, **kwargs):
         data = []
@@ -851,7 +910,10 @@ def init_tree(kernel):
     @tree_submenu(_("Raster-Wizard"))
     @tree_values("script", values=list(self.match("raster_script", suffix=True)))
     @tree_operation(
-        _("Apply: {script}"), node_type="elem image", help=_("Apply a predefined script to an image"), grouping="70_ELEM_IMAGES"
+        _("Apply: {script}"),
+        node_type="elem image",
+        help=_("Apply a predefined script to an image"),
+        grouping="70_ELEM_IMAGES",
     )
     def image_rasterwizard_apply(node, script=None, **kwargs):
         raster_script = self.lookup(f"raster_script/{script}")
@@ -888,11 +950,12 @@ def init_tree(kernel):
             image, box = node.as_image()
             vertical = mode.lower() != "horizontal"
             bidirectional = self._image_2_path_bidirectional
-            threshold = 0.5 if self._image_2_path_optimize else None # Half a percent
+            threshold = 0.5 if self._image_2_path_optimize else None  # Half a percent
             geom = Geomstr.image(
-                    image, vertical=vertical,
-                    bidirectional=bidirectional,
-                )
+                image,
+                vertical=vertical,
+                bidirectional=bidirectional,
+            )
             if threshold:
                 geom.two_opt_distance(auto_stop_threshold=threshold, feedback=feedback)
             # self.context
@@ -915,7 +978,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Convert to Path"))
     @tree_operation(
-        _("Horizontal"), node_type="elem image", help=_("Create a horizontal linepattern from the image"), grouping="70_ELEM_IMAGES_Y"
+        _("Horizontal"),
+        node_type="elem image",
+        help=_("Create a horizontal linepattern from the image"),
+        grouping="70_ELEM_IMAGES_Y",
     )
     def image_convert_to_path_horizontal(node, **kwargs):
         # Language hint _("To path: Horizontal")
@@ -923,7 +989,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Convert to Path"))
     @tree_operation(
-        _("Vertical"), node_type="elem image", help=_("Create a vertical linepattern from the image"), grouping="70_ELEM_IMAGES_Y"
+        _("Vertical"),
+        node_type="elem image",
+        help=_("Create a vertical linepattern from the image"),
+        grouping="70_ELEM_IMAGES_Y",
     )
     def image_convert_to_path_vertical(node, **kwargs):
         convert_image_to_path(node, "Vertical")
@@ -940,7 +1009,9 @@ def init_tree(kernel):
     @tree_operation(
         _("Bidirectional"),
         node_type="elem image",
-        help=_("Shall the line pattern be able to travel back and forth or will it always start at the same side"),
+        help=_(
+            "Shall the line pattern be able to travel back and forth or will it always start at the same side"
+        ),
         grouping="70_ELEM_IMAGES_Y",
     )
     def set_img_2_path_option_1(node, **kwargs):
@@ -951,13 +1022,14 @@ def init_tree(kernel):
     @tree_operation(
         _("Optimize travel"),
         node_type="elem image",
-        help=_("Shall the line pattern be able to travel back and forth or will it always start at the same side"),
+        help=_(
+            "Shall the line pattern be able to travel back and forth or will it always start at the same side"
+        ),
         grouping="70_ELEM_IMAGES_Y",
     )
     def set_img_2_path_option_2(node, **kwargs):
         self._image_2_path_optimize = not self._image_2_path_optimize
 
-
     def radio_match_speed(node, speed=0, **kwargs):
         return node.speed == float(speed)
 
@@ -965,7 +1037,10 @@ def init_tree(kernel):
     @tree_radio(radio_match_speed)
     @tree_values("speed", (5, 10, 50, 75, 100, 150, 200, 250, 300, 350, 400, 450, 500))
     @tree_operation(
-        _("{speed}mm/s"), node_type=op_image_nodes, help=_("Set speed for the operation"), grouping="OPS_70_MODIFY"
+        _("{speed}mm/s"),
+        node_type=op_image_nodes,
+        help=_("Set speed for the operation"),
+        grouping="OPS_70_MODIFY",
     )
     def set_speed_raster(node, speed=150, **kwargs):
         data = list()
@@ -984,7 +1059,10 @@ def init_tree(kernel):
     @tree_radio(radio_match_speed)
     @tree_values("speed", (2, 3, 4, 5, 6, 7, 10, 15, 20, 25, 30, 35, 40, 50))
     @tree_operation(
-        _("{speed}mm/s"), node_type=op_vector_nodes, help=_("Set speed for the operation"), grouping="OPS_70_MODIFY"
+        _("{speed}mm/s"),
+        node_type=op_vector_nodes,
+        help=_("Set speed for the operation"),
+        grouping="OPS_70_MODIFY",
     )
     def set_speed_vector_cut(node, speed=20, **kwargs):
         data = list()
@@ -1302,7 +1380,10 @@ def init_tree(kernel):
             activate(node)
 
     @tree_operation(
-        _("Clear all"), node_type="branch ops", help=_("Delete all operations"), grouping="10_OPS_DELETION"
+        _("Clear all"),
+        node_type="branch ops",
+        help=_("Delete all operations"),
+        grouping="10_OPS_DELETION",
     )
     def clear_all(node, **kwargs):
         if self.kernel.yesno(
@@ -1461,7 +1542,10 @@ def init_tree(kernel):
     # ==========
 
     @tree_operation(
-        _("Clear all"), node_type="branch elems", help=_("Delete all elements"), grouping="10_ELEM_DELETION"
+        _("Clear all"),
+        node_type="branch elems",
+        help=_("Delete all elements"),
+        grouping="10_ELEM_DELETION",
     )
     def clear_all_elems(node, **kwargs):
         # self("element* delete\n")
@@ -1477,7 +1561,10 @@ def init_tree(kernel):
     # ==========
 
     @tree_operation(
-        _("Clear all"), node_type="branch reg", help=_("Delete all registration marks"), grouping="REG_05_DELETION"
+        _("Clear all"),
+        node_type="branch reg",
+        help=_("Delete all registration marks"),
+        grouping="REG_05_DELETION",
     )
     def clear_all_regmarks(node, **kwargs):
         if self.kernel.yesno(
@@ -1624,10 +1711,18 @@ def init_tree(kernel):
     def remove_type_file(node, **kwargs):
         to_be_removed = [node]
         for e in self.elem_branch.children:
-            if e.type == "file" and e.filepath == node.filepath and e not in to_be_removed:
+            if (
+                e.type == "file"
+                and e.filepath == node.filepath
+                and e not in to_be_removed
+            ):
                 to_be_removed.append(e)
         for e in self.reg_branch.children:
-            if e.type == "file" and e.filepath == node.filepath and e not in to_be_removed:
+            if (
+                e.type == "file"
+                and e.filepath == node.filepath
+                and e not in to_be_removed
+            ):
                 to_be_removed.append(e)
         if len(to_be_removed) == 0:
             return
@@ -1864,9 +1959,7 @@ def init_tree(kernel):
                 node.remove_node()
         return True
 
-    @tree_conditional_try(
-        lambda node: node.data_type == "egv"
-    )
+    @tree_conditional_try(lambda node: node.data_type == "egv")
     @tree_operation(
         _("Convert to Elements"),
         node_type="blob",
@@ -1875,6 +1968,7 @@ def init_tree(kernel):
     )
     def egv2path(node, **kwargs):
         from meerk40t.lihuiyu.parser import LihuiyuParser
+
         parser = LihuiyuParser()
         parser.fix_speeds = True
         parser.parse(node.data, self)
@@ -1928,7 +2022,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Clone reference"))
     @tree_operation(
-        _("Make 1 copy"), node_type=("reference",), help=_("Add an additional reference of the master element"), grouping="20_OPS_DUPLICATION"
+        _("Make 1 copy"),
+        node_type=("reference",),
+        help=_("Add an additional reference of the master element"),
+        grouping="20_OPS_DUPLICATION",
     )
     def clone_single_element_op(node, **kwargs):
         clone_element_op(node, copies=1, **kwargs)
@@ -2220,7 +2317,12 @@ def init_tree(kernel):
     @tree_values("opname", values=material_ids)
     @tree_submenu_list(material_menus)
     @tree_calc("material", lambda opname: material_name(opname))
-    @tree_operation("{material}", node_type="branch ops", help=_("Populate the operation template list at the bottom"), grouping="OPS_60_MATMAN")
+    @tree_operation(
+        "{material}",
+        node_type="branch ops",
+        help=_("Populate the operation template list at the bottom"),
+        grouping="OPS_60_MATMAN",
+    )
     def load_ops(node, opname, **kwargs):
         self(f"material load {opname}\n")
         if self.update_statusbar_on_material_load:
@@ -2290,7 +2392,10 @@ def init_tree(kernel):
     ## @tree_separator_before()
     @tree_submenu(_("Append operation"))
     @tree_operation(
-        _("Append Image"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Image"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_image(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2299,7 +2404,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append operation"))
     @tree_operation(
-        _("Append Raster"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Raster"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_raster(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2308,7 +2416,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append operation"))
     @tree_operation(
-        _("Append Engrave"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Engrave"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_engrave(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2317,7 +2428,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append operation"))
     @tree_operation(
-        _("Append Cut"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Cut"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_cut(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2326,7 +2440,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append operation"))
     @tree_operation(
-        _("Append new Hatch"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append new Hatch"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_hatch(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2336,7 +2453,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append operation"))
     @tree_operation(
-        _("Append Dots"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Dots"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_dots(node, pos=None, **kwargs):
         self.op_branch.add("op dots", pos=pos)
@@ -2344,7 +2464,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append special operation(s)"))
     @tree_operation(
-        _("Append Home"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Home"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_home(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2383,7 +2506,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append special operation(s)"))
     @tree_operation(
-        _("Append Beep"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Beep"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_beep(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2413,7 +2539,10 @@ def init_tree(kernel):
     @tree_submenu(_("Append special operation(s)"))
     @tree_prompt("wait_time", _("Wait for how long (in seconds)?"), data_type=float)
     @tree_operation(
-        _("Append Wait"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Wait"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_wait(node, wait_time, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2426,7 +2555,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append special operation(s)"))
     @tree_operation(
-        _("Append Output"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Output"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_output(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2441,7 +2573,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Append special operation(s)"))
     @tree_operation(
-        _("Append Input"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Input"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_input(node, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2532,7 +2667,10 @@ def init_tree(kernel):
     @tree_submenu(_("Append special operation(s)"))
     @tree_prompt("opname", _("Console command to append to operations?"))
     @tree_operation(
-        _("Append Console"), node_type="branch ops", help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Append Console"),
+        node_type="branch ops",
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def append_operation_custom(node, opname, pos=None, **kwargs):
         with self.undoscope("Append operation"):
@@ -2627,7 +2765,12 @@ def init_tree(kernel):
         self.signal("updateelem_tree")
 
     @tree_submenu(_("Apply special effect"))
-    @tree_operation(_("Append Line-fill 0.1mm"), node_type=hatchable_elems, help=_("Apply hatch"), grouping="50_ELEM_MODIFY_ZMISC")
+    @tree_operation(
+        _("Append Line-fill 0.1mm"),
+        node_type=hatchable_elems,
+        help=_("Apply hatch"),
+        grouping="50_ELEM_MODIFY_ZMISC",
+    )
     def append_element_effect_eulerian(node, pos=None, **kwargs):
         hatch_me(
             node,
@@ -2639,7 +2782,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Apply special effect"))
     @tree_operation(
-        _("Append diagonal Line-fill 0.1mm"), node_type=hatchable_elems, help=_("Apply hatch"), grouping="50_ELEM_MODIFY_ZMISC"
+        _("Append diagonal Line-fill 0.1mm"),
+        node_type=hatchable_elems,
+        help=_("Apply hatch"),
+        grouping="50_ELEM_MODIFY_ZMISC",
     )
     def append_element_effect_eulerian_45(node, pos=None, **kwargs):
         hatch_me(
@@ -2651,7 +2797,12 @@ def init_tree(kernel):
         )
 
     @tree_submenu(_("Apply special effect"))
-    @tree_operation(_("Append Line-Fill 1mm"), node_type=hatchable_elems, help=_("Apply hatch"), grouping="50_ELEM_MODIFY_ZMISC")
+    @tree_operation(
+        _("Append Line-Fill 1mm"),
+        node_type=hatchable_elems,
+        help=_("Apply hatch"),
+        grouping="50_ELEM_MODIFY_ZMISC",
+    )
     def append_element_effect_line(node, pos=None, **kwargs):
         hatch_me(
             node,
@@ -2663,7 +2814,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Apply special effect"))
     @tree_operation(
-        _("Append diagonal Line-Fill 1mm"), node_type=hatchable_elems, help=_("Apply hatch"), grouping="50_ELEM_MODIFY_ZMISC"
+        _("Append diagonal Line-Fill 1mm"),
+        node_type=hatchable_elems,
+        help=_("Apply hatch"),
+        grouping="50_ELEM_MODIFY_ZMISC",
     )
     def append_element_effect_line_45(node, pos=None, **kwargs):
         hatch_me(
@@ -2809,7 +2963,6 @@ def init_tree(kernel):
                     except AttributeError:
                         pass
 
-
     @tree_conditional(lambda node: node.count_children() > 1)
     @tree_submenu(_("Duplicate element(s)"))
     @tree_operation(
@@ -2866,13 +3019,15 @@ def init_tree(kernel):
         dots_per_units = node.dpi / UNITS_PER_INCH
         new_width = width * dots_per_units
         new_height = height * dots_per_units
-
-        image = make_raster(
-            data,
-            bounds=bounds,
-            width=new_width,
-            height=new_height,
-        )
+        try:
+            image = make_raster(
+                data,
+                bounds=bounds,
+                width=new_width,
+                height=new_height,
+            )
+        except Exception:
+            return None, None
         matrix = Matrix.scale(width / new_width, height / new_height)
         matrix.post_translate(bounds[0], bounds[1])
         return image, matrix
@@ -2882,7 +3037,7 @@ def init_tree(kernel):
         _("Make raster image"),
         node_type=op_burnable_nodes,
         help=_("Create an image from the assigned elements."),
-        grouping="OPS_75_CONVERTIMAGE"
+        grouping="OPS_75_CONVERTIMAGE",
     )
     def make_raster_image(node, **kwargs):
         image, matrix = create_image_from_operation(node)
@@ -2911,11 +3066,12 @@ def init_tree(kernel):
                 return
             vertical = mode.lower() != "horizontal"
             bidirectional = self._image_2_path_bidirectional
-            threshold = 0.5 if self._image_2_path_optimize else None # Half a percent
+            threshold = 0.5 if self._image_2_path_optimize else None  # Half a percent
             geom = Geomstr.image(
-                    image, vertical=vertical,
-                    bidirectional=bidirectional,
-                )
+                image,
+                vertical=vertical,
+                bidirectional=bidirectional,
+            )
             if threshold:
                 geom.two_opt_distance(auto_stop_threshold=threshold, feedback=feedback)
             # self.context
@@ -2938,7 +3094,10 @@ def init_tree(kernel):
     @tree_submenu(_("Create image/path"))
     @tree_separator_before()
     @tree_operation(
-        _("Horizontal"), node_type="op raster", help=_("Create a horizontal linepattern from the raster"), grouping="OPS_75_CONVERTIMAGE"
+        _("Horizontal"),
+        node_type="op raster",
+        help=_("Create a horizontal linepattern from the raster"),
+        grouping="OPS_75_CONVERTIMAGE",
     )
     def raster_convert_to_path_horizontal(node, **kwargs):
         # Language hint _("To path: Horizontal")
@@ -2946,7 +3105,10 @@ def init_tree(kernel):
 
     @tree_submenu(_("Create image/path"))
     @tree_operation(
-        _("Vertical"), node_type="op raster", help=_("Create a vertical linepattern from the raster"), grouping="OPS_75_CONVERTIMAGE"
+        _("Vertical"),
+        node_type="op raster",
+        help=_("Create a vertical linepattern from the raster"),
+        grouping="OPS_75_CONVERTIMAGE",
     )
     def raster_convert_to_path_vertical(node, **kwargs):
         convert_raster_to_path(node, "Vertical")
@@ -2957,7 +3119,9 @@ def init_tree(kernel):
     @tree_operation(
         _("Bidirectional"),
         node_type="op raster",
-        help=_("Shall the line pattern be able to travel back and forth or will it always start at the same side"),
+        help=_(
+            "Shall the line pattern be able to travel back and forth or will it always start at the same side"
+        ),
         grouping="OPS_75_CONVERTIMAGE",
     )
     def set_raster_2_path_option_1(node, **kwargs):
@@ -2968,13 +3132,14 @@ def init_tree(kernel):
     @tree_operation(
         _("Optimize travel"),
         node_type="op raster",
-        help=_("Shall the line pattern be able to travel back and forth or will it always start at the same side"),
+        help=_(
+            "Shall the line pattern be able to travel back and forth or will it always start at the same side"
+        ),
         grouping="OPS_75_CONVERTIMAGE",
     )
     def set_raster_2_path_option_2(node, **kwargs):
         self._image_2_path_optimize = not self._image_2_path_optimize
 
-
     def add_after_index(node=None):
         try:
             if node is None:
@@ -2987,49 +3152,70 @@ def init_tree(kernel):
     ## @tree_separator_before()
     @tree_submenu(_("Insert operation"))
     @tree_operation(
-        _("Add Image"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Image"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_image(node, **kwargs):
         append_operation_image(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert operation"))
     @tree_operation(
-        _("Add Raster"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Raster"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_raster(node, **kwargs):
         append_operation_raster(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert operation"))
     @tree_operation(
-        _("Add Engrave"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Engrave"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_engrave(node, **kwargs):
         append_operation_engrave(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert operation"))
     @tree_operation(
-        _("Add Cut"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Cut"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_cut(node, **kwargs):
         append_operation_cut(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert operation"))
     @tree_operation(
-        _("Add Hatch"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Hatch"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_hatch(node, **kwargs):
         append_operation_hatch(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert operation"))
     @tree_operation(
-        _("Add Dots"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Dots"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_dots(node, **kwargs):
         append_operation_dots(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert special operation(s)"))
     @tree_operation(
-        _("Add Home"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Home"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_home(node, **kwargs):
         append_operation_home(node, pos=add_after_index(node), **kwargs)
@@ -3046,14 +3232,20 @@ def init_tree(kernel):
 
     @tree_submenu(_("Insert special operation(s)"))
     @tree_operation(
-        _("Add Beep"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Beep"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_beep(node, **kwargs):
         append_operation_beep(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert special operation(s)"))
     @tree_operation(
-        _("Add Interrupt"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Interrupt"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_interrupt(node, **kwargs):
         append_operation_interrupt(node, pos=add_after_index(node), **kwargs)
@@ -3061,7 +3253,10 @@ def init_tree(kernel):
     @tree_submenu(_("Insert special operation(s)"))
     @tree_prompt("wait_time", _("Wait for how long (in seconds)?"), data_type=float)
     @tree_operation(
-        _("Add Wait"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Wait"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_wait(node, wait_time, **kwargs):
         append_operation_wait(
@@ -3070,28 +3265,40 @@ def init_tree(kernel):
 
     @tree_submenu(_("Insert special operation(s)"))
     @tree_operation(
-        _("Add Output"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Output"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_output(node, **kwargs):
         append_operation_output(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert special operation(s)"))
     @tree_operation(
-        _("Add Input"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Input"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_input(node, **kwargs):
         append_operation_input(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert special operation(s)"))
     @tree_operation(
-        _("Add Coolant on"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Coolant on"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_cool_on(node, pos=None, **kwargs):
         append_operation_cool_on(node, pos=add_after_index(node), **kwargs)
 
     @tree_submenu(_("Insert special operation(s)"))
     @tree_operation(
-        _("Add Coolant Off"), node_type=op_nodes, help=_("Add an operation to the tree"), grouping="OPS_40_ADDITION"
+        _("Add Coolant Off"),
+        node_type=op_nodes,
+        help=_("Add an operation to the tree"),
+        grouping="OPS_40_ADDITION",
     )
     def add_operation_cool_off(node, pos=None, **kwargs):
         append_operation_cool_off(node, pos=add_after_index(node), **kwargs)
@@ -3130,7 +3337,12 @@ def init_tree(kernel):
             pos += 1
         append_operation_interrupt(node, pos=pos, **kwargs)
 
-    @tree_operation(_("Reload '{name}'"), node_type="file", help=_("Reload the content of the file"), grouping="40_ELEM_FILE")
+    @tree_operation(
+        _("Reload '{name}'"),
+        node_type="file",
+        help=_("Reload the content of the file"),
+        grouping="40_ELEM_FILE",
+    )
     def reload_file(node, **kwargs):
         filepath = node.filepath
         if not os.path.exists(filepath):
@@ -3142,10 +3354,18 @@ def init_tree(kernel):
             return
         to_be_removed = [node]
         for e in self.elem_branch.children:
-            if e.type == "file" and e.filepath == node.filepath and e not in to_be_removed:
+            if (
+                e.type == "file"
+                and e.filepath == node.filepath
+                and e not in to_be_removed
+            ):
                 to_be_removed.append(e)
         for e in self.reg_branch.children:
-            if e.type == "file" and e.filepath == node.filepath and e not in to_be_removed:
+            if (
+                e.type == "file"
+                and e.filepath == node.filepath
+                and e not in to_be_removed
+            ):
                 to_be_removed.append(e)
         for e in to_be_removed:
             e.remove_node()
@@ -3223,7 +3443,10 @@ def init_tree(kernel):
     @tree_submenu(_("Assign Operation"))
     @tree_values("op_assign", values=get_values)
     @tree_operation(
-        "{op_assign}", node_type=elem_nodes, help=_("Assign an operation to the selected elements"), grouping="40_ELEM_CLASSIFY"
+        "{op_assign}",
+        node_type=elem_nodes,
+        help=_("Assign an operation to the selected elements"),
+        grouping="40_ELEM_CLASSIFY",
     )
     def menu_assign_operations(node, op_assign, **kwargs):
         if self.classify_inherit_stroke:
@@ -3272,6 +3495,7 @@ def init_tree(kernel):
             else:
                 for ref in list(rnode.references):
                     ref.remove_node()
+
         # _("Remove assignments")
         with self.undoscope("Remove assignments"):
             for node in list(self.elems(emphasized=True)):
@@ -3330,7 +3554,10 @@ def init_tree(kernel):
     @tree_conditional(lambda node: not is_regmark(node))
     @tree_submenu(_("Duplicate group"))
     @tree_operation(
-        _("Make 1 copy"), node_type="group", help=_("Create one copy of the selected group"), grouping="20_ELEM_DUPLICATION"
+        _("Make 1 copy"),
+        node_type="group",
+        help=_("Create one copy of the selected group"),
+        grouping="20_ELEM_DUPLICATION",
     )
     def duplicate_groups_1(node, **kwargs):
         duplicate_groups_n(node, copies=1, **kwargs)
@@ -3345,7 +3572,6 @@ def init_tree(kernel):
         grouping="20_ELEM_DUPLICATION",
     )
     def duplicate_groups_n(node, copies, **kwargs):
-
         def copy_a_group(groupnode, parent, dx, dy):
             new_group = copy(groupnode)
             for orgnode in groupnode.children:
@@ -3373,8 +3599,12 @@ def init_tree(kernel):
 
                 if self.copy_increases_wordlist_references and hasattr(orgnode, "text"):
                     copy_node.text = self.wordlist_delta(orgnode.text, delta_wordlist)
-                elif self.copy_increases_wordlist_references and hasattr(orgnode, "mktext"):
-                    copy_node.mktext = self.wordlist_delta(orgnode.mktext, delta_wordlist)
+                elif self.copy_increases_wordlist_references and hasattr(
+                    orgnode, "mktext"
+                ):
+                    copy_node.mktext = self.wordlist_delta(
+                        orgnode.mktext, delta_wordlist
+                    )
                 new_group.add_node(copy_node)
                 if had_optional:
                     for property_op in self.kernel.lookup_all("path_updater/.*"):
@@ -3390,7 +3620,7 @@ def init_tree(kernel):
             delta_wordlist = 0
             for n in range(copies):
                 delta_wordlist += 1
-                copy_a_group(node, node.parent, (n + 1 ) * _dx, (n + 1) * _dy)
+                copy_a_group(node, node.parent, (n + 1) * _dx, (n + 1) * _dy)
         if copy_nodes:
             if self.classify_new:
                 self.classify(copy_nodes)
@@ -3400,7 +3630,10 @@ def init_tree(kernel):
     @tree_conditional(lambda node: not is_regmark(node))
     @tree_submenu(_("Duplicate element(s)"))
     @tree_operation(
-        _("Make 1 copy"), node_type=elem_nodes, help=_("Create one copy of the selected elements"), grouping="20_ELEM_DUPLICATION"
+        _("Make 1 copy"),
+        node_type=elem_nodes,
+        help=_("Create one copy of the selected elements"),
+        grouping="20_ELEM_DUPLICATION",
     )
     def duplicate_element_1(node, **kwargs):
         duplicate_element_n(node, copies=1, **kwargs)
@@ -3441,8 +3674,12 @@ def init_tree(kernel):
 
                 if self.copy_increases_wordlist_references and hasattr(orgnode, "text"):
                     copy_node.text = self.wordlist_delta(orgnode.text, delta_wordlist)
-                elif self.copy_increases_wordlist_references and hasattr(orgnode, "mktext"):
-                    copy_node.mktext = self.wordlist_delta(orgnode.mktext, delta_wordlist)
+                elif self.copy_increases_wordlist_references and hasattr(
+                    orgnode, "mktext"
+                ):
+                    copy_node.mktext = self.wordlist_delta(
+                        orgnode.mktext, delta_wordlist
+                    )
                 orgparent.add_node(copy_node)
                 if had_optional:
                     for property_op in self.kernel.lookup_all("path_updater/.*"):
@@ -3503,7 +3740,7 @@ def init_tree(kernel):
             "elem path",
         ),
         help=_("Adjusts the reference value for a wordlist, i.e. {name} to {name#+1}"),
-        grouping="50_ELEM_MODIFY_ZMISC"
+        grouping="50_ELEM_MODIFY_ZMISC",
     )
     def wlist_plus(singlenode, **kwargs):
         data = list()
@@ -3535,7 +3772,7 @@ def init_tree(kernel):
         help=_(
             "Adjusts the reference value for a wordlist, i.e. {name#+3} to {name#+2}"
         ),
-        grouping="50_ELEM_MODIFY_ZMISC"
+        grouping="50_ELEM_MODIFY_ZMISC",
     )
     def wlist_minus(singlenode, **kwargs):
         data = list()
@@ -3564,16 +3801,15 @@ def init_tree(kernel):
         _("...with {offset}mm distance"),
         node_type=elem_nodes,
         help=_("Create an outline around the selected elements"),
-        grouping="50_ELEM_MODIFY_ZMISC"
+        grouping="50_ELEM_MODIFY_ZMISC",
     )
     def make_outlines(node, offset=1, **kwargs):
         with self.undoscope("Outline"):
             self(f"outline {offset}mm\n")
         self.signal("refresh_tree")
-    
+
     @tree_conditional(
-        lambda node: not is_regmark(node)
-        and hasattr(node, "as_geometry")
+        lambda node: not is_regmark(node) and hasattr(node, "as_geometry")
     )
     @tree_submenu(_("Offset shapes..."))
     @tree_iterate("offset", 1, 5)
@@ -3581,7 +3817,7 @@ def init_tree(kernel):
         _("...to outside with {offset}mm distance"),
         node_type=elem_nodes,
         help=_("Create an outer offset around the selected elements"),
-        grouping="50_ELEM_MODIFY_ZMISC"
+        grouping="50_ELEM_MODIFY_ZMISC",
     )
     def make_positive_offsets(node, offset=1, **kwargs):
         with self.undoscope("Offset"):
@@ -3589,8 +3825,7 @@ def init_tree(kernel):
         self.signal("refresh_tree")
 
     @tree_conditional(
-        lambda node: not is_regmark(node)
-        and hasattr(node, "as_geometry")
+        lambda node: not is_regmark(node) and hasattr(node, "as_geometry")
     )
     @tree_submenu(_("Offset shapes..."))
     @tree_iterate("offset", 1, 5)
@@ -3598,7 +3833,7 @@ def init_tree(kernel):
         _("...to inside with {offset}mm distance"),
         node_type=elem_nodes,
         help=_("Create an inner offset around the selected elements"),
-        grouping="50_ELEM_MODIFY_ZMISC"
+        grouping="50_ELEM_MODIFY_ZMISC",
     )
     def make_negative_offsets(node, offset=1, **kwargs):
         with self.undoscope("Offset"):
@@ -3710,6 +3945,9 @@ def init_tree(kernel):
             result = True
         return result
 
+    def has_vtrace_vectorize(node):
+        return self.kernel.has_command("vtracer")
+
     @tree_submenu(_("Vectorization..."))
     @tree_separator_after()
     @tree_conditional(lambda node: has_vectorize(node))
@@ -3720,20 +3958,29 @@ def init_tree(kernel):
             "elem image",
         ),
         help=_("Vectorize the given element"),
-        grouping="70_ELEM_IMAGES_Z", # test
+        grouping="70_ELEM_IMAGES_Z",  # test
     )
     def trace_bitmap(node, **kwargs):
         with self.undoscope("Trace bitmap"):
             self("vectorize\n")
 
+    @tree_submenu(_("Vectorization..."))
+    @tree_conditional(lambda node: has_vtrace_vectorize(node))
+    @tree_operation(
+        _("Trace bitmap via vtracer"),
+        node_type=("elem image",),
+        help=_("Vectorize the given element"),
+        grouping="70_ELEM_IMAGES_Z",  # test
+    )
+    def trace_bitmap_vtrace(node, **kwargs):
+        self("vtracer\n")
+
     @tree_submenu(_("Vectorization..."))
     @tree_operation(
         _("Contour detection - shapes"),
-        node_type=(
-            "elem image",
-        ),
+        node_type=("elem image",),
         help=_("Recognize contours=shapes on the given element"),
-        grouping="70_ELEM_IMAGES_Z", # test
+        grouping="70_ELEM_IMAGES_Z",  # test
     )
     def contour_bitmap_polyline(node, **kwargs):
         current = self.setting(str, "contour_size", "big")
@@ -3752,11 +3999,9 @@ def init_tree(kernel):
     @tree_separator_after()
     @tree_operation(
         _("Contour detection - bounding"),
-        node_type=(
-            "elem image",
-        ),
+        node_type=("elem image",),
         help=_("Recognize contours=shapes on the given element"),
-        grouping="70_ELEM_IMAGES_Z", # test
+        grouping="70_ELEM_IMAGES_Z",  # test
     )
     def contour_bitmap_rectangles(node, **kwargs):
         current = self.setting(str, "contour_size", "big")
@@ -3787,7 +4032,7 @@ def init_tree(kernel):
     @tree_check(inner_check)
     @tree_operation(
         _("Ignore inner areas"),
-        node_type=("elem image", ),
+        node_type=("elem image",),
         help=_("Inner areas will be ignored"),
         grouping="70_ELEM_IMAGES_Z",
     )
@@ -3800,10 +4045,8 @@ def init_tree(kernel):
     @tree_check(sizecheck("big"))
     @tree_operation(
         _("Big objects"),
-        node_type=("elem image", ),
-        help=_(
-            "Only large object will be recognized if checked"
-        ),
+        node_type=("elem image",),
+        help=_("Only large object will be recognized if checked"),
         grouping="70_ELEM_IMAGES_Z",
     )
     def set_contour_size_big(node, **kwargs):
@@ -3814,10 +4057,8 @@ def init_tree(kernel):
     @tree_check(sizecheck("normal"))
     @tree_operation(
         _("Normal objects"),
-        node_type=("elem image", ),
-        help=_(
-            "Also medium sized objects will be recognized if checked"
-        ),
+        node_type=("elem image",),
+        help=_("Also medium sized objects will be recognized if checked"),
         grouping="70_ELEM_IMAGES_Z",
     )
     def set_contour_size_normal(node, **kwargs):
@@ -3828,10 +4069,8 @@ def init_tree(kernel):
     @tree_check(sizecheck("small"))
     @tree_operation(
         _("Small objects"),
-        node_type=("elem image", ),
-        help=_(
-            "Also small objects will be recognized if checked"
-        ),
+        node_type=("elem image",),
+        help=_("Also small objects will be recognized if checked"),
         grouping="70_ELEM_IMAGES_Z",
     )
     def set_contour_size_small(node, **kwargs):
@@ -3931,7 +4170,9 @@ def init_tree(kernel):
         grouping="50_ELEM_MODIFY_ZMISC",
     )
     def convert_to_path(singlenode, **kwargs):
-        nodes = (node for node in self.elems(emphasized=True) if hasattr(node, "as_geometry"))
+        nodes = (
+            node for node in self.elems(emphasized=True) if hasattr(node, "as_geometry")
+        )
         if not nodes:
             return
         with self.undoscope("Convert to path"):
@@ -3960,7 +4201,11 @@ def init_tree(kernel):
         grouping="50_ELEM_MODIFY_ZMISC",
     )
     def convert_to_path_effect(singlenode, **kwargs):
-        nodes = (node for node in self.flat(types=effect_nodes, emphasized=True) if hasattr(node, "as_geometry"))
+        nodes = (
+            node
+            for node in self.flat(types=effect_nodes, emphasized=True)
+            if hasattr(node, "as_geometry")
+        )
         if not nodes:
             return
         with self.undoscope("Convert to path"):
@@ -4191,7 +4436,9 @@ def init_tree(kernel):
     @tree_conditional(lambda node: node.lock)
     ## @tree_separator_before()
     @tree_operation(
-        _("Unlock element, allows manipulation"), node_type=elem_nodes, help=_("Remove manipulation protection flag")
+        _("Unlock element, allows manipulation"),
+        node_type=elem_nodes,
+        help=_("Remove manipulation protection flag"),
     )
     def element_unlock_manipulations(node, **kwargs):
         self("element unlock\n")
@@ -4295,7 +4542,10 @@ def init_tree(kernel):
     @tree_conditional(lambda node: is_regmark(node))
     @tree_submenu(_("Toggle magnet-lines"))
     @tree_operation(
-        _("Around border"), node_type=elem_group_nodes, help=_("Set/remove magnet lines around the regmark element"), grouping="SCENE"
+        _("Around border"),
+        node_type=elem_group_nodes,
+        help=_("Set/remove magnet lines around the regmark element"),
+        grouping="SCENE",
     )
     def regmark_to_magnet_1(node, **kwargs):
         if not hasattr(node, "bounds"):
@@ -4305,7 +4555,12 @@ def init_tree(kernel):
     @tree_conditional(lambda node: is_regmark(node))
     @tree_submenu(_("Toggle magnet-lines"))
     @tree_operation(
-        _("At center"), node_type=elem_group_nodes, help=_("Set/remove magnet lines right through the middle of the regmark element"), grouping="SCENE"
+        _("At center"),
+        node_type=elem_group_nodes,
+        help=_(
+            "Set/remove magnet lines right through the middle of the regmark element"
+        ),
+        grouping="SCENE",
     )
     def regmark_to_magnet_2(node, **kwargs):
         if not hasattr(node, "bounds"):
@@ -4368,7 +4623,10 @@ def init_tree(kernel):
     @tree_conditional(lambda node: not node.lock)
     @tree_submenu(_("Image"))
     @tree_operation(
-        _("Invert image"), node_type="elem image", help=_("Invert the image"), grouping="70_ELEM_IMAGES"
+        _("Invert image"),
+        node_type="elem image",
+        help=_("Invert the image"),
+        grouping="70_ELEM_IMAGES",
     )
     def image_invert(node, **kwargs):
         with self.undoscope("Invert image"):
@@ -4389,7 +4647,10 @@ def init_tree(kernel):
     @tree_conditional(lambda node: not node.lock)
     @tree_submenu(_("Image"))
     @tree_operation(
-        _("Flip vertical"), node_type="elem image", help=_("Mirror the image along the X-Axis"), grouping="70_ELEM_IMAGES"
+        _("Flip vertical"),
+        node_type="elem image",
+        help=_("Mirror the image along the X-Axis"),
+        grouping="70_ELEM_IMAGES",
     )
     def image_flip(node, **kwargs):
         with self.undoscope("Flip vertical"):
@@ -4398,7 +4659,10 @@ def init_tree(kernel):
     @tree_conditional(lambda node: not node.lock)
     @tree_submenu(_("Image"))
     @tree_operation(
-        _("Rotate 90° CW"), node_type="elem image", help=_("Rotate the image by 90° clockwise"), grouping="70_ELEM_IMAGES"
+        _("Rotate 90° CW"),
+        node_type="elem image",
+        help=_("Rotate the image by 90° clockwise"),
+        grouping="70_ELEM_IMAGES",
     )
     def image_cw(node, **kwargs):
         with self.undoscope("Rotate 90° CW"):
@@ -4407,7 +4671,10 @@ def init_tree(kernel):
     @tree_conditional(lambda node: not node.lock)
     @tree_submenu(_("Image"))
     @tree_operation(
-        _("Rotate 90° CCW"), node_type="elem image", help=_("Rotate the image by 90° counterclockwise"), grouping="70_ELEM_IMAGES"
+        _("Rotate 90° CCW"),
+        node_type="elem image",
+        help=_("Rotate the image by 90° counterclockwise"),
+        grouping="70_ELEM_IMAGES",
     )
     def image_ccw(node, **kwargs):
         with self.undoscope("Rotate 90° CCW"):
@@ -4524,7 +4791,12 @@ def init_tree(kernel):
         node.notify_collapse()
 
     @tree_submenu(_("Magnets"))
-    @tree_operation(_("...around horizontal edges"), node_type=elem_group_nodes, help=_("Create magnets around horizontal edges"), grouping="Magnet")
+    @tree_operation(
+        _("...around horizontal edges"),
+        node_type=elem_group_nodes,
+        help=_("Create magnets around horizontal edges"),
+        grouping="Magnet",
+    )
     def create_horiz_edges(node, **kwargs):
         if not hasattr(node, "bounds") or node.bounds is None:
             return
@@ -4533,7 +4805,12 @@ def init_tree(kernel):
         self.signal("create_magnets", to_create)
 
     @tree_submenu(_("Magnets"))
-    @tree_operation(_("...including center"), node_type=elem_group_nodes, help=_("Create magnets around horizontal edges + center"), grouping="Magnet")
+    @tree_operation(
+        _("...including center"),
+        node_type=elem_group_nodes,
+        help=_("Create magnets around horizontal edges + center"),
+        grouping="Magnet",
+    )
     def create_horiz_edges_plus_center(node, **kwargs):
         if not hasattr(node, "bounds") or node.bounds is None:
             return
@@ -4543,7 +4820,12 @@ def init_tree(kernel):
 
     @tree_submenu(_("Magnets"))
     @tree_iterate("steps", 3, 6)
-    @tree_operation(_("...create edges plus every 1/{steps}"), node_type=elem_group_nodes, help=_("Create magnets equally spaced along horizontal extension"), grouping="Magnet")
+    @tree_operation(
+        _("...create edges plus every 1/{steps}"),
+        node_type=elem_group_nodes,
+        help=_("Create magnets equally spaced along horizontal extension"),
+        grouping="Magnet",
+    )
     def create_x_horiz_edges(node, steps=3, **kwargs):
         if not hasattr(node, "bounds") or node.bounds is None:
             return
@@ -4560,7 +4842,12 @@ def init_tree(kernel):
 
     @tree_submenu(_("Magnets"))
     @tree_separator_before()
-    @tree_operation(_("...around vertical edges"), node_type=elem_group_nodes, help=_("Create magnets around vertical edges"), grouping="Magnet")
+    @tree_operation(
+        _("...around vertical edges"),
+        node_type=elem_group_nodes,
+        help=_("Create magnets around vertical edges"),
+        grouping="Magnet",
+    )
     def create_vert_edges(node, **kwargs):
         if not hasattr(node, "bounds") or node.bounds is None:
             return
@@ -4569,17 +4856,27 @@ def init_tree(kernel):
         self.signal("create_magnets", to_create)
 
     @tree_submenu(_("Magnets"))
-    @tree_operation(_("...including center"), node_type=elem_group_nodes, help=_("Create magnets around vertical edges + center"), grouping="Magnet")
+    @tree_operation(
+        _("...including center"),
+        node_type=elem_group_nodes,
+        help=_("Create magnets around vertical edges + center"),
+        grouping="Magnet",
+    )
     def create_vert_edges_plus_center(node, **kwargs):
         if not hasattr(node, "bounds") or node.bounds is None:
             return
         bb = node.bounds
         to_create = (("y", bb[1]), ("y", bb[3]), ("y", (bb[1] + bb[3]) / 2))
         self.signal("create_magnets", to_create)
-    @tree_submenu(_("Magnets"))
 
+    @tree_submenu(_("Magnets"))
     @tree_iterate("steps", 3, 6)
-    @tree_operation(_("...create edges plus every 1/{steps}"), node_type=elem_group_nodes, help=_("Create magnets equally spaced along vertical extension"), grouping="Magnet")
+    @tree_operation(
+        _("...create edges plus every 1/{steps}"),
+        node_type=elem_group_nodes,
+        help=_("Create magnets equally spaced along vertical extension"),
+        grouping="Magnet",
+    )
     def create_x_vert_edges(node, steps=3, **kwargs):
         if not hasattr(node, "bounds") or node.bounds is None:
             return