UC2-REST 0.2.0.43__tar.gz → 0.2.0.44__tar.gz

{uc2_rest-0.2.0.43 → uc2_rest-0.2.0.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.43
+Version: 0.2.0.44
 Summary: This pacage will help you to drive the ESP32-driven microscopy control modules from UC2
 Home-page: https://github.com/openUC2/UC2-REST
 Author: Benedict Diederich

{uc2_rest-0.2.0.43 → uc2_rest-0.2.0.44}/UC2_REST.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: UC2-REST
-Version: 0.2.0.43
+Version: 0.2.0.44
 Summary: This pacage will help you to drive the ESP32-driven microscopy control modules from UC2
 Home-page: https://github.com/openUC2/UC2-REST
 Author: Benedict Diederich

{uc2_rest-0.2.0.43 → uc2_rest-0.2.0.44}/UC2_REST.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ UC2_REST.egg-info/requires.txt
 UC2_REST.egg-info/top_level.txt
 tests/test_canota_reconnect.py
 tests/test_motor_axes.py
+tests/test_motor_get_reply.py
 tests/test_stage_scan.py
 uc2rest/MockSerial.py
 uc2rest/UC2Client.py

uc2_rest-0.2.0.44/tests/test_motor_get_reply.py

@@ -0,0 +1,92 @@
+"""/motor_get answers vs. position pushes that share their qid (no hardware).
+
+The firmware tags a motor's position push ({"steppers":[{.., "isDone": 1}]}) with the qid of
+that motor's last move; uc2rest's qids wrap after 254 commands, so such a frame can carry the
+qid of a later /motor_get. Taken as the answer, every other axis read 0 (ImSwitch FRAME
+calibration, 2026-11-12: "X reads 728.2 after a move to 19394.5" = device X 0).
+
+Run: python -m unittest tests.test_motor_get_reply  (from the repo root)
+"""
+import threading
+import time
+import unittest
+from unittest import mock
+
+import numpy as np
+
+from uc2rest.motor import Motor
+from uc2rest.mserial import Serial
+
+PUSH = {"steppers": [{"stepperid": 0, "position": -29000, "isDone": 1}], "qid": 7}
+REPLY = {"motor": {"steppers": [{"stepperid": i, "position": p} for i, p in enumerate((-29000, 19000, 60000, 5900))]},
+         "qid": 7}
+
+
+class _Parent:
+    def __init__(self, frames):
+        self.serial = mock.Mock()
+        self.logger = mock.Mock()
+        self.frames = frames
+
+    def post_json(self, path, payload, accept=None, **kwargs):
+        # like Serial.sendMessage: with accept, the matching frame first
+        if accept is not None:
+            hit = next((f for f in self.frames if accept(f)), None)
+            return "communication interrupted by timeout" if hit is None else [hit] + [f for f in self.frames if f is not hit]
+        return list(self.frames)
+
+
+class MotorGetReplyTest(unittest.TestCase):
+    def motor(self, frames):
+        parent = _Parent(frames)
+        m = parent.motor = Motor(parent=parent)
+        for ax in "AXYZ":
+            m.setup_motor(ax, minPos=-1e9, maxPos=1e9, stepSize=1, backlash=0)
+        return m
+
+    def test_push_with_our_qid_is_not_the_answer(self):
+        p = self.motor([PUSH, REPLY]).get_position()
+        self.assertEqual(list(p[:4]), [-29000, 19000, 60000, 5900])
+
+    def test_no_answer_reports_missing(self):
+        m = self.motor([PUSH])
+        self.assertTrue(np.isnan(m.get_position(missing=np.nan)[:4]).all())
+        self.assertEqual(list(m.get_position()[:4]), [0, 0, 0, 0])        # default: as before
+        self.assertEqual(m._read_firmware_positions(), {})
+
+    def test_filtered_can_reply_is_an_answer(self):
+        can = {"steppers": [{"stepperid": 4, "position": 3}, {"stepperid": 5, "isDone": -1}], "qid": 2}
+        self.assertTrue(Motor._is_motor_get_reply(can, ids=[4, 5]))
+        self.assertFalse(Motor._is_motor_get_reply(can))                 # a bare request wants {"motor": ...}
+        self.assertFalse(Motor._is_motor_get_reply(PUSH, ids=[0, 1]))
+        self.assertFalse(Motor._is_motor_get_reply(PUSH))
+        self.assertFalse(Motor._is_motor_get_reply("communication interrupted"))
+
+
+class SendMessageAcceptTest(unittest.TestCase):
+    """Serial.sendMessage waits past frames that share the qid but fail accept."""
+
+    def test_waits_for_the_accepted_frame(self):
+        s = Serial.__new__(Serial)
+        s.lock, s.responses, s.commands = threading.Lock(), {}, {}
+        s.identifier_counter, s.running, s.is_connected = 0, True, True
+        s.resetLastCommand, s.use_qid_done, s.DEBUG, s.manufacturer = False, False, False, "test"
+        s.timeReturnReceived, s._logger, s.cmdWriteCallBackFct = 5, mock.Mock(), None
+
+        def write(dev, payload):
+            qid = s.identifier_counter
+            def arrive():
+                for f in ({**PUSH, "qid": qid}, {**REPLY, "qid": qid}):
+                    time.sleep(0.05)
+                    with s.lock:
+                        s.responses.setdefault(qid, []).append(f)
+            threading.Thread(target=arrive, daemon=True).start()
+        s._write, s.serialdevice = write, None
+        r = s.sendMessage({"task": "/motor_get", "position": True}, nResponses=1, timeout=2,
+                          accept=Motor._is_motor_get_reply)
+        self.assertIn("motor", r[0])
+        self.assertEqual(len(r), 2)
+
+
+if __name__ == "__main__":
+    unittest.main()

{uc2_rest-0.2.0.43 → uc2_rest-0.2.0.44}/uc2rest/UC2Client.py

@@ -177,10 +177,13 @@ class UC2Client(object):
         # initialize module controller
         self.modules = Modules(parent=self)
     
-    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=1):
+    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=1, accept=None):
         if timeout <=0:
             getReturn = False
-        return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout)
+        if accept is None:      # serial implementations without the accept argument keep working
+            return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout)
+        return self.serial.post_json(path, payload, getReturn=getReturn, nResponses=nResponses, timeout=timeout,
+                                     accept=accept)
 
     def get_json(self, path, getReturn=True, timeout=1):
         if self.is_serial or self.isPyScript:

{uc2_rest-0.2.0.43 → uc2_rest-0.2.0.44}/uc2rest/__version__.py

@@ -6,7 +6,7 @@ __version__.py
 
 __title__ = 'UC2-REST'
 __description__ = 'This pacage will help you to drive the ESP32-driven microscopy control modules from UC2'
-__version__ = "v0.2.0.43"
+__version__ = "v0.2.0.44"
 __author__ = 'Benedict Diederich'
 __author_email__ = 'benedictdied@gmail.com'
 __license__ = 'GPL v3'

{uc2_rest-0.2.0.43 → uc2_rest-0.2.0.44}/uc2rest/motor.py

@@ -901,12 +901,25 @@ class Motor(object):
 
         return r
 
+    def _post_motor_get(self, payload, timeout, ids=None):
+        '''Send a /motor_get and return its answer (a dict), or {} when none came: frames that
+        only share its qid (position pushes) are skipped, see _is_motor_get_reply.'''
+        accept = lambda x: self._is_motor_get_reply(x, ids)
+        try:
+            r = self._parent.post_json("/motor_get", payload, getReturn=True, nResponses=1, timeout=timeout,
+                                       accept=accept)
+        except TypeError:       # a parent without the accept argument: take the first frame, but check it
+            r = self._parent.post_json("/motor_get", payload, getReturn=True, nResponses=1, timeout=timeout)
+        if isinstance(r, dict):
+            r = [r]
+        if not isinstance(r, list):     # "communication interrupted by timeout ...", "Failed to Send"
+            return {}
+        return next((x for x in r if accept(x)), {})
+
     def _read_firmware_positions(self, timeout=1):
         '''{stepperid: physical position} from /motor_get, or {} if no reply.'''
         stepSizes = np.array((self.stepSizeA, self.stepSizeX, self.stepSizeY, self.stepSizeZ))
-        r = self._parent.post_json("/motor_get", {"task": "/motor_get", "position": True},
-                                   getReturn=True, nResponses=1, timeout=timeout)
-        reply = r[0] if isinstance(r, list) and r and isinstance(r[0], dict) else {}
+        reply = self._post_motor_get({"task": "/motor_get", "position": True}, timeout)
         return {st["stepperid"]: st["position"] * stepSizes[st["stepperid"]] * self.direction[st["stepperid"]]
                 for st in reply.get("motor", {}).get("steppers", [])
                 if "position" in st and 0 <= st["stepperid"] < 4}
@@ -1039,9 +1052,27 @@ class Motor(object):
         r = self._parent.post_json(path, payload)
         return r
 
-    def get_position(self, axis=None, timeout=1):
+    @staticmethod
+    def _is_motor_get_reply(r, ids=None):
+        '''A /motor_get answer, not a position push of one motor ({"steppers":[{..,"isDone":..}]}),
+        which the firmware tags with the qid of that motor's last move - after the 254-command
+        qid wrap that can be ours. Taken as the answer it reported every other axis as 0
+        (ImSwitch FRAME calibration 2026-11-12: "X reads 728.2 after a move to 19394.5").
+        Answers: {"motor":{"steppers":[...]}}; for a request filtered to stepper ``ids`` (CAN
+        builds) also {"steppers":[...]} listing all of them.'''
+        if not isinstance(r, dict):
+            return False
+        if isinstance(r.get("motor"), dict):
+            return "steppers" in r["motor"]
+        st = r.get("steppers")
+        if not ids or not isinstance(st, list):
+            return False
+        return set(ids) <= {s.get("stepperid") for s in st if isinstance(s, dict)}
+
+    def get_position(self, axis=None, timeout=1, missing=0.0):
         '''
-        Positions in physical units as an array indexed by stepperid (0 where unknown).
+        Positions in physical units as an array indexed by stepperid (``missing`` where unknown:
+        no reply, or the axis not in it; pass np.nan to tell a lost reading from position 0).
         axis None: what a bare /motor_get lists (the board's own axes); a name, id or a list
         of them asks for exactly those axes, which CAN axes (e.g. ids 4-9 on a HAT) need.
         '''
@@ -1053,10 +1084,10 @@ class Motor(object):
         if axis is not None:
             axes = axis if isinstance(axis, (list, tuple)) else [axis]
             payload["motor"] = {"steppers": [{"stepperid": self.axis_id(a)} for a in axes]}
-        _position = np.zeros(self.nMotors)
+        _position = np.full(self.nMotors, missing, dtype=float)
 
-        # this may be an asynchronous call.. #FIXME!
-        r = self._parent.post_json(path, payload, getReturn = True, nResponses=1, timeout=timeout)[0]
+        r = self._post_motor_get(payload, timeout,
+                                 ids=None if axis is None else [s["stepperid"] for s in payload["motor"]["steppers"]])
         # bare request: {"motor":{"steppers":[...]}}, filtered request (CAN builds): {"steppers":[...]}
         for istepper in r.get("motor", r).get("steppers", []) if isinstance(r, dict) else []:
             stepperID = istepper.get("stepperid", -1)

{uc2_rest-0.2.0.43 → uc2_rest-0.2.0.44}/uc2rest/mserial.py

@@ -525,8 +525,9 @@ class Serial:
         message = json.dumps(message)
         return self.sendMessage(message, nResponses=0, timeout=timeout)
 
-    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=100):
-        """Make an HTTP POST request and return the JSON response"""
+    def post_json(self, path, payload, getReturn=True, nResponses=1, timeout=100, accept=None):
+        """Make an HTTP POST request and return the JSON response.
+        accept: see sendMessage."""
         if payload is None:
             payload = {}
         if "task" not in payload:
@@ -535,7 +536,7 @@ class Serial:
         # write message to the serial
         if not getReturn:
             nResponses = -1
-        writeResult = self.sendMessage(command=payload, nResponses=nResponses, timeout=timeout)
+        writeResult = self.sendMessage(command=payload, nResponses=nResponses, timeout=timeout, accept=accept)
         return writeResult
 
     def writeSerial(self, payload):
@@ -560,12 +561,17 @@ class Serial:
         '''
         self.callBackList.append({"callbackfct":callback, "pattern":pattern})
 
-    def sendMessage(self, command, nResponses=1, timeout = 20):
+    def sendMessage(self, command, nResponses=1, timeout = 20, accept=None):
         '''
         Sends a command to the device and optionally waits for a response.
         If nResponses is 0, then the command is sent but no response is expected.
         If nResponses is 1, then the command is sent and the response is returned.
         If nResponses is >1, then the command is sent and a list of responses is returned.
+        accept: optional predicate on one response. Responses are routed by their qid, and the
+        firmware also tags unsolicited frames with a qid (a motor's position push carries the
+        qid of that motor's last move; qids wrap after 254 commands), so the first frame with
+        our qid need not be the answer. With accept, wait until a response satisfies it and
+        return [that response] + the others.
         '''
         if type(command) == str:
             command = json.loads(command)
@@ -627,7 +633,16 @@ class Serial:
                     self._logger.debug("Communication interrupted by timeout or reset for command: "+str(self.commands[identifier]))
                 return "communication interrupted by timeout or reset: "+str(identifier) + " and code:"+str(self.commands[identifier])
             with self.lock:
-                if identifier in self.responses:
+                if accept is not None and identifier in self.responses:
+                    got = self.responses[identifier]
+                    hit = next((r for r in got if accept(r)), None)
+                    if hit is not None:
+                        del self.responses[identifier]
+                        others = [r for r in got if r is not hit]
+                        if others and self.DEBUG:
+                            self._logger.debug(f"qid {identifier}: skipped {len(others)} frame(s) that are not the answer: {others}")
+                        return [hit] + others
+                elif identifier in self.responses:
                     if len(self.responses[identifier])>=nResponses:
                         returnMessage = self.responses[identifier]
                         # remove the response from the list