motorcortex-python 0.25.0__tar.gz → 0.25.4__tar.gz

{motorcortex_python-0.25.0/motorcortex_python.egg-info → motorcortex_python-0.25.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: motorcortex-python
-Version: 0.25.0
+Version: 0.25.4
 Summary: Python bindings for Motorcortex Engine
 Home-page: https://www.motorcortex.io
 Author: Alexey Zakharov
@@ -8,8 +8,17 @@ Author-email: alexey.zakharov@vectioneer.com
 License: MIT
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pynng==0.8.*
+Requires-Dist: pynng>=0.9.0
 Requires-Dist: protobuf>=3.20
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 # motorcortex-python
 

{motorcortex_python-0.25.0 → motorcortex_python-0.25.4}/motorcortex/__init__.py

@@ -84,11 +84,21 @@ def connect(
     Establishes connections to Motorcortex request and subscribe endpoints, performs login, and loads the parameter tree.
 
     Args:
-        url (str): Connection URL in the format 'address:req_port:sub_port'.
-        motorcortex_types (module): Motorcortex message types module.
+        url (str): Connection URL in the format 'address:req_port:sub_port' or 'wss://address'.
+        motorcortex_types (MessageTypes): Motorcortex message types instance.
         param_tree (ParameterTree): ParameterTree instance to load parameters into.
         reconnect (bool, optional): Whether to enable automatic reconnection. Defaults to True.
-        **kwargs: Additional keyword arguments, including 'login' and 'password' for authentication.
+        **kwargs: Additional keyword arguments:
+            login (str): Username for authentication.
+            password (str): Password for authentication.
+            certificate (str, optional): Path to a TLS certificate file for secure connections.
+            timeout_ms (int, optional): Connection timeout in milliseconds. Defaults to 1000.
+            recv_timeout_ms (int, optional): Receive timeout in milliseconds. Defaults to 500.
+            token_update_interval_ms (int, optional): Session token refresh interval in milliseconds. Defaults to 30000.
+            state_update (Callable, optional): Custom callback for connection state changes.
+                If provided, disables the built-in reconnect logic.
+            req_number_of_threads (int, optional): Thread pool size for request connection. Defaults to 2.
+            sub_number_of_threads (int, optional): Thread pool size for subscribe connection. Defaults to 2.
 
     Returns:
         tuple: (req, sub)
@@ -100,20 +110,40 @@ def connect(
 
     Examples:
         >>> from motorcortex import connect, MessageTypes, ParameterTree
-        >>> url = "127.0.0.1:5555:5556"
         >>> types = MessageTypes()
         >>> tree = ParameterTree()
-        >>> req, sub = connect(url, types, tree, certificate="mcx.cert.crt", timeout_ms=1000, login="admin", password="iddqd")
-        >>> print(tree)  # Parameter tree loaded from server
+        >>> req, sub = connect("wss://192.168.2.100", types, tree,
+        ...                    certificate="mcx.cert.crt", timeout_ms=1000,
+        ...                    login="admin", password="admin",
+        ...                    token_update_interval_ms=15000)
     """
 
+    token_interval_sec = kwargs.get("token_update_interval_ms", 30000) / 1000.0
+
     initial_connect_done = [False]  # Now reconnections will trigger callback login
 
     if reconnect and not kwargs.get("state_update"):
 
         def stateUpdate(req, sub, state):
             if state == ConnectionState.CONNECTION_OK and initial_connect_done[0]:
-                req.login(kwargs.get("login"), kwargs.get("password")).get()
+                # Try to restore session using token, fall back to login
+                restored = False
+                if req.token:
+                    try:
+                        restore_reply = req.restoreSession(req.token)
+                        restore_msg = restore_reply.get(timeout_ms=5000)
+                        motorcortex_msg = motorcortex_types.motorcortex()
+                        if restore_msg and restore_msg.status == motorcortex_msg.OK:
+                            restored = True
+                            logger.debug("[SESSION] Session restored using token")
+                    except Exception as e:
+                        logger.debug(f"[SESSION] Token restore failed: {e}")
+
+                if not restored:
+                    logger.debug("[SESSION] Falling back to login")
+                    req.login(kwargs.get("login"), kwargs.get("password")).get()
+
+                req._startTokenRefresh(token_interval_sec)
                 sub.resubscribe()
 
         kwargs.update(state_update=stateUpdate)
@@ -143,6 +173,9 @@ def connect(
     tree = param_tree_reply.get()
     param_tree.load(tree)
 
+    # Start session token refresh
+    req._startTokenRefresh(token_interval_sec)
+
     initial_connect_done[0] = True  # Now reconnections will trigger callback login
 
     return req, sub
@@ -192,4 +225,4 @@ def statusToStr(motorcortex_msg: object, code: int) -> str:
 
     status += str(' (%s)' % hex(code))
 
-    return status
+    return status

{motorcortex_python-0.25.0 → motorcortex_python-0.25.4}/motorcortex/init_threads.py

@@ -16,5 +16,5 @@ def init_nng_threads(task=2, expire=1, poller=1, resolver=1):
         lib.nng_init_set_parameter(lib.NNG_INIT_NUM_EXPIRE_THREADS, expire)
         lib.nng_init_set_parameter(lib.NNG_INIT_NUM_POLLER_THREADS, poller)
         lib.nng_init_set_parameter(lib.NNG_INIT_NUM_RESOLVER_THREADS, resolver)
-    except:
-        logger.error(f"[INIT-THREADS] Interface is not avaliable")
+    except AttributeError:
+        logger.error("[INIT-THREADS] Cannot adjust thread count: interface unavailable")

{motorcortex_python-0.25.0 → motorcortex_python-0.25.4}/motorcortex/request.py

@@ -17,7 +17,7 @@ import hashlib
 import json
 import tempfile
 import os
-from threading import Event
+from threading import Event, Timer
 from concurrent.futures import ThreadPoolExecutor, Future
 from typing import Any, Callable, List, Optional, Union
 from pynng import Req0, TLSConfig
@@ -33,7 +33,7 @@ from motorcortex.nng_url import NngUrl
 
 class ConnectionState(Enum):
     """Enumeration of connection states.
-    
+
         - CONNECTING:           Connection is being established.
         - CONNECTION_OK:        Connection is successfully established.
         - CONNECTION_LOST:      Connection was lost.
@@ -152,7 +152,10 @@ class Request:
         self.__pool: ThreadPoolExecutor = ThreadPoolExecutor(max_workers=number_of_threads,
                                                              thread_name_prefix="mcx_req")
         self.__callback_handler: StateCallbackHandler = StateCallbackHandler()
-        logger.debug("Request object initialized with state: DISCONNECTED")
+        self.__token: Optional[str] = None
+        self.__token_timer: Optional[Timer] = None
+        self.__token_update_interval_sec: float = 30.0
+        logger.debug("[REQUEST] Request object initialized with state: DISCONNECTED")
 
     def url(self) -> Optional[str]:
         """Return the current connection URL."""
@@ -176,70 +179,70 @@ class Request:
         Returns:
             Reply: A promise that resolves when the connection is established.
         """
-        logger.debug(f"[CONNECT] Starting connection to {url}")
-        logger.debug(f"[CONNECT] Current state: {self.__connection_state.name}")
+        logger.debug(f"[REQUEST-CONNECT] Starting connection to {url}")
+        logger.debug(f"[REQUEST-CONNECT] Current state: {self.__connection_state.name}")
 
         self.__connection_state = ConnectionState.CONNECTING
         conn_timeout_ms, recv_timeout_ms, certificate, state_update = self.parse(**kwargs)
 
-        logger.debug(f"[CONNECT] Parameters - timeout: {conn_timeout_ms} ms, recv_timeout: {recv_timeout_ms} ms, "
+        logger.debug(f"[REQUEST-CONNECT] Parameters - timeout: {conn_timeout_ms} ms, recv_timeout: {recv_timeout_ms} ms, "
                      f"has_cert: {certificate is not None}, has_state_update: {state_update is not None}")
 
         if state_update:
-            logger.debug("[CONNECT] Starting state callback handler")
+            logger.debug("[REQUEST-CONNECT] Starting state callback handler")
             self.__callback_handler.start(state_update)
 
         self.__url = url
         tls_config = None
         if certificate:
             parsed = NngUrl(url)
-            logger.debug(f"[CONNECT] Using TLS with certificate: {certificate}")
+            logger.debug(f"[REQUEST-CONNECT] Using TLS with certificate: {certificate}")
             tls_config = TLSConfig(TLSConfig.MODE_CLIENT, ca_files=certificate, server_name=parsed.hostname)
 
-        logger.debug(f"[CONNECT] Creating Req0 socket with recv_timeout={recv_timeout_ms}ms")
+        logger.debug(f"[REQUEST-CONNECT] Creating Req0 socket with recv_timeout={recv_timeout_ms}ms")
         self.__socket = Req0(recv_timeout=recv_timeout_ms, tls_config=tls_config)
         self.__connected_event = Event()  # Create a fresh event for each connection
         self.__connected = False  # Reset state
 
-        logger.debug("[CONNECT] Socket created, registering callbacks")
+        logger.debug("[REQUEST-CONNECT] Socket created, registering callbacks")
 
         def pre_connect_cb(_pipe):
-            logger.debug(f"[CALLBACK] PRE_CONNECT fired - Connection established")
+            logger.debug(f"[REQUEST-CALLBACK] PRE_CONNECT fired - Connection established")
             old_state = self.__connection_state.name
             self.__connected = True
             self.__connection_state = ConnectionState.CONNECTION_OK
-            logger.debug(f"[CALLBACK] State transition: {old_state} -> {self.__connection_state.name}")
+            logger.debug(f"[REQUEST-CALLBACK] State transition: {old_state} -> {self.__connection_state.name}")
             self.__callback_handler.notify(self, self.connectionState())
             self.__connected_event.set()
-            logger.debug("[CALLBACK] Connection event set, connected=True")
+            logger.debug("[REQUEST-CALLBACK] Connection event set, connected=True")
 
         def post_remove_cb(_pipe):
-            logger.debug(f"[CALLBACK] POST_REMOVE fired - Connection lost/failed")
+            logger.debug(f"[REQUEST-CALLBACK] POST_REMOVE fired - Connection lost/failed")
             old_state = self.__connection_state.name
 
             if self.__connection_state == ConnectionState.DISCONNECTING:
                 self.__connection_state = ConnectionState.DISCONNECTED
-                logger.debug(f"[CALLBACK] Clean disconnect: {old_state} -> DISCONNECTED")
+                logger.debug(f"[REQUEST-CALLBACK] Clean disconnect: {old_state} -> DISCONNECTED")
             elif self.__connection_state == ConnectionState.CONNECTING:
                 self.__connection_state = ConnectionState.CONNECTION_FAILED
-                logger.debug(f"[CALLBACK] Connection failed: {old_state} -> CONNECTION_FAILED")
+                logger.debug(f"[REQUEST-CALLBACK] Connection failed: {old_state} -> CONNECTION_FAILED")
             elif self.__connection_state == ConnectionState.CONNECTION_OK:
                 self.__connection_state = ConnectionState.CONNECTION_LOST
-                logger.debug(f"[CALLBACK] Connection lost: {old_state} -> CONNECTION_LOST")
+                logger.debug(f"[REQUEST-CALLBACK] Connection lost: {old_state} -> CONNECTION_LOST")
 
             self.__connected = False
             self.__callback_handler.notify(self, self.connectionState())
             self.__connected_event.set()
-            logger.debug("[CALLBACK] Connection event set, connected=False")
+            logger.debug("[REQUEST-CALLBACK] Connection event set, connected=False")
 
         self.__socket.add_pre_pipe_connect_cb(pre_connect_cb)
         self.__socket.add_post_pipe_remove_cb(post_remove_cb)
-        logger.debug("[CONNECT] Callbacks registered successfully")
+        logger.debug("[REQUEST-CONNECT] Callbacks registered successfully")
 
-        logger.debug(f"[CONNECT] Starting dial to {url} (non-blocking)")
+        logger.debug(f"[REQUEST-CONNECT] Starting dial to {url} (non-blocking)")
         self.__socket.dial(url, block=False)
 
-        logger.debug(f"[CONNECT] Submitting waitForConnection to thread pool with timeout={conn_timeout_ms / 1000.0}s")
+        logger.debug(f"[REQUEST-CONNECT] Submitting waitForConnection to thread pool with timeout={conn_timeout_ms / 1000.0}s")
         return Reply(self.__pool.submit(self.waitForConnection, self.__connected_event,
                                         conn_timeout_ms / 1000.0, lambda: self.__connected))
 
@@ -247,29 +250,30 @@ class Request:
         """
         Close the request connection and clean up resources.
         """
-        logger.debug("[CLOSE] Closing connection")
-        logger.debug(f"[CLOSE] Current state: {self.__connection_state.name}, connected: {self.__connected}")
+        logger.debug("[REQUEST-CLOSE] Closing connection")
+        logger.debug(f"[REQUEST-CLOSE] Current state: {self.__connection_state.name}, connected: {self.__connected}")
 
         self.__connection_state = ConnectionState.DISCONNECTING
+        self._stopTokenRefresh()
         if self.__connected_event:
             self.__connected = False
             self.__connected_event.set()
-            logger.debug("[CLOSE] Connection event set for shutdown")
+            logger.debug("[REQUEST-CLOSE] Connection event set for shutdown")
         else:
-            logger.debug("[CLOSE] No connection event to set")
+            logger.debug("[REQUEST-CLOSE] No connection event to set")
 
         if self.__socket:
-            logger.debug("[CLOSE] Closing socket")
+            logger.debug("[REQUEST-CLOSE] Closing socket")
             self.__socket.close()
         else:
-            logger.debug("[CLOSE] No socket to close")
+            logger.debug("[REQUEST-CLOSE] No socket to close")
 
-        logger.debug("[CLOSE] Stopping callback handler")
+        logger.debug("[REQUEST-CLOSE] Stopping callback handler")
         self.__callback_handler.stop()
 
-        logger.debug("[CLOSE] Shutting down thread pool (blocking)")
+        logger.debug("[REQUEST-CLOSE] Shutting down thread pool (blocking)")
         self.__pool.shutdown(wait=True)
-        logger.debug("[CLOSE] Connection closed successfully")
+        logger.debug("[REQUEST-CLOSE] Connection closed successfully")
 
     def send(self, encoded_msg: Any, do_not_decode_reply: bool = False) -> Optional[Reply]:
         """
@@ -285,7 +289,7 @@ class Request:
         if self.__socket is not None:
             return Reply(self.__pool.submit(self.__send, self.__socket, encoded_msg,
                                             None if do_not_decode_reply else self.__protobuf_types))
-        logger.debug("[SEND] Attempted to send on null socket - connection not established?")
+        logger.debug("[REQUEST-SEND] Attempted to send on null socket - connection not established?")
         return None
 
     def login(self, login: str, password: str) -> Reply:
@@ -527,6 +531,72 @@ class Request:
         # encoding and sending data
         return self.send(self.__protobuf_types.encode(remove_group_msg))
 
+    @property
+    def token(self) -> Optional[str]:
+        """Return the current session token."""
+        return self.__token
+
+    def getSessionToken(self) -> Reply:
+        """Request a session token from the server."""
+        msg = self.__protobuf_types.createType('motorcortex.GetSessionTokenMsg')
+        return self.send(self.__protobuf_types.encode(msg))
+
+    def restoreSession(self, token: str) -> Reply:
+        """Restore a session using a saved token."""
+        msg = self.__protobuf_types.createType('motorcortex.RestoreSessionMsg')
+        msg.token = token
+        return self.send(self.__protobuf_types.encode(msg))
+
+    def _startTokenRefresh(self, interval_sec: float = 30.0) -> None:
+        """Start periodic session token refresh.
+
+        Args:
+            interval_sec: Interval between token refreshes in seconds.
+        """
+        self.__token_update_interval_sec = interval_sec
+        self._stopTokenRefresh()
+        # Fetch token immediately, then schedule periodic refresh
+        self.__fetchToken()
+        self.__scheduleTokenRefresh()
+
+    def _stopTokenRefresh(self) -> None:
+        """Stop periodic session token refresh."""
+        if self.__token_timer:
+            self.__token_timer.cancel()
+            self.__token_timer = None
+
+    def __scheduleTokenRefresh(self) -> None:
+        """Schedule the next token refresh."""
+        self._stopTokenRefresh()
+        self.__token_timer = Timer(self.__token_update_interval_sec, self.__onTokenTimer)
+        self.__token_timer.daemon = True
+        self.__token_timer.start()
+        logger.debug(f"[REQUEST-KEEPALIVE] Next token refresh in {self.__token_update_interval_sec}s")
+
+    def __onTokenTimer(self) -> None:
+        """Timer callback: fetch token and reschedule."""
+        self.__fetchToken()
+        # Always reschedule if not disconnecting/disconnected
+        if self.__connection_state not in (ConnectionState.DISCONNECTING, ConnectionState.DISCONNECTED):
+            self.__scheduleTokenRefresh()
+
+    def __fetchToken(self) -> None:
+        """Fetch a session token from the server."""
+        if self.__connection_state != ConnectionState.CONNECTION_OK:
+            logger.debug(f"[REQUEST-KEEPALIVE] Skipping token fetch, state: {self.__connection_state.name}")
+            return
+        try:
+            reply = self.getSessionToken()
+            if reply:
+                msg = reply.get(timeout_ms=5000)
+                if msg and hasattr(msg, 'token'):
+                    self.__token = msg.token
+                    logger.debug("[REQUEST-KEEPALIVE] Session token updated")
+                else:
+                    logger.debug("[REQUEST-KEEPALIVE] Server returned no token")
+        except Exception as e:
+            logger.debug(f"[REQUEST-KEEPALIVE] Token refresh failed: {e}")
+
     @staticmethod
     def __buildSetParameterMsg(
             path: str,
@@ -791,33 +861,33 @@ class Request:
         Returns:
             True if connection is established, raises on failure or timeout.
         """
-        logger.debug(f"[WAIT] waitForConnection started with timeout={timeout_sec}s")
+        logger.debug(f"[REQUEST-WAIT] waitForConnection started with timeout={timeout_sec}s")
 
         # Wait for the condition to be set or timeout
         if timeout_sec <= 0:
-            logger.debug("[WAIT] Waiting indefinitely for connection event")
+            logger.debug("[REQUEST-WAIT] Waiting indefinitely for connection event")
             result = event.wait()
         else:
-            logger.debug(f"[WAIT] Waiting up to {timeout_sec}s for connection event")
+            logger.debug(f"[REQUEST-WAIT] Waiting up to {timeout_sec}s for connection event")
             result = event.wait(timeout_sec)
 
         if not result:
-            logger.error(f"[WAIT] Connection timeout after {timeout_sec}s - no event received")
+            logger.error(f"[REQUEST-WAIT] Connection timeout after {timeout_sec}s - no event received")
             raise TimeoutError(f"Connection timeout after {timeout_sec}s")
 
-        logger.debug("[WAIT] Event received - checking connection status")
+        logger.debug("[REQUEST-WAIT] Event received - checking connection status")
 
         # Check if we actually connected (event could be set by close() or failure)
         if is_connected_fn:
             connected = is_connected_fn()
-            logger.debug(f"[WAIT] Connection status check: connected={connected}")
+            logger.debug(f"[REQUEST-WAIT] Connection status check: connected={connected}")
             if not connected:
-                logger.error("[WAIT] Event was set but connection failed or was closed")
+                logger.error("[REQUEST-WAIT] Event was set but connection failed or was closed")
                 raise ConnectionError("Connection failed or was closed before completion")
         else:
-            logger.debug("[WAIT] No connection status check function provided")
+            logger.debug("[REQUEST-WAIT] No connection status check function provided")
 
-        logger.debug("[WAIT] Connection successfully established")
+        logger.debug("[REQUEST-WAIT] Connection successfully established")
         return True
 
     @staticmethod
@@ -841,10 +911,10 @@ class Request:
         path = os.sep.join([tempfile.gettempdir(), "mcx-python-pt-" + str(tree_hash.hash)])
         tree = Request.loadParameterTreeFile(path, protobuf_types)
         if tree:
-            logger.debug('Found parameter tree in the cache')
+            logger.debug('[REQUEST] Found parameter tree in the cache')
             return tree
         else:
-            logger.debug('Failed to find parameter tree in the cache')
+            logger.debug('[REQUEST] Failed to find parameter tree in the cache')
 
         # getting and instantiating data type from the loaded dict
         param_tree_msg = protobuf_types.createType('motorcortex.GetParameterTreeMsg')
@@ -868,7 +938,7 @@ class Request:
         Returns:
             The saved ParameterTree instance.
         """
-        logger.debug('Saved parameter tree to the cache')
+        logger.debug('[REQUEST] Saved parameter tree to the cache')
         json_data = {}
         base64_data = base64.b64encode(parameter_tree.SerializeToString())
         json_data['md5'] = hashlib.md5(base64_data).hexdigest()
@@ -894,7 +964,7 @@ class Request:
         Returns:
             The loaded ParameterTree instance, or None if not found/invalid.
         """
-        logger.debug('Loaded parameter tree from the cache')
+        logger.debug('[REQUEST] Loaded parameter tree from the cache')
         param_tree_hash_msg = None
         if os.path.exists(path):
             with open(path, "r") as outfile:
@@ -907,4 +977,4 @@ class Request:
                         tree_raw = base64.b64decode(json_data['data'])
                         param_tree_hash_msg.ParseFromString(tree_raw)
 
-        return param_tree_hash_msg
+        return param_tree_hash_msg

motorcortex_python-0.25.4/motorcortex/version.py

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

{motorcortex_python-0.25.0 → motorcortex_python-0.25.4/motorcortex_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: motorcortex-python
-Version: 0.25.0
+Version: 0.25.4
 Summary: Python bindings for Motorcortex Engine
 Home-page: https://www.motorcortex.io
 Author: Alexey Zakharov
@@ -8,8 +8,17 @@ Author-email: alexey.zakharov@vectioneer.com
 License: MIT
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pynng==0.8.*
+Requires-Dist: pynng>=0.9.0
 Requires-Dist: protobuf>=3.20
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 # motorcortex-python
 

{motorcortex_python-0.25.0 → motorcortex_python-0.25.4}/motorcortex_python.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 MANIFEST.in
 README.md
+pyproject.toml
 setup.py
 motorcortex/__init__.py
 motorcortex/init_threads.py

{motorcortex_python-0.25.0 → motorcortex_python-0.25.4}/motorcortex_python.egg-info/requires.txt

@@ -1,2 +1,2 @@
-pynng==0.8.*
+pynng>=0.9.0
 protobuf>=3.20

motorcortex_python-0.25.4/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61,<70", "wheel"]
+build-backend = "setuptools.build_meta"

{motorcortex_python-0.25.0 → motorcortex_python-0.25.4}/setup.py

@@ -33,7 +33,8 @@ setup(name='motorcortex-python',
       url='https://www.motorcortex.io',
       license='MIT',
       packages=['motorcortex'],
-      install_requires=['pynng==0.8.*',
-                        'protobuf>=3.20'],
+      install_requires=[
+          'pynng>=0.9.0',
+          'protobuf>=3.20'],
       include_package_data=True,
       )

motorcortex_python-0.25.0/motorcortex/version.py

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