pamhyr: Rename '_sql_*' function to '_db_*'.

src/Model/BoundaryCondition/BoundaryCondition.py

@@ -51,7 +51,7 @@ class BoundaryCondition(SQLSubModel):
         BoundaryCondition._id_cnt = max(BoundaryCondition._id_cnt + 1, self.id)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE boundary_condition(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -77,7 +77,7 @@ class BoundaryCondition(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
@@ -102,7 +102,7 @@ class BoundaryCondition(SQLSubModel):
         return res
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = []
         tab = data["tab"]
 
@@ -144,7 +144,7 @@ class BoundaryCondition(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         tab = data["tab"]
 
         execute(f"DELETE FROM boundary_condition WHERE id = {self.id}")
@@ -158,16 +158,16 @@ class BoundaryCondition(SQLSubModel):
             "INSERT INTO " +
             "boundary_condition(id, name, type, tab, node) " +
             "VALUES (" +
-            f"{self.id}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._type)}', '{tab}', {node}" +
+            f"'{self._db_format(self._type)}', '{tab}', {node}" +
             ")"
         )
         execute(sql)
 
         ind = 0
         for d in self._data:
-            data0 = self._sql_format(str(d[0]))
+            data0 = self._db_format(str(d[0]))
-            data1 = self._sql_format(str(d[1]))
+            data1 = self._db_format(str(d[1]))
 
             sql = (
                 "INSERT INTO " +

src/Model/BoundaryCondition/BoundaryConditionList.py

@@ -38,7 +38,7 @@ class BoundaryConditionList(PamhyrModelListWithTab):
     ]
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data['status'])
 
         if data is None:
@@ -46,13 +46,13 @@ class BoundaryConditionList(PamhyrModelListWithTab):
 
         for tab in new._tabs:
             data["tab"] = tab
-            new._tabs[tab] = BoundaryCondition._sql_load(
+            new._tabs[tab] = BoundaryCondition._db_load(
                 execute, data
             )
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         execute("DELETE FROM boundary_condition")
 
         if data is None:
@@ -61,7 +61,7 @@ class BoundaryConditionList(PamhyrModelListWithTab):
         for tab in self._tabs:
             data["tab"] = tab
             for bc in self._tabs[tab]:
-                bc._sql_save(execute, data=data)
+                bc._db_save(execute, data=data)
 
         return True
 

src/Model/Friction/Friction.py

@@ -35,7 +35,7 @@ class Friction(SQLSubModel):
         self._end_strickler = None
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE friction(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -54,11 +54,11 @@ class Friction(SQLSubModel):
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = []
         reach = data["parent"]  # Reach object
         status = data["status"]
@@ -88,7 +88,7 @@ class Friction(SQLSubModel):
 
             yield ind, sec
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         ind = data["ind"]
         execute(
             "INSERT INTO " +

src/Model/Friction/FrictionList.py

@@ -35,28 +35,28 @@ class FrictionList(PamhyrModelList):
     ]
 
     @classmethod
-    def _sql_update_0_0_1(cls, execute, version):
+    def _db_update_0_0_1(cls, execute, version):
         execute("ALTER TABLE `section` RENAME TO `friction`")
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         if version == "0.0.0":
             logger.info(f"Update friction TABLE from {version}")
-            cls._sql_update_0_0_1(execute, version)
+            cls._db_update_0_0_1(execute, version)
 
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data['status'])
 
-        new._lst = Friction._sql_load(
+        new._lst = Friction._db_load(
             execute, data
         )
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         reach = data["reach"]
         execute(f"DELETE FROM friction WHERE reach = {reach.id}")
 
@@ -64,7 +64,7 @@ class FrictionList(PamhyrModelList):
         ind = 0
         for friction in self._lst:
             data["ind"] = ind
-            ok &= friction._sql_save(execute, data=data)
+            ok &= friction._db_save(execute, data=data)
             ind += 1
 
         return ok

src/Model/Geometry/PointXYZ.py

@@ -36,7 +36,7 @@ class PointXYZ(Point, SQLSubModel):
         self._z = float(z)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE geometry_pointXYZ(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -55,7 +55,7 @@ class PointXYZ(Point, SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         cls._update_submodel(execute, version)
 
         major, minor, release = version.strip().split(".")
@@ -71,7 +71,7 @@ class PointXYZ(Point, SQLSubModel):
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         status = data["status"]
         profile = data["profile"]
 
@@ -109,7 +109,7 @@ class PointXYZ(Point, SQLSubModel):
 
             yield ind, new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         profile = data["profile"]
         ind = data["ind"]
 
@@ -119,7 +119,7 @@ class PointXYZ(Point, SQLSubModel):
             "INSERT OR REPLACE INTO " +
             "geometry_pointXYZ(ind, name, x, y, z, profile, sl) " +
             "VALUES (" +
-            f"{ind}, '{self._sql_format(self._name)}', " +
+            f"{ind}, '{self._db_format(self._name)}', " +
             f"{self.x}, {self.y}, {self.z}, " +
             f"{profile.id}, {sl}" +
             ")"

src/Model/Geometry/ProfileXYZ.py

@@ -69,7 +69,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         )
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE geometry_profileXYZ(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -89,7 +89,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
             if int(release) < 2:
@@ -104,7 +104,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         profiles = []
         status = data["status"]
         reach = data["reach"]
@@ -147,7 +147,7 @@ class ProfileXYZ(Profile, SQLSubModel):
                 )
 
             data["profile"] = new
-            new._points = PointXYZ._sql_load(execute, data.copy())
+            new._points = PointXYZ._db_load(execute, data.copy())
 
             yield ind, new
 
@@ -155,7 +155,7 @@ class ProfileXYZ(Profile, SQLSubModel):
 
         # return profiles
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         ok = True
         ind = data["ind"]
 
@@ -166,7 +166,7 @@ class ProfileXYZ(Profile, SQLSubModel):
             "geometry_profileXYZ(id, ind, name, reach, " +
             "kp, num, code1, code2, sl) " +
             "VALUES (" +
-            f"{self.id}, {ind}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, {ind}, '{self._db_format(self._name)}', " +
             f"{self.reach.id}, {self.kp}, {self.num}, " +
             f"{self.code1}, {self.code1}, {sl}" +
             ")"
@@ -179,7 +179,7 @@ class ProfileXYZ(Profile, SQLSubModel):
         ind = 0
         for point in self.points:
             data["ind"] = ind
-            ok &= point._sql_save(execute, data)
+            ok &= point._db_save(execute, data)
             ind += 1
 
         return ok

src/Model/Geometry/Reach.py

@@ -52,25 +52,25 @@ class Reach(SQLSubModel):
         self._guidelines = {}
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data["status"], parent=data["parent"])
 
-        new._profiles = ProfileXYZ._sql_load(
+        new._profiles = ProfileXYZ._db_load(
             execute,
             data=data
         )
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         # Delete old data
         execute(f"DELETE FROM geometry_profileXYZ WHERE reach = {self.id}")
         # execute(f"DELETE FROM geometry_pointXYZ")
@@ -81,7 +81,7 @@ class Reach(SQLSubModel):
         ind = 0
         for profile in self.profiles:
             data["ind"] = ind
-            profile._sql_save(execute, data)
+            profile._db_save(execute, data)
             ind += 1
 
         return True

src/Model/InitialConditions/InitialConditions.py

@@ -52,7 +52,7 @@ class Data(SQLSubModel):
             self._update_from_discharge()
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE initial_conditions(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -70,11 +70,11 @@ class Data(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         id = data["reach"].id
         table = execute(
             "SELECT ind, name, comment, kp, discharge, height " +
@@ -109,7 +109,7 @@ class Data(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         ind = data["ind"]
 
         execute(
@@ -117,8 +117,8 @@ class Data(SQLSubModel):
             "initial_conditions(ind, name, comment, kp, " +
             "discharge, height, reach) " +
             "VALUES (" +
-            f"{ind}, '{self._sql_format(self.name)}', " +
+            f"{ind}, '{self._db_format(self.name)}', " +
-            f"'{self._sql_format(self._comment)}', " +
+            f"'{self._db_format(self._comment)}', " +
             f"{self._kp}, {self._discharge}, {self._height}, " +
             f"{self._reach.id}" +
             ")"
@@ -226,21 +226,21 @@ class InitialConditions(SQLSubModel):
         self._data = []
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(
             reach=data["reach"],
             status=data["status"]
         )
 
-        new._data = Data._sql_load(
+        new._data = Data._db_load(
             execute,
             data=data
         )
@@ -248,13 +248,13 @@ class InitialConditions(SQLSubModel):
         if new._data is not None:
             yield new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         ok = True
 
         ind = 0
         for d in self._data:
             data["ind"] = ind
-            ok &= d._sql_save(execute, data)
+            ok &= d._db_save(execute, data)
             ind += 1
 
         return ok

src/Model/InitialConditions/InitialConditionsDict.py

@@ -30,13 +30,13 @@ class InitialConditionsDict(PamhyrModelDict):
     ]
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data["status"])
 
         for reach in data["edges"]:
             data["reach"] = reach
 
-            ic = InitialConditions._sql_load(
+            ic = InitialConditions._db_load(
                 execute,
                 data=data
             )
@@ -46,7 +46,7 @@ class InitialConditionsDict(PamhyrModelDict):
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         ok = True
         if data is None:
             data = {}
@@ -55,7 +55,7 @@ class InitialConditionsDict(PamhyrModelDict):
 
         for reach in self._dict:
             data["reach"] = reach
-            ok &= self._dict[reach]._sql_save(execute, data)
+            ok &= self._dict[reach]._db_save(execute, data)
 
         return ok
 

src/Model/LateralContribution/LateralContribution.py

@@ -53,7 +53,7 @@ class LateralContribution(SQLSubModel):
             LateralContribution._id_cnt + 1, self.id)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE lateral_contribution(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -81,7 +81,7 @@ class LateralContribution(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
@@ -100,7 +100,7 @@ class LateralContribution(SQLSubModel):
         return res
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = []
         tab = data["tab"]
 
@@ -142,7 +142,7 @@ class LateralContribution(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         tab = data["tab"]
 
         execute(f"DELETE FROM lateral_contribution WHERE id = {self.id}")
@@ -157,8 +157,8 @@ class LateralContribution(SQLSubModel):
             "lateral_contribution(id, name, type, tab, " +
             "edge, begin_kp, end_kp) " +
             "VALUES (" +
-            f"{self.id}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._type)}', '{tab}', {edge}, " +
+            f"'{self._db_format(self._type)}', '{tab}', {edge}, " +
             f"{self._begin_kp}, {self._end_kp}" +
             ")"
         )
@@ -166,8 +166,8 @@ class LateralContribution(SQLSubModel):
 
         ind = 0
         for d in self._data:
-            data0 = self._sql_format(str(d[0]))
+            data0 = self._db_format(str(d[0]))
-            data1 = self._sql_format(str(d[1]))
+            data1 = self._db_format(str(d[1]))
 
             sql = (
                 "INSERT INTO " +

src/Model/LateralContribution/LateralContributionList.py

@@ -35,7 +35,7 @@ class LateralContributionList(PamhyrModelListWithTab):
     ]
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data['status'])
 
         if data is None:
@@ -43,13 +43,13 @@ class LateralContributionList(PamhyrModelListWithTab):
 
         for tab in new._tabs:
             data["tab"] = tab
-            new._tabs[tab] = LateralContribution._sql_load(
+            new._tabs[tab] = LateralContribution._db_load(
                 execute, data
             )
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         execute("DELETE FROM lateral_contribution")
 
         if data is None:
@@ -58,7 +58,7 @@ class LateralContributionList(PamhyrModelListWithTab):
         for tab in self._tabs:
             data["tab"] = tab
             for lc in self._tabs[tab]:
-                lc._sql_save(execute, data=data)
+                lc._db_save(execute, data=data)
 
         return True
 

src/Model/River.py

@@ -55,7 +55,7 @@ class RiverNode(Node, SQLSubModel):
         self._locker = None
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE river_node(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -69,11 +69,11 @@ class RiverNode(Node, SQLSubModel):
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         nodes = []
 
         table = execute("SELECT id, name, x, y FROM river_node")
@@ -85,10 +85,10 @@ class RiverNode(Node, SQLSubModel):
 
         return nodes
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         sql = (
             "INSERT OR REPLACE INTO river_node(id, name, x, y) VALUES (" +
-            f"{self.id}, '{self._sql_format(self.name)}', " +
+            f"{self.id}, '{self._db_format(self.name)}', " +
             f"{self.x}, {self.y}" +
             ")"
         )
@@ -125,7 +125,7 @@ class RiverReach(Edge, SQLSubModel):
         self._frictions = FrictionList(status=self._status)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE river_reach(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -142,11 +142,11 @@ class RiverReach(Edge, SQLSubModel):
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         reachs = []
 
         if data is None:
@@ -170,21 +170,21 @@ class RiverReach(Edge, SQLSubModel):
 
             data["reach"] = id
             data["parent"] = new
-            new._reach = Reach._sql_load(execute, data)
+            new._reach = Reach._db_load(execute, data)
 
-            new._frictions = FrictionList._sql_load(execute, data)
+            new._frictions = FrictionList._db_load(execute, data)
 
             reachs.append(new)
 
         return reachs
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         sql = (
             "INSERT OR REPLACE INTO " +
             "river_reach(id, name, enable, node1, node2) " +
             "VALUES (" +
-            f"{self.id}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, '{self._db_format(self._name)}', " +
-            f"{self._sql_format(self.is_enable())},"
+            f"{self._db_format(self.is_enable())},"
             f"{self.node1.id}, {self.node2.id}" +
             ")"
         )
@@ -236,73 +236,73 @@ class River(Graph, SQLSubModel):
         self._sediment_layers = SedimentLayerList(status=self._status)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         cls._create_submodel(execute)
         return True
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         cls._update_submodel(execute, version)
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(data["status"])
 
         # Stricklers (Stricklers is load in first because it's needed
         # for reachs)
-        new._stricklers = StricklersList._sql_load(
+        new._stricklers = StricklersList._db_load(
             execute,
             data
         )
         data["stricklers"] = new._stricklers
 
         # Initial conditions
-        new._sediment_layers = SedimentLayerList._sql_load(
+        new._sediment_layers = SedimentLayerList._db_load(
             execute,
             data
         )
         data["sediment_layers_list"] = new._sediment_layers
 
         # Network
-        new._nodes = RiverNode._sql_load(
+        new._nodes = RiverNode._db_load(
             execute,
             data
         )
         data["nodes"] = new.nodes()
 
-        new._edges = RiverReach._sql_load(
+        new._edges = RiverReach._db_load(
             execute,
             data
         )
         data["edges"] = new.edges()
 
         # Boundary Condition
-        new._boundary_condition = BoundaryConditionList._sql_load(
+        new._boundary_condition = BoundaryConditionList._db_load(
             execute,
             data
         )
         # Lateral Contribution
-        new._lateral_contribution = LateralContributionList._sql_load(
+        new._lateral_contribution = LateralContributionList._db_load(
             execute,
             data
         )
 
         # Initial conditions
-        new._initial_conditions = InitialConditionsDict._sql_load(
+        new._initial_conditions = InitialConditionsDict._db_load(
             execute,
             data
         )
 
         # Parameters
-        new._parameters = SolverParametersList._sql_load(
+        new._parameters = SolverParametersList._db_load(
             execute,
             data
         )
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         objs = (self._nodes + self._edges)
         objs.append(self._boundary_condition)
         objs.append(self._initial_conditions)

src/Model/SedimentLayer/SedimentLayer.py

@@ -84,7 +84,7 @@ class Layer(SQLSubModel):
         self._critical_constraint = float(critical_constraint)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE sedimentary_layer_layer(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -103,16 +103,16 @@ class Layer(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
             if int(release) < 2:
-                cls._sql_create(execute)
+                cls._db_create(execute)
 
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = []
         sl = data["sl"]
 
@@ -141,7 +141,7 @@ class Layer(SQLSubModel):
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         ind = data["ind"]
         sl = data["sl"]
 
@@ -150,8 +150,8 @@ class Layer(SQLSubModel):
             "sedimentary_layer_layer(id, ind, name, type, height, " +
             "d50, sigma, critical_constraint, sl) " +
             "VALUES (" +
-            f"{self.id}, {ind}, '{self._sql_format(self._name)}', " +
+            f"{self.id}, {ind}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._type)}', {self._height}, " +
+            f"'{self._db_format(self._type)}', {self._height}, " +
             f"{self._d50}, {self._sigma}, {self._critical_constraint}, " +
             f"{sl.id}" +
             ")"
@@ -224,7 +224,7 @@ class SedimentLayer(SQLSubModel):
         self._comment = comment
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE sedimentary_layer(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -236,16 +236,16 @@ class SedimentLayer(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
         if major == minor == "0":
             if int(release) < 2:
-                cls._sql_create(execute)
+                cls._db_create(execute)
 
         return True
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = []
 
         table = execute(
@@ -262,20 +262,20 @@ class SedimentLayer(SQLSubModel):
             )
 
             data["sl"] = sl.id
-            sl._layers = Layer._sql_load(execute, data)
+            sl._layers = Layer._db_load(execute, data)
 
             new.append(sl)
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         if data is None:
             data = {}
 
         sql = (
             "INSERT INTO sedimentary_layer (id, name, comment) " +
-            f"VALUES ({self.id}, '{self._sql_format(self._name)}', " +
+            f"VALUES ({self.id}, '{self._db_format(self._name)}', " +
-            f"'{self._sql_format(self._comment)}')"
+            f"'{self._db_format(self._comment)}')"
         )
         execute(sql)
 
@@ -284,7 +284,7 @@ class SedimentLayer(SQLSubModel):
         ind = 0
         for layer in self._layers:
             data["ind"] = ind
-            layer._sql_save(execute, data)
+            layer._db_save(execute, data)
             ind += 1
 
         return True

src/Model/SedimentLayer/SedimentLayerList.py

@@ -11,14 +11,14 @@ class SedimentLayerList(PamhyrModelList):
     _sub_classes = [SedimentLayer]
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data["status"])
 
-        new._lst = SedimentLayer._sql_load(execute, data)
+        new._lst = SedimentLayer._db_load(execute, data)
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         ok = True
 
         # Delete previous data
@@ -26,7 +26,7 @@ class SedimentLayerList(PamhyrModelList):
         execute("DELETE FROM sedimentary_layer_layer")
 
         for sl in self._lst:
-            ok &= sl._sql_save(execute, data)
+            ok &= sl._db_save(execute, data)
 
         return ok
 

src/Model/SolverParameters/SolverParametersList.py

@@ -79,7 +79,7 @@ class SolverParametersList(PamhyrModelList):
         )
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE solver_parameter(
             id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
@@ -93,7 +93,7 @@ class SolverParametersList(PamhyrModelList):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         major, minor, release = version.strip().split(".")
 
         if major == minor == "0":
@@ -130,9 +130,9 @@ class SolverParametersList(PamhyrModelList):
                         "solver_parameter(ind, name, value, solver) " +
                         "VALUES (" +
                         f"{ind}, " +
-                        f"'{cls._sql_format(name)}', " +
+                        f"'{cls._db_format(name)}', " +
-                        f"'{cls._sql_format(value)}', " +
+                        f"'{cls._db_format(value)}', " +
-                        f"'{cls._sql_format(solver)}'" +
+                        f"'{cls._db_format(solver)}'" +
                         ")"
                     )
 
@@ -164,7 +164,7 @@ class SolverParametersList(PamhyrModelList):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         status = data["status"]
         solvers = execute("SELECT DISTINCT solver FROM solver_parameter")
         new = {}
@@ -194,7 +194,7 @@ class SolverParametersList(PamhyrModelList):
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         t = self._solver._type
         execute(
             "DELETE FROM solver_parameter " +
@@ -208,9 +208,9 @@ class SolverParametersList(PamhyrModelList):
                 "solver_parameter(ind, name, value, solver) " +
                 "VALUES (" +
                 f"{ind}, " +
-                f"'{self._sql_format(param.name)}', " +
+                f"'{self._db_format(param.name)}', " +
-                f"'{self._sql_format(param.value)}', " +
+                f"'{self._db_format(param.value)}', " +
-                f"'{self._sql_format(t)}'" +
+                f"'{self._db_format(t)}'" +
                 ")"
             )
             execute(sql)

src/Model/Stricklers/Stricklers.py

@@ -48,7 +48,7 @@ class Stricklers(SQLSubModel):
         self._medium = medium
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         execute("""
           CREATE TABLE stricklers(
             id INTEGER NOT NULL PRIMARY KEY,
@@ -62,11 +62,11 @@ class Stricklers(SQLSubModel):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         stricklers = []
         status = data["status"]
 
@@ -97,14 +97,14 @@ class Stricklers(SQLSubModel):
 
         return stricklers
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         sql = (
             "INSERT INTO " +
             "stricklers(id, name, comment, minor, medium) " +
             "VALUES (" +
             f"{self.id}, " +
-            f"'{self._sql_format(self.name)}', " +
+            f"'{self._db_format(self.name)}', " +
-            f"'{self._sql_format(self.comment)}', " +
+            f"'{self._db_format(self.comment)}', " +
             f"{float(self.minor)}, {float(self.medium)}" +
             ")"
         )

src/Model/Stricklers/StricklersList.py

@@ -29,25 +29,25 @@ class StricklersList(PamhyrModelList):
     ]
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         new = cls(status=data["status"])
 
-        new._lst = Stricklers._sql_load(
+        new._lst = Stricklers._db_load(
             execute,
             data=data
         )
 
         return new
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         execute("DELETE FROM stricklers")
 
         objs = self._lst

src/Model/Study.py

@@ -183,7 +183,7 @@ class Study(SQLModel):
             "CREATE TABLE info(key TEXT NOT NULL UNIQUE, value TEXT NOT NULL)")
         self.execute(
             "INSERT INTO info VALUES ('version', " +
-            f"'{self._sql_format(self._version)}')",
+            f"'{self._db_format(self._version)}')",
             commit=True
         )
         self.execute("INSERT INTO info VALUES ('name', '')")
@@ -248,7 +248,7 @@ class Study(SQLModel):
         )
 
         # Load river data
-        new._river = River._sql_load(
+        new._river = River._db_load(
             lambda sql: new.execute(
                 sql,
                 fetch_one=False,
@@ -262,11 +262,11 @@ class Study(SQLModel):
     def _save(self):
         self.execute(
             f"UPDATE info SET " +
-            f"value='{self._sql_format(self.name)}' WHERE key='name'"
+            f"value='{self._db_format(self.name)}' WHERE key='name'"
         )
         self.execute(
             f"UPDATE info SET " +
-            f"value='{self._sql_format(self.description)}' " +
+            f"value='{self._db_format(self.description)}' " +
             "WHERE key='description'"
         )
         self.execute(

src/Model/Tools/PamhyrDB.py

@@ -61,7 +61,7 @@ class SQLModel(SQL):
         )
 
         for cls in self._sub_classes:
-            requests = cls._sql_create(fn)
+            requests = cls._db_create(fn)
 
         self.commit()
         return True
@@ -78,7 +78,7 @@ class SQLModel(SQL):
 
         ok = True
         for cls in self._sub_classes:
-            ok &= cls._sql_update(fn, version)
+            ok &= cls._db_update(fn, version)
 
         self.commit()
         return ok
@@ -95,7 +95,7 @@ class SQLModel(SQL):
 
         ok = True
         for obj in objs:
-            ok &= obj._sql_save(fn)
+            ok &= obj._db_save(fn)
 
         self.commit()
         return ok
@@ -113,7 +113,7 @@ class SQLModel(SQL):
 class SQLSubModel(object):
     _sub_classes = []
 
-    def _sql_format(self, value):
+    def _db_format(self, value):
         # Replace ''' by ''' to preserve SQL injection
         if value is str:
             value = value.replace("'", "'")
@@ -124,10 +124,10 @@ class SQLSubModel(object):
     @classmethod
     def _create_submodel(cls, execute):
         for sc in cls._sub_classes:
-            sc._sql_create(execute)
+            sc._db_create(execute)
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         """Create data base scheme
 
         Args:
@@ -136,15 +136,15 @@ class SQLSubModel(object):
         Returns:
             Return true, otherelse false if an issue appear
         """
-        raise NotImplementedMethodeError(cls, cls._sql_create)
+        raise NotImplementedMethodeError(cls, cls._db_create)
 
     @classmethod
     def _update_submodel(cls, execute, version):
         for sc in cls._sub_classes:
-            sc._sql_update(execute, version)
+            sc._db_update(execute, version)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         """Update data base scheme
 
         Args:
@@ -154,10 +154,10 @@ class SQLSubModel(object):
         Returns:
             Return true, otherelse false if an issue appear
         """
-        raise NotImplementedMethodeError(cls, cls._sql_update)
+        raise NotImplementedMethodeError(cls, cls._db_update)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
         """Load instance of this class from SQL data base
 
         Args:
@@ -167,13 +167,13 @@ class SQLSubModel(object):
         Returns:
             Return new instance of class
         """
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
     def _save_submodel(self, execute, objs, data=None):
         for o in objs:
-            o._sql_save(execute, data=data)
+            o._db_save(execute, data=data)
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
         """Save class data to data base
 
         Args:
@@ -184,4 +184,4 @@ class SQLSubModel(object):
             Return true, otherelse false if an issue appear during
             save
         """
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)

src/Model/Tools/PamhyrDict.py

@@ -38,19 +38,19 @@ class PamhyrModelDict(SQLSubModel):
         self._dict = {}
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)
 
     def __len__(self):
         return len(self._dict)

src/Model/Tools/PamhyrList.py

@@ -42,19 +42,19 @@ class PamhyrModelList(SQLSubModel):
     #######
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)
 
     ################
     # MODEL METHOD #
@@ -156,19 +156,19 @@ class PamhyrModelListWithTab(SQLSubModel):
     #######
 
     @classmethod
-    def _sql_create(cls, execute):
+    def _db_create(cls, execute):
         return cls._create_submodel(execute)
 
     @classmethod
-    def _sql_update(cls, execute, version):
+    def _db_update(cls, execute, version):
         return cls._update_submodel(execute, version)
 
     @classmethod
-    def _sql_load(cls, execute, data=None):
+    def _db_load(cls, execute, data=None):
-        raise NotImplementedMethodeError(cls, cls._sql_load)
+        raise NotImplementedMethodeError(cls, cls._db_load)
 
-    def _sql_save(self, execute, data=None):
+    def _db_save(self, execute, data=None):
-        raise NotImplementedMethodeError(self, self._sql_save)
+        raise NotImplementedMethodeError(self, self._db_save)
 
     ################
     # MODEL METHOD #

src/config.py

@@ -209,14 +209,14 @@ class Config(SQL):
             self.execute(f"""
               INSERT INTO solver VALUES (
                 '{solver._type}',
-                '{self._sql_format(solver._name)}',
+                '{self._db_format(solver._name)}',
-                '{self._sql_format(solver._description)}',
+                '{self._db_format(solver._description)}',
-                '{self._sql_format(solver._path_input)}',
+                '{self._db_format(solver._path_input)}',
-                '{self._sql_format(solver._path_solver)}',
+                '{self._db_format(solver._path_solver)}',
-                '{self._sql_format(solver._path_output)}',
+                '{self._db_format(solver._path_output)}',
-                '{self._sql_format(solver._cmd_input)}',
+                '{self._db_format(solver._cmd_input)}',
-                '{self._sql_format(solver._cmd_solver)}',
+                '{self._db_format(solver._cmd_solver)}',
-                '{self._sql_format(solver._cmd_output)}'
+                '{self._db_format(solver._cmd_output)}'
               )
               """,
                          commit=True)
@@ -227,8 +227,8 @@ class Config(SQL):
         for stricklers in self.stricklers.stricklers:
             self.execute(f"""
               INSERT INTO stricklers VALUES (
-                '{self._sql_format(stricklers._name)}',
+                '{self._db_format(stricklers._name)}',
-                '{self._sql_format(stricklers._comment)}',
+                '{self._db_format(stricklers._comment)}',
                 '{stricklers._minor}',
                 '{stricklers._medium}'
               )
@@ -255,11 +255,11 @@ class Config(SQL):
         for key in data:
             self.execute(
                 f"INSERT OR IGNORE INTO data VALUES " +
-                f" ('{key}', '{self._sql_format(data[key])}')"
+                f" ('{key}', '{self._db_format(data[key])}')"
             )
             self.execute(
                 f"UPDATE data SET " +
-                f"value='{self._sql_format(data[key])}' " +
+                f"value='{self._db_format(data[key])}' " +
                 f"WHERE key='{key}'"
             )
 
@@ -320,7 +320,7 @@ class Config(SQL):
         self.close_correctly = False
         self.execute(
             "UPDATE data SET " +
-            f"value='{self._sql_format(self.last_study)}' " +
+            f"value='{self._db_format(self.last_study)}' " +
             "WHERE key='last_study'"
         )
         self.execute(

src/tools.py

@@ -313,7 +313,7 @@ class SQL(object):
 
         return res
 
-    def _sql_format(self, value):
+    def _db_format(self, value):
         # Replace ''' by ''' to preserve SQL injection
         if value is str:
             value = value.replace("'", "'")