cratonapi 0.1.0__tar.gz

cratonapi-0.1.0/PKG-INFO

@@ -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/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-0.1.0/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-0.1.0/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-0.1.0/cratonapi/datacontainers/color.py

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

cratonapi-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/cratonapi/datacontainers/wellinfo.py

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

cratonapi-0.1.0/cratonapi/datacontainers/wellstratigraphiclevel.py

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

cratonapi-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/cratonapi/parsers/dataparsers/__init__.py

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

cratonapi-0.1.0/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-0.1.0/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