[clean] cleaned logs and old code

pyheatpump/cli.py

 import time
 import urllib
 import uvicorn
-from pprint import pprint
 import requests
 
 from pyheatpump.logger import logger_init
 
     build_url = lambda d: '{scheme}://{hostname}:{port}{path}'.format(**d)
 
-    """
-    @TODO : Use a proper certificate 
-
-    if base_url['scheme'] == 'https':
-        certificate = config.get('supervisor', 'certificate')
-        if not os.path.isfile(certificate):
-            raise Exception(f'Certificate not found :{certificate}') 
-        print(certificate)
-    else:
-        certificate = None
-    """
 
     post_url = {
         **base_url,

pyheatpump/config.py

 from starlette.routing import Route, Router
 from starlette.responses import PlainTextResponse, JSONResponse
 from starlette.exceptions import HTTPException
-from pprint import pprint
 import uvicorn
 import json
 
 
     interface = gateways()['default'][AF_INET][1]
     if len(ifaddresses(interface)) == 0:
-        logger.error("Can't find interface")
+        logger.error("Can't find interface %s", interface)
         sys.exit(1)
 
     if len(ifaddresses(interface)[AF_LINK]) == 0:
-        logger.error("Can't find interface")
+        logger.error("Can't find interface %s", interface)
         sys.exit(1)
 
     addr = ifaddresses(interface)[AF_LINK][0]['addr']
             config.set('heatpump','mac_address',mac_address)
             save_config()
         else:
-            print(f'Wrong mac format : {mac_address}')
+            logger.error(f'Wrong mac format : {mac_address}')
 
         return PlainTextResponse(' '.join((
             'Current ->',
         body = await request.body()
         last_update = int(body.decode() or 0)
         if last_update == 0:
-            print(f'Reset last update to current time')
             last_update = int(datetime.now().strftime('%s'))
+            logger.info('Reset last update to current time (%s)', last_update)
         else:
-            print(f'{"Forward" if last_update < 0 else "Rewind"} of {last_update} seconds')
+            logger.debug('%s of %s seconds', ("Forward" if last_update < 0 else "Rewind"), last_update)
             last_update = int(datetime.now().strftime('%s')) - last_update
 
 

pyheatpump/db.py

 from subprocess import Popen
 from .config import config
 import sys
-from pprint import pprint
 
 from pyheatpump.logger import logger_init
 logger = logger_init()
             except sqlite3.ProgrammingError:
                 pass
             except Exception as e:
-                print(e)
+                logger.error('DB.connect: %s', e)
                 sys.exit(1)
 
         logger.info('Will connect to database {}'.format(
 
             try:
                 return DB.Conn.execute((' '.join(f.readlines())).replace('\n', ''))
-            except StopIteration:
-                print('failed')
+            except StopIteration as e:
+                logger.error('sqlf(%s): %s', filename, e)
                 return []
             except sqlite3.IntegrityError as e:
-                print(e)
+                logger.error('sqlf(%s): %s', filename, e)
                 return []
             except sqlite3.OperationalError as e:
                 raise Exception(f'Can\'t find DB file {filename}') from e

pyheatpump/modbus.py

         real_serial_port = os.path.realpath(
             config.get('heatpump', 'serial_port'))
 
-        print('Connecting to serial port *{}* ({})'.format(
+        logger.info('Connecting to serial port *%s* (%s)',
             config.get('heatpump', 'serial_port'),
-            real_serial_port))
+            real_serial_port)
 
         serial_conn = Serial(
             port=real_serial_port,
             timeout=20)
 
     if serial_conn.open is False:
-        print('Opening serial port')
+        logger.debug('Opening serial port *%s*', config.get('heatpump', 'serial_port')
         serial_conn.open()
 
     return serial_conn
             response = rtu.send_message(req_adu, serial_conn)
             res.extend(response)
     except umodbus.exceptions.IllegalDataAddressError as e:
-        print(e)
-        print(f'{address} {qty}')
+        logger.error(e)
+        logger.debug('address:%s qty:%s', address, qty)
 
     logger.debug('read_coils [%s, %s] result: %s', start, end, res)
     return res
             response = rtu.send_message(req_adu, serial_conn)
             res.extend(response)
     except umodbus.exceptions.IllegalDataAddressError as e:
-        print(e)
-        print(f'{address} {qty}')
+        logger.error('read_holding_registers(%s, %s): address:%s, qty:%s\n%s',
+            start, end, address, qty, e)
 
     logger.debug('read_holding_registers [%s, %s] result: %s', start, end, res)
     return res
         return True
     except Exception as e:
         raise e
-
-if __name__ == '__main__':
-    response = read_holding_registers(1, 10)
-    print(len(response))
-    response = read_coils(90, 100)
-    print(len(response))
-    
-    """
-    Example codeo
-    write_coil(VariableValue(**{
-        'type':'D',
-        'address':91,
-        'value':1}))
-
-    resp = read_coils(91, 93)
-    print(f'91 : {response[0]} - 92 : {response[1]}')
-
-    write_coil(VariableValue(**{
-        'type':'D',
-        'address':91,
-        'value':0}))
-
-    response = read_coils(91, 93)
-    print(f'91 : {response[0]} - 92 : {response[1]}')
-
-    response = read_holding_registers(240, 242) 
-    print(response)
-
-    write_holding_register(VariableValue(**{
-        'type':'D',
-        'address':91,
-        'value':1})
-    """

pyheatpump/models/variable.py

             })
             return True
         except Exception as e:
-            print(e)
+            logger.error('Variable.insert: %s', e)
             return False
 
 

pyheatpump/models/variable_type.py

 from pyheatpump.db import DB, RowClass
 
+from pyheatpump.logger import logger_init
+logger = logger_init()
 
 class VariableType(RowClass):
     slabel: str = '' 
         try:
             elt = next(super().select('slabel', 'var_type'))
         except StopIteration:
-            print('No element exists')
+            logger.error('VariableType.select(%s, %s): does not exist')
         return elt
 
 

pyheatpump/models/variable_value.py

             )
             return True
         except Exception as e:
-            print(e)
+            logger.error('VariableValue.insert: %s', e)
             return False
 
 
     @staticmethod
     def get(var_type, address, time=datetime.now()):
         try:
-            print(int(time.strftime('%s'))+1)
             row = next(DB.sql(
             """SELECT * FROM var_value
             WHERE

pyheatpump/variable_types.py

 from configparser import ConfigParser
 from starlette.routing import Route, Router
 from starlette.responses import PlainTextResponse, JSONResponse
-from pprint import pprint
 import uvicorn
 import json
 

pyheatpump/variable_values.py

 from starlette.routing import Route, Router
 from starlette.responses import PlainTextResponse, JSONResponse
 from starlette.exceptions import HTTPException
-from pprint import pprint
 import uvicorn
 import json
 
             'address': address,
             'time': time
         }
-        print(args)
         if time is None:
             args.pop('time')
         else:

pyheatpump/variables.py

 from configparser import ConfigParser
 from starlette.routing import Route, Router
 from starlette.responses import PlainTextResponse, JSONResponse
-from pprint import pprint
 import uvicorn
 import json