cratonapi 0.1.0__py3-none-any.whl

cratonapi/__init__.py

@@ -0,0 +1,8 @@
+import cratonapi.datacontainers
+import cratonapi.ioconnections
+import cratonapi.parsers
+import cratonapi.requests
+import cratonapi.signals
+
+from .dataconnector import DataConnector
+from .signalconnector import SignalConnector

cratonapi/dataconnector.py

@@ -0,0 +1,99 @@
+import numpy as np
+
+from cratonapi.datacontainers import (
+    Grid,
+    GridDisplayProperties,
+    WellHodograph,
+    WellTrajectory,
+)
+from cratonapi.ioconnections import IOBase, IOPipe
+from cratonapi.parsers.dataparsers import *
+from cratonapi.requests.datarequests import *
+from cratonapi.requests.utilityrequests import dataconnectorgreetingrequest
+
+
+class DataConnector:
+    connection: IOBase
+    app_id: int
+
+    def __init__(self, connection: IOBase, new_app_id: int = 1):
+        self.connection = connection
+        self.app_id = new_app_id
+        self.__greeting()
+
+    def __greeting(self) -> None:
+        message = dataconnectorgreetingrequest.request(self.app_id)
+        self.connection.write(message)
+
+    def get_wells_list(self) -> np.ndarray:
+        """Request code 1"""
+        message = welllistrequest.request()
+        self.connection.write(message)
+        answer = self.connection.read()
+        return welllistparser.parse(answer)
+
+    def get_wells_data(self, count: int = 0, *wells_ids: int) -> np.ndarray:
+        """Request code 2"""
+        message = wellsrequest.request(count, *wells_ids)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return wellsparser.parse(answer)
+
+    def get_well_curves(self, well_id: int) -> np.ndarray:
+        """Request code 3"""
+        message = wellcurvesrequest.request(well_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return wellcurvesparser.parse(answer)
+
+    def get_stratigraphic_levels(self) -> np.ndarray:
+        """Request code 4"""
+        message = stratigraphiclevellistrequest.request()
+        self.connection.write(message)
+        answer = self.connection.read()
+        return stratigraphiclevelsparser.parse(answer)
+
+    def get_well_stratigraphic_levels(self, well_id: int) -> np.ndarray:
+        """Request code 5"""
+        message = wellstratigraphiclevellistrequest.request(well_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return wellstratigraphiclevelsparser.parse(answer)
+
+    def get_grids_list(self) -> np.ndarray:
+        """Request code 6"""
+        message = gridlistrequest.request()
+        self.connection.write(message)
+        answer = self.connection.read()
+        return gridlistparser.parse(answer)
+
+    def get_grid(self, grid_id: int) -> Grid:
+        """Request code 7"""
+        message = gridrequest.request(grid_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return gridparser.parse(answer)
+
+    def get_well_hodograph(self, well_id: int) -> WellHodograph:
+        """Request code 8"""
+        message = wellhodographrequest.request(well_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return wellhodographparser.parse(answer)
+
+    def get_well_trajectory(self, well_id: int) -> WellTrajectory:
+        """Request code 9"""
+        message = welltrajectoryrequest.request(well_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return welltrajectoryparser.parse(answer)
+
+    def get_grid_display_properties(self, grid_id: int) -> GridDisplayProperties:
+        """Request code 10"""
+        message = griddisplaypropertiesrequest.request(grid_id)
+        self.connection.write(message)
+        answer = self.connection.read()
+        return griddisplaypropertiesparser.parse(answer)
+
+    def disconnect(self) -> None:
+        self.connection.disconnect()

cratonapi/datacontainers/__init__.py

@@ -0,0 +1,11 @@
+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

cratonapi/datacontainers/color.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Color:
+    alpha: int
+    red: int
+    green: int
+    blue: int

cratonapi/datacontainers/grid.py

@@ -0,0 +1,18 @@
+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

cratonapi/datacontainers/griddisplayproperties.py

@@ -0,0 +1,22 @@
+from dataclasses import dataclass
+
+from numpy import ndarray
+
+from . 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

cratonapi/datacontainers/gridinfo.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class GridInfo:
+    grid_id: int
+    grid_name: str
+    grid_type: int
+    grid_visibility: int

cratonapi/datacontainers/stratigraphiclevel.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class StratigraphicLevel:
+    level_id: int
+    level_age: float
+    level_name: str

cratonapi/datacontainers/well.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Well:
+    well_id: int
+    well_name: str
+    outfall_x: float
+    outfall_y: float
+    altitude: float
+    bottom: float

cratonapi/datacontainers/wellcurve.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+from numpy import ndarray
+
+
+@dataclass
+class WellCurve:
+    curve_type: int
+    curve_name: str
+    point_values: ndarray
+    point_depths: ndarray

cratonapi/datacontainers/wellhodograph.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from numpy import ndarray
+
+
+@dataclass
+class WellHodograph:
+    time_shift: float
+    point_times: ndarray
+    point_depths: ndarray

cratonapi/datacontainers/wellinfo.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class WellInfo:
+    well_id: int
+    well_name: str

cratonapi/datacontainers/wellstratigraphiclevel.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class WellStratigraphicLevel:
+    level_id: int
+    level_depth: float

cratonapi/datacontainers/welltrajectory.py

@@ -0,0 +1,11 @@
+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

cratonapi/ioconnections/__init__.py

@@ -0,0 +1,4 @@
+from .iobase import IOBase
+from .iofile import IOFile
+from .iopipe import IOPipe
+from .ioreader import IOReader

cratonapi/ioconnections/iobase.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+
+
+class IOBase(ABC):
+    @abstractmethod
+    def __init__(self, path: str) -> None:
+        pass
+
+    @abstractmethod
+    def connect(self) -> None:
+        pass
+
+    @abstractmethod
+    def disconnect(self) -> None:
+        pass
+
+    @abstractmethod
+    def read(self) -> bytes:
+        pass
+
+    @abstractmethod
+    def write(self, message: bytes) -> None:
+        pass

cratonapi/ioconnections/iofile.py

@@ -0,0 +1,30 @@
+import sys
+from typing import BinaryIO, TextIO
+
+from . import IOBase
+
+
+class IOFile(IOBase):
+    file: BinaryIO
+    path: str
+    mode: str
+
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self.connect()
+
+    def connect(self) -> None:
+        try:
+            self.file = open(self.path, "rb+")
+        except OSError:
+            print("Unable to open file!")
+            sys.exit(-1)
+
+    def read(self) -> bytes:
+        return self.file.read()
+
+    def write(self, message: bytes) -> None:
+        self.file.write(message)
+
+    def disconnect(self) -> None:
+        self.file.close()

cratonapi/ioconnections/iopipe.py

@@ -0,0 +1,77 @@
+import time
+from ctypes.wintypes import HANDLE
+
+import win32con
+import win32event
+import win32file
+import win32pipe
+from win32ctypes.pywin32.pywintypes import error
+
+from . import IOBase
+
+
+class IOPipe(IOBase):
+    handler: HANDLE
+    overlapped: win32file.OVERLAPPED
+    continue_work: bool
+    path: str
+
+    def __init__(self, path: str) -> None:
+        self.overlapped = win32file.OVERLAPPED()
+        self.overlapped.hEvent = win32event.CreateEvent(None, True, 0, None)
+        self.continue_work = True
+        self.path = path
+        self.connect()
+
+    def connect(self) -> None:
+        try:
+            self.handler = win32file.CreateFile(
+                self.path,
+                win32file.GENERIC_READ | win32file.GENERIC_WRITE,
+                0,
+                None,
+                win32file.OPEN_EXISTING,
+                win32con.FILE_FLAG_OVERLAPPED,
+                None,
+            )
+            if self.handler != win32file.INVALID_HANDLE_VALUE:
+                win32pipe.SetNamedPipeHandleState(
+                    self.handler, win32pipe.PIPE_READMODE_BYTE, None, None
+                )
+                self.continue_work = True
+            else:
+                raise RuntimeError("Connection failed! ")
+        except error:
+            raise RuntimeError("Connection failed! ")
+
+    def read(self) -> bytes:
+        try:
+            _, available_data, _ = win32pipe.PeekNamedPipe(self.handler, 0)
+            while available_data == 0 and self.continue_work:
+                _, available_data, _ = win32pipe.PeekNamedPipe(self.handler, 0)
+            if not self.continue_work:
+                return bytes()
+            result, data = win32file.ReadFile(
+                self.handler, available_data, self.overlapped
+            )
+            buf = data.obj
+            available_data = 0
+            while available_data == 0:
+                _, available_data, _ = win32pipe.PeekNamedPipe(self.handler, 0)
+            while available_data != 0:
+                result, data = win32file.ReadFile(
+                    self.handler, available_data, self.overlapped
+                )
+                buf += data.obj
+                time.sleep(0.1)
+                _, available_data, _ = win32pipe.PeekNamedPipe(self.handler, 0)
+            return buf
+        except error:
+            raise RuntimeError("Listening has been stopped")
+
+    def write(self, message: bytes) -> None:
+        win32file.WriteFile(self.handler, message)
+
+    def disconnect(self) -> None:
+        self.continue_work = False
+        win32file.CloseHandle(self.handler)

cratonapi/ioconnections/ioreader.py

@@ -0,0 +1,30 @@
+import sys
+from typing import BinaryIO, TextIO
+
+from . import IOBase
+
+
+class IOReader(IOBase):
+    file: BinaryIO
+
+    mode: str
+
+    def __init__(self, path: str) -> None:
+        self.path = path
+        self.connect()
+
+    def connect(self) -> None:
+        try:
+            self.file = open(self.path, "rb+")
+        except OSError:
+            print("Unable to open file!")
+            sys.exit(-1)
+
+    def read(self) -> bytes:
+        return self.file.read()
+
+    def write(self, message: bytes) -> None:
+        pass
+
+    def disconnect(self) -> None:
+        self.file.close()

cratonapi/parsers/dataparsers/__init__.py

@@ -0,0 +1,12 @@
+from . import (
+    griddisplaypropertiesparser,
+    gridlistparser,
+    gridparser,
+    stratigraphiclevelsparser,
+    wellcurvesparser,
+    wellhodographparser,
+    welllistparser,
+    wellsparser,
+    wellstratigraphiclevelsparser,
+    welltrajectoryparser,
+)

cratonapi/parsers/dataparsers/griddisplaypropertiesparser.py

@@ -0,0 +1,73 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import Color, GridDisplayProperties
+
+
+def parse(message: bytes) -> GridDisplayProperties:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 10:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    (
+        isoline_min_level,
+        isoline_max_level,
+        isoline_level_step,
+        minor_isoline_alpha,
+        minor_isoline_red,
+        minor_isoline_green,
+        minor_isoline_blue,
+        minor_isoline_thickness,
+        major_isoline_alpha,
+        major_isoline_red,
+        major_isoline_green,
+        major_isoline_blue,
+        major_isoline_thickness,
+        major_isoline_step,
+        palette_min_level,
+        palette_max_level,
+        color_interpolation_type,
+        points_count,
+    ) = struct.unpack("<3f4Bf4BfH2dBI", message[16:67])
+    offset: int = 0
+    point_values = np.empty(points_count)
+    point_colors = np.empty(points_count, Color)
+    for point in range(points_count):
+        value, alpha, red, green, blue = struct.unpack(
+            "<f4B", message[67 + offset : 75 + offset]
+        )
+        offset += 8
+        point_values[point] = value
+        point_colors[point] = Color(alpha, red, green, blue)
+    return GridDisplayProperties(
+        isoline_min_level,
+        isoline_max_level,
+        isoline_level_step,
+        Color(
+            minor_isoline_alpha,
+            minor_isoline_red,
+            minor_isoline_green,
+            minor_isoline_blue,
+        ),
+        minor_isoline_thickness,
+        Color(
+            major_isoline_alpha,
+            major_isoline_red,
+            major_isoline_green,
+            major_isoline_blue,
+        ),
+        major_isoline_thickness,
+        major_isoline_step,
+        palette_min_level,
+        palette_max_level,
+        color_interpolation_type,
+        point_values,
+        point_colors,
+    )

cratonapi/parsers/dataparsers/gridlistparser.py

@@ -0,0 +1,31 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import GridInfo
+
+
+def parse(message: bytes) -> np.ndarray:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 6:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    grids_count = struct.unpack("<I", message[16:20])[0]
+    offset = 0
+    grid_list = np.empty(grids_count, GridInfo)
+    for grid_num in range(grids_count):
+        grid_id, grid_type, grid_visibility, grid_name_symbols_count = struct.unpack(
+            "<IBBH", message[20 + offset : 28 + offset]
+        )
+        grid_name_bytes = message[28 + offset : 28 + offset + grid_name_symbols_count]
+        offset += grid_name_symbols_count + 8
+        grid_name = grid_name_bytes.decode("cp1251")
+        new_grid = GridInfo(grid_id, grid_name, grid_type, grid_visibility)
+        grid_list[grid_num] = new_grid
+    return grid_list

cratonapi/parsers/dataparsers/gridparser.py

@@ -0,0 +1,36 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import Grid
+
+
+def parse(message: bytes) -> Grid:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 7:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    grid_identifier = struct.unpack("<I", message[16:20])[0]
+    n_x, n_y, x_min, x_max, y_min, y_max, z_min, z_max, blank_code = struct.unpack(
+        "<2H7d", message[20:80]
+    )
+    data = struct.unpack(f"<{n_x * n_y}d", message[80 : 80 + (8 * n_x * n_y)])
+    return Grid(
+        grid_identifier,
+        n_x,
+        n_y,
+        x_min,
+        x_max,
+        y_min,
+        y_max,
+        z_min,
+        z_max,
+        blank_code,
+        np.asarray(data),
+    )

cratonapi/parsers/dataparsers/stratigraphiclevelsparser.py

@@ -0,0 +1,31 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import StratigraphicLevel
+
+
+def parse(message: bytes) -> np.ndarray:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 4:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    levels_count = struct.unpack("<I", message[16:20])[0]
+    offset = 0
+    level_list = np.empty(levels_count, StratigraphicLevel)
+    for level_num in range(levels_count):
+        level_id, level_age, level_name_symbols_count = struct.unpack(
+            "<IfH", message[20 + offset : 30 + offset]
+        )
+        level_name_bytes = message[30 + offset : 30 + offset + level_name_symbols_count]
+        offset += level_name_symbols_count + 10
+        level_name = level_name_bytes.decode("cp1251")
+        new_level = StratigraphicLevel(level_id, level_age, level_name)
+        level_list[level_num] = new_level
+    return level_list

cratonapi/parsers/dataparsers/wellcurvesparser.py

@@ -0,0 +1,43 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import WellCurve
+
+
+def parse(message: bytes) -> np.ndarray:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 3:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    curves_count = struct.unpack("<I", message[16:20])[0]
+    curve_list = np.empty(curves_count, WellCurve)
+    offset = 0
+    for curve_num in range(curves_count):
+        curve_type, curve_name_symbols_count = struct.unpack(
+            "<BH", message[20 + offset : 23 + offset]
+        )
+        curve_name_bytes = message[23 + offset : 23 + offset + curve_name_symbols_count]
+        offset += curve_name_symbols_count
+        curve_name = curve_name_bytes.decode("cp1251")
+        points_count = struct.unpack("<I", message[23 + offset : 27 + offset])[0]
+        point_values = np.empty(points_count)
+        point_depths = np.empty(points_count)
+        for point in range(points_count):
+            point_value, point_depth = struct.unpack(
+                "<dd", message[27 + offset : 43 + offset]
+            )
+            point_values[point] = point_value
+            point_depths[point] = point_depth
+            offset += 16
+        offset += 7
+        curve_list[curve_num] = WellCurve(
+            curve_type, curve_name, point_values, point_depths
+        )
+    return curve_list

cratonapi/parsers/dataparsers/wellhodographparser.py

@@ -0,0 +1,31 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import WellHodograph
+
+
+def parse(message: bytes) -> WellHodograph:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 8:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    points_count = struct.unpack("<I", message[16:20])[0]
+    point_times = np.empty(points_count)
+    point_depths = np.empty(points_count)
+    offset = 0
+    for point in range(points_count):
+        point_depth, point_time = struct.unpack(
+            "<2d", message[20 + offset : 36 + offset]
+        )
+        point_times[point] = point_time
+        point_depths[point] = point_depth
+        offset += 16
+    time_shift = struct.unpack("<d", message[20 + offset : 28 + offset])[0]
+    return WellHodograph(time_shift, point_times, point_depths)

cratonapi/parsers/dataparsers/welllistparser.py

@@ -0,0 +1,31 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import WellInfo
+
+
+def parse(message: bytes) -> np.ndarray:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 1:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    wells_count = struct.unpack("<H", message[16:18])[0]
+    offset = 0
+    well_list = np.empty(wells_count, WellInfo)
+    for well_num in range(wells_count):
+        well_id, well_name_symbols_count = struct.unpack(
+            "<IH", message[18 + offset : 24 + offset]
+        )
+        well_name_bytes = message[24 + offset : 24 + offset + well_name_symbols_count]
+        offset += well_name_symbols_count + 6
+        well_name = well_name_bytes.decode("cp1251")
+        new_well = WellInfo(well_id, well_name)
+        well_list[well_num] = new_well
+    return well_list

cratonapi/parsers/dataparsers/wellsparser.py

@@ -0,0 +1,33 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import Well
+
+
+def parse(message: bytes) -> np.ndarray:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 2:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    wells_count = struct.unpack("<H", message[16:18])[0]
+    well_list = np.empty(wells_count, Well)
+    offset = 0
+    for well_num in range(wells_count):
+        well_id, well_name_symbols_count = struct.unpack(
+            "<IH", message[18 + offset : 24 + offset]
+        )
+        well_name_bytes = message[24 + offset : 24 + offset + well_name_symbols_count]
+        well_name = well_name_bytes.decode("cp1251")
+        offset += well_name_symbols_count
+        x, y = struct.unpack("<dd", message[24 + offset : 40 + offset])
+        altitude, bottom = struct.unpack("<ff", message[40 + offset : 48 + offset])
+        well_list[well_num] = Well(well_id, well_name, x, y, altitude, bottom)
+        offset += 30
+    return well_list

cratonapi/parsers/dataparsers/wellstratigraphiclevelsparser.py

@@ -0,0 +1,27 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import WellStratigraphicLevel
+
+
+def parse(message: bytes) -> np.ndarray:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 5:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    levels_count = struct.unpack("<I", message[16:20])[0]
+    offset = 0
+    level_list = np.empty(levels_count, WellStratigraphicLevel)
+    for level_num in range(levels_count):
+        level_id, level_depth = struct.unpack("<If", message[20 + offset : 28 + offset])
+        new_level = WellStratigraphicLevel(level_id, level_depth)
+        level_list[level_num] = new_level
+        offset += 8
+    return level_list

cratonapi/parsers/dataparsers/welltrajectoryparser.py

@@ -0,0 +1,34 @@
+import struct
+
+import numpy as np
+
+from cratonapi.datacontainers import WellTrajectory
+
+
+def parse(message: bytes) -> WellTrajectory:
+    if len(message) < 16:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, request, uid = struct.unpack("<IHHI", message[4:16])
+    if operation != 3 or request != 9:
+        raise RuntimeError("Incorrect operation or request codes!")
+    if len(message) - 8 != size:
+        raise RuntimeError("Incomplete message!")
+    points_count = struct.unpack("<I", message[16:20])[0]
+    point_depths = np.empty(points_count)
+    point_x_shifts = np.empty(points_count)
+    point_y_shifts = np.empty(points_count)
+    point_z_shifts = np.empty(points_count)
+    offset = 0
+    for point in range(points_count):
+        depth, shift_x, shift_y, shift_z = struct.unpack(
+            "<4f", message[20 + offset : 36 + offset]
+        )
+        point_depths[point] = depth
+        point_x_shifts[point] = shift_x
+        point_y_shifts[point] = shift_y
+        point_z_shifts[point] = shift_z
+        offset += 16
+    return WellTrajectory(point_depths, point_x_shifts, point_y_shifts, point_z_shifts)

cratonapi/parsers/signalparsers/__init__.py

@@ -0,0 +1,4 @@
+from cratonapi.parsers.signalparsers import (
+    griddisplaypropertieschangesignalparser,
+    signalcodeparser,
+)

cratonapi/parsers/signalparsers/griddisplaypropertieschangesignalparser.py

@@ -0,0 +1,8 @@
+import struct
+
+
+def parse(message: bytes) -> int:
+    if len(message) != 16:
+        raise RuntimeError("Incomplete message!")
+    grid_id = struct.unpack("<I", message[12:16])[0]
+    return grid_id

cratonapi/parsers/signalparsers/signalcodeparser.py

@@ -0,0 +1,23 @@
+import struct
+
+from cratonapi.parsers.signalparsers import griddisplaypropertieschangesignalparser
+from cratonapi.signals import *
+
+
+def parse(message: bytes) -> AbstractSignal:
+    if len(message) < 12:
+        raise RuntimeError("Incomplete message!")
+    signature = message[0:4].decode("utf-8")
+    if signature != "WSPM":
+        raise RuntimeError("Incorrect signature!")
+    size, operation, signal_id = struct.unpack("<IHH", message[4:12])
+    if operation != 4:
+        raise RuntimeError("Message is not a signal!")
+    match signal_id:
+        case SignalType.grid_list_changed:
+            return GridListChangedSignal()
+        case SignalType.grid_display_properties_changed:
+            grid_id = griddisplaypropertieschangesignalparser.parse(message)
+            return GridDisplayPropertiesChangedSignal(grid_id)
+        case _:
+            return AbstractSignal()

cratonapi/requests/datarequests/__init__.py

@@ -0,0 +1,12 @@
+from . import (
+    griddisplaypropertiesrequest,
+    gridlistrequest,
+    gridrequest,
+    stratigraphiclevellistrequest,
+    wellcurvesrequest,
+    wellhodographrequest,
+    welllistrequest,
+    wellsrequest,
+    wellstratigraphiclevellistrequest,
+    welltrajectoryrequest,
+)

cratonapi/requests/datarequests/griddisplaypropertiesrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request(grid_id: int) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 12
+    operation = 2
+    request_id = 10
+    uid = 0
+    return struct.pack("<IIHHII", signature, size, operation, request_id, uid, grid_id)

cratonapi/requests/datarequests/gridlistrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request() -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 8
+    operation = 2
+    request_id = 6
+    uid = 0
+    return struct.pack("<IIHHI", signature, size, operation, request_id, uid)

cratonapi/requests/datarequests/gridrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request(grid_id: int) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 12
+    operation = 2
+    request_id = 7
+    uid = 0
+    return struct.pack("<IIHHII", signature, size, operation, request_id, uid, grid_id)

cratonapi/requests/datarequests/stratigraphiclevellistrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request() -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 8
+    operation = 2
+    request_id = 4
+    uid = 0
+    return struct.pack("<IIHHI", signature, size, operation, request_id, uid)

cratonapi/requests/datarequests/wellcurvesrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request(well_id: int) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 12
+    operation = 2
+    request_id = 3
+    uid = 0
+    return struct.pack("<IIHHII", signature, size, operation, request_id, uid, well_id)

cratonapi/requests/datarequests/wellhodographrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request(well_id: int) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 12
+    operation = 2
+    request_id = 8
+    uid = 0
+    return struct.pack("<IIHHII", signature, size, operation, request_id, uid, well_id)

cratonapi/requests/datarequests/welllistrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request() -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 8
+    operation = 2
+    request_id = 1
+    uid = 0
+    return struct.pack("<IIHHI", signature, size, operation, request_id, uid)

cratonapi/requests/datarequests/wellsrequest.py

@@ -0,0 +1,28 @@
+import struct
+
+
+def request(count: int, *wells_ids: int) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 10 + count * 4
+    operation = 2
+    request_id = 2
+    uid = 0
+    if count == 0:
+        return struct.pack(
+            "<IIHHIH", signature, size, operation, request_id, uid, count
+        )
+    elif count == 1:
+        return struct.pack(
+            "<IIHHIHI", signature, size, operation, request_id, uid, count, wells_ids[0]
+        )
+    else:
+        return struct.pack(
+            f"<IIHHIH{count}I",
+            signature,
+            size,
+            operation,
+            request_id,
+            uid,
+            count,
+            *wells_ids,
+        )

cratonapi/requests/datarequests/wellstratigraphiclevellistrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request(well_id: int) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 12
+    operation = 2
+    request_id = 5
+    uid = 0
+    return struct.pack("<IIHHII", signature, size, operation, request_id, uid, well_id)

cratonapi/requests/datarequests/welltrajectoryrequest.py

@@ -0,0 +1,10 @@
+import struct
+
+
+def request(well_id: int) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    size = 12
+    operation = 2
+    request_id = 9
+    uid = 0
+    return struct.pack("<IIHHII", signature, size, operation, request_id, uid, well_id)

cratonapi/requests/utilityrequests/__init__.py

@@ -0,0 +1 @@
+from . import dataconnectorgreetingrequest, listenergreetingrequest

cratonapi/requests/utilityrequests/dataconnectorgreetingrequest.py

@@ -0,0 +1,8 @@
+import struct
+
+
+def request(app_id: int = 1) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    operation = 1
+    size = 3
+    return struct.pack("<IIHB", signature, size, operation, app_id)

cratonapi/requests/utilityrequests/listenergreetingrequest.py

@@ -0,0 +1,17 @@
+import struct
+
+
+def request(signals_to_listen: tuple) -> bytes:
+    signature = int.from_bytes(str.encode("WSPM"), "little")
+    operation = 1
+    app_id = 0
+    size = 5 + 2 * len(signals_to_listen)
+    return struct.pack(
+        f"<IIHBH{len(signals_to_listen)}H",
+        signature,
+        size,
+        operation,
+        app_id,
+        len(signals_to_listen),
+        *signals_to_listen,
+    )

cratonapi/signalconnector.py

@@ -0,0 +1,35 @@
+from typing import Callable
+
+from cratonapi.ioconnections import IOBase, IOPipe
+from cratonapi.parsers.signalparsers import *
+from cratonapi.requests.utilityrequests import listenergreetingrequest
+
+
+class SignalConnector:
+    connection: IOBase
+    signals_to_listen: tuple
+    continue_listening: bool
+
+    def __init__(self, signals_to_listen: tuple, connection: IOBase):
+        self.connection = connection
+        self.signals_to_listen = signals_to_listen
+        self.continue_listening = True
+        self.__greeting()
+
+    def __greeting(self) -> None:
+        message = listenergreetingrequest.request(self.signals_to_listen)
+        self.connection.write(message)
+
+    def listen(self, callback: Callable) -> None:
+        answer: bytes
+        while self.continue_listening:
+            try:
+                answer = self.connection.read()
+                signal = signalcodeparser.parse(answer)
+                callback(signal)
+            except RuntimeError:
+                continue
+
+    def disconnect(self) -> None:
+        self.continue_listening = False
+        self.connection.disconnect()

cratonapi/signals/__init__.py

@@ -0,0 +1,4 @@
+from .abstractsignal import AbstractSignal
+from .griddisplaypropertieschangedsignal import GridDisplayPropertiesChangedSignal
+from .gridlistchangedsignal import GridListChangedSignal
+from .signaltype import SignalType

cratonapi/signals/abstractsignal.py

@@ -0,0 +1,7 @@
+from abc import ABC
+from dataclasses import dataclass
+
+
+@dataclass
+class AbstractSignal(ABC):
+    pass

cratonapi/signals/griddisplaypropertieschangedsignal.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+from .abstractsignal import AbstractSignal
+
+
+@dataclass
+class GridDisplayPropertiesChangedSignal(AbstractSignal):
+    grid_id: int

cratonapi/signals/gridlistchangedsignal.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+from .abstractsignal import AbstractSignal
+
+
+@dataclass
+class GridListChangedSignal(AbstractSignal):
+    pass

cratonapi/signals/signaltype.py

@@ -0,0 +1,6 @@
+from enum import IntEnum
+
+
+class SignalType(IntEnum):
+    grid_list_changed = 1
+    grid_display_properties_changed = 2

cratonapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: cratonapi
+Version: 0.1.0
+Summary: Python support for W-Seis interprocess communication API
+Author: Kirill Natalin
+Author-email: natalin.2000@mail.ru
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: pywin32 (>=306,<307)
+Requires-Dist: pywin32-ctypes (>=0.2.2,<0.3.0)
+Description-Content-Type: text/markdown
+
+

cratonapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,58 @@
+cratonapi/__init__.py,sha256=hJigtrhgjg4xZDUCXUiaeqz-qbU_49mVDV9msEBEkNo,234
+cratonapi/dataconnector.py,sha256=Pnqleuv7dDwyrGyk5nrTjeuOKuzfFlgKz_ptVnci6w4,3628
+cratonapi/datacontainers/__init__.py,sha256=lumPmBLEwcUf6aGbxDSOetft8Yz11GvXg-AEsQ6J0cU,428
+cratonapi/datacontainers/color.py,sha256=wp1-Lp8rQLHCxH0PWwfWVVQsCt-IRdxHlneBZ7F7MiQ,126
+cratonapi/datacontainers/grid.py,sha256=4GVTeRXhLntTxn-1VbaVrwl5DRMQJb9yggUeFP5Kbts,286
+cratonapi/datacontainers/griddisplayproperties.py,sha256=Jvf9TlQNeajzgT31f00zx0fx7pHy8oPrEvCpkXKOygg,542
+cratonapi/datacontainers/gridinfo.py,sha256=ZFeh0PiZ8uexHfvkT4O1klTHK5gqTeLd6oQL7pqpftc,152
+cratonapi/datacontainers/stratigraphiclevel.py,sha256=hYvnFCC6_YsdntAY3iEqAQTNrcfWxeuyedX4zXj16Fg,140
+cratonapi/datacontainers/well.py,sha256=bJDuEzDazLkI_iG2TznoCtugOrv89IR5vrxkUKEJ-pw,186
+cratonapi/datacontainers/wellcurve.py,sha256=sM7-3oB_zhcbarIID_5JRphz43vhP2cznXoJ_c-apcE,194
+cratonapi/datacontainers/wellhodograph.py,sha256=zBP51YPOF_FJHS0Twar0fM9ydq_KOc2Wz6Clork4Urw,178
+cratonapi/datacontainers/wellinfo.py,sha256=hsSMyOerKu9bTlBR0fhgcyIKzIqrVr-2pbIIKQ3q3k4,106
+cratonapi/datacontainers/wellstratigraphiclevel.py,sha256=1jJ3Fa1lW0kjKR3Xa0-ZFJjw-6eBQb3oV3BaubPwZ-g,125
+cratonapi/datacontainers/welltrajectory.py,sha256=8IhCzsoj0r5HCdhnd5AXS8W2wi9SVvg539P4HhB4TY4,217
+cratonapi/ioconnections/__init__.py,sha256=1nzJJagK93u9HOxaxSMQ8A-Av8Dv8vqOajH4nPQae00,116
+cratonapi/ioconnections/iobase.py,sha256=uXfHBsTJG3lAu7om5Gmzza9dHsUAIyjnmvnmpbVCsnc,431
+cratonapi/ioconnections/iofile.py,sha256=aisFTPutIFjsVofDlyL1xuQimv9hhPfCMVXgksN1WzA,647
+cratonapi/ioconnections/iopipe.py,sha256=IHRdE4wYd4pNw9vrM17QNw0E4V6ZxIlk9qC9ozO4dYU,2654
+cratonapi/ioconnections/ioreader.py,sha256=OCGlbvibf-03WIU7b1QT88NG9ggMi4PCMa19cj1744c,616
+cratonapi/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cratonapi/parsers/dataparsers/__init__.py,sha256=jwcYi-hxfJwS32MqD_xqWnWbSTaPtqUjrWlRk1_f1ck,275
+cratonapi/parsers/dataparsers/griddisplaypropertiesparser.py,sha256=-HpOcEMf8fztldyPqu01f7cbE6gn6P0Je99Opj-4HOM,2312
+cratonapi/parsers/dataparsers/gridlistparser.py,sha256=-9aS3TOzsRTjkaE47jJ86aQs_uNVKW8IEKikn_zLXMw,1253
+cratonapi/parsers/dataparsers/gridparser.py,sha256=1CZv2KOh7lZy1nFrOBes5q27HGQvbCKN_DGHB_eREy4,1086
+cratonapi/parsers/dataparsers/stratigraphiclevelsparser.py,sha256=SCVZ3uxg-5_xK0B8dutSNsNI_a_-JQSApWgXPH_-lPQ,1268
+cratonapi/parsers/dataparsers/wellcurvesparser.py,sha256=y8LDjBdga8eod2umImzFvbZkK5ufmT0Bnyy0ad4kkyk,1728
+cratonapi/parsers/dataparsers/wellhodographparser.py,sha256=eeKhnWPimU9b5CWl7_zQIS7kr7KudMjOiG2vBjSLPGs,1177
+cratonapi/parsers/dataparsers/welllistparser.py,sha256=oLEqhmXUo9m-AZBkmfA9pQMHbtBiEmziNLZXFi7lBZ4,1195
+cratonapi/parsers/dataparsers/wellsparser.py,sha256=X8kSaZJpHi1qTe4eSHH4uTpiLvg_OPQVeCAmvyeyOnc,1354
+cratonapi/parsers/dataparsers/wellstratigraphiclevelsparser.py,sha256=rJCz-NdGrzErlPCVjaOqByr_IeVowV-OKPSnZe6cB2g,1047
+cratonapi/parsers/dataparsers/welltrajectoryparser.py,sha256=ZBu9p_cvzOM-4dtjjjgjzdGfSpngDg6M8cbKAv82wEA,1304
+cratonapi/parsers/signalparsers/__init__.py,sha256=KopqzxAaUgb3B6Lyq63YMly67dWZzIVU2noIw_D14A0,119
+cratonapi/parsers/signalparsers/griddisplaypropertieschangesignalparser.py,sha256=ysjOhSj42v7TvWjsv4ZE2id9PYlK6s9YC3lF1FKox28,207
+cratonapi/parsers/signalparsers/signalcodeparser.py,sha256=2n_lZm3kuXROEFCjPgitP6svam0ON8ft8pX5Dd9xdIY,905
+cratonapi/requests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cratonapi/requests/datarequests/__init__.py,sha256=_uHqFkUacjwls7nXu-agH4vJJbJ_OOwh_V1Cs5A4AkM,291
+cratonapi/requests/datarequests/griddisplaypropertiesrequest.py,sha256=hdKzWd3rXInKvNc_eyRiRhdWqpWQJak80cd2jgm-G3s,275
+cratonapi/requests/datarequests/gridlistrequest.py,sha256=LQaL4Ddt4AJWJua3QGYfa3bCEkU17jdLZcL4xPistSM,251
+cratonapi/requests/datarequests/gridrequest.py,sha256=VWkIN3e4Wf39TuTXVQEy8I_KiMyj-cyOgy1nKlfpsJ4,274
+cratonapi/requests/datarequests/stratigraphiclevellistrequest.py,sha256=f8UNFVGOulwjDVlmfqTFdPWe1flEHZJM3QOSM_ATnJs,251
+cratonapi/requests/datarequests/wellcurvesrequest.py,sha256=zqNJE_lIeK0TpICwhOjAKhbcB3X8IDEA_KKdzGTCzt0,274
+cratonapi/requests/datarequests/wellhodographrequest.py,sha256=Ycf59nRudUvvLBMmcko6Apm_kLCThBokJbA7iJVVf6U,274
+cratonapi/requests/datarequests/welllistrequest.py,sha256=QyTbn5iy1W4uzdoEzX0oUJ_xo5HasFKgjPAzfwM-QC0,251
+cratonapi/requests/datarequests/wellsrequest.py,sha256=45sqngNutSAf4_IEzE6Vcn4zqfdILhTnMaen1YJUxLk,738
+cratonapi/requests/datarequests/wellstratigraphiclevellistrequest.py,sha256=BLFBnBG9jsaZzR-XRcjezCTvMmiBdbiwP6rg_EVPlVI,274
+cratonapi/requests/datarequests/welltrajectoryrequest.py,sha256=v99HUMlc1HZ0WYpiuj7A0SW2-BH6XHfskJ6eCUnoMS4,274
+cratonapi/requests/utilityrequests/__init__.py,sha256=mH9Noqp3FlAWrIAzm0qutjJ26q9qynoF8o_iN7DNqq0,69
+cratonapi/requests/utilityrequests/dataconnectorgreetingrequest.py,sha256=FLEXpZADK7x5qPuA85mLpS9Xb6QHnYWjZN0AU2mHAgk,223
+cratonapi/requests/utilityrequests/listenergreetingrequest.py,sha256=FD5KvUtxU1chfQ2g7AF8htBcYhK7m6yz_lEKGUrFCsQ,419
+cratonapi/signalconnector.py,sha256=IivNyxlR-hDZ1UPlpHJx_oMBw53M7N8gu7m_4_UwJ5Q,1146
+cratonapi/signals/__init__.py,sha256=r-5w2wFYWDodX4Rah3QcAfU68wBLnq4f-ktrkuJFzFY,222
+cratonapi/signals/abstractsignal.py,sha256=miz_95asmXAxdIp-3he4Lmi9JwyFu56W3u0bORjR8kA,110
+cratonapi/signals/griddisplaypropertieschangedsignal.py,sha256=mupU0M3tL5d92YDGqOJkEs0EcyFjHuzs7i1ZgGchVMs,174
+cratonapi/signals/gridlistchangedsignal.py,sha256=3ZljPCVwjQuXPjlJHNZcwZrkg6U8f1lTD2-A6us849k,153
+cratonapi/signals/signaltype.py,sha256=21rgt_2f1dPzCHAe5GsVi5ptpqkPpP8WmRc6YDB6QQc,126
+cratonapi-0.1.0.dist-info/METADATA,sha256=h9VRfEOPHne1yUzzxXklluC2UAbGS-BkGA5EHtg0K_8,520
+cratonapi-0.1.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+cratonapi-0.1.0.dist-info/RECORD,,

cratonapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.8.1
+Root-Is-Purelib: true
+Tag: py3-none-any