SecsGemPro 1.0.0__tar.gz

secsgempro-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: SecsGemPro
+Version: 1.0.0
+Summary: secs/gem
+Author: LiuWei
+Author-email: 183074632@qq.com
+Requires-Python: >=3.11,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: python-dateutil (>=2.9.0.post0,<3.0.0)
+Description-Content-Type: text/markdown
+
+### secsgem

secsgempro-1.0.0/README.md

@@ -0,0 +1 @@
+### secsgem

secsgempro-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "SecsGemPro"
+version = "1.0.0"
+description = "secs/gem"
+authors = ["LiuWei <183074632@qq.com>"]
+readme = "README.md"
+packages = [{include = "secsgem"},]
+
+
+[tool.poetry.dependencies]
+python = ">=3.11,<3.13"
+python-dateutil = ">=2.9.0.post0,<3.0.0"
+
+
+[[tool.poetry.source]]
+name = "mirrors"
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+priority = "primary"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

secsgempro-1.0.0/secsgem/__init__.py

@@ -0,0 +1 @@
+"""module imports."""

secsgempro-1.0.0/secsgem/common/__init__.py

@@ -0,0 +1,35 @@
+"""Contains helper functions."""
+
+from .block_send_info import BlockSendInfo
+from .byte_queue import ByteQueue
+from .callbacks import CallbackHandler
+from .connection import Connection
+from .events import EventProducer
+from .header import Header
+from .helpers import format_hex, function_name, indent_block, is_errorcode_ewouldblock, is_windows
+from .message import Block, Message
+from .protocol import Protocol
+from .protocol_dispatcher import ProtocolDispatcher
+from .settings import DeviceType, Settings
+from .state_machine import State, StateMachine, Transition, UnknownTransitionError, WrongSourceStateError
+from .tcp_client_connection import TcpClientConnection
+from .tcp_server_connection import TcpServerConnection
+from .timeouts import Timeouts
+
+__all__ = [
+    "BlockSendInfo",
+    "ByteQueue",
+    "CallbackHandler",
+    "Connection",
+    "EventProducer",
+    "Header",
+    "format_hex", "function_name", "indent_block", "is_windows", "is_errorcode_ewouldblock",
+    "Message", "Block",
+    "Protocol",
+    "ProtocolDispatcher",
+    "Settings", "DeviceType",
+    "State", "StateMachine", "Transition", "UnknownTransitionError", "WrongSourceStateError",
+    "TcpClientConnection",
+    "TcpServerConnection",
+    "Timeouts",
+]

secsgempro-1.0.0/secsgem/common/block_send_info.py

@@ -0,0 +1,50 @@
+"""Helper to track block send result across threads."""
+from __future__ import annotations
+
+import enum
+import threading
+
+
+class BlockSendResult(enum.Enum):
+    """Enum for send result including not send state."""
+
+    NOT_SENT = 0
+    SENT_OK = 1
+    SENT_ERROR = 2
+
+
+class BlockSendInfo:
+    """Container for sending block and waiting for result."""
+
+    def __init__(self, data: bytes):
+        """Initialize block send info object.
+
+        Args:
+            data: data to send.
+
+        """
+        self._data = data
+
+        self._result = BlockSendResult.NOT_SENT
+        self._result_trigger = threading.Event()
+
+    @property
+    def data(self) -> bytes:
+        """Get the data for sending."""
+        return self._data
+
+    def resolve(self, result: bool):
+        """Resolve the send data with a result.
+
+        Args:
+            result: result to resolve with
+
+        """
+        self._result = BlockSendResult.SENT_OK if result else BlockSendResult.SENT_ERROR
+        self._result_trigger.set()
+
+    def wait(self) -> bool:
+        """Wait for the message is sent and a result is available."""
+        self._result_trigger.wait()
+
+        return self._result == BlockSendResult.SENT_OK

secsgempro-1.0.0/secsgem/common/byte_queue.py

@@ -0,0 +1,124 @@
+"""Queue for bytes."""
+from __future__ import annotations
+
+import threading
+
+
+class ByteQueue:
+    """FIFO class for queuing and retrieving bytes."""
+
+    def __init__(self) -> None:
+        """Initialize the queue."""
+        self._buffer = bytearray()
+        self._buffer_lock = threading.Condition()
+
+    def append(self, data: bytes):
+        """Add bytes to the end of the queue.
+
+        Args:
+            data: bytes to add
+
+        """
+        with self._buffer_lock:
+            self._buffer.extend(data)
+            self._buffer_lock.notify_all()
+
+    def pop(self, size: int = 1) -> bytes:
+        """Remove and return bytes from the beginning of queue.
+
+        Args:
+            size: number of bytes to remove
+
+        Returns:
+            removed bytes
+
+        """
+        with self._buffer_lock:
+            data = self._buffer[:size]
+            del self._buffer[:size]
+            return data
+
+    def pop_byte(self) -> int:
+        """Remove and return single byte from the beginning of queue.
+
+        Returns:
+            removed byte
+
+        """
+        with self._buffer_lock:
+            data = self._buffer[0]
+            del self._buffer[0]
+            return data
+
+    def peek(self, size: int = 1) -> bytes:
+        """Get bytes from beginning of the queue without removing them.
+
+        Args:
+            size: number of bytes to peek
+
+        Returns:
+            peek bytes
+
+        """
+        return self._buffer[:size]
+
+    def peek_byte(self, position: int = 0) -> int:
+        """Get single byte in the buffer without removing.
+
+        Args:
+            position: byte position to peek at
+
+        Returns:
+            peek bytes
+
+        """
+        return self._buffer[position]
+
+    def clear(self):
+        """Clear the bytes in the queue."""
+        with self._buffer_lock:
+            self._buffer.clear()
+
+    def __len__(self) -> int:
+        """Get the length of the queue.
+
+        Returns:
+            queue length
+
+        """
+        return len(self._buffer)
+
+    def wait_for(self, size: int = 1, peek: bool = False) -> bytes:
+        """Wait until the requested number of bytes is available in the receive queue.
+
+        Args:
+            size: number of bytes
+            peek: only look, don't remove the item from the queue.
+
+        Returns:
+            Found bytes
+
+        """
+        def min_size() -> bool:
+            return len(self._buffer) >= size
+
+        if len(self._buffer) < size:
+            with self._buffer_lock:
+                self._buffer_lock.wait_for(min_size)
+
+        if peek:
+            return self.peek(size)
+
+        return self.pop(size)
+
+    def wait_for_byte(self, peek: bool = False) -> int:
+        """Wait until one byte is available in the receive queue.
+
+        Args:
+            peek: only look, don't remove the item from the queue.
+
+        Returns:
+            Found byte
+
+        """
+        return self.wait_for(peek=peek)[0]

secsgempro-1.0.0/secsgem/common/callbacks.py

@@ -0,0 +1,117 @@
+"""Contains callback handling routines."""
+from __future__ import annotations
+
+import typing
+
+
+class _CallbackCallWrapper:
+    def __init__(self, handler: CallbackHandler, name: str):
+        self._name = name
+        self._handler = handler
+
+    def __call__(self, *args: tuple, **kwargs: dict) -> typing.Any:
+        return self.handler._call(self.name, *args, **kwargs)  # noqa: SLF001
+
+    @property
+    def name(self) -> str:
+        """Get the callback name."""
+        return self._name
+
+    @property
+    def handler(self) -> CallbackHandler:
+        """Get the handler for the callback."""
+        return self._handler
+
+
+class CallbackHandler:
+    """Handler for callbacks for HSMS/SECS/GEM events.
+
+    This handler manages callbacks for events that can happen on a handler for a connection.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the handler."""
+        self._callbacks: dict[str, typing.Callable] = {}
+        self.target: object = None
+        self._object_intitialized = True
+
+    def __setattr__(self, name: str, value: typing.Callable):
+        """Set an item as object member.
+
+        Args:
+            name: name of the callback
+            value: callback function
+
+        """
+        if "_object_intitialized" not in self.__dict__ or name in self.__dict__:
+            dict.__setattr__(self, name, value)
+            return
+
+        if value is None:
+            if name in self._callbacks:
+                del self._callbacks[name]
+        else:
+            self._callbacks[name] = value
+
+    def __getattr__(self, name: str) -> typing.Callable:
+        """Get a callable function for an event.
+
+        Args:
+            name: name of the event
+
+        """
+        return _CallbackCallWrapper(self, name)
+
+    class _CallbacksIter:
+        def __init__(self, keys):
+            self._keys = list(keys)
+            self._counter = 0
+
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            if self._counter < len(self._keys):
+                i = self._counter
+                self._counter += 1
+                return self._keys[i]
+
+            raise StopIteration
+
+    def __iter__(self) -> _CallbacksIter:
+        """Get an iterator for the callbacks.
+
+        Returns:
+            callback iterator
+
+        """
+        return self._CallbacksIter(self._callbacks.keys())
+
+    def __contains__(self, callback: str) -> bool:
+        """Check if a callback is present.
+
+        Args:
+            callback: name of the event
+
+        Returns:
+            True if callback present
+
+        """
+        if callback in self._callbacks:
+            return True
+
+        delegate_handler = getattr(self.target, "_on_" + callback, None)
+        if callable(delegate_handler):
+            return True
+
+        return False
+
+    def _call(self, callback: str, *args, **kwargs) -> typing.Any:
+        if callback in self._callbacks:
+            return self._callbacks[callback](*args, **kwargs)
+
+        delegate_handler = getattr(self.target, "_on_" + callback, None)
+        if callable(delegate_handler):
+            return delegate_handler(*args, **kwargs)
+
+        return None

secsgempro-1.0.0/secsgem/common/codec_jis_x_0201.py

@@ -0,0 +1,32 @@
+"""JIS X 0201 Codec required for JIS8 encoding of JIS8."""
+import codecs
+
+jis8_decoding_map = codecs.make_identity_dict(range(256))  # type: ignore[attr-defined]
+jis8_decoding_map.update({
+    0x005C: 0x00A5,  # Yen Sign
+    0x007E: 0x203E,  # Overline
+})
+
+for i in range(0x00A1, 0x00E0):
+    jis8_decoding_map[i] = i + 0xFEC0
+
+jis8_encoding_map = codecs.make_encoding_map(jis8_decoding_map)  # type: ignore[attr-defined]
+
+
+def _jis_x_0201_encode(data, errors="strict"):
+    return codecs.charmap_encode(data, errors, jis8_encoding_map)
+
+
+def _jis_x_0201_decode(data, errors="strict"):
+    return codecs.charmap_decode(data, errors, jis8_decoding_map)
+
+
+def _jis_x_0201_search(name):
+    if name == "jis_8":
+        return codecs.CodecInfo(encode=_jis_x_0201_encode, decode=_jis_x_0201_decode, name="jis_8")
+
+    return None
+
+
+# register the codec
+codecs.register(_jis_x_0201_search)

secsgempro-1.0.0/secsgem/common/connection.py

@@ -0,0 +1,106 @@
+"""Connection base function."""
+import abc
+
+from .events import Event
+from .settings import Settings
+
+
+class Connection(abc.ABC):
+    """Abstract base class for a connection."""
+
+    def __init__(self, settings: Settings) -> None:
+        """Initialize connection object."""
+        super().__init__()
+
+        self._settings = settings
+
+        self._on_connected = Event()
+        self._on_data = Event()
+        self._on_disconnecting = Event()
+        self._on_disconnected = Event()
+
+        self._connected = False
+        self._disconnecting = False
+
+    @property
+    def on_connected(self) -> Event:
+        """Get the connected event.
+
+        Callbacks to this event are called, when a connection was established.
+
+        """
+        return self._on_connected
+
+    @property
+    def on_data(self) -> Event:
+        """Get the data received event.
+
+        Callbacks to this event are called, when data was received.
+
+        """
+        return self._on_data
+
+    @property
+    def on_disconnecting(self) -> Event:
+        """Get the disconnecting event.
+
+        Callbacks to this event are called, before the connection is separated.
+
+        """
+        return self._on_disconnecting
+
+    @property
+    def on_disconnected(self) -> Event:
+        """Get the disconnect event.
+
+        Callbacks to this event are called, after the connection was separated.
+
+        """
+        return self._on_disconnected
+
+    @property
+    def connected(self) -> bool:
+        """Get the connected flag.
+
+        This flag is True, when a connection is established.
+
+        """
+        return self._connected
+
+    @property
+    def disconnecting(self) -> bool:
+        """Get the disconnecting flag.
+
+        This flag is True, when the connection is about to be separated.
+
+        """
+        return self._disconnecting
+
+    @abc.abstractmethod
+    def enable(self):
+        """Enable the connection.
+
+        Open port and start receiver thread.
+        """
+        raise NotImplementedError("Connection.enable missing implementation")
+
+    @abc.abstractmethod
+    def disable(self):
+        """Disable the connection.
+
+        Close port and stop receiver thread.
+        """
+        raise NotImplementedError("Connection.disable missing implementation")
+
+    @abc.abstractmethod
+    def send_data(self, data: bytes) -> bool:
+        """Send data to the remote host.
+
+        Args:
+            data: encoded data.
+
+        Returns:
+            True if succeeded, False if failed
+
+        """
+        raise NotImplementedError("Connection.send_data missing implementation")