yrcom 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yrcom
-Version: 0.3.0
+Version: 0.3.2
 Summary: Yaskawa robot communication — Ethernet Server, HSES and HSES File Control (pure stdlib)
 Author: cmosbk
 License: MIT
@@ -12,12 +12,21 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.26; extra == "docs"
+Requires-Dist: black>=24; extra == "docs"
 Dynamic: license-file
 
 # yrcom
 
 [![CI](https://github.com/CMOSBK/yrcom/actions/workflows/ci.yml/badge.svg)](https://github.com/CMOSBK/yrcom/actions/workflows/ci.yml)
 
+📖 **Documentation: <https://cmosbk.github.io/yrcom/>** — getting started, the
+transport guide and the full API reference (every command, generated from the
+source).
+
 Yaskawa robot communication as a standalone Python library — a single,
 hardware-verified communication core meant to be shared across projects
 instead of being duplicated.

{yrcom-0.3.0 → yrcom-0.3.2}/README.md

@@ -2,6 +2,10 @@
 
 [![CI](https://github.com/CMOSBK/yrcom/actions/workflows/ci.yml/badge.svg)](https://github.com/CMOSBK/yrcom/actions/workflows/ci.yml)
 
+📖 **Documentation: <https://cmosbk.github.io/yrcom/>** — getting started, the
+transport guide and the full API reference (every command, generated from the
+source).
+
 Yaskawa robot communication as a standalone Python library — a single,
 hardware-verified communication core meant to be shared across projects
 instead of being duplicated.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "yrcom"
-version = "0.3.0"
+version = "0.3.2"
 description = "Yaskawa robot communication — Ethernet Server, HSES and HSES File Control (pure stdlib)"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -15,6 +15,7 @@ dependencies = []
 
 [project.optional-dependencies]
 dev = ["pytest>=8"]
+docs = ["mkdocs>=1.6", "mkdocs-material>=9.5", "mkdocstrings[python]>=0.26", "black>=24"]
 
 [project.scripts]
 yrcom-sim = "yrcom.hses_sim:_main"

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

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

{yrcom-0.3.0 → yrcom-0.3.2}/src/yrcom/hses_client.py

@@ -581,6 +581,8 @@ class HsesClient(_HsesSocket):
         position_group: int = 0,
         b_vars: "list[dict]" = [],
         i_vars: "list[dict]" = [],
+        d_vars: "list[dict]" = [],
+        r_vars: "list[dict]" = [],
         io_signals: "list[dict]" = [],
         read_cio: bool = False,
     ) -> dict:
@@ -590,7 +592,11 @@ class HsesClient(_HsesSocket):
         alarm_slots:    number of alarm history slots (0=skip, max 4)
         include_job:    read executing job info
         position_group: 0=skip, 1-8=pulse, 101-108=cartesian
-        b_vars/i_vars:  list of {"label": str, "no": int}
+        b_vars/i_vars/d_vars/r_vars:
+                        list of {"label": str, "no": int}. Each becomes one
+                        request inside the burst, so its value shares the
+                        instant of the rest of the row rather than arriving a
+                        round trip later.
         io_signals:     list of {"label": str, "logical": int}
 
         Returns flat dict of all decoded fields.
@@ -622,6 +628,14 @@ class HsesClient(_HsesSocket):
             reqs.append((_CMD_I_VAR, v["no"], 1, _SVC_GET_SINGLE, b""))
             tags.append(f"i_var:{v['label']}")
 
+        for v in d_vars:
+            reqs.append((_CMD_D_VAR, v["no"], 1, _SVC_GET_SINGLE, b""))
+            tags.append(f"d_var:{v['label']}")
+
+        for v in r_vars:
+            reqs.append((_CMD_R_VAR, v["no"], 1, _SVC_GET_SINGLE, b""))
+            tags.append(f"r_var:{v['label']}")
+
         # CIO counter: low byte at logical 72000 (inst 7200), high byte at 72010 (inst 7201)
         if read_cio:
             reqs.append((_CMD_IO_PLURAL, 7200, 0, _SVC_READ_ALL, struct.pack("<I", 2)))
@@ -666,6 +680,12 @@ class HsesClient(_HsesSocket):
             elif tag.startswith("i_var:"):
                 if resp.status == 0 and len(resp.data) >= 2:
                     out[f"var_{tag[6:]}"] = struct.unpack_from("<h", resp.data, 0)[0]
+            elif tag.startswith("d_var:"):
+                if resp.status == 0 and len(resp.data) >= 4:
+                    out[f"var_{tag[6:]}"] = struct.unpack_from("<i", resp.data, 0)[0]
+            elif tag.startswith("r_var:"):
+                if resp.status == 0 and len(resp.data) >= 4:
+                    out[f"var_{tag[6:]}"] = struct.unpack_from("<f", resp.data, 0)[0]
             elif tag == "cio":
                 if resp.status == 0 and len(resp.data) >= 6:
                     # response: 4-byte count + 2 data bytes

{yrcom-0.3.0 → 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.0 → yrcom-0.3.2/src/yrcom.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yrcom
-Version: 0.3.0
+Version: 0.3.2
 Summary: Yaskawa robot communication — Ethernet Server, HSES and HSES File Control (pure stdlib)
 Author: cmosbk
 License: MIT
@@ -12,12 +12,21 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.26; extra == "docs"
+Requires-Dist: black>=24; extra == "docs"
 Dynamic: license-file
 
 # yrcom
 
 [![CI](https://github.com/CMOSBK/yrcom/actions/workflows/ci.yml/badge.svg)](https://github.com/CMOSBK/yrcom/actions/workflows/ci.yml)
 
+📖 **Documentation: <https://cmosbk.github.io/yrcom/>** — getting started, the
+transport guide and the full API reference (every command, generated from the
+source).
+
 Yaskawa robot communication as a standalone Python library — a single,
 hardware-verified communication core meant to be shared across projects
 instead of being duplicated.

{yrcom-0.3.0 → 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/src/yrcom.egg-info/requires.txt

@@ -0,0 +1,9 @@
+
+[dev]
+pytest>=8
+
+[docs]
+mkdocs>=1.6
+mkdocs-material>=9.5
+mkdocstrings[python]>=0.26
+black>=24

{yrcom-0.3.0 → yrcom-0.3.2}/tests/test_hses_client.py

@@ -624,6 +624,30 @@ def test_poll_all_status_and_job():
     assert out["job_name"] == "MASTER"
 
 
+def test_poll_all_reads_every_variable_kind_in_one_burst():
+    """D and R used to be reachable only as standalone reads, which put their
+    value a round trip away from the rest of the row."""
+    status_data = struct.pack("<II", 0x40, 0x40)
+    c, _ = _client([
+        _reply(hc._CMD_STATUS, status_data, req_id=1),
+        _reply(hc._CMD_B_VAR, struct.pack("<B", 7), req_id=2),
+        _reply(hc._CMD_I_VAR, struct.pack("<h", -3), req_id=3),
+        _reply(hc._CMD_D_VAR, struct.pack("<i", -70000), req_id=4),
+        _reply(hc._CMD_R_VAR, struct.pack("<f", 1.5), req_id=5),
+    ])
+    out = c.poll_all(
+        include_job=False,
+        b_vars=[{"label": "b", "no": 1}],
+        i_vars=[{"label": "i", "no": 2}],
+        d_vars=[{"label": "d", "no": 3}],
+        r_vars=[{"label": "r", "no": 4}],
+    )
+    assert out["var_b"] == 7
+    assert out["var_i"] == -3
+    assert out["var_d"] == -70000          # signed 32-bit, beyond an I variable
+    assert out["var_r"] == pytest.approx(1.5)
+
+
 def test_poll_all_raises_on_status_error():
     c, _ = _client([_reply(hc._CMD_STATUS, b"", req_id=1, status=0x08)])
     with pytest.raises(HsesError):

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()

yrcom-0.3.0/src/yrcom.egg-info/requires.txt

@@ -1,3 +0,0 @@
-
-[dev]
-pytest>=8