motorcortex-python 1.2.0__tar.gz → 1.2.1__tar.gz

{motorcortex_python-1.2.0/motorcortex_python.egg-info → motorcortex_python-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: motorcortex-python
-Version: 1.2.0
+Version: 1.2.1
 Summary: Python bindings for Motorcortex Engine
 Home-page: https://www.motorcortex.io
 Author: Alexey Zakharov

{motorcortex_python-1.2.0 → motorcortex_python-1.2.1}/motorcortex/__init__.py

@@ -41,6 +41,7 @@ from motorcortex.exceptions import (
     McxTimeout,
 )
 from motorcortex.motorcortex_pb2 import StatusCode as _PbStatusCode
+from motorcortex import _request_utils
 from motorcortex.setup_logger import logger  # not re-exported — ``__all__`` gates package surface
 
 # Build an ``IntEnum`` facade over the protobuf ``StatusCode`` enum so
@@ -312,7 +313,15 @@ def connect(
 
     if reconnect and not kwargs.get("state_update"):
 
+        # The initial CONNECTION_OK edge can land after connect() returns
+        # (the cookie probe + hello finish in the background), so it must
+        # not be mistaken for a reconnect that needs a re-login.
+        initial_ok_seen = [False]
+
         def stateUpdate(req, sub, state):
+            if state == ConnectionState.CONNECTION_OK and not initial_ok_seen[0]:
+                initial_ok_seen[0] = True
+                return
             _reconnect_state_update(
                 req, sub, state,
                 motorcortex_types=motorcortex_types,
@@ -342,7 +351,12 @@ def connect(
             )
         # Open subscribe connection
         sub = Subscribe(req, motorcortex_types, kwargs.get("sub_number_of_threads", 2))
-        if not sub.connect(makeUrl(sub_address, sub_port), **kwargs).get():
+        sub_reply = sub.connect(makeUrl(sub_address, sub_port), **kwargs)
+        # Wait for the dial only: the cookie probe and hello carry on in
+        # the background (up to 2 s on an old server that never answers)
+        # while login and a cached tree load go ahead.
+        dialed = getattr(sub, "_dialed", None)
+        if not (dialed.result() if dialed is not None else sub_reply.get()):
             raise McxConnectionError(
                 "Failed to establish subscribe connection: {}:{}".format(sub_address, sub_port)
             )
@@ -360,7 +374,18 @@ def connect(
             )
 
         # Requesting a parameter tree
-        param_tree_reply = req.getParameterTree()
+        # On a cache miss, wait for the cookie-probe verdict so an old
+        # server (no compressed tree handler, silently drops the request)
+        # gets the plain tree straight away instead of waiting on a reply
+        # that never comes. A cache hit never calls this.
+        def compressed_hint():
+            try:
+                sub_reply.get(timeout_ms=_request_utils.CAPABILITY_PROBE_TIMEOUT_MS + 3000)
+            except Exception:
+                return None
+            return getattr(sub, "_server_has_routing", None)
+
+        param_tree_reply = req.getParameterTree(compressed=compressed_hint)
         tree = param_tree_reply.get()
         param_tree.load(tree)
     except Exception:

{motorcortex_python-1.2.0 → motorcortex_python-1.2.1}/motorcortex/_request_utils.py

@@ -21,7 +21,10 @@ import os
 import tempfile
 import zlib
 from threading import Event
-from typing import Any, Callable, Optional, Tuple
+from typing import Any, Callable, Optional, Tuple, Union
+
+from pynng._nng import lib  # type: ignore[import-untyped]
+from pynng.exceptions import check_err  # type: ignore[import-untyped]
 
 from motorcortex.exceptions import McxConnectionError
 from motorcortex.setup_logger import logger
@@ -29,6 +32,12 @@ from motorcortex.setup_logger import logger
 
 _CACHE_PREFIX = "mcx-python-pt"
 
+#: Old servers silently drop unknown request hashes — cap how long a
+#: capability probe (routing cookie, compressed tree) may wait so a
+#: pre-2.36 server costs at most 2 s per probe. Mirrors
+#: CAPABILITY_PROBE_TIMEOUT_MS in motorcortex-cpp and motorcortex-js.
+CAPABILITY_PROBE_TIMEOUT_MS = 2000
+
 
 def parse_connect_kwargs(
         conn_timeout_ms: int = 0,
@@ -114,6 +123,7 @@ def fetch_parameter_tree(
         protobuf_types: Any,
         socket: Any,
         url: Optional[str] = None,
+        compressed: Union[Optional[bool], Callable[[], Optional[bool]]] = None,
 ) -> Any:
     """Fetch the parameter tree, hitting the local cache first.
 
@@ -132,6 +142,19 @@ def fetch_parameter_tree(
             :func:`send_and_recv`.
         url: Connection URL — hashed into the cache filename so two
             engines with the same ``tree_hash`` don't collide.
+        compressed: Server-capability hint from the routing-cookie probe
+            (same scheme as motorcortex-js). The cookie handler and the
+            compressed tree handler both landed in core 2.36, so:
+            ``False`` — the server did not hand out a cookie, so it has no
+            compressed handler: skip straight to the plain request.
+            ``True`` — the server is >= 2.36: request compressed with the
+            socket's own timeout, so a big reply on a slow link never
+            races a short cap.
+            ``None`` — unknown (no Subscribe, raw ``Request`` use): try
+            compressed, capped at ``CAPABILITY_PROBE_TIMEOUT_MS``.
+            May also be a callable returning one of those; it is only
+            called on a cache miss, so a still-running probe never delays
+            a cached tree load.
 
     Returns:
         A ``ParameterTreeMsg`` — either the cached one or the freshly
@@ -152,10 +175,10 @@ def fetch_parameter_tree(
     ``ParameterTreeMsg`` type, so callers (and the cache write below)
     can't tell the difference. Tried for every URL scheme (ipc, tcp,
     ws, tls+tcp, wss) — the request is just bytes over
-    :func:`send_and_recv`. ``send_and_recv`` in this repo has no
-    per-call timeout knob, so on an old server the compressed attempt
-    costs at most one ``recv_timeout`` (the socket's own) before
-    falling back.
+    :func:`send_and_recv`. Old servers never answer the unknown hash, and
+    the socket's ``recv_timeout`` is infinite by default, so an uncapped
+    attempt would hang the connect forever — hence the ``compressed``
+    hint and the per-request probe cap.
     """
     path = parameter_tree_cache_path(url, tree_hash)
     cached = load_parameter_tree_file(path, protobuf_types)
@@ -164,11 +187,20 @@ def fetch_parameter_tree(
         return cached
     logger.debug("[REQUEST] Failed to find parameter tree in the cache")
 
+    if callable(compressed):
+        compressed = compressed()
+    if compressed is False:
+        logger.debug("[REQUEST] server predates the compressed tree — requesting plain")
+        request_msg = protobuf_types.createType("motorcortex.GetParameterTreeMsg")
+        handle = send_and_recv(socket, protobuf_types.encode(request_msg), protobuf_types)
+        return save_parameter_tree_file(path, handle)
+
     try:
         compressed_request = protobuf_types.createType(
             "motorcortex.GetParameterTreeCompressedMsg")
         compressed_reply = send_and_recv(
-            socket, protobuf_types.encode(compressed_request), protobuf_types)
+            socket, protobuf_types.encode(compressed_request), protobuf_types,
+            timeout_ms=None if compressed else CAPABILITY_PROBE_TIMEOUT_MS)
         if compressed_reply is not None \
                 and getattr(compressed_reply, "status", 1) == 0 \
                 and getattr(compressed_reply, "compressed", b""):
@@ -209,6 +241,7 @@ def send_and_recv(
         socket: Any,
         encoded_msg: Any,
         protobuf_types: Optional[Any],
+        timeout_ms: Optional[int] = None,
 ) -> Any:
     """One-shot synchronous request/reply over an nng Req0 socket.
 
@@ -225,6 +258,12 @@ def send_and_recv(
         encoded_msg: Bytes to send.
         protobuf_types: If truthy, decoded wire reply is returned.
             Otherwise the raw buffer is returned.
+        timeout_ms: Receive timeout for this one request, set on the nng
+            context so the worker thread is released when it expires
+            (``pynng.Timeout`` is raised). ``None`` keeps the socket's
+            ``recv_timeout``. A ``Reply.get(timeout_ms=...)`` alone only
+            stops the caller waiting — the worker stays blocked in
+            ``recv()`` for as long as the socket timeout allows.
 
     Returns:
         Decoded reply (when ``protobuf_types`` supplied and buffer is
@@ -232,6 +271,8 @@ def send_and_recv(
     """
     ctx = socket.new_context()
     try:
+        if timeout_ms is not None:
+            check_err(lib.nng_ctx_set_ms(ctx.context, b"recv-timeout", timeout_ms))
         ctx.send(encoded_msg)
         buffer = ctx.recv()
         if buffer:
@@ -239,7 +280,10 @@ def send_and_recv(
                 return protobuf_types.decode(buffer)
             return buffer
     except Exception as e:
-        logger.error("[SEND] Error during send/recv: %s: %s", type(e).__name__, e)
+        # A capped request timing out is an expected probe outcome on old
+        # servers, not an error worth shouting about.
+        log = logger.debug if timeout_ms is not None else logger.error
+        log("[SEND] Error during send/recv: %s: %s", type(e).__name__, e)
         raise
     finally:
         ctx.close()

{motorcortex_python-1.2.0 → motorcortex_python-1.2.1}/motorcortex/request.py

@@ -344,12 +344,16 @@ class Request:
         self._callback_handler.stop()
         self._pool.shutdown(wait=True)
 
-    def send(self, encoded_msg: Any, do_not_decode_reply: bool = False) -> "Reply[Any]":
+    def send(self, encoded_msg: Any, do_not_decode_reply: bool = False,
+             timeout_ms: Optional[int] = None) -> "Reply[Any]":
         """Send an encoded message to the server.
 
         Args:
             encoded_msg: Encoded protobuf message.
             do_not_decode_reply: If True, do not decode the reply.
+            timeout_ms: Receive timeout for this request only; on expiry
+                the reply fails with ``pynng.Timeout``. Defaults to the
+                socket's ``recv_timeout_ms``.
 
         Returns:
             Reply: A promise for the server's reply.
@@ -368,7 +372,7 @@ class Request:
             )
         return Reply(self._pool.submit(
             _request_utils.send_and_recv, self._socket, encoded_msg,
-            None if do_not_decode_reply else self._protobuf_types,
+            None if do_not_decode_reply else self._protobuf_types, timeout_ms,
         ))
 
     def login(self, login: str, password: str) -> "Reply[_pb.StatusMsg]":
@@ -412,7 +416,7 @@ class Request:
         # encoding and sending data
         return self.send(self._protobuf_types.encode(param_tree_hash_msg))
 
-    def getSubCookie(self) -> "Reply[_pb.SubCookieMsg]":
+    def getSubCookie(self, timeout_ms: Optional[int] = None) -> "Reply[_pb.SubCookieMsg]":
         """Request a single-use pub/sub identity cookie (internal plumbing).
 
         Doubles as the routing capability probe: old servers (<2.36.1)
@@ -420,16 +424,31 @@ class Request:
         FAILED — both mean "no routing", not an error. Used by Subscribe
         for the data-channel hello; not needed in application code.
 
+        Args:
+            timeout_ms: Receive timeout for this request (see ``send``).
+
         Returns:
             Reply: A promise for the sub cookie.
         """
         msg = self._protobuf_types.createType('motorcortex.GetSubCookieMsg')
-        return self.send(self._protobuf_types.encode(msg))
+        return self.send(self._protobuf_types.encode(msg), timeout_ms=timeout_ms)
 
-    def getParameterTree(self) -> "Reply[_pb.ParameterTreeMsg]":
+    def getParameterTree(
+            self,
+            compressed: Union[Optional[bool], Callable[[], Optional[bool]]] = None,
+    ) -> "Reply[_pb.ParameterTreeMsg]":
         """
         Request a parameter tree from the server.
 
+        Args:
+            compressed: Server-capability hint for the compressed tree
+                transport: ``True`` / ``False`` if the routing-cookie
+                probe showed the server is / is not >= 2.36, ``None``
+                (default) to try it with a short probe timeout, or a
+                callable returning one of those, evaluated only on a
+                cache miss. See
+                :func:`motorcortex._request_utils.fetch_parameter_tree`.
+
         Returns:
             Reply: A promise for the parameter tree.
         """
@@ -437,6 +456,7 @@ class Request:
         return Reply(self._pool.submit(
             self._getParameterTree,
             self.getParameterTreeHash(), self._protobuf_types, self._socket, self._url,
+            compressed,
         ))
 
     def save(self, path: str, file_name: str) -> "Reply[_pb.StatusMsg]":
@@ -692,6 +712,7 @@ class Request:
             protobuf_types: MessageTypes,
             socket: Req0,
             url: Optional[str] = None,
+            compressed: Union[Optional[bool], Callable[[], Optional[bool]]] = None,
     ) -> Any:
         """Thunk that unwraps ``hash_reply`` and delegates to
         :func:`motorcortex._request_utils.fetch_parameter_tree`.
@@ -702,6 +723,6 @@ class Request:
         """
         tree_hash = hash_reply.get()
         return _request_utils.fetch_parameter_tree(
-            tree_hash.hash, protobuf_types, socket, url,
+            tree_hash.hash, protobuf_types, socket, url, compressed,
         )
 

{motorcortex_python-1.2.0 → motorcortex_python-1.2.1}/motorcortex/subscribe.py

@@ -25,10 +25,10 @@ if TYPE_CHECKING:  # pragma: no cover
     from motorcortex.message_types import MessageTypes
 
 
-#: Old servers silently drop unknown request hashes — cap how long a
-#: capability probe may wait so a pre-2.36.1 server costs at most 2 s
-#: per connect attempt. Mirrors CAPABILITY_PROBE_TIMEOUT_MS in cpp.
-CAPABILITY_PROBE_TIMEOUT_MS = 2000
+#: Re-exported from ``_request_utils`` (shared with the compressed-tree
+#: probe) — old servers silently drop unknown request hashes, so a
+#: pre-2.36.1 server costs at most 2 s per connect attempt.
+CAPABILITY_PROBE_TIMEOUT_MS = _request_utils.CAPABILITY_PROBE_TIMEOUT_MS
 
 #: First upstream message on a routed data-channel stream: magic + the
 #: single-use cookie fetched via ``Request.getSubCookie``.
@@ -39,7 +39,12 @@ def _fetch_cookie(req: "Request") -> Optional[str]:
     """Best-effort single-use cookie fetch. None is not an error — it
     selects the anonymous (pre-routing) subscribe path."""
     try:
-        msg = req.getSubCookie().get(timeout_ms=CAPABILITY_PROBE_TIMEOUT_MS)
+        # The cap goes on the nng context, not only on Reply.get: an old
+        # server never answers, and with the default infinite socket
+        # recv_timeout the request worker would stay blocked for good —
+        # one leaked worker per (re)connect until the pool is exhausted.
+        msg = req.getSubCookie(timeout_ms=CAPABILITY_PROBE_TIMEOUT_MS).get(
+            timeout_ms=CAPABILITY_PROBE_TIMEOUT_MS + 1000)
     except Exception as e:
         logger.debug("[SUBSCRIBE] cookie probe failed/timed out: %s", e)
         return None
@@ -117,6 +122,17 @@ class Subscribe:
         self._url: Optional[str] = None
         self._tls_config: Optional[TLSConfig] = None
         self._conn_timeout_ms: int = 1000
+        #: Outcome of the last conclusive cookie probe: True if the server
+        #: handed out a cookie (core >= 2.36, which also has the compressed
+        #: tree handler), False if it did not, None if never probed. Passed
+        #: to ``Request.getParameterTree`` as the compressed-tree hint.
+        self._server_has_routing: Optional[bool] = None
+        #: Resolves with the initial dial's outcome, before the cookie
+        #: probe and hello. ``motorcortex.connect`` waits on this instead
+        #: of the full ``connect()`` Reply so the ~2 s probe against an
+        #: old server overlaps login and a cached tree load (mirrors
+        #: motorcortex-js, which backgrounds the routing hello).
+        self._dialed: "Future[bool]" = Future()
         self._req: Request = req
         self._protobuf_types: Any = protobuf_types
         self._subscriptions: Dict[int, Subscription] = dict()
@@ -247,11 +263,19 @@ class Subscribe:
         return Reply(future)
 
     def _initial_connect(self) -> bool:
+        try:
+            return self._initial_connect_body()
+        finally:
+            # Every exit path must resolve it — connect() callers block on it.
+            if not self._dialed.done():
+                self._dialed.set_result(False)
+
+    def _initial_connect_body(self) -> bool:
         if self._closed:
             # close() beat this pool worker to it before it even started.
             return False
 
-        ok = self._dial_and_hello(allow_cookie=True)
+        ok = self._dial_and_hello(allow_cookie=True, dialed=self._dialed)
 
         if not ok:
             self._connection_state = ConnectionState.CONNECTION_FAILED
@@ -276,7 +300,8 @@ class Subscribe:
             return False
         return True
 
-    def _dial_and_hello(self, allow_cookie: bool) -> bool:
+    def _dial_and_hello(self, allow_cookie: bool,
+                        dialed: "Optional[Future[bool]]" = None) -> bool:
         """Dial FIRST, then fetch the single-use cookie, then hello.
 
         Fetch-first would burn a cookie on every attempt against a dead
@@ -299,6 +324,8 @@ class Subscribe:
         except Exception as e:
             logger.debug("[SUBSCRIBE] dial failed: %s", e)
             return False
+        if dialed is not None:
+            dialed.set_result(True)
 
         cookie = None
         if allow_cookie:
@@ -320,6 +347,7 @@ class Subscribe:
                     self._req.connectionState().name)
                 self._stream.close()
                 return False
+            self._server_has_routing = cookie is not None
         if cookie:
             try:
                 # Fire-and-forget by design (no ack on the wire): a send
@@ -469,7 +497,6 @@ class Subscribe:
 
         self._connection_state = ConnectionState.DISCONNECTING
         for s in self._subscriptions.values():
-            s.done()
             s.stop()  # stop the ordered dispatch consumer thread
         self._subscriptions.clear()
 
@@ -525,8 +552,6 @@ class Subscribe:
         # find and remove subscription
         if sub_id in self._subscriptions:
             sub = self._subscriptions[sub_id]
-            # stop sub update thread
-            sub.done()
             sub.stop()  # stop the ordered dispatch consumer thread
             del self._subscriptions[sub_id]
 

motorcortex_python-1.2.1/motorcortex/version.py

@@ -0,0 +1 @@
+__version__ = '1.2.1'

{motorcortex_python-1.2.0 → motorcortex_python-1.2.1/motorcortex_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: motorcortex-python
-Version: 1.2.0
+Version: 1.2.1
 Summary: Python bindings for Motorcortex Engine
 Home-page: https://www.motorcortex.io
 Author: Alexey Zakharov

motorcortex_python-1.2.0/motorcortex/version.py

@@ -1 +0,0 @@
-__version__ = '1.2.0'