SpecLog 0.0.1__tar.gz

speclog-0.0.1/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: SpecLog
+Version: 0.0.1
+Summary: A Python Package for logging data from instrumentations
+Author-email: Yen-Chun Huang <yen-chun.huang@bruker.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: matplotlib>=3.7.1
+Requires-Dist: numpy>=1.24.3
+Requires-Dist: PySide6>=6.9.0
+Requires-Dist: pyqtgraph>=0.13.3
+Requires-Dist: spinlab>=1.1.3
+Requires-Dist: pyserial>=3.5
+
+# SpecLog
+Python Package for Spectrometer Logging

speclog-0.0.1/README.md

@@ -0,0 +1,2 @@
+# SpecLog
+Python Package for Spectrometer Logging

speclog-0.0.1/SpecLog/SpecLog.py

@@ -0,0 +1,277 @@
+"""
+SpecLog: The logging program for instrumentations
+
+SpecLog: read configurations, get available devices, send command and save return.
+
+Author: Yen-Chun Huang
+
+Company: Bridge 12 Technologies, Inc
+"""
+
+from .device import *
+import time
+import datetime
+import os
+from .loggerConfig import *
+from .debugLog import *
+
+
+class SpecLog:
+    def __init__(self, config_file: str = None):
+        self.config = loggerConfig(config_file)
+        self.debugLogger = debugLog(config_file).logger
+        self.settings = self.config.settings
+        self.commands = (
+            self.config.commands
+        )  # dictionary {model: {variable: {command, alias, min, max, static}}}
+        self.device_config = self.config.devices
+
+        self.log_dir = self.settings["log_folder_location"] + "/LOG/"
+        self._checkDirectory()
+
+        self.delay = int(self.settings["log_interval"])
+        self.max_size = int(self.settings["save_file_size_kb"])
+
+        self.connectDevices()
+        self.reconnectDevices()
+        
+        self.data_by_variable = self._getDataDictByVariable(
+            self.commands
+        )  # initial empty dictionary for storing data
+        
+        self.header = self._makeLogHeader()
+        self.last_query_time = None
+        self.current_log_file = None
+        self.warning = 0
+
+    def log(self):
+        """
+        Send command to a valid device, analyze return and save data to log file
+
+        It runs one time only.
+        """
+        # if not self.current_log_file:
+        #     self.debugLogger.info("new log file created")
+        #     self._createNewLog()
+
+        now = time.time()
+        if self.reconnectDevices():  # check the device connections
+            self.debugLogger.info("A device is reconnected")
+        if not self.last_query_time or now - self.last_query_time > self.delay:
+            warning_level = 0
+            self._setTimeInDataDictByVariable()  # update time
+            devices_info = (
+                self.devices.devices_info
+            )  # dictionary: {model: {status, config_status, device, id_command}}
+            for name, info in self.commands.items():
+                delimiter = self.device_config[name]["delimiter"]
+                index = self.device_config[name]["index"]
+                device = devices_info[name]["device"]
+                termination = self.device_config[name]["termination"]
+                for variable in info.keys():
+                    info[variable]['min'], info[variable]['max'], info[variable]['static']
+                    if self.devices.checkDeviceStatus(
+                        name
+                    ):  # check the connection of a device
+                        try:
+                            command = info[variable]["command"]
+                            device.write((command+termination).encode())  # send command to device
+                            data_string = device.read_until(termination.encode()).decode()
+                            data = self._returnStringConverter(
+                                data_string, delimiter, index
+                            )
+                        except Exception as err:
+                            self.devices.device_info["status"] = False
+                            data = "nan"
+                   
+                    else:
+                        data = "nan"  # write nan to not available data
+                    self.data_by_variable[variable] = data
+
+                    # check warning
+                    if data == "nan":
+                        warning_level = 2
+
+                    elif info[variable]['static'] and float(data) != info[variable]['static']:
+                        warning_level = 2
+                    
+                    else:
+                        if info[variable]['min']:
+                            if float(data) <= info[variable]['min'] * 1.05:
+                                warning_level = max(warning_level, 1)
+                            elif float(data) < info[variable]['min']:
+                                warning_level = 2
+                                
+
+                        if info[variable]['max']:
+                            if float(data) >= info[variable]['max'] * 0.95:
+                                warning_level = max(warning_level, 1)
+                            elif float(data) > info[variable]['max']:
+                                warning_level = 2
+                    self.warning = warning_level
+
+            self.last_query_time = now
+
+            # if self._checkFileSize():  # exceed the maximum file size
+            #     if self._createNewLog():  # create log with header
+            #         self.debugLogger.info("File size exceed, new log file created")
+
+            self._saveData()
+
+    def connectDevices(self):
+        """
+        Call DEVICE
+        """
+        self.devices = DEVICE(self.config, self.debugLogger)  # establish communication
+        self.devices._getPorts()
+        self.available_addresses = self.devices.deviceAddresses
+        return True
+
+    def reconnectDevices(self):
+        restart_DEVICE = False
+        self.devices._getPorts()
+        for name in self.device_config.keys():
+            address = self.device_config[name]["address"]
+
+            if (
+                address not in self.devices.deviceAddresses
+                and address in self.available_addresses
+            ):  # when a connection is loss
+                # This step is to prevent the moment when the device is shown in the resource manager but connection fails
+                self.available_addresses.remove(address)
+
+            if (
+                address in self.devices.deviceAddresses
+                and address not in self.available_addresses
+                and not self.devices.devices_info[name]["status"]
+            ):
+                restart_DEVICE = True
+
+        if restart_DEVICE:
+            del self.devices  # delete the DEVICE class
+            return self.connectDevices()
+
+        else:
+            return False
+
+    def _checkDirectory(self):
+        if not os.path.exists(self.log_dir):
+            os.mkdir(self.log_dir)
+            return False
+        return True
+
+    def _findLog(self):
+        """
+        Find current log file
+        
+        """
+        today = datetime.datetime.now().strftime("%Y%m%d")  # YYYYMMDD
+        self.current_log_file = self.log_dir + "/log_" + today + ".csv"
+        
+        return "log_" + today + ".csv" in os.listdir(self.log_dir)
+
+    def _createNewLog(self):
+        """
+        Create new log file in log directory
+        """
+        # now = datetime.datetime.now().strftime("%Y%m%d%H%M%S")  # YYYYMMDDHMS
+
+        with open(self.current_log_file, "w") as f:
+            f.write(self.header)
+
+        return True
+
+    def _makeLogHeader(self):
+        """
+        Make a log header base on the data by variable dictionary
+
+        Return:
+            header (str) format: 'Date, Time, variable 1, variable 2.....'
+        """
+        list_of_items = list(self.data_by_variable.keys())
+        header = ", ".join(list_of_items) + "\n"
+
+        return header
+
+    def _saveData(self):
+        """
+        Save current data to current log file
+
+        """
+        list_of_data = list(self.data_by_variable.values())
+        data_string = ", ".join(list_of_data) + "\n"
+
+        if not self._findLog():
+            self._createNewLog()
+        with open(self.current_log_file, "a") as f:
+            f.write(data_string)
+
+        return True
+
+    # def _checkFileSize(self):
+    #     """
+    #     Check the size of file
+
+    #     Return:
+    #         bool: True if file is oversize
+    #     """
+    #     if os.path.getsize(self.current_log_file) > self.max_size * 1024:
+    #         return True
+    #     else:
+    #         return False
+
+    def _getDataDictByVariable(self, command_dict: dict):
+        """
+        Get the variable list based on the model and it's command dictionary
+        Args:
+            command_dict (dict): the command list for a device, {variable: {command, alias, min, max, static}}
+
+        Returns:
+            data_dict (dict): the data dictionary in format {variable: reading}
+
+        """
+        today = str(datetime.date.today())
+        now = str(datetime.datetime.now().strftime("%H:%M:%S"))
+        data_dict = {"Date": today, "Time": now}
+        for info in command_dict.values():
+            temp_dict = {key: None for key in info}
+            data_dict = {**data_dict, **temp_dict}
+
+        return data_dict
+
+    def _returnStringConverter(self, string: str, delimiter: str, index: int):
+        """
+        Convert returned string and acquire data from it
+        Args:
+            delimiter (str): the delimiter for string analysis
+            index (int): the data index
+
+        Returns:
+            data (string): return data in str
+        """
+        try:
+            if delimiter:
+                data = string.split(delimiter)[index]
+            else:
+                data = string.split()[index]
+            data = data.replace(" ", "")  # remove white space
+            data = data.replace("\n", "")
+            data = data.replace("\t", "") 
+            data = data.replace("\r", "") 
+            data = data.strip()
+        except:
+            self.debugLogger.error("String Convert Fail: recived: %s, delimiter: %s, index: %s" %(string, delimiter, index))
+        return data
+
+    def _setTimeInDataDictByVariable(self):
+        """
+        Update the time in data dictionary by variable
+        """
+        today = str(datetime.date.today())
+        now = str(datetime.datetime.now().strftime("%H:%M:%S"))
+        self.data_by_variable["Date"] = today
+        self.data_by_variable["Time"] = now
+        return True
+
+# if __name__ == '__main__':
+#     SpecLog()

speclog-0.0.1/SpecLog/SpecLogger.py

@@ -0,0 +1,128 @@
+"""
+This is the python program to control pyB12logger 
+"""
+
+import os
+import sys
+import argparse
+import shutil
+import subprocess
+from collections import Counter
+from .SpecLog import *
+
+# auto start and adding icon to desktop (public)
+startup_folder = os.path.join(
+    os.environ["APPDATA"],
+    r"Microsoft\Windows\Start Menu\Programs\Startup"
+)
+desktop_folder = os.path.join(os.environ["USERPROFILE"], "Desktop")
+
+source_running_logger = os.path.join(
+    os.path.dirname(sys.executable), "scripts", "SpecLogger_running.exe"
+)
+
+source_monitor = os.path.join(
+    os.path.dirname(sys.executable), "scripts", "pymonitor.exe"
+)
+
+def main_func():
+    parser = argparse.ArgumentParser(prog="SpecLogger")
+    parser.add_argument(
+        "status",
+        type=str,
+        nargs="?",
+        default=None,
+        choices=["start", "stop"],
+        help="To start/stop SpecLogger. If no argument, the SpecLogger will start by default",
+    )
+    parser.add_argument(
+        "-desktop",
+        type=str,
+        default=False,
+        choices=["True", "False"],
+        help="To create desktop icons",
+    )
+    parser.add_argument(
+        "-startup",
+        type=str,
+        default=None,
+        choices=["True", "False"],
+        help="To enable/disable SpecLogger at startup.",
+    )
+    parser.add_argument(
+        "-debug",
+        type=str,
+        default="False",
+        choices=["True", "False"],
+        help="To start debug console SpecLogger.",
+    )
+    args = parser.parse_args()
+
+    if args.startup == "True":
+        target = os.path.join(startup_folder, "SpecLogger_running.exe")
+        if not os.path.exists(target):
+            shutil.copy(source_running_logger, target)
+            print("SpecLogger will run on startup.")
+    elif args.startup == "False":
+        if not os.path.exists(startup_folder + "/SpecLogger_running.exe"):
+            print(startup_folder + "SpecLogger_running.exe")
+            print("SpecLogger does not run on startup.")
+        else:
+            os.remove(startup_folder + "/SpecLogger_running.exe")
+            print("SpecLogger will not run on startup.")
+
+    if args.desktop == "True":
+        target_logger = os.path.join(desktop_folder, "SpecLogger_running.exe")
+        target_monitor = os.path.join(desktop_folder, "pymonitor.exe")
+
+        if not os.path.exists(target_logger):
+            shutil.copy(source_running_logger, target_logger)
+            print("Create SpecLogger_running.exe on the desktop.")
+        else:
+            print("SpecLogger_running.exe is on desktop already.")
+
+        if not os.path.exists(target_monitor):
+            shutil.copy(source_monitor, target_monitor)
+            print("Create pymonitor.exe on the desktop.")
+        else:
+            print("pymonitor.exe is on desktop already.")
+
+    if not args.startup and not args.desktop and not args.status:  # not arguments
+        args.status = "start"
+
+    if args.status == "start":
+        current_exe = (
+            os.popen("wmic process get description")
+            .read()
+            .strip()
+            .replace(" ", "")
+            .split("\n\n")
+        )
+        hashDict = Counter(current_exe)
+
+        if (
+            "SpecLogger_running.exe" in hashDict
+            and hashDict["SpecLogger_running.exe"] > 0
+        ):
+            print("SpecLogger has started already.")
+            return
+
+        else:
+            if args.debug == "False":
+                subprocess.Popen(
+                    "SpecLogger_running.exe", creationflags=subprocess.CREATE_NO_WINDOW
+                )
+                print("SpecLogger started")
+            elif args.debug == "True":
+                os.startfile("SpecLogger_running.exe")
+                print("SpecLogger debug mode started")
+
+    elif args.status == "stop":
+        os.system("taskkill /im SpecLogger_running.exe /F /t")
+        print("SpecLogger stopped")
+    else:  # ignore
+        return
+
+
+if __name__ == "__main__":
+    main_func()

speclog-0.0.1/SpecLog/__init__.py

@@ -0,0 +1,5 @@
+from .SpecLog import *
+from .device import *
+from .monitor import *
+from .version import *
+from .ui import plotting

speclog-0.0.1/SpecLog/config/config.py

@@ -0,0 +1,93 @@
+"""
+global config
+"""
+import configparser
+from pathlib import Path
+import warnings
+import os
+import shutil
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def _escape_split(s, delim=",", escape="\\"):
+    tokens = []
+    previous_escape = False
+    subtoken = ""
+    for k in range(len(s)):
+        if s[k] == delim and (not previous_escape):
+            if len(subtoken) > 0:
+                tokens.append(subtoken)
+            subtoken = ""  # reset subtoken
+        else:
+            # ESCAPE DELIM  -> DELIM
+            if previous_escape and s[k] != escape and s[k] == delim:
+                subtoken = subtoken[:-1] + s[k]
+            else:
+                # add to subtoken
+                subtoken += s[k]
+            # set previous_escape flag:
+            # If for current char is escape (True and s[k]=='\\') and previous_escape is False -> set it to True
+            # If for current char is escape (True and s[k]=='\\') and previous_escape is True -> case of '\\\\' -> escaping an escape character -> set it back to False
+            # if current char is no escape character -> set it to false
+            previous_escape = (not previous_escape) and (s[k] == escape)
+    if len(subtoken) > 0:
+        tokens.append(subtoken)
+    return tokens
+
+
+def _kwarg_converter(s: str):
+    tokens = _escape_split(s, ",", escape="\\")
+    args = []
+    kwargs = {}
+    for k in tokens:
+        subtokens = _escape_split(k, "=", escape="\\")
+        if len(subtokens) == 1:
+            args.append(subtokens[0])
+        else:
+            kwargs[subtokens[0].strip()] = subtokens[1].strip()
+    return args, kwargs
+
+
+def _get_log_config(configname, key=None):
+    config = configparser.ConfigParser(
+        converters={
+            "list": lambda x: list(x.strip("[").strip("]").split(",")),
+            "args_kwargs": _kwarg_converter,
+        }
+    )
+    # define three possible locations:
+    log_current_config = Path.cwd() / configname
+    log_home_config = Path.home() / configname
+
+    log_cfg_folder = str(Path(__file__).parent)  # / configname #.with_name("config"))
+
+    log_global_config = Path(log_cfg_folder) / configname
+
+    if key == "public":
+        # copy command to public location
+        # check if command location
+        log_public = "C:/Users/Public/"
+        list_dir = os.listdir(log_public)
+        log_dir = log_public + "LOG_Config"
+        if "LOG_Config" not in list_dir:
+            os.mkdir(log_dir)
+
+        log_public_config = log_dir + "/" + configname
+
+        if configname not in os.listdir(log_dir):
+            shutil.copy(log_global_config, log_dir + "/" + configname)
+
+        config.read(log_public_config)
+    else:
+        config_read_list = [log_global_config, log_home_config, log_current_config]
+
+        # user defined takes precedence
+        config.read(config_read_list)
+
+    return config
+
+
+CONFIG = _get_log_config("config.cfg", key="public")

speclog-0.0.1/SpecLog/debugLog.py

@@ -0,0 +1,36 @@
+"""
+This is debug log class for logger
+
+Author: Yen-Chun Huang
+
+Company: Bridge 12 Technologies. Inc
+"""
+
+import logging
+from .loggerConfig import *
+import os
+
+
+class debugLog:
+    def __init__(self, config_file: str = None):
+        config = loggerConfig(config_file)
+        settings = config.settings
+        log_dir = settings["log_folder_location"] + "/LOG/"
+
+        if not os.path.exists(log_dir):
+            os.mkdir(log_dir)
+
+        logpath = log_dir + "/debug_log.txt"
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.DEBUG)
+        ch = logging.FileHandler(str(logpath))
+        ch.setLevel(logging.INFO)
+        ch2 = logging.StreamHandler()
+        ch2.setLevel(logging.DEBUG)
+        formatter = logging.Formatter(
+            "%(asctime)s - [%(filename)s:%(lineno)d] - %(levelname)s - %(message)s"
+        )
+        ch.setFormatter(formatter)
+        ch2.setFormatter(formatter)
+        self.logger.addHandler(ch)
+        self.logger.addHandler(ch2)