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

meerk40t/gui/wxmmain.py

@@ -2,6 +2,7 @@ import datetime
 import os
 import platform
 import sys
+import threading
 from functools import partial
 from math import isinf
 
@@ -126,6 +127,42 @@ from .mwindow import MWindow
 _ = wx.GetTranslation
 MULTIPLE = "<Multiple files loaded>"
 
+class GUIThread:
+    """
+    This will take from any thread a command to be executed and inserts it into the main thread
+    This prevents threading & lock issues exhibited by passing along commands 
+    via ``consoleserver`` or ``webserver``
+    """
+    def __init__(self, context, *args, **kwargs):
+        self.context = context
+        self._execution_lock = threading.Lock()
+        self._execution_buffer = []
+        self._execution_timer = Job(
+            process=self.execute_command,
+            job_name="console-execute",
+            interval=0.1,
+            run_main=True,
+        )
+        self.context.kernel.register("gui/handover", self.process_command)
+
+    def execute_command(self):
+        cmd = ""
+        another = False
+        with self._execution_lock:
+            if self._execution_buffer:
+                cmd = self._execution_buffer[0]
+                self._execution_buffer.pop(0)
+                another = len(self._execution_buffer) > 0
+        if cmd:
+            self.context(cmd + "\n")
+            if another:
+                self.context.kernel.schedule(self._execution_timer)
+
+    def process_command(self, command):
+        with self._execution_lock:
+            self._execution_buffer.append(command)
+            self.context.kernel.schedule(self._execution_timer)        
+
 class Autosaver:
     """
     Minimal autosave functionality.
@@ -137,7 +174,7 @@ class Autosaver:
     def __init__(self, context, *args, **kwargs):
         self.context = context
         self.needs_saving = False
-        safe_dir = os.path.realpath(get_safe_path(self.context.kernel.name))
+        safe_dir = self.context.kernel.os_information["WORKDIR"]
         self.autosave_file = os.path.join(safe_dir, "_autosave.svg")
 
         choices = [
@@ -394,6 +431,7 @@ class MeerK40t(MWindow):
         self.tips_at_startup()
         self.parametric_info = None
         self.autosave = Autosaver(self.context)
+        self.handover = GUIThread(self.context)
         kernel = self.context.kernel
         if hasattr(kernel.args, "maximized") and kernel.args.maximized:
             self.Maximize()
@@ -538,10 +576,18 @@ class MeerK40t(MWindow):
                     myPilImage = Image.new(
                         "RGB", (myWxImage.GetWidth(), myWxImage.GetHeight())
                     )
-                    myPilImage.frombytes(myWxImage.GetData())
+                    try:
+                        byte_data = bytes(myWxImage.GetData())
+                        myPilImage.frombytes(byte_data)
+                    except TypeError as e:
+                        console = self.context.root.channel("console")
+                        console(f"Error while pasting image: {e}")
+                        return None
                     return myPilImage
 
                 image = imageToPil(WxBitmapToWxImage(bmp))
+                if image is None:
+                    return
                 dpi = DEFAULT_PPI
                 matrix = Matrix(f"scale({UNITS_PER_PIXEL})")
                 # _("Paste image")
@@ -2345,6 +2391,22 @@ class MeerK40t(MWindow):
                 > 0,
             },
         )
+        secondary_commands = [
+            "element union",
+            "element difference",
+            "element xor",
+            "element intersection",
+        ]
+        try:
+            import pyclipr
+            primary_commands = [
+                "clipper union",
+                "clipper difference",
+                "clipper xor",
+                "clipper intersection",
+            ]
+        except ImportError:
+            primary_commands = list(secondary_commands)
         kernel.register(
             "button/geometry/Union",
             {
@@ -2352,7 +2414,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_union,
                 "tip": _("Create a union of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Union", "element union\n"),
+                "action": exec_in_undo_scope("Union", f"{primary_commands[0]}\n"),
+                "action_right": exec_in_undo_scope("Union", f"{secondary_commands[0]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))
@@ -2367,7 +2430,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_subtract,
                 "tip": _("Create a difference of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Difference", "element difference\n"),
+                "action": exec_in_undo_scope("Difference", f"{primary_commands[1]}\n"),
+                "action_right": exec_in_undo_scope("Difference", f"{secondary_commands[1]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))
@@ -2382,7 +2446,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_xor,
                 "tip": _("Create a xor of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Xor", "element xor\n"),
+                "action": exec_in_undo_scope("XOR", f"{primary_commands[2]}\n"),
+                "action_right": exec_in_undo_scope("XOR", f"{secondary_commands[2]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))
@@ -2397,7 +2462,8 @@ class MeerK40t(MWindow):
                 "icon": icon_cag_common,
                 "tip": _("Create a intersection of the selected elements"),
                 "help": "cag",
-                "action": exec_in_undo_scope("Intersection", "element intersection\n"),
+                "action": exec_in_undo_scope("Intersection", f"{primary_commands[3]}\n"),
+                "action_right": exec_in_undo_scope("Intersection", f"{secondary_commands[3]}\n"),
                 "size": bsize_small,
                 "rule_enabled": lambda cond: len(
                     list(kernel.elements.elems(emphasized=True))

meerk40t/gui/wxmscene.py

@@ -156,13 +156,9 @@ class MeerK40tScenePanel(wx.Panel):
         self.context.setting(bool, "clear_magnets", True)
 
         # Save / Load the content of magnets
-        from os.path import join, realpath
+        from os.path import join
 
-        from meerk40t.kernel.functions import get_safe_path
-
-        self._magnet_file = join(
-            realpath(get_safe_path(self.context.kernel.name)), "magnets.cfg"
-        )
+        self._magnet_file = join(self.context.kernel.os_information["WORKDIR"], "magnets.cfg")
         self.load_magnets()
         # Add a plugin routine to be called at the time of a full new start
         context.kernel.register(

meerk40t/gui/wxmtree.py

@@ -580,7 +580,7 @@ class ShadowTree:
         self.tree_images = None
         self.name = "Project"
         self._freeze = False
-        testsize = dip_size(self, 20, 20)
+        testsize = dip_size(self.wxtree, 20, 20)
         self.iconsize = testsize[1]
         self.iconstates = {}
         self.last_call = 0
@@ -1430,17 +1430,23 @@ class ShadowTree:
         @param kwargs:
         @return:
         """
-        parent = node.parent
-        parent_item = parent._item
-        if parent_item is None:
-            # We are appending items in tree before registration.
+        try:
+            parent = node.parent
+            parent_item = parent._item
+            if parent_item is None:
+                # We are appending items in tree before registration.
+                return
+            tree = self.wxtree
+            if pos is None:
+                node._item = tree.AppendItem(parent_item, self.name)
+            else:
+                node._item = tree.InsertItem(parent_item, pos, self.name)
+            tree.SetItemData(node._item, node)
+        except Exception as e:
+            # Invalid tree?
+            self.context.signal("rebuild_tree", "all")
+            print (f"We encountered an error at node registration: {e}")
             return
-        tree = self.wxtree
-        if pos is None:
-            node._item = tree.AppendItem(parent_item, self.name)
-        else:
-            node._item = tree.InsertItem(parent_item, pos, self.name)
-        tree.SetItemData(node._item, node)
         self.update_decorations(node, False)
         wxcolor = self.wxtree.GetForegroundColour()
         attribute_to_try = "fill" if node.type == "elem text" else "stroke"

meerk40t/gui/wxutils.py

@@ -1222,7 +1222,7 @@ class StaticBoxSizer(wx.StaticBoxSizer):
         if label is None:
             label = ""
         self.sbox = wx.StaticBox(parent, id, label=label)
-        self.sbox.SetMinSize(dip_size(self, 50, 50))
+        self.sbox.SetMinSize(dip_size(self.sbox, 50, 50))
         super().__init__(self.sbox, orientation)
         self.parent = parent
 

meerk40t/image/imagetools.py

@@ -43,7 +43,12 @@ def img_to_polygons(
     _, th2 = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
     # Find contours in the binary image
-    contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    try:
+        contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    except ValueError:
+        # Invalid data
+        return ([], [])
+
     # print(f"Found {len(contours)} contours and {len(hierarchies)} hierarchies")
     width, height = node_image.size
     minarea = int(minimal / 100.0 * width * height)
@@ -147,9 +152,14 @@ def do_innerwhite(
         _, thresh = cv2.threshold(gray, 250, 255, cv2.THRESH_BINARY)
 
         # Find contours
-        contours, hierarchy = cv2.findContours(
-            thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
-        )
+        try:
+            contours, hierarchy = cv2.findContours(
+                thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE
+            )
+        except ValueError:
+            # Invalid data
+            continue
+
         linecandidates = list()
 
         minarea = int(minimal / 100.0 * width * height)
@@ -402,7 +412,12 @@ def img_to_rectangles(
     _, th2 = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
 
     # Find contours in the binary image
-    contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    try:
+        contours, hierarchies = cv2.findContours(th2, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE)
+    except ValueError:
+        # Invalid data
+        return ([], [])
+
     # print(f"Found {len(contours)} contours and {len(hierarchies)} hierarchies")
     width, height = node_image.size
     minarea = int(minimal / 100.0 * width * height)

meerk40t/kernel/kernel.py

@@ -1,7 +1,6 @@
 import functools
 import inspect
 import os
-import platform
 import re
 import subprocess
 import threading
@@ -181,9 +180,20 @@ class Kernel(Settings):
         # Arguments Objects
         self.args = None
 
+        self.os_information = self._get_environment()
+
     def __str__(self):
         return f"Kernel({self.name}, {self.profile}, {self.version})"
 
+    def _get_environment(self):
+        from platform import system
+        from tempfile import gettempdir
+        return {
+            "OS_NAME":  system(),
+            "OS_TEMPDIR": os.path.realpath(gettempdir()),
+            "WORKDIR": os.path.realpath(get_safe_path(self.name, create=True)),
+        }
+
     def set_language(self, language, localedir="locale"):
         from . import set_language
 
@@ -1906,6 +1916,8 @@ class Kernel(Settings):
             # Could be recurring job. Reset on reschedule.
         except AttributeError:
             pass
+        if job.job_name is None:
+            job.job_name = f"job_{id(job)}"
         self.jobs[job.job_name] = job
         return job
 
@@ -2667,6 +2679,9 @@ class Kernel(Settings):
             channel(_("----------"))
             channel(_("Scheduled Processes:"))
             for i, job_name in enumerate(self.jobs):
+                if job_name is None:
+                    channel(_("Empty job definition..."))
+                    continue
                 job = self.jobs[job_name]
                 parts = list()
                 parts.append(f"{i + 1}:")
@@ -2737,6 +2752,8 @@ class Kernel(Settings):
                 channel(_("Timers:"))
                 i = 0
                 for job_name in self.jobs:
+                    if job_name is None:
+                        continue
                     if not job_name.startswith("timer"):
                         continue
                     i += 1
@@ -2772,6 +2789,8 @@ class Kernel(Settings):
                     skipped = False
                     canceled = False
                     for job_name in list(self.jobs):
+                        if job_name is None:
+                            continue
                         if not job_name.startswith("timer"):
                             continue
                         timer_name = job_name[5:]
@@ -2830,7 +2849,7 @@ class Kernel(Settings):
 
         @self.console_command("beep", _("Perform beep"))
         def beep(channel, _, **kwargs):
-            OS_NAME = platform.system()
+            OS_NAME = self.os_information["OS_NAME"]
             system_sound = {
                 "Windows": r"c:\Windows\Media\Sounds\Alarm01.wav",
                 "Darwin": "/System/Library/Sounds/Ping.aiff",

meerk40t/main.py

@@ -11,7 +11,7 @@ import os.path
 import sys
 
 APPLICATION_NAME = "MeerK40t"
-APPLICATION_VERSION = "0.9.7010"
+APPLICATION_VERSION = "0.9.7020"
 
 if not getattr(sys, "frozen", False):
     # If .git directory does not exist we are running from a package like pypi

meerk40t/network/console_server.py

@@ -26,6 +26,8 @@ def plugin(kernel, lifecycle=None):
             command, channel, _, port=23, silent=False, quit=False, **kwargs
         ):
             root = kernel.root
+            # Variable to store input
+            root.__console_buffer = ""
             try:
                 server = root.open_as("module/TCPServer", "console-server", port=port)
                 if quit:
@@ -36,25 +38,61 @@ def plugin(kernel, lifecycle=None):
                     "{kernel_name} {kernel_version} Telnet Console.\r\n"
                 ).format(kernel_name=kernel.name, kernel_version=kernel.version)
                 send.line_end = "\r\n"
-
                 recv = root.channel("console-server/recv")
-                recv.watch(root.console)
-                channel(
-                    _(
-                        "{name} {version} console server on port: {port}".format(
-                            name=kernel.name, version=kernel.version, port=port
-                        )
+            except (OSError, ValueError):
+                channel(_("Server failed on port: {port}").format(port=port))
+                return
+                
+            def exec_command(data: str) -> None:
+                # We are in a different thread, so let's hand over stuff to the gui 
+                if isinstance(data, bytes):
+                    try:
+                        data = data.decode()
+                    except UnicodeDecodeError as e:
+                        return
+                start = 0
+                while True:
+                    idx = data.find("|", start)
+                    if idx < 0:
+                        break
+                    # Is the amount of quotation marks odd (ie non-even)?
+                    # Yes: we are in the middle of a str
+                    # No: we can split the command
+                    quotations = data.count('"', 0, idx)
+                    if quotations % 2 == 0:
+                        data = data[:idx].rstrip() + "\n" + data[idx+1:].lstrip()
+                    start = idx + 1
+                root.__console_buffer += data
+                while "\n" in root.__console_buffer:
+                    pos = root.__console_buffer.find("\n")
+                    command = root.__console_buffer[0:pos].strip("\r")
+                    root.__console_buffer = root.__console_buffer[pos + 1 :]
+                    if handover is None:
+                        root.console(command + "\n")
+                    else:
+                        handover(command)
+
+            handover = None
+            for result in root.find("gui/handover"):
+                # Do we have a thread handover routine?
+                if result is not None:
+                    handover, _path, suffix_path  = result
+                    break
+            recv.watch(exec_command)
+
+            channel(
+                _(
+                    "{name} {version} console server on port: {port}".format(
+                        name=kernel.name, version=kernel.version, port=port
                     )
                 )
+            )
 
-                if not silent:
-                    console = root.channel("console")
-                    console.watch(send)
-                    server.events_channel.watch(console)
+            if not silent:
+                console = root.channel("console")
+                console.watch(send)
+                server.events_channel.watch(console)
 
-            except (OSError, ValueError):
-                channel(_("Server failed on port: {port}").format(port=port))
-            return
 
         @kernel.console_option(
             "port", "p", type=int, default=2080, help=_("port to listen on.")

meerk40t/network/web_server.py

@@ -34,6 +34,13 @@ class WebServer(Module):
         )
         self.server_headers = dict()
         self.client_headers = dict()
+        self.handover = None
+        root = self.context.root
+        for result in root.find("gui/handover"):
+            # Do we have a thread handover routine?
+            if result is not None:
+                self.handover, _path, suffix_path  = result
+                break
 
     def stop(self):
         self.state = "terminate"
@@ -45,6 +52,13 @@ class WebServer(Module):
         if self.socket is not None:
             self.socket.close()
             self.socket = None
+    
+    def send(self, command):
+        if self.handover is None:
+            self.context(f"{command}\n")
+        else:
+            self.handover(command)
+
 
     def receive(self, data):
         def parse_received_data():
@@ -92,7 +106,7 @@ class WebServer(Module):
                     content = f"Received command: '{command}'"
             elif self.client_headers["TYPE"] == "POST" and "post_cmd" in self.client_headers:
                 command = self.client_headers["post_cmd"]
-                self.context(command + "\n")
+                self.send(command)
                 content = f"Received command: '{command}'"
             return content_type, content
 

meerk40t/ruida/device.py

@@ -263,18 +263,22 @@ class RuidaDevice(Service):
                 choice_dict["choices"] = ["UNCONFIGURED"]
                 choice_dict["display"] = ["pyserial-not-installed"]
 
+        from platform import system
+        is_linux = system() == "Linux"
+
         choices = [
             {
                 "attr": "serial_port",
                 "object": self,
                 "default": "UNCONFIGURED",
                 "type": str,
-                "style": "option",
+                "style": "combosmall" if is_linux else "option",
                 "label": "",
                 "tip": _("What serial interface does this device connect to?"),
                 "section": "_10_Serial Interface",
                 "subsection": "_00_",
                 "dynamic": update,
+                "exclusive": not is_linux, 
             },
             {
                 "attr": "baud_rate",

meerk40t/tools/polybool.py

@@ -275,7 +275,8 @@ class LinkedList:
         data.next = None
 
         def remove_func():
-            data.previous.next = data.next
+            if data.previous is not None:
+                data.previous.next = data.next
             if data.next is not None:
                 data.next.previous = data.previous
             data.previous = None