def test_insertion(self):
# type: () -> None
"""
Test the insert functions of class Well
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
wells = Well.load_all_from_db(self.session)
marker_1 = WellMarker(301.43, StratigraphicObject.init_stratigraphy(self.session, "ku"), self.session,
"Comment 1")
marker_2 = WellMarker(351.65, StratigraphicObject.init_stratigraphy(self.session, "mo"), self.session)
marker_3 = WellMarker(934.23, StratigraphicObject.init_stratigraphy(self.session, "mm"), self.session,
"Comment 3")
wells[0].insert_marker(marker_1)
self.assertEqual(len(wells[0].marker), 6)
self.assertEqual(wells[0].marker[5], marker_1)
self.assertRaises(ValueError, wells[1].insert_marker, marker_3)
wells[2].insert_multiple_marker([marker_1, marker_2])
self.assertEqual(len(wells[2].marker), 6)
self.assertEqual(wells[2].marker[2], marker_1)
self.assertEqual(wells[2].marker[4], marker_2)
del wells
wells = Well.load_all_from_db(self.session)
self.assertEqual(wells[2].marker[2], marker_1)
self.assertEqual(wells[2].marker[4], marker_2)
del wells
wells = Well.load_all_from_db(self.session)
self.assertRaises(ValueError, wells[1].insert_multiple_marker, [marker_1, marker_2, marker_3])
def test_log_handling(self):
# type: () -> None
"""
Tests the log handling functionality
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
log_values = (
(
(10, 4, "", ""),
(15, "45.4", "name 1", "Comment 1"),
(16, 34.3, "", ""),
(17, 234, "", "Comment 2"),
(5, "34.4", "", "Comment 3")
),
(
(34.3, 4, "", ""),
(13, 234, "", "Comment 2"),
(34, "34.4", "", "Comment 3")
)
)
well = Well.load_by_wellname_from_db("Well_2", self.session)
for i in range(len(log_values)):
log = WellLog("log {}".format(i), "unit name", self.session, "", "")
log.save_to_db()
well.add_log(log)
for value in log_values[i]:
log.insert_log_value(WellLogValue(value[0], value[1], self.session, value[2], value[3]))
del log
del well
well = Well.load_by_wellname_from_db("Well_2", self.session)
self.assertEqual(2, len(well.logs))
self.assertEqual(5, len(well.logs[0].log_values))
self.assertEqual("log 0", well.logs[0].property_name)
self.assertEqual(3, len(well.logs[1].log_values))
self.assertEqual("log 1", well.logs[1].property_name)
well.delete_log(well.logs[1])
del well
well = Well.load_by_wellname_from_db("Well_2", self.session)
self.assertEqual(1, len(well.logs))
self.assertEqual(5, len(well.logs[0].log_values))
self.assertEqual("log 0", well.logs[0].property_name)
logs = WellLog.load_all_from_db(self.session)
self.assertEqual(1, len(logs))
def test_loading(self):
# type: () -> None
"""
Test the different types of loading of lines from the db.
Part 1: load all wells from the database
Part 2: load well by name
Part 3: load wells in given extent
Part 4: load wells with minimal depth
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
# Part 1: load all wells from the database
wells = Well.load_all_from_db(self.session)
self.assertEqual(len(wells), 3)
self.assertEqual(wells[0].well_name, "Well_1")
self.assertEqual(wells[1].well_name, "Well_2")
self.assertEqual(wells[2].well_name, "Well_3")
self.assertEqual(len(wells[1].marker), 4)
self.assertTrue(wells[1].marker[0].horizon == wells[1].marker[3].horizon)
del wells
# Part 2: load well by name
well = Well.load_by_wellname_from_db("Well_2", self.session)
self.assertEqual(well.well_name, "Well_2")
self.assertEqual(well.short_name, "W2")
self.assertEqual(well.depth, 341)
self.assertEqual(len(well.marker), 4)
self.assertEqual(well.marker[1].horizon.statigraphic_name, "mm")
self.assertEqual(well.marker[1].depth, 120)
del well
# Part 3: load wells in given extent
# extent x: 500 - 1,300
# extent y: 0 - 2,400
# result: "Well_1" and "Well_2"
wells = Well.load_in_extent_from_db(self.session, 500, 1300, 0, 2400)
self.assertEqual(len(wells), 2)
self.assertEqual(wells[0].well_name, "Well_1")
self.assertEqual(wells[1].well_name, "Well_2")
self.assertEqual(len(wells[0].marker), 5)
self.assertEqual(len(wells[1].marker), 4)
del wells
# Part 4: load wells with minimal depth
wells = Well.load_deeper_than_value_from_db(self.session, 395.23)
self.assertEqual(len(wells), 2)
self.assertEqual(wells[0].well_name, "Well_1")
self.assertEqual(wells[1].well_name, "Well_3")
self.assertTrue(wells[0].depth >= 395.23)
self.assertTrue(wells[1].depth >= 395.23)
del wells
def test_get_marker_by_depth(self):
# type: () -> None
"""
Test the Well.get_marker_by_depth function
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
well = Well.load_by_wellname_from_db("Well_1", self.session)
self.assertEqual(well.get_marker_by_depth(16).horizon.statigraphic_name, "sm")
self.assertRaises(ValueError, well.get_marker_by_depth, 100)
def test_delete_marker(self):
# type: () -> None
"""
Test the Well.get_marker_by_depth function
:return: Nothing
:raises AssertionError: Raises AssertionError if a test fails
"""
well = Well.load_by_wellname_from_db("Well_1", self.session)
marker = well.get_marker_by_depth(16)
self.assertEqual(marker.horizon.statigraphic_name, "sm")
self.assertRaises(ValueError, well.get_marker_by_depth, 100)
well.delete_marker(marker)
well.save_to_db()
self.assertEqual(len(well.marker), 4)
del well
well = Well.load_by_wellname_from_db("Well_1", self.session)
self.assertEqual(len(well.marker), 4)
new_marker = WellMarker(23423, StratigraphicObject.init_stratigraphy(self.session, "so"), self.session,
"Nothing")
self.assertRaises(ValueError, well.delete_marker, new_marker)
self.assertRaises(TypeError, well.delete_marker, "test")
def setUp(self):
# type: () -> None
"""
Initialise a temporary database connection for all test cases and fill the database with test data
:return: None
"""
# initialise a in-memory sqlite database
self.handler = DBHandler(connection="sqlite://", echo=False)
self.session = self.handler.get_session()
# add test data to the database
self.well = {
"well_name": "Well_1",
"short_name": "W1",
"reference": "none",
"east": 1234.56,
"north": 123.45,
"altitude": 10.5,
"depth": 555,
"log_values": ((10, 4, "", ""),
(15, "45.4", "name 1", "Comment 1"),
(16, 34.3, "", ""),
(17, 234, "", "Comment 2"),
(5, "34.4", "", "Comment 3"))
}
well = Well(self.well["well_name"], self.well["short_name"], self.well["depth"], self.well["reference"],
self.well["east"], self.well["north"], self.well["altitude"], self.session, "", "")
well.save_to_db()
logging = WellLog("logging", "unit name", self.session, "", "")
logging.save_to_db()
well.add_log(logging)
for value in self.well["log_values"]:
logging.insert_log_value(WellLogValue(value[0], value[1], self.session, value[2], value[3]))
def run(self):
"""
Save well logs to the database
:return: Nothing, emits Qt Signals
"""
self._mutex.lock()
service = DatabaseService.get_instance()
service.close_session()
service.connect()
session = service.get_session()
failed_imports = 0
try:
onekey = self._data[next(iter(self._data.keys()))]["values"]
# import json
# self._logger.info(json.dumps(onekey, indent=2))
count = len(onekey)
well_name_col = self._selection["well_name"]
depth_col = self._selection["depth"]
reference = ImportService.get_instance().get_crs()
if reference is None:
reference = ""
else:
reference = reference.toWkt()
self._logger.debug("Saving with reference system\n{}".format(reference))
for i in range(count):
self.update_progress.emit(100 * i / count)
try:
well_name = self._data[well_name_col]["values"][i]
except ValueError:
self._logger.warn("No well_name specified for current data set at line {}".format(i))
failed_imports += 1
continue
if (well_name is None) or (well_name == ""):
self._logger.warn("Unknown well name found: [{}]".format(well_name))
failed_imports += 1
continue
try:
well: Well = Well.load_by_wellname_from_db(well_name, session)
if well is None:
self._logger.warn("No well with name [{}] found...".format(well_name))
failed_imports += 1
continue
well.reference_system = reference
# add / update properties
for item in self._properties:
self._logger.debug("Property: {}".format(item))
if well.has_log(item.name):
log = well.get_log(item.name)
else:
log = WellLog(property_name = item.name, property_unit = item.unit, session=session)
well.add_log(log)
depth = self._data[depth_col]["values"][i]
value = self._data[item.name]["values"][i]
try:
log_value: WellLogValue = log.get_value_by_depth(depth)
except ValueError:
log_value = WellLogValue(depth, value, session=session)
log_value.value = value
log.insert_log_value(log_value)
self._logger.debug("well: {}".format(well))
well.save_to_db()
except DatabaseRequestException:
self._logger.warn("Cannot find well with name [{}]. Skipping log import".format(well_name))
failed_imports += 1
if self._cancel:
self._logger.debug("Import canceled")
self.import_failed.emit(self._message)
break
if not self._cancel:
if failed_imports > 0:
self.import_finished_with_warnings.emit("Could not import {} properties.".format(failed_imports))
self.update_progress.emit(100)
self.import_finished.emit()
except Exception as e:
msg = str(ExceptionHandler(e))
self.import_failed.emit(msg)
self._logger.error("Error", msg, to_messagebar=True)
finally:
service.close_session()
self._mutex.unlock()
self.quit()
def run(self) -> bool:
"""
Save the Well Object(s) to the database
:return: True if function executed successfully, else False
"""
self._mutex.lock()
service = DatabaseService.get_instance()
service.close_session()
service.connect()
session = DatabaseService.get_instance().get_session()
try:
onekey = self._data[next(iter(self._data.keys()))]["values"]
count = len(onekey)
name = self._selection["name"]
short_name = self._selection["short_name"]
east = self._selection["easting"]
north = self._selection["northing"]
alt = self._selection["altitude"]
total_depth = self._selection["total_depth"]
strat = self._selection["strat"]
depth_to = self._selection["depth_to"]
comment = self._selection["comment"]
reference = ImportService.get_instance().get_crs()
if reference is None:
reference = ""
else:
reference = reference.toWkt()
self._logger.debug("Saving with reference system\n{}".format(reference))
wells = dict()
maximum = count
for i in range(count):
if (self._data[east]["values"][i] == "") and (self._data[north]["values"][i] == ""):
continue
na = self._data[name]["values"][i]
sn = "" if short_name == "" else self._data[short_name]["values"][i]
e = float(self._data[east]["values"][i])
n = float(self._data[north]["values"][i])
kb = None if alt == "" else float(self._data[alt]["values"][i])
td = -1 if total_depth == "" else float(self._data[total_depth]["values"][i])
s = "" if strat == "" else self._data[strat]["values"][i]
dt = -1 if depth_to == "" else float(self._data[depth_to]["values"][i])
c = "" if comment == "" else self._data[comment]["values"][i]
strat_obj = StratigraphicObject.init_stratigraphy(session, s, -1)
strat_obj.save_to_db()
marker = WellMarker(dt, strat_obj, session=session, comment=c)
# marker.save_to_db()
# point = GeoPoint(None, False if (h is None) else True, reference,
# e, n, 0 if (h is None) else h, session, sn, c)
if na in wells:
wells[na]["marker"].append(marker)
else:
wells[na] = {
"short_name": sn,
"easting": e,
"northing": n,
"altitude": kb,
"total_depth": td,
"marker": [marker]
}
maximum += 1
if self._cancel:
self._logger.debug("Import canceled")
self.import_failed.emit(self._message)
break
self.update_progress.emit(100 * i / maximum)
i = count
if not self._cancel:
for well_name in wells:
i += 1
well = wells[well_name]
new_well = Well.load_by_wellname_from_db(well_name, session)
if new_well is not None:
try:
self._logger.debug("Updating existing well: {}".format(new_well))
for marker in new_well.marker:
WellMarker.delete_from_db(marker, session)
new_well.save_to_db()
new_well.marker = well["marker"]
new_well.short_name = well["short_name"]
new_well.easting = well["easting"]
new_well.northing = well["northing"]
new_well.depth = well["total_depth"]
except WellMarkerDepthException as e:
self._logger.error("WellMarkerDepthException", "{}\n{}".format(new_well, str(e)))
return False
else:
self._logger.debug("Creating new well with name [{}]".format(well_name))
new_well = Well(well_name, well["short_name"], well["total_depth"], reference_system=reference,
easting=well["easting"], northing=well["northing"], altitude=well["altitude"],
session=session)
new_well.marker = well["marker"]
new_well.save_to_db()
self._logger.debug("Saved well:\n{}".format(new_well))
self.update_progress.emit(100 * i / maximum)
if self._cancel:
self._logger.debug("Import canceled")
self.import_failed.emit(self._message)
break
if not self._cancel:
self.update_progress.emit(100)
self._logger.debug("Lines successfully imported")
self.import_finished.emit()
except Exception as e:
msg = str(ExceptionHandler(e))
self.import_failed.emit(msg)
self._logger.error("Error", msg)
finally:
service.close_session()
self._mutex.unlock()
self.quit()
def setUp(self):
# type: () -> None
"""
Initialise a temporary database connection for all test cases and fill the database with test data
:return: None
"""
# initialise a in-memory sqlite database
self.handler = DBHandler(connection="sqlite://", echo=False)
self.session = self.handler.get_session()
# add test data to the database
self.wells = [
{
"name": "Well_1",
"short_name": "W1",
"comment": "A drilled well",
"east": 1234.56,
"north": 123.45,
"altitude": 10.5,
"depth": 555,
"marker": ((10, "mu", 4, ""),
(15, "so", 3, "Comment 1"),
(16, "sm", 2, ""),
(17, "su", 1, "Comment 2"),
(5, "mm", 5, "Comment 3"))
}, {
"name": "Well_2",
"short_name": "W2",
"comment": "",
"east": 1000.23,
"north": 2300.34,
"altitude": 342.23,
"depth": 341,
"marker": ((12, "mo", 6, ""),
(120, "mm", 5, "Comment 1"),
(300, "Fault", 0, "Comment 2"),
(320, "mo", 6, ""))
}, {
"name": "Well_3",
"short_name": "W3",
"comment": "A third well",
"east": 3454.34,
"north": 2340.22,
"altitude": 342.20,
"depth": 645.21,
"marker": ((34, "mu", 4, ""),
(234, "so", 3, "Comment 1"),
(345, "Fault", 0, "Comment 2"),
(635, "mu", 4, "Comment 3"))
}
]
for well in self.wells:
new_well = Well(well["name"], well["short_name"], well["depth"], "spatial_reference_unknown", well["east"],
well["north"], well["altitude"], self.session, "well_set", well["comment"])
new_well.save_to_db()
for mark in well["marker"]:
new_well.marker.append(
WellMarker(mark[0], StratigraphicObject.init_stratigraphy(self.session, mark[1], mark[2], False),
self.session, well["name"], mark[3]))
new_well.marker[-1].save_to_db()
def test_setter_and_getter(self):
# type: () -> None
"""
Test setter and getter functionality
:return: Nothing
:raises AssertionError: Raises Assertion Error if a test fails
"""
# first part: test setter
wells = Well.load_all_from_db(self.session)
test_string = "abcdefghijklmnopqrstuvwxyz1234567890"
wells[0].comment = "new comment set"
wells[1].comment = 4 * test_string
wells[0].easting = "-344.3"
wells[1].easting = -1234.34
# self.assertRaises(ValueError, setattr, wells[2], "easting", "test")
# python >= 2.7 => not included in all ArcGIS versions...
with(self.assertRaises(ValueError)): # python <= 2.6
wells[2].easting = "test"
wells[0].northing = -234.56
wells[1].northing = "-2345.356"
with(self.assertRaises(ValueError)):
wells[2].northing = "test"
wells[0].altitude = -343.67
wells[1].altitude = "-235.34"
with(self.assertRaises(ValueError)):
wells[2].altitude = "test"
wells[0].depth = 235.65
wells[1].depth = "3456.14"
with(self.assertRaises(ValueError)):
wells[2].depth = "test"
with(self.assertRaises(ValueError)):
wells[2].depth = -123.43
with(self.assertRaises(WellMarkerDepthException)):
wells[2].depth = 500
wells[0].well_name = "new Well Name"
wells[1].well_name = 4 * test_string
wells[0].short_name = "NWN"
wells[1].short_name = test_string
# changes are stored automatically to the database through SQLAlchemy
del wells
# second part: test getters
wells = Well.load_all_from_db(self.session)
self.assertEqual(wells[0].comment, "new comment set")
self.assertEqual(len(wells[1].comment), 100)
self.assertEqual(wells[0].easting, -344.3)
self.assertEqual(wells[1].easting, -1234.34)
self.assertEqual(wells[2].easting, 3454.34)
self.assertEqual(wells[0].northing, -234.56)
self.assertEqual(wells[1].northing, -2345.356)
self.assertEqual(wells[2].northing, 2340.22)
self.assertEqual(wells[0].altitude, -343.67)
self.assertEqual(wells[1].altitude, -235.34)
self.assertEqual(wells[2].altitude, 342.2)
self.assertEqual(wells[0].depth, 235.65)
self.assertEqual(wells[1].depth, 3456.14)
self.assertEqual(wells[2].depth, 645.21)
self.assertEqual(wells[0].well_name, "new Well Name")
self.assertEqual(len(wells[1].well_name), 100)
self.assertEqual(wells[0].short_name, "NWN")
self.assertEqual(len(wells[1].short_name), 20)
# setter and getter for session
wells[2].session = wells[1].session