Config: Switch save from pickle to sqlite.

src/config.py

@@ -3,18 +3,199 @@
 import os
 import pickle
 
+from tools import SQL
+
+from Model.Stricklers.Stricklers import Stricklers
 from Model.Stricklers.StricklersList import StricklersList
 
+from Solver.Solvers import solver_type_list
+
 config_dir = "/.cache/pamhyr/"
-config_file = "config.pkl"
+config_file = "config.sqlite3"
 
-class Config(object):
+class Config(SQL):
     def __init__(self):
-        super(Config, self).__init__()
-
+        self._version = '0.0.1'
         self.filename = Config.filename()
         self.set_default_value()
 
+        super(Config, self).__init__(db = self.filename)
+
+    def _create(self):
+        cur = self._db.cursor()
+
+        # Info (meta data)
+        cur.execute("CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
+        cur.execute(f"INSERT INTO info VALUES ('version', '{self._version}')")
+
+        # Key / Value (data)
+        cur.execute("CREATE TABLE data(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
+
+        # Solver
+        cur.execute("""
+           CREATE TABLE solver(
+             type TEXT NOT NULL,
+             name TEXT NOT NULL UNIQUE,
+             description TEXT NOT NULL,
+
+             path_input TEXT NOT NULL,
+             path_solver TEXT NOT NULL,
+             path_output TEXT NOT NULL,
+
+             cmd_input TEXT NOT NULL,
+             cmd_solver TEXT NOT NULL,
+             cmd_output TEXT NOT NULL
+           )
+           """)
+
+        # Stricklers
+        cur.execute("""
+           CREATE TABLE stricklers(
+             name TEXT NOT NULL UNIQUE,
+             comment TEXT NOT NULL,
+             minor REAL NOT NULL,
+             medium REAL NOT NULL
+           )
+           """)
+
+        self._db.commit()
+
+    def _update(self):
+        cur = self._db.cursor()
+        version = cur.execute(f"SELECT value FROM info WHERE key='version'")
+
+        if version.fetchone()[0] != self._version:
+            print("update")
+
+    def _load_solver(self):
+        cur = self._db.cursor()
+        self._solvers = []
+
+        solvers = cur.execute("SELECT * FROM solver")
+        for solver in solvers.fetchall():
+            solver_type = solver[0]
+            ctor = solver_type_list[solver_type]
+
+            new = ctor(solver[1])
+            new._description = solver[2]
+            new._path_input = solver[3]
+            new._path_solver = solver[4]
+            new._path_output = solver[5]
+            new._cmd_input = solver[6]
+            new._cmd_solver = solver[7]
+            new._cmd_output = solver[8]
+
+            self._solvers.append(new)
+
+    def _load_stricklers(self):
+        cur = self._db.cursor()
+        self.stricklers = StricklersList()
+
+        id = 0
+        stricklers = cur.execute("SELECT * FROM stricklers")
+        for strickler in stricklers.fetchall():
+            new = Stricklers()
+            new._name = strickler[0]
+            new._comment = strickler[1]
+            new._minor = float(strickler[2])
+            new._medium = float(strickler[3])
+
+            self.stricklers.insert(id, new)
+            id += 1
+
+    def _load(self):
+        cur = self._db.cursor()
+
+        # Meshing tool
+        v = cur.execute("SELECT value FROM data WHERE key='meshing_tool'")
+        self.meshing_tool = v.fetchone()[0]
+
+        # Const
+        v = cur.execute("SELECT value FROM data WHERE key='segment'")
+        self.segment = int(v.fetchone()[0])
+        v = cur.execute("SELECT value FROM data WHERE key='max_listing'")
+        self.max_listing = int(v.fetchone()[0])
+
+        # Backup
+        v = cur.execute("SELECT value FROM data WHERE key='backup_enable'")
+        self.backup_enable = v.fetchone()[0] == "True"
+        v = cur.execute("SELECT value FROM data WHERE key='backup_path'")
+        self.backup_path = v.fetchone()[0]
+        v = cur.execute("SELECT value FROM data WHERE key='backup_frequence'")
+        self.backup_frequence = v.fetchone()[0]
+        v = cur.execute("SELECT value FROM data WHERE key='backup_max'")
+        self.backup_max = int(v.fetchone()[0])
+
+        # Editor
+        v = cur.execute("SELECT value FROM data WHERE key='editor'")
+        self.editor = v.fetchone()[0]
+
+        # Languages
+        v = cur.execute("SELECT value FROM data WHERE key='lang'")
+        self.lang = v.fetchone()[0]
+
+        self._load_solver()
+        self._load_stricklers()
+
+    def _save_solver(self):
+        cur = self._db.cursor()
+        cur.execute(f"DELETE FROM solver")
+
+        for solver in self.solvers:
+            cur.execute(f"""
+              INSERT INTO solver VALUES (
+                '{solver._type}',
+                '{solver._name}',
+                '{solver._description}',
+                '{solver._path_input}',
+                '{solver._path_solver}',
+                '{solver._path_output}',
+                '{solver._cmd_input}',
+                '{solver._cmd_solver}',
+                '{solver._cmd_output}'
+              )
+            """)
+
+        self._db.commit()
+
+    def _save_stricklers(self):
+        cur = self._db.cursor()
+        cur.execute(f"DELETE FROM stricklers")
+
+        for stricklers in self.stricklers.stricklers:
+            cur.execute(f"""
+              INSERT INTO stricklers VALUES (
+                '{stricklers._name}',
+                '{stricklers._comment}',
+                '{stricklers._minor}',
+                '{stricklers._medium}'
+              )
+            """)
+
+        self._db.commit()
+
+    def _save(self):
+        cur = self._db.cursor()
+        data = {
+            "segment": self.segment,
+            "meshing_tool": self.meshing_tool,
+            "max_listing": self.max_listing,
+            "backup_enable": self.backup_enable,
+            "backup_path": self.backup_path,
+            "backup_frequence": self.backup_frequence,
+            "backup_max": self.backup_max,
+            "editor": self.editor,
+            "lang": self.lang,
+        }
+
+        for key in data:
+            cur.execute(f"INSERT OR IGNORE INTO data VALUES ('{key}', '{data[key]}')")
+            cur.execute(f"UPDATE data SET value='{data[key]}' WHERE key='{key}'")
+
+        self._db.commit()
+        self._save_solver()
+        self._save_stricklers()
+
     def set_default_value(self):
         # Solvers
         self._solvers = []
@@ -62,17 +243,8 @@ class Config(object):
         self._solvers = solvers
 
     def save(self):
-        os.makedirs(os.path.dirname(self.filename), exist_ok=True)
-        with open(self.filename, 'wb') as out_file:
-            pickle.dump(self, out_file)
+        self._save()
 
     @classmethod
     def load(cls):
-        filename = cls.filename()
-        if os.path.isfile(filename):
-            with open(filename, 'rb') as in_file:
-                me = pickle.load(in_file)
-                return me
-        else:
-            print("config: New config")
-            return cls()
+        return cls()

src/tools.py

 # -*- coding: utf-8 -*-
 
 import time
+import sqlite3
 import traceback
 
+from pathlib import Path
+
 from colorama import Fore
 from colorama import Back
 from colorama import Style
@@ -153,3 +156,33 @@ def old_pamhyr_date_to_timestamp(date:str):
     )
 
     return ts
+
+#######
+# SQL #
+#######
+
+# This class is an abstract class to make class with save and load
+# from sqlite3.
+
+class SQL(object):
+    def __init__(self, db = "db.sqlite3"):
+        exists = Path(db).exists()
+        self._db = sqlite3.connect(db)
+        if not exists:
+            self._create()      # Create db
+            self._save()        # Save
+        else:
+            self._update()      # Update db scheme if necessary
+            self._load()        # Load data
+
+    def _create(self):
+        print("Create")
+
+    def _update(self):
+        print("Update")
+
+    def _save(self):
+        print("Save")
+
+    def _load(self):
+        print("Load")