Initial commit

DataConnector.py

+import numpy as np
+import win32event
+
+import ioconnections
+import parsers.dataparsers
+import parsers.utilityparsers
+import requests.datarequests
+import requests.utilityrequests
+from datacontainers import Grid, GridDisplayProperties, WellHodograph, WellTrajectory
+
+
+class DataConnector:
+    connection: ioconnections.IOBase
+    app_id: int
+
+    def __init__(self, connection: ioconnections.IOBase, new_app_id: int):
+        self.connection = connection
+        self.app_id = new_app_id
+
+    def greeting(self) -> None:
+        message = requests.utilityrequests.DataConnectorGreetingRequest.request(
+            self.app_id
+        )
+        self.connection.write(message)
+
+    def get_wells_list(self) -> np.ndarray:
+        """Request code 1"""
+        message = requests.datarequests.WellListRequest.request()
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.WellListParser.parse(answer)
+
+    def get_wells_data(self, count: int = 0, *wells_ids: int) -> np.ndarray:
+        """Request code 2"""
+        message = requests.datarequests.WellsRequest.request(count, *wells_ids)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.WellsParser.parse(answer)
+
+    def get_well_curves(self, well_id: int) -> np.ndarray:
+        """Request code 3"""
+        message = requests.datarequests.WellCurvesRequest.request(well_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.WellCurvesParser.parse(answer)
+
+    def get_stratigraphic_levels(self) -> np.ndarray:
+        """Request code 4"""
+        message = requests.datarequests.StratigraphicLevelListRequest.request()
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.StratigraphicLevelsParser.parse(answer)
+
+    def get_well_stratigraphic_levels(self, well_id: int) -> np.ndarray:
+        """Request code 5"""
+        message = requests.datarequests.WellStratigraphicLevelListRequest.request(
+            well_id
+        )
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.WellStratigraphicLevelsParser.parse(answer)
+
+    def get_grids_list(self) -> np.ndarray:
+        """Request code 6"""
+        message = requests.datarequests.GridListRequest.request()
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.GridListParser.parse(answer)
+
+    def get_grid(self, grid_id: int) -> Grid:
+        """Request code 7"""
+        message = requests.datarequests.GridRequest.request(grid_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.GridParser.parse(answer)
+
+    def get_well_hodograph(self, well_id: int) -> WellHodograph:
+        """Request code 8"""
+        message = requests.datarequests.WellHodographRequest.request(well_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.WellHodographParser.parse(answer)
+
+    def get_well_trajectory(self, well_id: int) -> WellTrajectory:
+        """Request code 9"""
+        message = requests.datarequests.WellTrajectoryRequest.request(well_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.WellTrajectoryParser.parse(answer)
+
+    def get_grid_display_properties(self, grid_id: int) -> GridDisplayProperties:
+        """Request code 10"""
+        message = requests.datarequests.GridDisplayPropertiesRequest.request(grid_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return parsers.dataparsers.GridDisplayPropertiesParser.parse(answer)

DataConnectorExample.py

+import matplotlib.pyplot as plt
+import numpy as np
+
+from DataConnector import DataConnector
+from ioconnections.IOPipe import IOPipe
+
+# 1 - статический анализатор DONE
+# 2 - выделить ioconnections - pipeIO - fileIO DONE
+# 3 - overlapped параметр / тесты
+# 4 - async ioconnections
+
+
+if __name__ == "__main__":
+    try:
+        connection = IOPipe()
+        connection.connect()
+        app_id = int(input("Enter connection id"))
+        handler = DataConnector(connection, app_id)
+
+        while True:
+            order = int(
+                input(
+                    r"Order:"
+                    r"1 - Well list "
+                    r"2 - Well data "
+                    r"3 - Well curves "
+                    r"4 - Stratigraphic levels "
+                    r"5 - Well stratigraphic levels "
+                    r"6 - Grid list "
+                    r"7 - Grid "
+                    r"8 - Well hodograph "
+                    r"9 - Well trajectory "
+                    r"10 - Grid display properties "
+                    r"0 - Exit"
+                )
+            )
+            match order:
+                case 0:
+                    handler.greeting()
+                    print(handler.app_id)
+                case 1:
+                    wells = handler.get_wells_list()
+                    for val in wells:
+                        print(val.well_id, val.well_name)
+                case 2:
+                    # No info in message with concrete well ids
+                    string = input("Enter well ids (zero, if you need all wells) ")
+                    well_ids = tuple(int(x) for x in string.split(" "))
+                    if len(well_ids) == 1 and well_ids[0] == 0:
+                        wells = handler.get_wells_data(0)
+                    else:
+                        wells = handler.get_wells_data(len(well_ids), *well_ids)
+                    for val in wells:
+                        print(val.well_id)
+                case 3:
+                    well_id = int(input("Enter well id "))
+                    curves = handler.get_well_curves(well_id)
+                    plt.plot(curves[0].point_depths, curves[0].point_values)
+                    plt.show()
+                    print(curves[0].point_values)
+                    print(curves[0].point_depths)
+                case 4:
+                    levels = handler.get_stratigraphic_levels()
+                    for val in levels:
+                        print(val.level_id)
+                case 5:
+                    well_id = int(input("Enter well id "))
+                    levels = handler.get_well_stratigraphic_levels(well_id)
+                    for val in levels:
+                        print(val.level_id)
+                case 6:
+                    grids = handler.get_grids_list()
+                    for val in grids:
+                        print(val.grid_id)
+                case 7:
+                    grid_id = int(input("Enter grid id "))
+                    grid = handler.get_grid(grid_id)
+                    plot = np.reshape(grid.data, (grid.n_y, grid.n_x))
+                    plt.imshow(plot, interpolation="none")
+                    plt.gca().invert_yaxis()
+                    plt.show()
+                    print(grid.n_x, grid.n_y, grid.n_id, grid.data)
+                case 8:
+                    #   No hodograph points in message from GisWell
+                    well_id = int(input("Enter well id "))
+                    hodograph = handler.get_well_hodograph(well_id)
+                    print(hodograph.point_times)
+                case 9:
+                    #   Trajectory points are filled with zeros, IDK why
+                    well_id = int(input("Enter well id "))
+                    trajectory = handler.get_well_trajectory(well_id)
+                    print(trajectory.point_depths)
+                case 10:
+                    grid_id = int(input("Enter grid id "))
+                    display_info = handler.get_grid_display_properties(grid_id)
+                    print(display_info.palette_values)
+                case _:
+                    print("Alright")
+                    break
+        connection.disconnect()
+    except RuntimeError as e:
+        print("Error happened", e)

SignalConnector.py

+import ioconnections
+import parsers.signalparsers
+import parsers.utilityparsers
+import requests.utilityrequests.ListenerGreetingRequest
+
+
+class SignalConnector:
+    connection: ioconnections.IOBase
+    continue_listening: bool
+
+    def __init__(self, connection: ioconnections.IOBase):
+        self.connection = connection
+
+    def greeting(self) -> None:
+        message = requests.utilityrequests.ListenerGreetingRequest.request()
+        self.connection.write(message)
+
+    def listen(self) -> None:
+        answer: bytes
+        while self.connection.continue_work:
+            try:
+                answer = self.connection.read()
+                parsers.signalparsers.SignalCodeParser.parse(answer)
+            except RuntimeError:
+                continue

SignalConnectorExample.py

+from threading import Thread
+
+from ioconnections.IOPipe import IOPipe
+from SignalConnector import SignalConnector
+
+# 1 - статический анализатор DONE
+# 2 - выделить ioconnections - pipeIO - fileIO DONE
+# 3 - overlapped параметр / тесты
+# 4 - async ioconnections
+
+
+if __name__ == "__main__":
+    try:
+        connection = IOPipe()
+        connection.connect()
+        handler = SignalConnector(connection)
+        handler.greeting()
+        p1 = Thread(target=handler.listen)
+        p1.start()
+        if int(input("Enter 0 for stop listening\n")) == 0:
+            handler.connection.continue_work = False
+            p1.join()
+    except RuntimeError as e:
+        print("Error happened", e)

datacontainers/Color.py

+from dataclasses import dataclass
+
+
+@dataclass
+class Color:
+    alpha: int
+    red: int
+    green: int
+    blue: int

datacontainers/Grid.py

+from dataclasses import dataclass
+
+from numpy import ndarray
+
+
+@dataclass
+class Grid:
+    n_id: int
+    n_x: int
+    n_y: int
+    x_min: float
+    x_max: float
+    y_min: float
+    y_max: float
+    z_min: float
+    z_max: float
+    blank_code: float
+    data: ndarray

datacontainers/GridDisplayProperties.py

+from dataclasses import dataclass
+
+from numpy import ndarray
+
+from datacontainers.Color import Color
+
+
+@dataclass
+class GridDisplayProperties:
+    isoline_min_level: float
+    isoline_max_level: float
+    isoline_level_step: float
+    minor_isoline_color: Color
+    minor_isoline_thickness: float
+    major_isoline_color: Color
+    major_isoline_thickness: float
+    major_isoline_step: int
+    min_palette_level: float
+    max_palette_level: float
+    color_interpolation_type: int
+    palette_values: ndarray
+    palette_colors: ndarray

datacontainers/GridInfo.py

+from dataclasses import dataclass
+
+
+@dataclass
+class GridInfo:
+    grid_id: int
+    grid_name: str
+    grid_type: int
+    grid_visibility: int

datacontainers/StratigraphicLevel.py

+from dataclasses import dataclass
+
+
+@dataclass
+class StratigraphicLevel:
+    level_id: int
+    level_age: float
+    level_name: str

datacontainers/Well.py

+from dataclasses import dataclass
+
+
+@dataclass
+class Well:
+    well_id: int
+    well_name: str
+    outfall_x: float
+    outfall_y: float
+    altitude: float
+    bottom: float

datacontainers/WellCurve.py

+from dataclasses import dataclass
+
+from numpy import ndarray
+
+
+@dataclass
+class WellCurve:
+    curve_type: int
+    curve_name: str
+    point_values: ndarray
+    point_depths: ndarray

datacontainers/WellHodograph.py

+from dataclasses import dataclass
+
+from numpy import ndarray
+
+
+@dataclass
+class WellHodograph:
+    time_shift: float
+    point_times: ndarray
+    point_depths: ndarray

datacontainers/WellInfo.py

+from dataclasses import dataclass
+
+
+@dataclass
+class WellInfo:
+    well_id: int
+    well_name: str

datacontainers/WellStratigraphicLevel.py

+from dataclasses import dataclass
+
+
+@dataclass
+class WellStratigraphicLevel:
+    level_id: int
+    level_depth: float

datacontainers/WellTrajectory.py

+from dataclasses import dataclass
+
+from numpy import ndarray
+
+
+@dataclass
+class WellTrajectory:
+    point_depths: ndarray
+    point_x_shifts: ndarray
+    point_y_shifts: ndarray
+    point_z_shifts: ndarray

datacontainers/__init__.py

+from .Color import Color
+from .Grid import Grid
+from .GridDisplayProperties import GridDisplayProperties
+from .GridInfo import GridInfo
+from .StratigraphicLevel import StratigraphicLevel
+from .Well import Well
+from .WellCurve import WellCurve
+from .WellHodograph import WellHodograph
+from .WellInfo import WellInfo
+from .WellStratigraphicLevel import WellStratigraphicLevel
+from .WellTrajectory import WellTrajectory