config.py

# -*- coding: utf-8 -*-

import os
import pickle
import logging

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.sqlite3"

logger = logging.getLogger()

class Config(SQL):
    def __init__(self):
        self._version = '0.0.1'
        self.filename = Config.filename()
        self.set_default_value()

        logging.info(f"Configuration file : {self.filename}")

        super(Config, self).__init__(filename = self.filename)

    def _create(self):
        # Info (meta data)
        self.execute("CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
        self.execute(f"INSERT INTO info VALUES ('version', '{self._version}')")

        # Key / Value (data)
        self.execute("CREATE TABLE data(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")

        # Solver
        self.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
        self.execute("""
           CREATE TABLE stricklers(
             name TEXT NOT NULL UNIQUE,
             comment TEXT NOT NULL,
             minor REAL NOT NULL,
             medium REAL NOT NULL
           )
           """)

        self.commit()

    def _update(self):
        version = self.execute(f"SELECT value FROM info WHERE key='version'")[0]

        if version != self._version:
            logger.info(f"Configuration file update from {version} to {self._version}...")

    def _load_solver(self):
        self._solvers = []

        solvers = self.execute(
            "SELECT * FROM solver",
            fetch_one = False
        )
        for solver in solvers:
            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):
        self.stricklers = StricklersList()

        id = 0
        stricklers = self.execute(
            "SELECT * FROM stricklers",
            fetch_one = False
        )
        for strickler in stricklers:
            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):
        # Meshing tool
        v = self.execute("SELECT value FROM data WHERE key='meshing_tool'")
        self.meshing_tool = v[0]

        # Const
        v = self.execute("SELECT value FROM data WHERE key='segment'")
        self.segment = int(v[0])
        v = self.execute("SELECT value FROM data WHERE key='max_listing'")
        self.max_listing = int(v[0])

        # Backup
        v = self.execute("SELECT value FROM data WHERE key='backup_enable'")
        self.backup_enable = v[0] == "True"
        v = self.execute("SELECT value FROM data WHERE key='backup_path'")
        self.backup_path = v[0]
        v = self.execute("SELECT value FROM data WHERE key='backup_frequence'")
        self.backup_frequence = v[0]
        v = self.execute("SELECT value FROM data WHERE key='backup_max'")
        self.backup_max = int(v[0])

        # Editor
        v = self.execute("SELECT value FROM data WHERE key='editor'")
        self.editor = v[0]

        # Languages
        v = self.execute("SELECT value FROM data WHERE key='lang'")
        self.lang = v[0]

        # Debug
        v = self.execute("SELECT value FROM data WHERE key='debug'")
        self.debug = v[0] == "True"

        self._load_solver()
        self._load_stricklers()

    def _save_solver(self):
        self.execute(f"DELETE FROM solver")

        for solver in self.solvers:
            self.execute(f"""
              INSERT INTO solver VALUES (
                '{solver._type}',
                '{self._sql_format(solver._name)}',
                '{self._sql_format(solver._description)}',
                '{self._sql_format(solver._path_input)}',
                '{self._sql_format(solver._path_solver)}',
                '{self._sql_format(solver._path_output)}',
                '{self._sql_format(solver._cmd_input)}',
                '{self._sql_format(solver._cmd_solver)}',
                '{self._sql_format(solver._cmd_output)}'
              )
              """,
              commit = True)

    def _save_stricklers(self):
        self.execute(f"DELETE FROM stricklers")

        for stricklers in self.stricklers.stricklers:
            self.execute(f"""
              INSERT INTO stricklers VALUES (
                '{self._sql_format(stricklers._name)}',
                '{self._sql_format(stricklers._comment)}',
                '{stricklers._minor}',
                '{stricklers._medium}'
              )
            """)

        self.commit()

    def _save(self):
        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,
            "debug": self.debug,
        }

        for key in data:
            self.execute(
                f"INSERT OR IGNORE INTO data VALUES " +
                f" ('{key}', '{self._sql_format(data[key])}')"
            )
            self.execute(
                f"UPDATE data SET " +
                f"value='{self._sql_format(data[key])}' " +
                f"WHERE key='{key}'"
            )

        self.commit()
        self._save_solver()
        self._save_stricklers()

    def set_default_value(self):
        # Solvers
        self._solvers = []

        # Meshing tool
        self.meshing_tool = ""

        # Const
        self.segment = 1000
        self.max_listing = 500000

        # Backup
        self.backup_enable = True
        self.backup_path = ""
        self.backup_frequence = "00:05:00"
        self.backup_max = 10

        # Editor
        self.editor = "editor @file"

        # Languages
        self.lang = ""

        # Stricklers
        self.stricklers = StricklersList()

        # Debug
        self.debug = False

    @classmethod
    def filename(cls):
        file = ""

        if os.name == 'posix':
            file = os.path.expanduser('~') + config_dir + config_file
        else:
            ndir = os.path.expanduser('~') + config_dir.replace("/", "\\")
            os.makedirs(ndir, exist_ok = True)
            file = ndir + config_file

        return file

    @classmethod
    def languages(cls):
        return {
            "System":  "",
            "English": "en",
            "French":  "fr",
        }

    @property
    def solvers(self):
        return self._solvers.copy()

    @solvers.setter
    def solvers(self, solvers):
        self._solvers = solvers

    def save(self):
        self._save()

    @classmethod
    def load(cls):
        return cls()