Merge pull request nunobrum#103 from TSprech/PrintLoggingReplacement

Replacing Print Statements with Logging Module

Author: nunobrum

.gitignore

@@ -1,4 +1,5 @@
 .vscode/
+.idea/
 __pycache__/
 PyLTSpice.egg-info
 venv

PyLTSpice/LTSteps.py

@@ -88,22 +88,22 @@
 import sys
 
 from PyLTSpice.log.ltsteps import *
-
+import logging
+_logger = logging.getLogger("PyLTSpice.LTSteps")
 
 def main():
     """
     Main function for the LTSteps.py script
     """
-
     def valid_extension(filename):
         """A simple function to check if the filename has a valid extension"""
         return filename.endswith('.txt') or filename.endswith('.log') or filename.endswith('.mout')
 
     if len(sys.argv) > 1:
         filename = sys.argv[1]
         if not valid_extension(filename):
-            print("Invalid extension in filename '%s'" % filename)
-            print("This tool only supports the following extensions :'.txt','.log','.mout'")
+            _logger.error("Invalid extension in filename '%s'" % filename)
+            _logger.error("This tool only supports the following extensions :'.txt','.log','.mout'")
             exit(-1)
     else:
         filename = None
@@ -114,8 +114,8 @@ def valid_extension(filename):
                 newer_date = date
                 filename = f
     if filename is None:
-        print("File not found")
-        print("This tool only supports the following extensions :'.txt','.log','.mout'")
+        _logger.error("File not found")
+        _logger.error("This tool only supports the following extensions :'.txt','.log','.mout'")
         exit(-1)
 
     fname_out = None
@@ -126,15 +126,15 @@ def valid_extension(filename):
     elif filename.endswith('.mout'):
         fname_out = filename[:-len('mout')] + 'tmout'
     else:
-        print("Error in file type")
-        print("This tool only supports the following extensions :'.txt','.log','.mout'")
+        _logger.error("Error in file type")
+        _logger.error("This tool only supports the following extensions :'.txt','.log','.mout'")
         exit(-1)
 
     if fname_out is not None:
-        print("Processing File %s" % filename)
-        print("Creating File %s" % fname_out)
+        _logger.debug("Processing File %s" % filename)
+        _logger.debug("Creating File %s" % fname_out)
         if filename.endswith('txt'):
-            print("Processing Data File")
+            _logger.debug("Processing Data File")
             reformat_LTSpice_export(filename, fname_out)
         elif filename.endswith("log"):
             data = LTSpiceLogReader(filename)

PyLTSpice/__init__.py

@@ -6,3 +6,52 @@
 from .sim.spice_editor import SpiceEditor, SpiceCircuit
 from .sim.sim_runner import SimRunner
 from .sim.sim_batch import SimCommander
+
+
+def all_loggers():
+    """
+    Returns all the name strings used as logger identifiers.
+
+    :return: A List of strings which contains all the logger's names used in this library.
+    :rtype: list[str]
+    """
+    return [
+        "PyLTSpice.RunTask",
+        "PyLTSpice.LTSteps",
+        "PyLTSpice.SimClient",
+        "PyLTSpice.SimServer",
+        "PyLTSpice.ServerSimRunner",
+        "PyLTSpice.LTSteps",
+        "PyLTSpice.RawRead",
+        "PyLTSpice.LTSpiceSimulator",
+        "PyLTSpice.NGSpiceSimulator",
+        "PyLTSpice.SimBatch",
+        "PyLTSpice.SimRunner",
+        "PyLTSpice.SimStepper",
+        "PyLTSpice.SpiceEditor",
+        "PyLTSpice.XYCESimulator",
+        "PyLTSpice.SimBatch"]
+
+
+def set_log_level(level):
+    """
+    Sets the logging level for all loggers used in the library.
+
+    :param level: The logging level to be used, eg. logging.ERROR, logging.DEBUG, etc.
+    :type level: int
+    """
+    import logging
+    for logger in all_loggers():
+        logging.getLogger(logger).setLevel(level)
+
+
+def add_log_handler(handler):
+    """
+    Sets the logging handler for all loggers used in the library.
+
+    :param handler: The logging handler to be used, eg. logging.NullHandler
+    :type handler: Handler
+    """
+    import logging
+    for logger in all_loggers():
+        logging.getLogger(logger).addHandler(handler)

PyLTSpice/client_server/sim_client.py

@@ -25,7 +25,8 @@
 import time
 from collections import OrderedDict
 from dataclasses import dataclass
-
+import logging
+_logger = logging.getLogger("PyLTSpice.SimClient")
 
 class SimClientInvalidRunId(LookupError):
     """Raised when asking for a run_no that doesn't exist"""
@@ -104,15 +105,15 @@ def __init__(self, host_address, port):
         self.server = xmlrpc.client.ServerProxy(f'{host_address}:{port}')
         # print(self.server.system.listMethods())
         self.session_id = self.server.start_session()
-        print("started ", self.session_id)
+        _logger.info("started ", self.session_id)
         self.started_jobs = OrderedDict()  # This list keeps track of started jobs on the server
         self.stored_jobs = OrderedDict()  # This list keeps track of finished simulations that haven't yet been transferred.
         self.completed_jobs = 0
         self.minimum_time_between_server_calls = 0.2  # Minimum time between server calls
         self._last_server_call = time.clock()
 
     def __del__(self):
-        print("closing session ", self.session_id)
+        _logger.info("closing session ", self.session_id)
         self.server.close_session(self.session_id)
 
     def run(self, circuit):
@@ -147,7 +148,7 @@ def run(self, circuit):
             self.started_jobs[job_info] = job_info
             return run_id
         else:
-            print(f"Circuit {circuit} doesn't exit")
+            _logger.error(f"Circuit {circuit} doesn't exit")
             return -1
 
     def get_runno_data(self, runno) -> str:

PyLTSpice/client_server/sim_server.py

@@ -20,6 +20,8 @@
 from typing import Tuple
 from xmlrpc.client import Binary
 from xmlrpc.server import SimpleXMLRPCServer
+import logging
+_logger = logging.getLogger("PyLTSpice.SimServer")
 
 import threading
 import zipfile
@@ -46,18 +48,18 @@ def __init__(self, simulator, parallel_sims=4, output_folder='./temp1', port=900
         self.server_thread.start()
 
     def run(self, session_id, circuit_name, zip_data):
-        print("Run ", session_id, circuit_name)
+        _logger.info("Run ", session_id, circuit_name)
         if session_id not in self.sessions:
             return -1  # This indicates that no job is started
         # Create a buffer from the zip data
         zip_buffer = io.BytesIO(zip_data.data)
-        print("Created the buffer")
+        _logger.debug("Created the buffer")
         # Extract the contents of the zip file
         with zipfile.ZipFile(zip_buffer, 'r') as zip_file:
-            print(zip_file.namelist())
+            _logger.debug(zip_file.namelist())
             zip_file.extract(circuit_name, self.output_folder)
 
-        print(f"Running simulation of {circuit_name}")
+        _logger.info(f"Running simulation of {circuit_name}")
         runno = self.simulation_manager.add_simulation(circuit_name)
         if runno != -1:
             self.sessions[session_id].append(runno)
@@ -67,7 +69,7 @@ def start_session(self):
         """Returns an unique key that represents the session. It will be later used to sort the sim_tasks belonging
         to the session."""
         session_id = str(uuid.uuid4())  # Needs to be a string, otherwise the rpc client can't handle it
-        print("Starting session ", session_id)
+        _logger.info("Starting session ", session_id)
         self.sessions[session_id] = []
         return session_id
 
@@ -83,15 +85,15 @@ def status(self, session_id):
 
             * 'stop' - server time
         """
-        print("collecting status for ", session_id)
+        _logger.debug("collecting status for ", session_id)
         ret = []
         for task_info in self.simulation_manager.completed_tasks:
-            print(task_info)
+            _logger.debug(task_info)
             runno = task_info['runno']
             if runno in self.sessions[session_id]:
                 ret.append(runno)  # transfers the dictionary from the simulation_manager completed task
                 # to the return dictionary 
-        print("returning status", ret)
+        _logger.debug("returning status", ret)
         return ret
 
     def get_files(self, session_id, runno) -> Tuple[str, Binary]:
@@ -117,10 +119,10 @@ def close_session(self, session_id):
         return True  # Needs to return always something. None is not supported
 
     def stop_server(self):
-        print("stopping...ServerInterface")
+        _logger.info("stopping...ServerInterface")
         self.simulation_manager.stop()
         self.server.shutdown()
-        print("stopped...ServerInterface")
+        _logger.info("stopped...ServerInterface")
         return True  # Needs to return always something. None is not supported
 
     def running(self):

PyLTSpice/client_server/srv_sim_runner.py

@@ -22,6 +22,8 @@
 from typing import Any, Callable, Union
 from pathlib import Path
 import zipfile
+import logging
+_logger = logging.getLogger("PyLTSpice.ServerSimRunner")
 
 from PyLTSpice.sim.sim_runner import SimRunner
 from PyLTSpice.sim.spice_editor import SpiceEditor
@@ -71,10 +73,10 @@ def run(self) -> None:
                         'start': task.start_time,
                         'stop': task.stop_time,
                     })
-                    print(task, "is finished")
+                    _logger.debug(task, "is finished")
                     del self.runner.sim_tasks[i]
-                    print(self.completed_tasks[-1])
-                    print(len(self.completed_tasks))
+                    _logger.debug(self.completed_tasks[-1])
+                    _logger.debug(len(self.completed_tasks))
 
             time.sleep(0.2)
             if self._stop is True:
@@ -84,13 +86,13 @@ def run(self) -> None:
 
     def add_simulation(self, netlist: Union[str, Path, SpiceEditor], *, timeout: float = 600) -> int:
         """"""
-        print("starting ", netlist)
+        _logger.debug("starting ", netlist)
         task = self.runner.run(netlist, wait_resource=True, timeout=timeout, callback=zip_files)
         if task is None:
-            print("Failed to start task ", netlist)
+            _logger.error("Failed to start task ", netlist)
             return -1
         else:
-            print("Started task ", netlist, " with job_id", task.runno)
+            _logger.info("Started task ", netlist, " with job_id", task.runno)
             return task.runno
 
     def _erase_files_and_info(self, pos):
@@ -114,7 +116,7 @@ def cleanup_completed(self):
             self._erase_files_and_info(0)
 
     def stop(self):
-        print("stopping...ServerSimRunner")
+        _logger.info("stopping...ServerSimRunner")
         self._stop = True
 
     def running(self):

PyLTSpice/log/ltsteps.py

@@ -83,7 +83,8 @@
 from collections import OrderedDict
 from typing import Union, Iterable, List
 from ..utils.detect_encoding import detect_encoding
-
+import logging
+_logger = logging.getLogger("PyLTSpice.LTSteps")
 
 class LTComplex(object):
     """
@@ -207,7 +208,7 @@ def reformat_LTSpice_export(export_file: str, tabular_file: str):
                         header_keys.append(param.split('=')[0])
                     param_header = "\t".join(header_keys)
                     fout.write("Run\t%s\t%s" % (param_header, headers))
-                    print("Run\t%s\t%s" % (param_header, headers))
+                    _logger.debug("Run\t%s\t%s" % (param_header, headers))
                     go_header = False
                     # print("%s\t%s"% (run_no, param_values))
         else:
@@ -336,7 +337,7 @@ def __init__(self, log_filename: str, read_measures=True, step_set={}, encoding=
                 r"^(?P<name>\w+)(:\s+.*)?=(?P<value>[\d\.E+\-\(\)dB,°]+)(( FROM (?P<from>[\d\.E+-]*) TO (?P<to>[\d\.E+-]*))|( at (?P<at>[\d\.E+-]*)))?",
                 re.IGNORECASE)
 
-        print("Processing LOG file", log_filename)
+        _logger.debug("Processing LOG file", log_filename)
         with open(log_filename, 'r', encoding=self.encoding) as fin:
             line = fin.readline()
 
@@ -470,14 +471,14 @@ def __init__(self, log_filename: str, read_measures=True, step_set={}, encoding=
                     if dataname:  # If previous measurement was saved
                         # store the info
                         if len(measurements):
-                            print("Storing Measurement %s (count %d)" % (dataname, len(measurements)))
+                            _logger.debug("Storing Measurement %s (count %d)" % (dataname, len(measurements)))
                             self.measure_count += len(measurements)
                             for k, title in enumerate(headers):
                                 self.dataset[title] = [line[k] for line in measurements]
                         headers = []
                         measurements = []
                     dataname = line[13:]  # text which is after "Measurement: ". len("Measurement: ") -> 13
-                    print("Reading Measurement %s" % line[13:])
+                    _logger.debug("Reading Measurement %s" % line[13:])
                 else:
                     tokens = line.split("\t")
                     if len(tokens) >= 2:
@@ -494,20 +495,20 @@ def __init__(self, log_filename: str, read_measures=True, step_set={}, encoding=
                             headers = [dataname] + tokens[2:]
                             measurements = []
                     else:
-                        print("->", line)
+                        _logger.debug("->", line)
 
                 line = fin.readline()  # advance to the next line
 
             # storing the last data into the dataset
             if dataname:
-                print("Storing Measurement %s (count %d)" % (dataname, len(measurements)))
+                _logger.debug("Storing Measurement %s (count %d)" % (dataname, len(measurements)))
             if len(measurements):
                 self.measure_count += len(measurements)
                 for k, title in enumerate(headers):
                     self.dataset[title] = [line[k] for line in measurements]
 
-            print("%d measurements" % len(self.dataset))
-            print("Identified %d steps, read %d measurements" % (self.step_count, self.measure_count))
+            _logger.debug("%d measurements" % len(self.dataset))
+            _logger.info("Identified %d steps, read %d measurements" % (self.step_count, self.measure_count))
 
     def __getitem__(self, key):
         """
@@ -643,7 +644,7 @@ def export_data(self, export_file: str, append_with_line_prefix=None):
             mode = 'a'  # Appends an existing file
 
         if len(self.dataset) == 0:
-            print("Empty data set. Exiting without writing file.")
+            _logger.warning("Empty data set. Exiting without writing file.")
             return
 
         fout = open(export_file, mode, encoding=self.encoding)