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

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/ruida/gui/gui.py

@@ -48,7 +48,7 @@ def plugin(service, lifecycle):
 
         from meerk40t.ruida.gui.ruidaconfig import RuidaConfiguration
         from meerk40t.ruida.gui.ruidacontroller import RuidaController
-        from meerk40t.ruida.gui.ruidaoperationproperties import RuidaOperationPanel
+        # from meerk40t.ruida.gui.ruidaoperationproperties import RuidaOperationPanel
 
         service.register("window/Controller", RuidaController)
         service.register("window/Configuration", RuidaConfiguration)
@@ -56,11 +56,11 @@ def plugin(service, lifecycle):
         service.register("winpath/Controller", service)
         service.register("winpath/Configuration", service)
 
-        service.register("property/RasterOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/CutOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/EngraveOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/ImageOpNode/Ruida", RuidaOperationPanel)
-        service.register("property/DotsOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/RasterOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/CutOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/EngraveOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/ImageOpNode/Ruida", RuidaOperationPanel)
+        # service.register("property/DotsOpNode/Ruida", RuidaOperationPanel)
 
         service.add_service_delegate(RuidaGui(service))
 

meerk40t/ruida/gui/ruidaoperationproperties.py

@@ -17,16 +17,7 @@ class RuidaOperationPanel(ScrolledPanel):
         self.parent = args[0]
         self.operation = node
 
-        choices = [
-            {
-                "attr": "air_assist",
-                "object": node,
-                "default": True,
-                "type": bool,
-                "label": _("Air Assist"),
-                "tip": _("Trigger the per element air assist"),
-            },
-        ]
+        choices = []
 
         self.panel = ChoicePropertyPanel(
             self, wx.ID_ANY, context=self.context, choices=choices, scrolling=False

meerk40t/ruida/rdjob.py

@@ -1376,13 +1376,13 @@ class RDJob:
         part = current_settings.get("part", 0)
         speed = current_settings.get("speed", 0)
         power = current_settings.get("power", 0) / 10.0
-        air = current_settings.get("air_assist", True)
+        air = current_settings.get("coolant", 0)
         self.layer_end()
         self.layer_number_part(part)
         self.laser_device_0()
-        if air:
+        if air == 1:
             self.air_assist_on()
-        else:
+        elif air==2:
             self.air_assist_off()
         self.speed_laser_1(speed)
         self.laser_on_delay(0)

meerk40t/tools/geomstr.py

@@ -179,6 +179,94 @@ def remove(s, i):
     """
     s[i:-1] = s[i + 1 :]
 
+def stitch_geometries(geometry_list:list, tolerance:float=0.0) -> list:
+    action_list = list(geometry_list)
+    result_list = []
+    start_points = []
+    end_points = []
+    anychanges = True
+    were_stitches = False
+    iteration_loop = 0
+    while anychanges:
+        iteration_loop += 1
+        # print (f"Loop {iteration_loop}")
+        anychanges = False
+        for g1 in action_list:
+            if g1 is None:
+                continue
+            fp1 = g1.first_point
+            lp1 = g1.last_point
+            if fp1 is None or lp1 is None:
+                continue
+            was_stitched = False
+            for idx, g2 in enumerate(result_list):
+                fp2 = start_points[idx]
+                lp2 = end_points[idx]
+                # end - start: append
+                # end - end : append reverse
+                # start - start: insert reverse
+                # start - end: insert
+                dist_e_s = abs(lp2 - fp1)
+                dist_e_e = abs(lp2 - lp1)
+                dist_s_s = abs(fp2 - fp1)
+                dist_s_e = abs(fp2 - lp1)
+                # print (f"test #{idx} ({fp1.real:.2f},{fp1.imag:.2f})->({lp1.real:.2f},{lp1.imag:.2f}) versus ({fp2.real:.2f},{fp2.imag:.2f})->({lp2.real:.2f},{lp2.imag:.2f})")
+                # print (f"Gaps: e -> s: {dist_e_s:.3f}, e -> e: {dist_e_e:.3f}, s -> s: {dist_s_s:.3f},s -> e: {dist_s_e:.3f},")
+                if dist_e_s <= tolerance:
+                    # append
+                    if dist_e_s > 0:
+                        g2.line(lp2, fp1)
+                    g2.append(g1, end=False)
+                    was_stitched = True
+                elif dist_e_e <= tolerance:
+                    # append reverse
+                    g1.reverse()
+                    if dist_e_e > 0:
+                        g2.line(lp2, lp1)
+                    g2.append(g1, end=False)
+                    was_stitched = True
+                elif dist_s_s <= tolerance:
+                    # insert reverse
+                    g1.reverse()
+                    if dist_s_s > 0:
+                        g1.line(fp1, fp2)
+                    g2.insert(0, g1.segments[:g1.index])
+                    was_stitched = True
+                elif dist_s_e <= tolerance:
+                    # insert
+                    if dist_s_e > 0:
+                        g1.line(lp1, fp2)
+                    g2.insert(0, g1.segments[:g1.index])
+                    was_stitched = True
+                if was_stitched:
+                    # print ("stitched")
+                    # g2.debug_me()
+                    anychanges = True
+                    start_points[idx] = g2.first_point
+                    end_points[idx] = g2.last_point
+                    result_list[idx] = g2
+                    were_stitches = True
+                    break
+
+            if not was_stitched:
+                # print ("Unchanged")
+                result_list.append(g1)
+                start_points.append(fp1)
+                end_points.append(lp1)
+        if anychanges:
+            action_list = list(result_list)
+            result_list.clear()
+            start_points.clear()
+            end_points.clear()
+    if were_stitches:
+        for g1 in result_list:
+            fp1 = g1.first_point
+            lp1 = g1.last_point
+            dist_e_s = abs(lp1 - fp1)
+            if 0 < dist_e_s <= tolerance:
+                g1.line(lp1, fp1)
+        return result_list
+    return None
 
 class Simplifier:
     # Copyright (c) 2014 Elliot Hallmark

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

meerk40t/tools/shxparser.py

@@ -229,6 +229,22 @@ class ShxFont:
                 self._parse_unifont(f)
             else:
                 raise ShxFontParseError(f"{self.type} is not a valid shx file type.")
+            self.translate_names_to_codes()
+
+    def translate_names_to_codes(self):
+        # We can't properly deal with long names, 
+        # so we translate them a virtual character 
+        gdict = list(self.glyphs.items())
+        virtual_char = len(self.glyphs)
+        for key, data in gdict:
+            if isinstance(key, str) and len(key) > 1:
+                while True:
+                    newkey = chr(virtual_char)
+                    if newkey not in self.glyphs:
+                        break
+                    virtual_char += 1
+                self.glyphs[newkey] = data
+                del self.glyphs[key]
 
     def _parse_header(self, f):
         header = read_string(f)
@@ -351,6 +367,7 @@ class ShxFont:
         try:
             return self._code.pop()
         except IndexError as e:
+            print (f"Error in {self.font_name}: no codes to pop")
             raise ShxFontParseError("No codes to pop()") from e
 
     def render(
@@ -471,7 +488,10 @@ class ShxFont:
         line_lengths = _do_render(vtext, offsets)
 
     def _parse_code(self):
-        b = self.pop()
+        try:
+            b = self.pop()
+        except ShxFontParseError:
+            return
         direction = b & 0x0F
         length = (b & 0xF0) >> 4
         if length == 0:
@@ -608,7 +628,10 @@ class ShxFont:
 
         :return:
         """
-        factor = self.pop()
+        try:
+            factor = self.pop()
+        except ShxFontParseError:
+            return
         if self._debug:
             print(
                 f"DIVIDE_VECTOR {self._scale}/{factor} {'(Skipped)' if self._skip else ''}"
@@ -679,7 +702,10 @@ class ShxFont:
         self._last_x, self._last_y = self._x, self._y
 
     def _draw_subshape_shapes(self):
-        subshape = self.pop()
+        try:
+            subshape = self.pop()
+        except ShxFontParseError:
+            return
         if self._debug:
             print(
                 f"Appending glyph {subshape} (Type={self.type}). {'(Skipped)' if self._skip else ''}"
@@ -694,21 +720,28 @@ class ShxFont:
         self._code += bytearray(reversed(shape))
 
     def _draw_subshape_bigfont(self):
-        subshape = self.pop()
+        try:
+            subshape = self.pop()
+        except ShxFontParseError:
+            return
         if self._debug:
             print(
                 f"Appending glyph {subshape} (Type={self.type}). {'(Skipped)' if self._skip else ''}"
             )
         if subshape == 0:
-            subshape = int_16le([self.pop(), self.pop()])
-            origin_x = self.pop() * self._scale
-            origin_y = self.pop() * self._scale
-            width = self.pop() * self._scale
-            height = self.pop() * self._scale
-            if self._debug:
-                print(
-                    f"Extended Bigfont Glyph: {subshape}, origin_x = {origin_x}, origin_y = {origin_y}. {width}x{height}"
-                )
+            try:
+                subshape = int_16le([self.pop(), self.pop()])
+            
+                origin_x = self.pop() * self._scale
+                origin_y = self.pop() * self._scale
+                width = self.pop() * self._scale
+                height = self.pop() * self._scale
+                if self._debug:
+                    print(
+                        f"Extended Bigfont Glyph: {subshape}, origin_x = {origin_x}, origin_y = {origin_y}. {width}x{height}"
+                    )
+            except ShxFontParseError:
+                return
         if self._skip:
             self._skip = False
             return
@@ -719,7 +752,11 @@ class ShxFont:
         self._code += bytearray(reversed(shape))
 
     def _draw_subshape_unifont(self):
-        subshape = int_16le([self.pop(), self.pop()])
+        try:
+            subshape = int_16le([self.pop(), self.pop()])
+        except ShxFontParseError:
+            return
+
         if self._debug:
             print(
                 f"Appending glyph {subshape} (Type={self.type}). {'(Skipped)' if self._skip else ''}"
@@ -755,8 +792,12 @@ class ShxFont:
         ranges from -128 to +127.
         :return:
         """
-        dx = signed8(self.pop()) * self._scale
-        dy = signed8(self.pop()) * self._scale
+        try:
+            dx = signed8(self.pop()) * self._scale
+            dy = signed8(self.pop()) * self._scale
+        except ShxFontParseError:
+            return
+
         if self._debug:
             print(f"XY_DISPLACEMENT {dx} {dy} {'(Skipped)' if self._skip else ''}")
         if self._skip:
@@ -777,8 +818,11 @@ class ShxFont:
         :return:
         """
         while True:
-            dx = signed8(self.pop()) * self._scale
-            dy = signed8(self.pop()) * self._scale
+            try:
+                dx = signed8(self.pop()) * self._scale
+                dy = signed8(self.pop()) * self._scale
+            except ShxFontParseError:
+                return
             if self._debug:
                 print(
                     f"POLY_XY_DISPLACEMENT {dx} {dy} {'(Skipped)' if self._skip else ''}"
@@ -816,8 +860,11 @@ class ShxFont:
         and the span.
         :return:
         """
-        radius = self.pop() * self._scale
-        sc = signed8(self.pop())
+        try:
+            radius = self.pop() * self._scale
+            sc = signed8(self.pop())
+        except ShxFontParseError:
+            return
         s = (sc >> 4) & 0x7
         c = sc & 0x7
         if self._debug:
@@ -858,13 +905,15 @@ class ShxFont:
         90° + (28/256 * 45°) = 95°
         """
         octant = tau / 8.0
-        start_offset = octant * self.pop() / 256.0
-        end_offset = octant * self.pop() / 256.0
-        radius = (256 * self.pop() + self.pop()) * self._scale
-        sc = signed8(self.pop())
-        s = (sc >> 4) & 0x7
-        c = sc & 0x7
-
+        try:
+            start_offset = octant * self.pop() / 256.0
+            end_offset = octant * self.pop() / 256.0
+            radius = (256 * self.pop() + self.pop()) * self._scale
+            sc = signed8(self.pop())
+            s = (sc >> 4) & 0x7
+            c = sc & 0x7
+        except ShxFontParseError:
+            return
         if self._debug:
             print(
                 f"FRACTION_ARC {start_offset}, {end_offset}, {radius}, {s}, {c} {'(Skipped)' if self._skip else ''}"
@@ -903,10 +952,12 @@ class ShxFont:
 
         :return:
         """
-
-        dx = signed8(self.pop()) * self._scale
-        dy = signed8(self.pop()) * self._scale
-        h = signed8(self.pop())
+        try:
+            dx = signed8(self.pop()) * self._scale
+            dy = signed8(self.pop()) * self._scale
+            h = signed8(self.pop())
+        except ShxFontParseError:
+            return
 
         if self._debug:
             print(f"BULGE_ARC {dx}, {dy}, {h} {'(Skipped)' if self._skip else ''}")
@@ -939,8 +990,12 @@ class ShxFont:
         """
         h = 0
         while True:
-            dx = signed8(self.pop()) * self._scale
-            dy = signed8(self.pop()) * self._scale
+            try:
+                dx = signed8(self.pop()) * self._scale
+                dy = signed8(self.pop()) * self._scale
+            except ShxFontParseError:
+                return
+
             if self._debug:
                 print(
                     f"POLY_BULGE_ARC {dx}, {dy}, {h} {'(Skipped)' if self._skip else ''}"
@@ -949,7 +1004,10 @@ class ShxFont:
                 if self._debug:
                     print(f"POLY_BULGE_ARC (TERMINATED)")
                 break
-            h = signed8(self.pop())
+            try:
+                h = signed8(self.pop())
+            except ShxFontParseError:
+                return
             if self._skip:
                 continue
             r = abs(complex(dx, dy)) / 2

{meerk40t-0.9.7010.dist-info → meerk40t-0.9.7030.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: meerk40t
-Version: 0.9.7010
+Version: 0.9.7030
 Summary: MeerK40t LaserCutter Software
 Home-page: https://github.com/meerk40t/meerk40t
 Author: Tatarize