yrcom 0.3.1__tar.gz → 0.3.2__tar.gz

{yrcom-0.3.1/src/yrcom.egg-info → yrcom-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yrcom
-Version: 0.3.1
+Version: 0.3.2
 Summary: Yaskawa robot communication — Ethernet Server, HSES and HSES File Control (pure stdlib)
 Author: cmosbk
 License: MIT

{yrcom-0.3.1 → yrcom-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yrcom"
-version = "0.3.1"
+version = "0.3.2"
 description = "Yaskawa robot communication — Ethernet Server, HSES and HSES File Control (pure stdlib)"
 readme = "README.md"
 requires-python = ">=3.11"

{yrcom-0.3.1 → yrcom-0.3.2}/src/yrcom/__init__.py

@@ -40,7 +40,7 @@ from .hses_server_codec import (
     encode_error,
 )
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"
 
 __all__ = [
     "YaskawaClient", "VarType", "EthernetServerClient",

{yrcom-0.3.1 → yrcom-0.3.2}/src/yrcom/yaskawa_client.py

@@ -104,6 +104,9 @@ class YaskawaClient:
         self.port = port
         self.timeout = timeout
         self.sock: socket.socket | None = None
+        # Bytes already received but not yet consumed. TCP is a byte stream: one recv() may
+        # hold a header and its answer together, or only part of a line.
+        self._rx = b""
 
     # ── Context manager ───────────────────────────────────────────────────────
 
@@ -120,6 +123,7 @@ class YaskawaClient:
         """Open TCP socket to the controller. No-op if already connected."""
         if self.sock is not None:
             return
+        self._rx = b""
         try:
             self.sock = socket.create_connection((self.host, self.port), timeout=self.timeout)
         except Exception:
@@ -131,6 +135,7 @@ class YaskawaClient:
         if self.sock:
             self.sock.close()
             self.sock = None
+        self._rx = b""
 
     # ── Protocol primitives ───────────────────────────────────────────────────
 
@@ -160,39 +165,56 @@ class YaskawaClient:
             raise RuntimeError("Socket not connected")
         header = f"HOSTCTRL_REQUEST {command} {size}\r\n"
         self.sock.sendall(header.encode("ascii"))
-        self._recv_until_ok()
+        reply = self._recv_until_ok()
+        if reply.startswith("NG"):
+            # Request refused: no answer line follows, so waiting for one would only time out.
+            return reply
         if size > 0 and data:
             payload = data if data.endswith("\r") else data + "\r"
             self.sock.sendall(payload.encode("ascii"))
         return self._recv_answer()
 
-    def _recv_until_ok(self) -> str:
-        """Receive until OK or NG appears in the buffer."""
+    def _recv_line(self) -> str | None:
+        """Return the next line from the stream without its terminator, or None
+        if the peer closed the connection with nothing left to read.
+
+        Lines end in ``\r\n`` (handshake and header replies) or a bare ``\r``
+        (answer data). Reads until a terminator is buffered, so a reply split
+        over several segments, or several replies in one segment, are handled
+        the same way. A ``\n`` left over from ``\r\n`` split across segments is
+        skipped at the start of the next line.
+        """
         if self.sock is None:
             raise RuntimeError("Socket not connected")
-        buf = ""
         while True:
+            self._rx = self._rx.lstrip(b"\n")
+            end = self._rx.find(b"\r")
+            if end >= 0:
+                line, self._rx = self._rx[:end], self._rx[end + 1:]
+                if self._rx.startswith(b"\n"):
+                    self._rx = self._rx[1:]
+                return line.decode("ascii")
             chunk = self.sock.recv(_RECV_SIZE)
             if not chunk:
-                break
-            buf += chunk.decode("ascii")
-            if "OK" in buf or "NG" in buf:
-                break
-        return buf
+                # Peer closed: hand out an unterminated rest once, then report the end.
+                line, self._rx = self._rx, b""
+                return line.decode("ascii") if line else None
+            self._rx += chunk
 
-    def _recv_answer(self) -> str:
-        """Receive the answer data (ends with \\r or \\r\\n)."""
-        if self.sock is None:
-            raise RuntimeError("Socket not connected")
-        buf = ""
+    def _recv_until_ok(self) -> str:
+        """Receive lines until one starts with OK or NG and return it (with ``\r\n``);
+        "" if the peer closed first."""
         while True:
-            chunk = self.sock.recv(_RECV_SIZE)
-            if not chunk:
-                break
-            buf += chunk.decode("ascii")
-            if "\r\n" in buf or "\r" in buf:
-                break
-        return buf
+            line = self._recv_line()
+            if line is None:
+                return ""
+            if line.startswith(("OK", "NG")):
+                return line + "\r\n"
+
+    def _recv_answer(self) -> str:
+        """Receive one answer line (data ends with ``\r`` or ``\r\n``); "" if the peer closed."""
+        line = self._recv_line()
+        return "" if line is None else line + "\r"
 
     # ── Transaction patterns ──────────────────────────────────────────────────
 

{yrcom-0.3.1 → yrcom-0.3.2/src/yrcom.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yrcom
-Version: 0.3.1
+Version: 0.3.2
 Summary: Yaskawa robot communication — Ethernet Server, HSES and HSES File Control (pure stdlib)
 Author: cmosbk
 License: MIT

{yrcom-0.3.1 → yrcom-0.3.2}/src/yrcom.egg-info/SOURCES.txt

@@ -20,5 +20,6 @@ tests/test_hses_file.py
 tests/test_hses_server_codec.py
 tests/test_hses_sim.py
 tests/test_robot_connection.py
+tests/test_tcp_framing.py
 tests/test_yaskawa_client.py
 tests/test_yaskawa_commands.py

yrcom-0.3.2/tests/test_tcp_framing.py

@@ -0,0 +1,103 @@
+"""Ethernet Server replies arrive as a TCP byte stream: a header and its answer may come
+in one segment, a line may be split over several, and ``\\r\\n`` may be cut between
+``\\r`` and ``\\n``. The client must read lines, not whatever one recv() returns."""
+from __future__ import annotations
+
+import socket
+import threading
+import time
+
+import pytest
+
+from yrcom.robot_connection import PersistentTcpClient
+from yrcom.yaskawa_client import YaskawaClient
+
+GREETING = b"OK: NX Information Server(Ver. W4.00)\r\n"
+
+
+def _serve(chunks_for_request, keep=0.3):
+    """One-connection server: answers CONNECT with GREETING, then every request header
+    with the chunks `chunks_for_request(n)` returns (n = request number, from 0)."""
+    srv = socket.socket()
+    srv.bind(("127.0.0.1", 0))
+    srv.listen(1)
+
+    def run():
+        conn, _ = srv.accept()
+        f = conn.makefile("rb")
+        f.readline()                                  # CONNECT Robot_access ...
+        conn.sendall(GREETING)
+        n = 0
+        while True:
+            if not f.readline():                      # HOSTCTRL_REQUEST ...
+                break
+            for c in chunks_for_request(n):
+                conn.sendall(c)
+                time.sleep(0.005)                     # separate segments where intended
+            n += 1
+        time.sleep(keep)
+        conn.close()
+
+    threading.Thread(target=run, daemon=True).start()
+    return srv, srv.getsockname()[1]
+
+
+REPLY = b"OK: RSTATS\r\n" + b"194,64\r"
+
+
+def _bytewise(data: bytes) -> list[bytes]:
+    return [bytes([b]) for b in data]
+
+
+@pytest.mark.parametrize("chunks", [
+    [b"OK: RSTATS\r\n", b"194,64\r"],                         # header and answer apart
+    [REPLY],                                                  # header and answer in one segment
+    _bytewise(REPLY),                                         # one byte per segment
+    [b"OK: RSTATS\r", b"\n194,", b"64\r"],                    # \r\n cut between \r and \n
+    [b"OK: RSTATS\r\n194,64\r\n"],                            # answer terminated with \r\n
+], ids=["apart", "together", "bytewise", "crlf-split", "answer-crlf"])
+def test_rstats_survives_any_segmentation(chunks):
+    srv, port = _serve(lambda n: chunks)
+    try:
+        with YaskawaClient("127.0.0.1", port, timeout=2.0) as c:
+            c.send_start(keep_alive=-1)
+            assert c.read_rstats(decode=False, persistent=True) == [194, 64]
+    finally:
+        srv.close()
+
+
+def test_two_replies_in_one_segment_stay_apart():
+    # first request: both replies of the session arrive at once; the second request must
+    # get its own answer from the buffer, not wait for the network
+    both = b"OK: RSTATS\r\n1,2\r" + b"OK: RSTATS\r\n3,4\r"
+    srv, port = _serve(lambda n: [both] if n == 0 else [])
+    try:
+        with YaskawaClient("127.0.0.1", port, timeout=2.0) as c:
+            c.send_start(keep_alive=-1)
+            assert c.read_rstats(decode=False, persistent=True) == [1, 2]
+            assert c.read_rstats(decode=False, persistent=True) == [3, 4]
+    finally:
+        srv.close()
+
+
+def test_ng_header_returns_without_waiting():
+    srv, port = _serve(lambda n: [b"NG: HOSTCTRL_REQUEST\r\n"])
+    try:
+        with YaskawaClient("127.0.0.1", port, timeout=2.0) as c:
+            c.send_start(keep_alive=-1)
+            t0 = time.monotonic()
+            assert c.send_command("RSTATS").startswith("NG")
+            assert time.monotonic() - t0 < 1.0          # no timeout wait for an answer line
+    finally:
+        srv.close()
+
+
+def test_persistent_connection_together_and_bytewise():
+    for chunks in ([REPLY], _bytewise(REPLY)):
+        srv, port = _serve(lambda n, ch=chunks: ch)
+        try:
+            tcp = PersistentTcpClient("127.0.0.1", port, timeout=2.0)
+            assert tcp.read_rstats(decode=False) == [194, 64]
+            tcp.close()
+        finally:
+            srv.close()