styly-netsync-server 0.12.0__tar.gz → 0.14.0__tar.gz

{styly_netsync_server-0.12.0 → styly_netsync_server-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: styly-netsync-server
-Version: 0.12.0
+Version: 0.14.0
 Summary: STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences
 Author-email: "STYLY, Inc." <info@styly.inc>
 License-Expression: Apache-2.0

{styly_netsync_server-0.12.0 → styly_netsync_server-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "styly-netsync-server"
-version = "0.12.0"
+version = "0.14.0"
 description = "STYLY NetSync Server - Multiplayer framework for Location-Based Entertainment VR/MR experiences"
 readme = "README.md"
 requires-python = ">=3.11"

{styly_netsync_server-0.12.0 → styly_netsync_server-0.14.0}/src/styly_netsync/binary_serializer.py

@@ -6,7 +6,10 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 # Message type identifiers
-PROTOCOL_VERSION = 5
+# v6: Network Variable wire messages dropped the per-write timestamp field.
+# Bumped so mixed old/new builds fail the handshake instead of silently
+# misparsing NV traffic (the version byte rides on transform/object messages).
+PROTOCOL_VERSION = 6
 MSG_CLIENT_TRANSFORM = 1
 MSG_ROOM_TRANSFORM = 2  # Legacy room transform with short IDs only
 MSG_RPC = 3  # Remote procedure call
@@ -24,6 +27,7 @@ MSG_ROOM_OBJECTS = 14  # Server → Clients (PUB): room object states
 MSG_OBJECT_OWNERSHIP_REQUEST = 15  # Client → Server: RequestOwnership/ReleaseOwnership
 MSG_OBJECT_OWNERSHIP_CHANGED = 16  # Server → Clients (ROUTER): ownership changed
 MSG_OBJECT_OWNERSHIP_REJECTED = 17  # Server → Client (ROUTER): request rejected
+MSG_CLIENT_VAR_CLEAR = 18  # Clear all client variables for the sender
 
 # Transform data type identifiers (deprecated - kept for reference)
 
@@ -685,7 +689,7 @@ def serialize_global_var_set(data: dict[str, Any]) -> bytes:
     """Serialize global variable set message
 
     Args:
-        data: Dictionary with senderClientNo, variableName, variableValue, timestamp
+        data: Dictionary with senderClientNo, variableName, variableValue
     """
     buffer = bytearray()
 
@@ -703,9 +707,6 @@ def serialize_global_var_set(data: dict[str, Any]) -> bytes:
     value = data.get("variableValue", "")[:1024]
     _pack_string(buffer, value, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    buffer.extend(struct.pack("<d", data.get("timestamp", 0.0)))
-
     return bytes(buffer)
 
 
@@ -728,7 +729,6 @@ def serialize_global_var_sync(data: dict[str, Any]) -> bytes:
     for var in variables:
         _pack_string(buffer, var.get("name", "")[:64])
         _pack_string(buffer, var.get("value", "")[:1024], use_ushort=True)
-        buffer.extend(struct.pack("<d", var.get("timestamp", 0.0)))
         buffer.extend(struct.pack("<H", var.get("lastWriterClientNo", 0)))
 
     return bytes(buffer)
@@ -738,7 +738,8 @@ def serialize_client_var_set(data: dict[str, Any]) -> bytes:
     """Serialize client variable set message
 
     Args:
-        data: Dictionary with senderClientNo, targetClientNo, variableName, variableValue, timestamp
+        data: Dictionary with senderClientNo, targetClientNo, variableName,
+            variableValue
     """
     buffer = bytearray()
 
@@ -759,8 +760,22 @@ def serialize_client_var_set(data: dict[str, Any]) -> bytes:
     value = data.get("variableValue", "")[:1024]
     _pack_string(buffer, value, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    buffer.extend(struct.pack("<d", data.get("timestamp", 0.0)))
+    return bytes(buffer)
+
+
+def serialize_client_var_clear(data: dict[str, Any]) -> bytes:
+    """Serialize client variable clear message.
+
+    Args:
+        data: Dictionary with senderClientNo.
+    """
+    buffer = bytearray()
+
+    # Message type
+    buffer.append(MSG_CLIENT_VAR_CLEAR)
+
+    # Sender client number (2 bytes)
+    buffer.extend(struct.pack("<H", data.get("senderClientNo", 0)))
 
     return bytes(buffer)
 
@@ -790,7 +805,6 @@ def serialize_client_var_sync(data: dict[str, Any]) -> bytes:
         for var in variables:
             _pack_string(buffer, var.get("name", "")[:64])
             _pack_string(buffer, var.get("value", "")[:1024], use_ushort=True)
-            buffer.extend(struct.pack("<d", var.get("timestamp", 0.0)))
             buffer.extend(struct.pack("<H", var.get("lastWriterClientNo", 0)))
 
     return bytes(buffer)
@@ -811,10 +825,7 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
     offset += 1
 
     # Validate message type is within valid range
-    if (
-        message_type < MSG_CLIENT_TRANSFORM
-        or message_type > MSG_OBJECT_OWNERSHIP_REJECTED
-    ):
+    if message_type < MSG_CLIENT_TRANSFORM or message_type > MSG_CLIENT_VAR_CLEAR:
         # Return invalid message type with None data instead of raising exception
         return message_type, None, b""
 
@@ -843,6 +854,8 @@ def deserialize(data: bytes) -> tuple[int, dict[str, Any] | None, bytes]:
             return message_type, _deserialize_client_var_set(data, offset), b""
         elif message_type == MSG_CLIENT_VAR_SYNC:
             return message_type, _deserialize_client_var_sync(data, offset), b""
+        elif message_type == MSG_CLIENT_VAR_CLEAR:
+            return message_type, _deserialize_client_var_clear(data, offset), b""
         elif message_type == MSG_OBJECT_POSE:
             return message_type, _deserialize_object_pose(data, offset), b""
         elif message_type == MSG_ROOM_OBJECTS:
@@ -897,15 +910,11 @@ def _deserialize_client_body(data: bytes, offset: int) -> tuple[dict[str, Any],
     moving_floor_local = bool(flags & POSE_FLAG_MOVING_FLOOR_LOCAL)
 
     physical = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, True)
-    head = _create_transform_dict(
-        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
-    )
+    head = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local)
     right = _create_transform_dict(
         0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
     )
-    left = _create_transform_dict(
-        0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local
-    )
+    left = _create_transform_dict(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, moving_floor_local)
 
     head_pos = (0.0, 0.0, 0.0)
     head_rot = (0.0, 0.0, 0.0, 1.0)
@@ -1231,10 +1240,6 @@ def _deserialize_global_var_set(data: bytes, offset: int) -> dict[str, Any]:
     # Variable value
     result["variableValue"], offset = _unpack_string(data, offset, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    result["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-    offset += 8
-
     return result
 
 
@@ -1251,8 +1256,6 @@ def _deserialize_global_var_sync(data: bytes, offset: int) -> dict[str, Any]:
         var = {}
         var["name"], offset = _unpack_string(data, offset)
         var["value"], offset = _unpack_string(data, offset, use_ushort=True)
-        var["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-        offset += 8
         var["lastWriterClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
         offset += 2
         result["variables"].append(var)
@@ -1278,9 +1281,15 @@ def _deserialize_client_var_set(data: bytes, offset: int) -> dict[str, Any]:
     # Variable value
     result["variableValue"], offset = _unpack_string(data, offset, use_ushort=True)
 
-    # Timestamp (8 bytes double)
-    result["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-    offset += 8
+    return result
+
+
+def _deserialize_client_var_clear(data: bytes, offset: int) -> dict[str, Any]:
+    """Deserialize client variable clear message."""
+    result: dict[str, Any] = {}
+
+    # Sender client number (2 bytes)
+    result["senderClientNo"] = struct.unpack("<H", data[offset : offset + 2])[0]
 
     return result
 
@@ -1306,8 +1315,6 @@ def _deserialize_client_var_sync(data: bytes, offset: int) -> dict[str, Any]:
             var = {}
             var["name"], offset = _unpack_string(data, offset)
             var["value"], offset = _unpack_string(data, offset, use_ushort=True)
-            var["timestamp"] = struct.unpack("<d", data[offset : offset + 8])[0]
-            offset += 8
             var["lastWriterClientNo"] = struct.unpack("<H", data[offset : offset + 2])[
                 0
             ]

{styly_netsync_server-0.12.0 → styly_netsync_server-0.14.0}/src/styly_netsync/client.py

@@ -1027,7 +1027,11 @@ class net_sync_manager:
             logger.error(f"Error processing global var sync: {e}")
 
     def _process_client_var_sync(self, msg_data: dict[str, Any]) -> None:
-        """Process client variable sync."""
+        """Process client variable sync.
+
+        Each included client number is a full authoritative snapshot. Missing
+        keys are removed from the local cache for that client.
+        """
         try:
             client_variables = msg_data.get("clientVariables", {})
 
@@ -1037,34 +1041,50 @@ class net_sync_manager:
                 except ValueError:
                     continue
 
-                if client_no not in self._client_variables:
-                    self._client_variables[client_no] = {}
+                old_vars = self._client_variables.get(client_no, {})
+                new_vars: dict[str, str] = {}
 
                 for var in variables:
                     name = var.get("name", "")
                     value = var.get("value", "")
-                    old_value = self._client_variables[client_no].get(name)
+                    if name:
+                        new_vars[name] = value
 
-                    self._client_variables[client_no][name] = value
+                changed_events: list[tuple[int, str, str | None, str | None]] = []
+                for name in set(old_vars) - set(new_vars):
+                    changed_events.append((client_no, name, old_vars.get(name), None))
 
+                for name, value in new_vars.items():
+                    old_value = old_vars.get(name)
                     if old_value != value:
-                        with self._lock:
-                            self._stats["nv_updates"] += 1
+                        changed_events.append((client_no, name, old_value, value))
 
-                        event = ("client", client_no, name, old_value, value)
-                        if self._auto_dispatch:
-                            self.on_client_variable_changed.invoke(
-                                client_no, name, old_value, value
-                            )
-                        else:
+                self._client_variables[client_no] = new_vars
+
+                for event_client_no, name, old_value, new_value in changed_events:
+                    with self._lock:
+                        self._stats["nv_updates"] += 1
+
+                    event: tuple[str, int, str, str | None, str | None] = (
+                        "client",
+                        event_client_no,
+                        name,
+                        old_value,
+                        new_value,
+                    )
+                    if self._auto_dispatch:
+                        self.on_client_variable_changed.invoke(
+                            event_client_no, name, old_value, new_value
+                        )
+                    else:
+                        try:
+                            self._nv_queue.put_nowait(event)
+                        except Full:
                             try:
+                                self._nv_queue.get_nowait()
                                 self._nv_queue.put_nowait(event)
-                            except Full:
-                                try:
-                                    self._nv_queue.get_nowait()
-                                    self._nv_queue.put_nowait(event)
-                                except Empty:
-                                    pass
+                            except Empty:
+                                pass
 
         except Exception as e:
             logger.error(f"Error processing client var sync: {e}")
@@ -1202,7 +1222,6 @@ class net_sync_manager:
                 "senderClientNo": self._client_no,
                 "variableName": name,
                 "variableValue": value,
-                "timestamp": time.time(),
             }
             message = binary_serializer.serialize_global_var_set(var_data)
             return self._enqueue_control(
@@ -1224,7 +1243,6 @@ class net_sync_manager:
                 "targetClientNo": target_client_no,
                 "variableName": name,
                 "variableValue": value,
-                "timestamp": time.time(),
             }
             message = binary_serializer.serialize_client_var_set(var_data)
             return self._enqueue_control(
@@ -1235,6 +1253,27 @@ class net_sync_manager:
             logger.error(f"Error queueing client variable: {e}")
             return False
 
+    def clear_my_client_variables(self) -> bool:
+        """Queue a request to clear this client's variables on the server."""
+        if not self._running or not self._dealer_socket or self._client_no is None:
+            return False
+
+        try:
+            clear_data = {
+                "senderClientNo": self._client_no,
+            }
+            message = binary_serializer.serialize_client_var_clear(clear_data)
+            sent = self._enqueue_control(
+                self._room, message, msg_type="client_variable_clear"
+            )
+            if sent:
+                self._clear_local_client_variables(self._client_no)
+            return sent
+
+        except Exception as e:
+            logger.error(f"Error queueing client variable clear: {e}")
+            return False
+
     def _enqueue_control(
         self, room_id: str, payload: bytes, msg_type: str = "control"
     ) -> bool:
@@ -1294,6 +1333,34 @@ class net_sync_manager:
         """Return a copy of all variables for the given client."""
         return self._client_variables.get(client_no, {}).copy()
 
+    def _clear_local_client_variables(self, client_no: int) -> None:
+        """Clear local client-variable cache for a client and emit events."""
+        old_vars = self._client_variables.get(client_no, {}).copy()
+        self._client_variables[client_no] = {}
+
+        for name, old_value in old_vars.items():
+            with self._lock:
+                self._stats["nv_updates"] += 1
+
+            event: tuple[str, int, str, str | None, str | None] = (
+                "client",
+                client_no,
+                name,
+                old_value,
+                None,
+            )
+            if self._auto_dispatch:
+                self.on_client_variable_changed.invoke(client_no, name, old_value, None)
+            else:
+                try:
+                    self._nv_queue.put_nowait(event)
+                except Full:
+                    try:
+                        self._nv_queue.get_nowait()
+                        self._nv_queue.put_nowait(event)
+                    except Empty:
+                        pass
+
     def is_client_stealth_mode(self, client_no: int) -> bool:
         """Check if the client is in stealth mode."""
         return self._client_stealth_flags.get(client_no, False)

{styly_netsync_server-0.12.0 → styly_netsync_server-0.14.0}/src/styly_netsync/client_simulator.py

@@ -46,6 +46,7 @@ import zmq
 # Import public APIs from styly_netsync module
 from styly_netsync.binary_serializer import (
     MSG_CLIENT_POSE,
+    MSG_CLIENT_VAR_CLEAR,
     MSG_CLIENT_VAR_SET,
     MSG_CLIENT_VAR_SYNC,
     MSG_DEVICE_ID_MAPPING,
@@ -95,6 +96,7 @@ MESSAGE_TYPE_NAMES: dict[int, str] = {
     MSG_GLOBAL_VAR_SYNC: "GLOBAL_VAR_SYNC",
     MSG_CLIENT_VAR_SET: "CLIENT_VAR_SET",
     MSG_CLIENT_VAR_SYNC: "CLIENT_VAR_SYNC",
+    MSG_CLIENT_VAR_CLEAR: "CLIENT_VAR_CLEAR",
     MSG_OBJECT_POSE: "OBJECT_POSE",
     MSG_ROOM_OBJECTS: "ROOM_OBJECTS",
     MSG_OBJECT_OWNERSHIP_REQUEST: "OBJECT_OWNERSHIP_REQUEST",
@@ -646,7 +648,6 @@ class NetworkTransport:
                 "targetClientNo": sender_client_no,  # Set variable for ourselves
                 "variableName": var_name,
                 "variableValue": value,
-                "timestamp": time.time(),
             }
             binary_data = serialize_client_var_set(var_data)
             self.socket.send_multipart(

{styly_netsync_server-0.12.0 → styly_netsync_server-0.14.0}/src/styly_netsync/rest_bridge.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import threading
 import time
-from typing import TYPE_CHECKING, Annotated
+from typing import TYPE_CHECKING, Annotated, Protocol
 
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
@@ -18,7 +18,6 @@ logger = logging.getLogger(__name__)
 
 MAX_NAME = 64
 MAX_VALUE = 1024
-MAX_CLIENT_VARS = 20
 MAX_GLOBAL_VARS = 100
 
 # Constrained string types for variable names and values
@@ -32,45 +31,26 @@ class UpsertBody(BaseModel):
     variables: dict[VarName, VarValue] = Field(default_factory=dict)
 
 
-class PreseedStore:
-    """In-memory storage for queued device variables."""
+class ClientVariableServer(Protocol):
+    """Server-side operations used by REST client-variable endpoints."""
 
-    def __init__(self) -> None:
-        self._data: dict[tuple[str, str], dict[str, str]] = {}
-        self._lock = threading.RLock()
-
-    def upsert(
-        self, room_id: str, device_id: str, kvs: dict[str, str]
-    ) -> dict[str, str]:
-        """Merge incoming key-values for a device within a room."""
-        with self._lock:
-            key = (room_id, device_id)
-            current = self._data.get(key, {})
-            new_keys = [name for name in kvs if name not in current]
-            if len(current) + len(new_keys) > MAX_CLIENT_VARS:
-                raise ValueError(
-                    f"Too many client variables (> {MAX_CLIENT_VARS}) for device {device_id}"
-                )
-            current.update(kvs)
-            self._data[key] = current
-            return dict(current)
-
-    def get(self, room_id: str, device_id: str) -> dict[str, str]:
-        """Return a copy of stored variables for a device."""
-        with self._lock:
-            return dict(self._data.get((room_id, device_id), {}))
-
-    def all_for_room(self, room_id: str) -> dict[str, dict[str, str]]:
-        """Return all stored variables for the given room."""
-        with self._lock:
-            result: dict[str, dict[str, str]] = {}
-            for (stored_room, device_id), variables in self._data.items():
-                if stored_room == room_id:
-                    result[device_id] = dict(variables)
-            return result
+    def upsert_client_variables_for_device(
+        self, room_id: str, device_id: str, variables: dict[str, str]
+    ) -> tuple[int | None, dict[str, str]]:
+        """Upsert client variables and return mapping plus per-key states."""
+        ...
 
+    def get_client_variables_for_device(
+        self, room_id: str, device_id: str
+    ) -> tuple[int | None, dict[str, str]]:
+        """Return the mapped client number and current variables."""
+        ...
 
-store = PreseedStore()
+    def delete_client_variables_for_device(
+        self, room_id: str, device_id: str, name: str | None = None
+    ) -> tuple[int | None, int]:
+        """Delete client variables and return mapping plus deletion count."""
+        ...
 
 
 class GlobalVarStore:
@@ -157,7 +137,6 @@ class RoomBridge:
                         next_handshake_at = now + 0.5
                 else:
                     try:
-                        self.flush_all_known_mappings()
                         self.flush_global_vars()
                     except Exception as exc:
                         logger.debug("Flush failed: %s", exc)
@@ -261,14 +240,6 @@ class RoomBridge:
                     applied.add(name)
         return applied
 
-    def flush_all_known_mappings(self) -> None:
-        """Flush queued variables for devices whose client numbers are known."""
-        pending = store.all_for_room(self.room_id)
-        for device_id, kvs in pending.items():
-            client_no = self.get_client_no(device_id)
-            if client_no:
-                self._apply_to_client(client_no, kvs)
-
     def flush_global_vars(self) -> None:
         """Flush queued global variables for this room."""
         pending = global_store.pop(self.room_id)
@@ -304,7 +275,12 @@ class BridgeManager:
             return bridge
 
 
-def create_app(server_addr: str, dealer_port: int, sub_port: int) -> FastAPI:
+def create_app(
+    server_addr: str,
+    dealer_port: int,
+    sub_port: int,
+    server: ClientVariableServer | None = None,
+) -> FastAPI:
     """Create the FastAPI application hosting the REST bridge."""
     app = FastAPI(title="NetSync REST Bridge", version="1.0.0")
 
@@ -329,14 +305,17 @@ def create_app(server_addr: str, dealer_port: int, sub_port: int) -> FastAPI:
     def upsert(room_id: str, device_id: str, body: UpsertBody) -> dict[str, object]:
         if not body.variables:
             raise HTTPException(status_code=400, detail="variables must not be empty")
-        try:
-            store.upsert(room_id, device_id, body.variables)
-        except ValueError as exc:
-            raise HTTPException(status_code=409, detail=str(exc)) from exc
-
-        bridge = manager.get(room_id)
-        statuses = bridge.apply_now_or_queue(device_id, body.variables)
-        client_no = bridge.get_client_no(device_id)
+        if server is not None:
+            try:
+                client_no, statuses = server.upsert_client_variables_for_device(
+                    room_id, device_id, body.variables
+                )
+            except ValueError as exc:
+                raise HTTPException(status_code=409, detail=str(exc)) from exc
+        else:
+            bridge = manager.get(room_id)
+            statuses = bridge.apply_now_or_queue(device_id, body.variables)
+            client_no = bridge.get_client_no(device_id)
 
         return {
             "roomId": room_id,
@@ -387,21 +366,26 @@ def create_app(server_addr: str, dealer_port: int, sub_port: int) -> FastAPI:
 
     @app.get("/v1/rooms/{room_id}/devices/{device_id}/client-variables")
     def get_client_variables(room_id: str, device_id: str) -> dict[str, object]:
-        bridge = manager.get(room_id)
-        client_no, variables = bridge.get_client_variables(device_id)
+        if server is not None:
+            client_no, variables = server.get_client_variables_for_device(
+                room_id, device_id
+            )
+        else:
+            bridge = manager.get(room_id)
+            client_no, variables = bridge.get_client_variables(device_id)
         return {"clientNo": client_no, "variables": variables}
 
     @app.get("/v1/rooms/{room_id}/devices/{device_id}/client-variables/{name}")
     def get_client_variable(
         room_id: str, device_id: str, name: VarName
     ) -> dict[str, object]:
-        bridge = manager.get(room_id)
-        client_no, variables = bridge.get_client_variables(device_id)
-        if client_no is None:
-            raise HTTPException(
-                status_code=404,
-                detail=f"Device '{device_id}' has no client mapping",
+        if server is not None:
+            client_no, variables = server.get_client_variables_for_device(
+                room_id, device_id
             )
+        else:
+            bridge = manager.get(room_id)
+            client_no, variables = bridge.get_client_variables(device_id)
         if name not in variables:
             raise HTTPException(
                 status_code=404,
@@ -409,6 +393,32 @@ def create_app(server_addr: str, dealer_port: int, sub_port: int) -> FastAPI:
             )
         return {"clientNo": client_no, "value": variables[name]}
 
+    @app.delete("/v1/rooms/{room_id}/devices/{device_id}/client-variables")
+    def delete_client_variables(room_id: str, device_id: str) -> dict[str, object]:
+        if server is None:
+            raise HTTPException(
+                status_code=501,
+                detail="Client variable deletion requires an injected server",
+            )
+        client_no, deleted_count = server.delete_client_variables_for_device(
+            room_id, device_id
+        )
+        return {"clientNo": client_no, "deletedCount": deleted_count}
+
+    @app.delete("/v1/rooms/{room_id}/devices/{device_id}/client-variables/{name}")
+    def delete_client_variable(
+        room_id: str, device_id: str, name: VarName
+    ) -> dict[str, object]:
+        if server is None:
+            raise HTTPException(
+                status_code=501,
+                detail="Client variable deletion requires an injected server",
+            )
+        client_no, deleted_count = server.delete_client_variables_for_device(
+            room_id, device_id, name
+        )
+        return {"clientNo": client_no, "deletedCount": deleted_count}
+
     return app