Merge pull request mrbeam#1536 from mrbeam/SW-1338__back_propagation

SW-1338  back propagation

Author: Yelko-mrbeam

README.md

@@ -35,10 +35,16 @@ Access from the browser:
 ## Running unit tests
 Create a Python 2 virtual environment and activate it:
 ```shell
-virtualenv -p /usr/bin/python2.7 tests_req
+virtualenv -p /usr/bin/python2.7 tests_venv
+source tests_venv/bin/activate
+```
+
+Install test requirements:
+```shell
+pip install -r test-requirements.txt
 ```
 
 Run the unit tests directly from **Pycharm** or from the command line:
 ```shell
-python -m pytest paht/to/MrBeamPlugin/tests/
+python -m pytest tests/
 ```

octoprint_mrbeam/__init__.py

@@ -13,6 +13,7 @@
 import datetime
 import collections
 import logging
+import unicodedata
 from subprocess import check_output
 
 import octoprint.plugin
@@ -38,6 +39,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

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/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)
 

octoprint_mrbeam/decorator/__init__.py

@@ -0,0 +1,27 @@
+from functools import wraps
+
+from octoprint_mrbeam.model import EmptyImport
+
+
+def prevent_execution_on_import_error(import_to_check, default_return=None, callable=None, params=None):
+    def decorator(function):
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            if is_empty_import(import_to_check):
+                if callable is None:
+                    return default_return
+                elif params is None:
+                    return callable()
+                else:
+                    return callable(*params)
+
+            result = function(*args, **kwargs)
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+def is_empty_import(import_to_check):
+    return isinstance(import_to_check, EmptyImport)

octoprint_mrbeam/decorator/catch_import_error.py

@@ -1,4 +1,4 @@
-iobeam==1.0.0a0
-mrb-hw-info==1.0.0a0
-mrbeam-ledstrips==1.0.0a0
-mrbeamdoc==1.0.0a0
+iobeam==1.0.0
+mrb-hw-info==1.0.0
+mrbeam-ledstrips==1.0.0
+mrbeamdoc==1.0.0

octoprint_mrbeam/dependencies.txt

@@ -72,6 +72,7 @@ def __init__(self, plugin):
         self._just_initialized = False
 
         self._last_rpm_values = deque(maxlen=5)
+        self._last_pressure_values = deque(maxlen=5)
         self._job_dust_values = []
 
         self.extraction_limit = 0.3
@@ -120,6 +121,9 @@ def shutdown(self):
 
     def _subscribe(self):
         self._iobeam.subscribe(IoBeamValueEvents.DYNAMIC_VALUE, self._handle_fan_data)
+        self._iobeam.subscribe(
+            IoBeamValueEvents.EXHAUST_DYNAMIC_VALUE, self._handle_exhaust_data
+        )
         self._iobeam.subscribe(
             IoBeamValueEvents.FAN_ON_RESPONSE, self._on_command_response
         )
@@ -142,6 +146,25 @@ def _subscribe(self):
         self._event_bus.subscribe(OctoPrintEvents.PRINT_RESUMED, self._onEvent)
         self._event_bus.subscribe(OctoPrintEvents.SHUTDOWN, self._onEvent)
 
+    def _handle_exhaust_data(self, args):
+        """
+        hanldes exhaust data comming from iobeam EXHAUST_DYNAMIC_VALUE event
+
+        Args:
+            args: data from the iobeam event
+
+        Returns:
+
+        """
+        pressure = args.get("pressure", None)
+        if pressure is not None:
+            self._logger.debug(
+                "last pressure values append {} - {}".format(
+                    pressure, self._last_pressure_values
+                )
+            )
+            self._last_pressure_values.append(pressure)
+
     def _handle_fan_data(self, args):
         err = False
         if args["state"] is not None:
@@ -247,19 +270,13 @@ def _finish_test_fan_rpm(self):
         try:
             # Write to analytics if the values are valid
             if self._validate_values():
-                if len(self._last_rpm_values):
-                    rpm_average = sum(self._last_rpm_values) / len(
-                        self._last_rpm_values
-                    )
-                else:
-                    rpm_average = -1
-
                 data = dict(
-                    rpm_val=rpm_average,
+                    rpm_val=list(self._last_rpm_values),
                     fan_state=self._state,
                     usage_count=self._usage_handler.get_total_usage(),
                     prefilter_count=self._usage_handler.get_prefilter_usage(),
                     carbon_filter_count=self._usage_handler.get_carbon_filter_usage(),
+                    pressure_val=list(self._last_pressure_values),
                 )
                 self._analytics_handler.add_fan_rpm_test(data)
 
@@ -463,12 +480,15 @@ def _validate_values(self):
 
         if not result and not self._plugin.is_boot_grace_period():
             msg = "Fan error: {errs}".format(errs=", ".join(errs))
-            log_message = msg + " - Data from iobeam: state:{state}, rpm:{rpm}, dust:{dust}, connected:{connected}, age:{age:.2f}s".format(
-                state=self._state,
-                rpm=self._rpm,
-                dust=self._dust,
-                connected=self._connected,
-                age=(time.time() - self._data_ts),
+            log_message = (
+                msg
+                + " - Data from iobeam: state:{state}, rpm:{rpm}, dust:{dust}, connected:{connected}, age:{age:.2f}s".format(
+                    state=self._state,
+                    rpm=self._rpm,
+                    dust=self._dust,
+                    connected=self._connected,
+                    age=(time.time() - self._data_ts),
+                )
             )
             self._pause_laser(
                 trigger=msg, analytics="invalid-old-fan-data", log_message=msg

octoprint_mrbeam/iobeam/dust_manager.py

@@ -55,6 +55,7 @@ class IoBeamValueEvents(object):
     RPM_VALUE = "iobeam.rpm.value"
     STATE_VALUE = "iobeam.state.value"
     DYNAMIC_VALUE = "iobeam.dynamic.value"
+    EXHAUST_DYNAMIC_VALUE = "iobeam.exhaust.dynamic"
     CONNECTED_VALUE = "iobeam.connected.value"
     FAN_ON_RESPONSE = "iobeam.fan.on.response"
     FAN_OFF_RESPONSE = "iobeam.fan.off.response"
@@ -1068,7 +1069,13 @@ def _handle_exhaust(self, dataset):
         :param dataset:
         :return: error count
         """
-        # self._logger.info("exhaust dataset: '%s'", dataset)
+        self._logger.debug("exhaust dataset: '%s'", dataset)
+        # get the pressure sensor reading this will come as dust with the current iobeam version
+        if "dust" in dataset:
+            vals = {
+                "pressure": dataset["dust"],
+            }
+            self._call_callback(IoBeamValueEvents.EXHAUST_DYNAMIC_VALUE, dataset, vals)
         return 0
 
     def _handle_link_quality(self, dataset):