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

meerk40t/extra/coolant.py

@@ -0,0 +1,403 @@
+"""
+This module provides interfaces to coolants (airassist or others).
+External modules can register the existence of an airassist.
+Devices can then claim ownership of such a registered device
+and react on device specific coolant commands
+"""
+
+
+class Coolants:
+    """
+    Base class
+    """
+
+    def __init__(self, kernel):
+        self.kernel = kernel
+        self._coolants = []
+        # {
+        #     "id": cool_id,
+        #     "label": label,
+        #     "function": cool_function,
+        #     "config": config_function,
+        #     "devices": [],
+        #     "constraints": constraints,
+        # }
+
+    def remove_coolant_method(self, cool_id):
+        cool_id = cool_id.lower()
+        if cool_id in ("popup", "gcode_m7", "gcode_m8"):
+            # builtin...
+            return 0
+        to_be_deleted = []
+        for idx, cool in enumerate(self._coolants):
+            if cool_id == cool["id"]:
+                to_be_deleted.insert(0, idx)
+        for idx in to_be_deleted:
+            self._coolants.pop(idx)
+        return len(to_be_deleted)
+
+    def register_coolant_method(
+        self, cool_id, cool_function, config_function=None, label=None, constraints=None
+    ):
+        """
+        Announces the availability of a new coolant method.
+        Mainly used from plugins.
+        Args:
+            cool_id ([str]): unique identifier for the method. There are two predefined
+                methods generated from within meerk40t:
+                a) 'popup' which just popups an instruction message
+                    to turn on / off the airassist
+                b) 'grbl' which uses the internal M7 / M9 commands ofa grbl compatible
+                    device. So it has a 'grbl' constraint (see below)
+            cool_function ([function]): The routine to call when coolant needs
+                to be activated / deactivated. This routine expects two parameters:
+                    def coolant_method (device, flag)
+                        device: device that uses the routine
+                        flag: indicator to turn it on (True) or off (False)
+            config_function ([function], optional): The routine to call, if you want
+                to edit parameters for this method. It expects one
+                Defaults to None, indicating it has no such function.
+            label ([str], optional): A description of the method.
+                Defaults to None which will use the cool_id as label
+            constraints ([str], optional): [description].
+                Defaults to None, so available to all devices.
+        Returns:
+            [type]: [description]
+        """
+        cool_id = cool_id.lower()
+
+        for cool in self._coolants:
+            # A coolant method with that id had already been registered
+            # so we just update it. Honestly this should not happen.
+            if cool_id == cool["id"]:
+                cool["label"] = label
+                cool["function"] = cool_function
+                cool["config"] = config_function
+                cool["constraints"] = constraints
+                return True
+        self._coolants.append(
+            {
+                "id": cool_id,
+                "label": label,
+                "function": cool_function,
+                "config": config_function,
+                "devices": [],
+                "constraints": constraints,
+                "current_state": [],
+            }
+        )
+        return True
+
+    def coolant_on(self, device):
+        for cool in self._coolants:
+            if device in cool["devices"]:
+                idx = cool["devices"].index(device)
+                if not cool["current_state"][idx]:
+                    cool["current_state"][idx] = True
+                    routine = cool["function"]
+                    routine(device, True)
+                    self.kernel.signal("coolant_set", device.label, True)
+                return True
+        return False
+
+    def coolant_off(self, device):
+        for cool in self._coolants:
+            if device in cool["devices"]:
+                idx = cool["devices"].index(device)
+                if cool["current_state"][idx]:
+                    cool["current_state"][idx] = False
+                    routine = cool["function"]
+                    routine(device, False)
+                    self.kernel.signal("coolant_set", device.label, False)
+                return True
+        return False
+
+    def coolant_toggle(self, device):
+        for cool in self._coolants:
+            if device in cool["devices"]:
+                idx = cool["devices"].index(device)
+                new_state = not cool["current_state"][idx]
+                cool["current_state"][idx] = new_state
+                routine = cool["function"]
+                routine(device, new_state)
+                self.kernel.signal("coolant_set", device.label, new_state)
+                return True
+        return False
+
+    def coolant_state(self, device):
+        for cool in self._coolants:
+            if device in cool["devices"]:
+                idx = cool["devices"].index(device)
+                return cool["current_state"][idx]
+        # Nothing found
+        return False
+
+    def coolant_on_by_id(self, identifier):
+        # Caveat, this will be executed independently of devices registered!
+        cool_id = identifier.lower()
+        for cool in self._coolants:
+            if cool_id == cool["id"]:
+                routine = cool["function"]
+                routine(None, True)
+                return True
+        return False
+
+    def coolant_off_by_id(self, identifier):
+        # Caveat, this will be executed independently of devices registered!
+        cool_id = identifier.lower()
+        for cool in self._coolants:
+            if cool_id == cool["id"]:
+                routine = cool["function"]
+                routine(None, False)
+                return True
+        return False
+
+    def registered_coolants(self):
+        """
+        Returns the dictionary of all registered coolants
+        """
+        return self._coolants
+
+    def claim_coolant(self, device, coolant):
+        found = None
+        if coolant is None:
+            coolant = ""
+        devname = device.name.lower()
+        # print (f"Claim: {device.label} ({devname}): {coolant}")
+        for cool in self._coolants:
+            relevant = True
+            if cool["constraints"]:
+                allowed = cool["constraints"].split(",")
+                relevant = any(candidate.lower() in devname for candidate in allowed)
+            if not relevant:
+                # Skipped as not relevant...
+                continue
+            if cool["id"] == coolant.lower():
+                found = cool["function"]
+                if device not in cool["devices"]:
+                    cool["devices"].append(device)
+                    cool["current_state"].append(False)
+            else:
+                try:
+                    idx = cool["devices"].index(device)
+                    cool["devices"].pop(idx)
+                    cool["current_state"].pop(idx)
+                except ValueError:
+                    # wasn't inside
+                    pass
+
+        return found
+
+    def get_device_function(self, device, coolant=None):
+        found = None
+        for cool in self._coolants:
+            if coolant is None:
+                if device in cool["devices"]:
+                    found = cool["function"]
+                    break
+            elif cool["id"] == coolant.lower():
+                found = cool["function"]
+                break
+
+        return found
+
+    def get_device_coolant(self, device, coolant=None):
+        found = None
+        for cool in self._coolants:
+            if coolant is None:
+                if device in cool["devices"]:
+                    found = cool
+                    break
+            elif cool["id"] == coolant.lower():
+                found = cool
+                break
+
+        return found
+
+    def get_devices_using(self, coolant_id):
+        dev_str = ""
+        multiple = False
+        for cool in self._coolants:
+            if cool["id"] == coolant_id.lower():
+                for idx, dev in enumerate(cool["devices"]):
+                    if multiple:
+                        dev_str += ", "
+                    multiple = True
+                    dev_str += (
+                        f"{dev.label} [{'on' if cool['current_state'][idx] else 'off'}]"
+                    )
+                break
+
+        return dev_str
+
+    def coolant_choice_helper(self, device):
+        """
+        Sets the choices and display of the coolant values dynamically
+        @param choice_dict:
+        @return:
+        """
+
+        def update(choice_dict):
+            _ = self.kernel.translation
+            devname = device.name.lower()
+            choices = []
+            display = []
+            choices.append("")
+            display.append(_("Nothing"))
+            for cool in self._coolants:
+                relevant = True
+                if cool["constraints"]:
+                    relevant = False
+                    allowed = cool["constraints"].split(",")
+                    for candidate in allowed:
+                        if candidate.lower() in devname:
+                            relevant = True
+                            break
+                if not relevant:
+                    continue
+                choices.append(cool["id"])
+                if cool["label"]:
+                    display.append(cool["label"])
+                else:
+                    display.append(cool["id"])
+            choice_dict["choices"] = choices
+            choice_dict["display"] = display
+
+        return update
+
+
+def plugin(kernel, lifecycle):
+    if lifecycle == "register":
+        _ = kernel.translation
+        context = kernel.root
+        context.coolant = Coolants(kernel)
+
+        def base_coolant_popup(context, mode):
+            if hasattr(context, "label"):
+                lasername = context.label
+            else:
+                lasername = "your laser"
+            if mode:
+                msg = _("Please switch the airassist for {laser} on").format(
+                    laser=lasername
+                )
+            else:
+                msg = _("Please switch the airassist for {laser} off").format(
+                    laser=lasername
+                )
+            context.kernel.yesno(
+                msg, caption=_("Air-Assist"), option_yes=_("OK"), option_no=_("OK")
+            )
+
+        def base_coolant_grbl_m7(context, mode):
+            if mode:
+                context("gcode M7\n")
+            else:
+                context("gcode M9\n")
+
+        def base_coolant_grbl_m8(context, mode):
+            if mode:
+                context("gcode M8\n")
+            else:
+                context("gcode M9\n")
+
+        context.coolant.register_coolant_method(
+            "popup", base_coolant_popup, config_function=None, label=_("Warnmessage")
+        )
+        context.coolant.register_coolant_method(
+            "gcode_m7",
+            base_coolant_grbl_m7,
+            config_function=None,
+            label=_("GCode M7/M9"),
+            constraints="grbl",
+        )
+        context.coolant.register_coolant_method(
+            "gcode_m8",
+            base_coolant_grbl_m8,
+            config_function=None,
+            label=_("GCode M8/M9"),
+            constraints="grbl",
+        )
+
+        @context.console_command(
+            ("coolants", "vents"), help=_("displays registered coolant methods")
+        )
+        def display_coolant(command, channel, _, **kwargs):
+            # elements = context.elements
+            coolant = kernel.root.coolant
+            cool = coolant.registered_coolants()
+            if len(cool):
+                channel(_("Registered coolant-interfaces:"))
+                for cool_instance in cool:
+                    c_name = cool_instance["id"]
+                    c_label = cool_instance["label"]
+                    claimed = coolant.get_devices_using(c_name)
+                    if c_label:
+                        c_name += " - " + c_label
+                    if claimed == "":
+                        claimed = _("Not used")
+
+                    channel(_("{name}: {devices}").format(name=c_name, devices=claimed))
+
+            else:
+                channel(_("There are no coolant-interfaces known to MeerK40t"))
+
+        @context.console_command(
+            ("coolant_on", "vent_on"), help=_("Turns on the coolant for the active device")
+        )
+        def turn_coolant_on(command, channel, _, **kwargs):
+            try:
+                device = context.device
+            except AttributeError:
+                channel("No active device found")
+                return
+
+            coolant = kernel.root.coolant
+            if coolant.coolant_on(device):
+                channel("Coolant turned on")
+            else:
+                channel("Active device does not support coolant")
+
+        @context.console_command(
+            ("coolant_off", "vent_off"), help=_("Turns off the coolant for the active device")
+        )
+        def turn_coolant_off(command, channel, _, **kwargs):
+            try:
+                device = context.device
+            except AttributeError:
+                channel("No active device found")
+                return
+
+            coolant = kernel.root.coolant
+            if coolant.coolant_off(device):
+                channel("Coolant turned off")
+            else:
+                channel("Active device does not support coolant")
+
+        @context.console_argument("id", type=str)
+        @context.console_command(
+            ("coolant_on_by_id", "vent_on_by_id"), help=_("Turns the coolant on using the given method")
+        )
+        def turn_coolant_on_by_id(command, channel, _, id=None, **kwargs):
+            if id is None:
+                channel("You need to provide an identifier")
+                return
+            coolant = kernel.root.coolant
+            if coolant.coolant_on_by_id(id):
+                channel(f"Coolant {id} turned on")
+            else:
+                channel(f"Method {id} could not be found")
+        
+        @context.console_argument("id", type=str)
+        @context.console_command(
+            ("coolant_off_by_id", "vent_off_by_id"), help=_("Turns the coolant off using the given method")
+        )
+        def turn_coolant_off_by_id(command, channel, _, id=None, **kwargs):
+            if id is None:
+                channel("You need to provide an identifier")
+                return
+            coolant = kernel.root.coolant
+            if coolant.coolant_off_by_id(id):
+                channel(f"Coolant {id} turned off")
+            else:
+                channel(f"Method {id} could not be found")

meerk40t/extra/encode_detect.py

@@ -0,0 +1,204 @@
+"""
+Try to detect some common encoding patterns.
+Based on https://github.com/magnetikonline/py-encoding-detect
+
+It will detect the following encodings of a text file:
+
+    ASCII
+    UTF-8
+    UTF-16BE
+    UTF-16LE
+
+"""
+
+
+class EncodingDetectFile:
+    ENCODING_ASCII = "ascii"
+    ENCODING_CP1252 = "cp1252"
+    ENCODING_UTF_8 = "utf_8"
+    ENCODING_UTF_16_BE = "utf_16_be"
+    ENCODING_UTF_16_LE = "utf_16_le"
+
+    # http://unicode.org/faq/utf_bom.html#BOM
+    BOM_UTF_8 = "\xef\xbb\xbf"
+    BOM_UTF_16_BE = "\xfe\xff"
+    BOM_UTF_16_LE = "\xff\xfe"
+
+    BYTE_EOL = (13, 10)  # \r\n
+
+    UTF_16_NULL_PERCENT_POSITIVE = 0.7
+    UTF_16_NULL_PERCENT_NEGATIVE = 0.1
+
+    def _detect_bom(self, fh):
+        def result(encoding, bom_marker):
+            return (encoding, bom_marker, None)
+
+        # test 2 byte UTF-16 BOMs
+        file_data = fh.read(2)
+        # print(f"first 2 bytes: {file_data}")
+        if file_data == EncodingDetectFile.BOM_UTF_16_BE:
+            return result(
+                EncodingDetectFile.ENCODING_UTF_16_BE, EncodingDetectFile.BOM_UTF_16_BE
+            )
+
+        if file_data == EncodingDetectFile.BOM_UTF_16_LE:
+            return result(
+                EncodingDetectFile.ENCODING_UTF_16_LE, EncodingDetectFile.BOM_UTF_16_LE
+            )
+
+        # test 3 byte UTF-8 BOM
+        file_data += fh.read(1)
+        # print(f"first 3 bytes: {file_data}")
+        if file_data == EncodingDetectFile.BOM_UTF_8:
+            return result(
+                EncodingDetectFile.ENCODING_UTF_8, EncodingDetectFile.BOM_UTF_8
+            )
+
+        # no BOM marker - return bytes read so far
+        return False, False, file_data
+
+    def _detect_ascii_utf8(self, file_data):
+        ascii_chars_only = True
+
+        byte_follow = 0
+        for file_byte in file_data:
+            # process additional character byte(s)
+            if byte_follow:
+                if 128 <= file_byte <= 191:
+                    byte_follow -= 1
+                    ascii_chars_only = False
+                    continue
+
+                # not ASCII or UTF-8
+                return False
+
+            # determine byte length of character
+            # https://en.wikipedia.org/wiki/UTF-8#Codepage_layout
+            if 1 <= file_byte <= 127:
+                # single byte
+                continue
+
+            if 194 <= file_byte <= 223:
+                # one byte follows
+                byte_follow = 1
+                continue
+
+            if 224 <= file_byte <= 239:
+                # two bytes follow
+                byte_follow = 2
+                continue
+
+            if 240 <= file_byte <= 244:
+                # three bytes follow
+                byte_follow = 3
+                continue
+
+            # not ASCII or UTF-8
+            return EncodingDetectFile.ENCODING_CP1252
+
+        # end of file data [byte_follow] must be zero to ensure last character was consumed
+        if byte_follow:
+            return False
+
+        # success - return ASCII or UTF-8 result
+        return (
+            EncodingDetectFile.ENCODING_ASCII
+            if (ascii_chars_only)
+            else EncodingDetectFile.ENCODING_UTF_8
+        )
+
+    def _detect_utf16(self, file_data):
+        null_byte_odd, null_byte_even = 0, 0
+        eol_odd, eol_even = 0, 0
+
+        odd_byte = None
+        for file_byte in file_data:
+            # build pairs of bytes
+            if odd_byte is None:
+                odd_byte = file_byte
+                continue
+
+            # look for odd/even null byte and check other byte for EOL
+            if odd_byte == 0:
+                null_byte_odd += 1
+                if file_byte in EncodingDetectFile.BYTE_EOL:
+                    eol_even += 1
+
+            elif file_byte == 0:
+                null_byte_even += 1
+                if odd_byte in EncodingDetectFile.BYTE_EOL:
+                    eol_odd += 1
+
+            odd_byte = None
+
+        # attempt detection based on line endings
+        if (not eol_odd) and eol_even:
+            return EncodingDetectFile.ENCODING_UTF_16_BE
+
+        if eol_odd and (not eol_even):
+            return EncodingDetectFile.ENCODING_UTF_16_LE
+
+        # can't detect on line endings - evaluate ratio of null bytes in odd/even positions
+        # this will give an indication of how much ASCII (1-127) level text is present
+        data_size_half = len(file_data) / 2
+        threshold_positive = int(
+            data_size_half * EncodingDetectFile.UTF_16_NULL_PERCENT_POSITIVE
+        )
+        threshold_negative = int(
+            data_size_half * EncodingDetectFile.UTF_16_NULL_PERCENT_NEGATIVE
+        )
+
+        # must have enough file data to have value ([threshold_positive] must be non-zero)
+        if threshold_positive:
+            if (null_byte_odd > threshold_positive) and (
+                null_byte_even < threshold_negative
+            ):
+                return EncodingDetectFile.ENCODING_UTF_16_BE
+
+            if (null_byte_odd < threshold_negative) and (
+                null_byte_even > threshold_positive
+            ):
+                return EncodingDetectFile.ENCODING_UTF_16_LE
+
+        # not UTF-16 - or insufficient data to determine with confidence
+        return False
+
+    def load(self, file_path):
+        # open file
+        try:
+            fh = open(file_path, "rb")
+        except Exception:
+            return False
+
+        # detect a byte order mark (BOM)
+        file_encoding, bom_marker, file_data = self._detect_bom(fh)
+        if file_encoding:
+            # file has a BOM - decode everything past it
+            try:
+                decode = fh.read().decode(file_encoding)
+            except UnicodeDecodeError:
+                return False
+            # print(f"decoded: {decode}")
+            fh.close()
+
+            return (file_encoding, bom_marker, decode)
+
+        # no BOM - read remaining file data
+        file_data += fh.read()
+        #  print(f"All bytes: {file_data}")
+        fh.close()
+
+        # test for ASCII/UTF-8
+        file_encoding = self._detect_ascii_utf8(file_data)
+        if file_encoding:
+            # file is ASCII or UTF-8 (without BOM)
+            return (file_encoding, None, file_data.decode(file_encoding))
+
+        # test for UTF-16
+        file_encoding = self._detect_utf16(file_data)
+        if file_encoding:
+            # file is UTF-16(-like) (without BOM)
+            return (file_encoding, None, file_data.decode(file_encoding))
+
+        # can't determine encoding
+        return False