Merge pull request #24 from Josef-MrBeam/beta

stable release

Author: JFSolution

octoprint_mrbeam/__init__.py

@@ -4,6 +4,7 @@
 import __builtin__
 import copy
 import json
+import operator
 import os
 import platform
 import pprint
@@ -13,7 +14,9 @@
 import datetime
 import collections
 import logging
+import unicodedata
 from subprocess import check_output
+import pkg_resources
 
 import octoprint.plugin
 import requests
@@ -38,6 +41,9 @@
 from ._version import get_versions
 
 __version__ = get_versions()["version"]
+if isinstance(__version__, unicode):
+    __version__ = unicodedata.normalize('NFKD', __version__).encode('ascii', 'ignore')
+
 del get_versions
 
 from octoprint_mrbeam.iobeam.iobeam_handler import ioBeamHandler, IoBeamEvents
@@ -100,6 +106,7 @@
 from octoprint_mrbeam.util.uptime import get_uptime, get_uptime_human_readable
 from octoprint_mrbeam.util import get_thread
 from octoprint_mrbeam import camera
+from octoprint_mrbeam.util.version_comparator import compare_pep440_versions
 
 # this is a easy&simple way to access the plugin and all injections everywhere within the plugin
 __builtin__._mrbeam_plugin_implementation = None
@@ -155,6 +162,7 @@ class MrBeamPlugin(
     TIME_NTP_SYNC_CHECK_INTERVAL_FAST = 10.0
     TIME_NTP_SYNC_CHECK_INTERVAL_SLOW = 120.0
 
+
     def __init__(self):
         self.mrbeam_plugin_initialized = False
         self._shutting_down = False
@@ -175,6 +183,7 @@ def __init__(self):
         self._serial_num = None
         self._mac_addrs = dict()
         self._model_id = None
+        self._explicit_update_check = False
         self._grbl_version = None
         self._device_series = self._device_info.get_series()
         self.called_hosts = []
@@ -257,10 +266,10 @@ def initialize(self):
         self.led_event_listener.set_fps(self._settings.get(["leds", "fps"]))
         # start iobeam socket only once other handlers are already initialized so that we can handle info message
         self.iobeam = ioBeamHandler(self)
-        self.temperature_manager = temperatureManager(self)
         self.dust_manager = dustManager(self)
         self.hw_malfunction_handler = hwMalfunctionHandler(self)
         self.laserhead_handler = laserheadHandler(self)
+        self.temperature_manager = temperatureManager(self)
         self.compressor_handler = compressor_handler(self)
         self.wizard_config = WizardConfig(self)
         self.job_time_estimation = JobTimeEstimation(self)
@@ -738,6 +747,16 @@ def calibration_tool_mode(self):
         self._fixEmptyUserManager()
         return ret
 
+    @property
+    def explicit_update_check(self):
+        return self._explicit_update_check
+
+    def set_explicit_update_check(self):
+        self._explicit_update_check = True
+
+    def clear_explicit_update_check(self):
+        self._explicit_update_check = False
+
     ##~~ UiPlugin mixin
 
     def will_handle_ui(self, request):
@@ -811,7 +830,7 @@ def on_ui_render(self, now, request, render_kwargs):
                 now=now,
                 init_ts_ms=time.time() * 1000,
                 language=language,
-                beamosVersionNumber=self._plugin_version,
+                mrBeamPluginVersionNumber=self._plugin_version,
                 beamosVersionBranch=self._branch,
                 beamosVersionDisplayVersion=display_version_string,
                 beamosVersionImage=self._octopi_info,
@@ -1281,6 +1300,16 @@ def generate_backlash_compenation_pattern_gcode(self, data):
             res = dict(calibration_pattern=destFile, target=FileDestinations.LOCAL)
             return jsonify(res)
 
+    # simpleApiCommand: compare_pep440_versions;
+    def handle_pep440_comparison_result(self, data):
+        try:
+            result = compare_pep440_versions(data['v1'], data['v2'], data['operator'])
+            return make_response(json.dumps(result), 200)
+        except KeyError as e:
+            self._logger.error("Key is missing in data: %s", e)
+            return make_response(json.dumps(None), 500)
+
+
     # ~~ helpers
 
     # helper method to write data to user settings
@@ -1347,7 +1376,7 @@ def calibration_wrapper(self):
             locales=dict(),
             supportedExtensions=[],
             # beamOS version
-            beamosVersionNumber=self._plugin_version,
+            mrBeamPluginVersionNumber=self._plugin_version,
             beamosVersionBranch=self._branch,
             beamosVersionDisplayVersion=display_version_string,
             beamosVersionImage=self._octopi_info,
@@ -1913,6 +1942,7 @@ def get_api_commands(self):
             camera_stop_lens_calibration=[],
             generate_calibration_markers_svg=[],
             cancel_final_extraction=[],
+            compare_pep440_versions=[]
         )
 
     def on_api_command(self, command, data):
@@ -2040,6 +2070,8 @@ def on_api_command(self, command, data):
             )  # TODO move this func to other file
         elif command == "cancel_final_extraction":
             self.dust_manager.set_user_abort_final_extraction()
+        elif command == "compare_pep440_versions":
+            return self.handle_pep440_comparison_result(data)
 
         return NO_CONTENT
 
@@ -2981,10 +3013,10 @@ def __calc_time_ntp_offset(self, log_out_of_sync=False):
                 timer.start()
 
     def is_beta_channel(self):
-        return self._settings.get(["dev", "software_tier"]) == SWUpdateTier.BETA
+        return self._settings.get(["dev", "software_tier"]) == SWUpdateTier.BETA.value
 
     def is_develop_channel(self):
-        return self._settings.get(["dev", "software_tier"]) == SWUpdateTier.DEV
+        return self._settings.get(["dev", "software_tier"]) == SWUpdateTier.DEV.value
 
     def _get_mac_addresses(self):
         if not self._mac_addrs:

octoprint_mrbeam/analytics/analytics_handler.py

@@ -36,7 +36,7 @@ def analyticsHandler(plugin):
 
 class AnalyticsHandler(object):
     QUEUE_MAXSIZE = 1000
-    ANALYTICS_LOG_VERSION = 22  # bumped for SW-653 - added frontend event update_info_call_failure to see when this backend call fails
+    ANALYTICS_LOG_VERSION = 23  # bumped for SW-1317 - added pressure to test fan rpm event
 
     def __init__(self, plugin):
         self._plugin = plugin

octoprint_mrbeam/analytics/timer_handler.py

@@ -1,4 +1,5 @@
 # coding=utf-8
+import re
 
 import netifaces
 import requests
@@ -215,7 +216,7 @@ def _software_versions(self):
         it made sens when we did a filesystem checksum calculation... _software_versions_and_checksums()
         """
         sw_versions = self._get_software_versions()
-        self._logger.debug("_software_versions: %s", sw_versions)
+        self._logger.debug("Software Version info: \n{}".format(sw_versions))
         self._plugin.analytics_handler.add_software_versions(sw_versions)
 
     def _software_versions_and_checksums(self):
@@ -279,31 +280,38 @@ def _software_versions_and_checksums(self):
 
     def _get_software_versions(self):
         result = dict()
-        configured_checks = None
+        software_info = None
+
         try:
-            pluginInfo = self._plugin._plugin_manager.get_plugin_info("softwareupdate")
-            if pluginInfo is not None:
-                impl = pluginInfo.implementation
-                configured_checks = impl._configured_checks
-            else:
-                self._logger.error(
-                    "_get_software_versions() Can't get pluginInfo.implementation"
-                )
+            plugin_info = self._plugin._plugin_manager.get_plugin_info("softwareupdate")
+            impl = plugin_info.implementation
+            # using the method get_current_versions() is OK as it is threadsafe
+            software_info, _, _ = impl.get_current_versions()
+            self._logger.debug("Software_info: \n {}".format(software_info))
         except Exception as e:
             self._logger.exception(
-                "Exception while reading configured_checks from softwareupdate plugin. "
+                "Exception while reading software_info from softwareupdate plugin. Error:{} ".format(e)
             )
+            return result
 
-        if configured_checks is None:
+        if isinstance(software_info, dict) is False:
             self._logger.warn(
-                "_get_software_versions() Can't read software version from softwareupdate plugin."
+                "get_current_versions() Can't read software version from softwareupdate plugin."
+            )
+            return result
+
+        # Reaching this section means we are OK so far
+        for name, info in software_info.iteritems():
+            commit_hash = info["information"]["local"].get("name", None)
+            if commit_hash is not None:
+                # regex: "Commit 89nhfbffnf7f8fbfgfndhf" --> "89nhfbffnf7f8fbfgfndhf"
+                regex_match = re.match(r"Commit (\S+)", commit_hash)
+                if regex_match is not None:
+                    commit_hash = regex_match.group(1)
+            result[name] = dict(
+                version=info.get("displayVersion", None),
+                commit_hash=commit_hash,
             )
-        else:
-            for name, config in configured_checks.iteritems():
-                result[name] = dict(
-                    version=config.get("displayVersion", None),
-                    commit_hash=config.get("current", None),
-                )
         return result
 
     def _num_files(self):

octoprint_mrbeam/analytics/usage_handler.py

@@ -1,7 +1,10 @@
 import os
 import time
+import unicodedata
+
 import yaml
 
+from octoprint_mrbeam.iobeam.iobeam_handler import IoBeamValueEvents
 from octoprint_mrbeam.mrb_logger import mrb_logger
 from octoprint.events import Events as OctoPrintEvents
 from octoprint_mrbeam.mrbeam_events import MrBeamEvents
@@ -18,7 +21,6 @@ def usageHandler(plugin):
 
 
 class UsageHandler(object):
-    MAX_DUST_FACTOR = 2.0
     MIN_DUST_FACTOR = 0.5
     MAX_DUST_VALUE = 0.5
     MIN_DUST_VALUE = 0.2
@@ -40,12 +42,6 @@ def __init__(self, plugin):
         self.start_ntp_synced = None
 
         self._last_dust_value = None
-        self._dust_mapping_m = (self.MAX_DUST_FACTOR - self.MIN_DUST_FACTOR) / (
-            self.MAX_DUST_VALUE - self.MIN_DUST_VALUE
-        )
-        self._dust_mapping_b = (
-            self.MIN_DUST_FACTOR - self._dust_mapping_m * self.MIN_DUST_VALUE
-        )
 
         analyticsfolder = os.path.join(
             self._settings.getBaseFolder("base"),
@@ -78,12 +74,26 @@ def _on_mrbeam_plugin_initialized(self, event, payload):
             self._laser_head_serial = self._lh["serial"]
         else:
             self._laser_head_serial = "no_serial"
-
+        self._calculate_dust_mapping()
         self._init_missing_usage_data()
         self.log_usage()
 
         self._subscribe()
 
+    def _calculate_dust_mapping(self):
+        max_dust_factor = self._laserhead_handler.current_laserhead_max_dust_factor
+        self._dust_mapping_m = (max_dust_factor - self.MIN_DUST_FACTOR) / (
+            self.MAX_DUST_VALUE - self.MIN_DUST_VALUE
+        )
+        self._dust_mapping_b = (
+            self.MIN_DUST_FACTOR - self._dust_mapping_m * self.MIN_DUST_VALUE
+        )
+        self._logger.debug(
+            "new dust mapping -> {} - {} - {}".format(
+                max_dust_factor, self._dust_mapping_m, self._dust_mapping_b
+            )
+        )
+
     def log_usage(self):
         self._logger.info(
             "Usage: total_usage: {}, pre-filter: {}, main filter: {}, current laser head: {}, mechanics: {}, compressor: {} - {}".format(
@@ -117,6 +127,9 @@ def _subscribe(self):
         self._event_bus.subscribe(
             MrBeamEvents.LASER_HEAD_READ, self.event_laser_head_read
         )
+        self._plugin.iobeam.subscribe(
+            IoBeamValueEvents.LASERHEAD_CHANGED, self._event_laserhead_changed
+        )
 
     def event_laser_head_read(self, event, payload):
         # Update laser head info if necessary --> Only update if there is a serial number different than the previous
@@ -164,6 +177,17 @@ def event_stop(self, event, payload):
 
             self.write_usage_analytics(action="job_finished")
 
+    def _event_laserhead_changed(self, event):
+        """
+        will be triggered if the laser head changed,
+        refreshes the laserhead max dust factor that will be used for the new laser head
+
+        Returns:
+
+        """
+        self._logger.debug("Laserhead changed recalculate dust mapping")
+        self._calculate_dust_mapping()
+
     def _set_time(self, job_duration):
         if job_duration is not None and job_duration > 0.0:
 
@@ -356,36 +380,66 @@ def _load_usage_data(self):
                 "Trying to recover from _backup_file file: %s", self._backup_file
             )
             recovery_try = True
-            if os.path.isfile(self._backup_file):
+            try:
+                with open(self._backup_file, "r") as stream:
+                    data = yaml.safe_load(stream)
+                if self._validate_data(data):
+                    data["restored"] = (
+                        data["restored"] + 1 if "restored" in data else 1
+                    )
+                    self._usage_data = data
+                    self._write_usage_data()
+                    success = True
+                    self._logger.info("Recovered from _backup_file file. Yayy!")
+            except yaml.constructor.ConstructorError:
                 try:
-                    data = None
-                    with open(self._backup_file, "r") as stream:
-                        data = yaml.safe_load(stream)
-                    if self._validate_data(data):
-                        data["restored"] = (
-                            data["restored"] + 1 if "restored" in data else 1
-                        )
-                        self._usage_data = data
-                        success = True
-                        self._write_usage_data()
-                        self._logger.info("Recovered from _backup_file file. Yayy!")
-                except:
-                    self._logger.error("Can't read _backup_file file.")
+                    success = self._repair_backup_usage_data()
+                except Exception:
+                    self._logger.error("Repair of the _backup_file failed.")
+            except OSError:
+                self._logger.error("There is no _backup_file file.")
+            except yaml.YAMLError:
+                self._logger.error("There was a YAMLError with the _backup_file file.")
+            except:
+                self._logger.error("Can't read _backup_file file.")
 
         if not success:
             self._logger.warn("Resetting usage data. (marking as incomplete)")
             self._usage_data = self._get_usage_data_template()
             if recovery_try:
                 self._write_usage_data()
 
+    def _repair_backup_usage_data(self):
+        """
+        repairs a broken usage backup file, where the version is saved in unicode
+
+        Returns:
+            boolean: successfull
+        """
+        success = False
+        with open(self._backup_file, "r") as stream:
+            data = yaml.load(stream)
+        if self._validate_data(data):
+            #checks if the version is saved in unicode and converts it into a string see SW-1269
+            if isinstance(data["version"], unicode):
+                data["version"] = unicodedata.normalize('NFKD', data["version"]).encode('ascii', 'ignore')
+            data["restored"] = (
+                data["restored"] + 1 if "restored" in data else 1
+            )
+            self._usage_data = data
+            success = True
+            self._write_usage_data()
+            self._logger.info("Could repair _backup_file file. Yayy!")
+        return success
+
     def _write_usage_data(self, file=None):
         self._usage_data["version"] = self._plugin_version
         self._usage_data["ts"] = time.time()
         self._usage_data["serial"] = self._device_serial
         file = self._storage_file if file is None else file
         try:
             with open(file, "w") as outfile:
-                yaml.dump(self._usage_data, outfile, default_flow_style=False)
+                yaml.safe_dump(self._usage_data, outfile, default_flow_style=False)
         except:
             self._logger.exception("Can't write file %s due to an exception: ", file)