parouby
/
Pamhyr2
mirror of https://gitlab.com/pamhyr/pamhyr2
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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

setup.py
Pierre-Antoine Rouby 2023-10-27 14:15:42 +02:00
parent 8d92fbbdac
commit ea2dbfba3e
23 changed files with 186 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/Model/BoundaryCondition/BoundaryCondition.py
View File

@ -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._sql_format(self._type)}', '{tab}', {node}" +
f"{self.id}, '{self._db_format(self._name)}', " +
f"'{self._db_format(self._type)}', '{tab}', {node}" +
")"
)
execute(sql)
ind = 0
for d in self._data:
data0 = self._sql_format(str(d[0]))
data1 = self._sql_format(str(d[1]))
data0 = self._db_format(str(d[0]))
data1 = self._db_format(str(d[1]))
sql = (
"INSERT INTO " +

8
src/Model/BoundaryCondition/BoundaryConditionList.py
View File

@ -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

8
src/Model/Friction/Friction.py
View File

@ -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 " +

14
src/Model/Friction/FrictionList.py
View File

@ -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

10
src/Model/Geometry/PointXYZ.py
View File

@ -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}" +
")"

14
src/Model/Geometry/ProfileXYZ.py
View File

@ -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

12
src/Model/Geometry/Reach.py
View File

@ -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

24
src/Model/InitialConditions/InitialConditions.py
View File

@ -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"'{self._sql_format(self._comment)}', " +
f"{ind}, '{self._db_format(self.name)}', " +
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

8
src/Model/InitialConditions/InitialConditionsDict.py
View File

@ -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

16
src/Model/LateralContribution/LateralContribution.py
View File

@ -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._sql_format(self._type)}', '{tab}', {edge}, " +
f"{self.id}, '{self._db_format(self._name)}', " +
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]))
data1 = self._sql_format(str(d[1]))
data0 = self._db_format(str(d[0]))
data1 = self._db_format(str(d[1]))
sql = (
"INSERT INTO " +

8
src/Model/LateralContribution/LateralContributionList.py
View File

@ -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

50
src/Model/River.py
View File

@ -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._sql_format(self.is_enable())},"
f"{self.id}, '{self._db_format(self._name)}', " +
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)

32
src/Model/SedimentLayer/SedimentLayer.py
View File

@ -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._sql_format(self._type)}', {self._height}, " +
f"{self.id}, {ind}, '{self._db_format(self._name)}', " +
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"'{self._sql_format(self._comment)}')"
f"VALUES ({self.id}, '{self._db_format(self._name)}', " +
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

8
src/Model/SedimentLayer/SedimentLayerList.py
View File

@ -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

20
src/Model/SolverParameters/SolverParametersList.py
View File

@ -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._sql_format(value)}', " +
f"'{cls._sql_format(solver)}'" +
f"'{cls._db_format(name)}', " +
f"'{cls._db_format(value)}', " +
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._sql_format(param.value)}', " +
f"'{self._sql_format(t)}'" +
f"'{self._db_format(param.name)}', " +
f"'{self._db_format(param.value)}', " +
f"'{self._db_format(t)}'" +
")"
)
execute(sql)

12
src/Model/Stricklers/Stricklers.py
View File

@ -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._sql_format(self.comment)}', " +
f"'{self._db_format(self.name)}', " +
f"'{self._db_format(self.comment)}', " +
f"{float(self.minor)}, {float(self.medium)}" +
")"
)

10
src/Model/Stricklers/StricklersList.py
View File

@ -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

8
src/Model/Study.py
View File

@ -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(

30
src/Model/Tools/PamhyrDB.py
View File

@ -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 '&#39;' to preserve SQL injection
if value is str:
value = value.replace("'", "&#39;")
@ -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)

12
src/Model/Tools/PamhyrDict.py
View File

@ -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):
raise NotImplementedMethodeError(cls, cls._sql_load)
def _db_load(cls, execute, data=None):
raise NotImplementedMethodeError(cls, cls._db_load)
def _sql_save(self, execute, data=None):
raise NotImplementedMethodeError(self, self._sql_save)
def _db_save(self, execute, data=None):
raise NotImplementedMethodeError(self, self._db_save)
def __len__(self):
return len(self._dict)

24
src/Model/Tools/PamhyrList.py
View File

@ -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):
raise NotImplementedMethodeError(cls, cls._sql_load)
def _db_load(cls, execute, data=None):
raise NotImplementedMethodeError(cls, cls._db_load)
def _sql_save(self, execute, data=None):
raise NotImplementedMethodeError(self, self._sql_save)
def _db_save(self, execute, data=None):
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):
raise NotImplementedMethodeError(cls, cls._sql_load)
def _db_load(cls, execute, data=None):
raise NotImplementedMethodeError(cls, cls._db_load)
def _sql_save(self, execute, data=None):
raise NotImplementedMethodeError(self, self._sql_save)
def _db_save(self, execute, data=None):
raise NotImplementedMethodeError(self, self._db_save)
################
# MODEL METHOD #

26
src/config.py
View File

@ -209,14 +209,14 @@ class Config(SQL):
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)}'
'{self._db_format(solver._name)}',
'{self._db_format(solver._description)}',
'{self._db_format(solver._path_input)}',
'{self._db_format(solver._path_solver)}',
'{self._db_format(solver._path_output)}',
'{self._db_format(solver._cmd_input)}',
'{self._db_format(solver._cmd_solver)}',
'{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._sql_format(stricklers._comment)}',
'{self._db_format(stricklers._name)}',
'{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(

2
src/tools.py
View File

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