rocket-welder-sdk 1.1.43__py3-none-any.whl → 1.1.45__py3-none-any.whl

rocket_welder_sdk/transport/frame_source.py

@@ -10,7 +10,7 @@ class IFrameSource(ABC):
 
     Transport-agnostic interface that handles the question: "where do frames come from?"
     This abstraction decouples protocol logic (KeyPoints, SegmentationResults) from
-    transport mechanisms (File, TCP, WebSocket, NNG). Each frame is read atomically.
+    transport mechanisms (File, TCP, WebSocket, Unix Socket). Each frame is read atomically.
     """
 
     @abstractmethod
@@ -40,7 +40,7 @@ class IFrameSource(ABC):
         Check if more frames are available.
 
         For streaming transports (file), this checks for EOF.
-        For message-based transports (NNG), this may always return True until disconnection.
+        For message-based transports, this may always return True until disconnection.
 
         Returns:
             True if more frames are available, False otherwise

rocket_welder_sdk/transport/websocket_transport.py

@@ -0,0 +1,316 @@
+"""
+WebSocket transport for reading/writing frames.
+Matches C# WebSocketFrameSink and WebSocketFrameSource from RocketWelder.SDK.Transport.
+
+Uses the websockets library for async WebSocket support.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Optional, Protocol
+
+from .frame_sink import IFrameSink
+from .frame_source import IFrameSource
+
+
+class WebSocketProtocol(Protocol):
+    """Protocol for WebSocket-like objects (for type checking)."""
+
+    @property
+    def closed(self) -> bool: ...
+
+    @property
+    def state(self) -> Any: ...
+
+    async def send(self, message: bytes) -> None: ...
+
+    async def recv(self) -> bytes: ...
+
+    async def close(self) -> None: ...
+
+
+class WebSocketFrameSink(IFrameSink):
+    """
+    Frame sink that writes to a WebSocket connection.
+
+    Each frame is sent as a single binary WebSocket message.
+
+    Attributes:
+        leave_open: If True, doesn't close WebSocket on disposal
+    """
+
+    __slots__ = ("_closed", "_leave_open", "_websocket")
+
+    def __init__(self, websocket: WebSocketProtocol, leave_open: bool = False) -> None:
+        """
+        Create a WebSocket frame sink.
+
+        Args:
+            websocket: WebSocket connection to write to
+            leave_open: If True, doesn't close WebSocket on disposal
+        """
+        if websocket is None:
+            raise ValueError("websocket cannot be None")
+        self._websocket = websocket
+        self._leave_open = leave_open
+        self._closed = False
+
+    def write_frame(self, frame_data: bytes) -> None:
+        """
+        Write a complete frame to the WebSocket synchronously.
+
+        Note: WebSocket is inherently async, so this runs the async
+        version in a new event loop. Prefer write_frame_async for better performance.
+
+        Args:
+            frame_data: Complete frame data to write
+
+        Raises:
+            RuntimeError: If sink is closed or WebSocket is not open
+        """
+        if self._closed:
+            raise RuntimeError("WebSocketFrameSink is closed")
+
+        # Use asyncio.run for simplicity (creates new event loop)
+        try:
+            loop = asyncio.get_running_loop()
+            # If we're already in an async context, use run_coroutine_threadsafe
+            future = asyncio.run_coroutine_threadsafe(self.write_frame_async(frame_data), loop)
+            future.result()
+        except RuntimeError:
+            # No running event loop, create a new one
+            asyncio.run(self.write_frame_async(frame_data))
+
+    async def write_frame_async(self, frame_data: bytes) -> None:
+        """
+        Write a complete frame to the WebSocket asynchronously.
+
+        Args:
+            frame_data: Complete frame data to write
+
+        Raises:
+            RuntimeError: If sink is closed or WebSocket is not open
+        """
+        if self._closed:
+            raise RuntimeError("WebSocketFrameSink is closed")
+
+        if self._websocket.closed:
+            raise RuntimeError(f"WebSocket is not open: {self._websocket.state.name}")
+
+        # Send as single binary message
+        await self._websocket.send(frame_data)
+
+    def flush(self) -> None:
+        """
+        Flush any buffered data.
+
+        WebSocket sends immediately, so this is a no-op.
+        """
+        pass
+
+    async def flush_async(self) -> None:
+        """
+        Flush any buffered data asynchronously.
+
+        WebSocket sends immediately, so this is a no-op.
+        """
+        pass
+
+    def close(self) -> None:
+        """Close the sink and release resources."""
+        if self._closed:
+            return
+        self._closed = True
+
+        if not self._leave_open and not self._websocket.closed:
+            try:
+                loop = asyncio.get_running_loop()
+                future = asyncio.run_coroutine_threadsafe(self.close_async(), loop)
+                future.result()
+            except RuntimeError:
+                asyncio.run(self._close_websocket())
+
+    async def close_async(self) -> None:
+        """Close the sink and release resources asynchronously."""
+        if self._closed:
+            return
+        self._closed = True
+
+        await self._close_websocket()
+
+    async def _close_websocket(self) -> None:
+        """Internal async close helper."""
+        if not self._leave_open and not self._websocket.closed:
+            try:  # noqa: SIM105
+                await self._websocket.close()
+            except Exception:
+                # Best effort close
+                pass
+
+
+class WebSocketFrameSource(IFrameSource):
+    """
+    Frame source that reads from a WebSocket connection.
+
+    Each WebSocket binary message is treated as a complete frame.
+
+    Attributes:
+        leave_open: If True, doesn't close WebSocket on disposal
+    """
+
+    __slots__ = ("_closed", "_leave_open", "_websocket")
+
+    def __init__(self, websocket: WebSocketProtocol, leave_open: bool = False) -> None:
+        """
+        Create a WebSocket frame source.
+
+        Args:
+            websocket: WebSocket connection to read from
+            leave_open: If True, doesn't close WebSocket on disposal
+        """
+        if websocket is None:
+            raise ValueError("websocket cannot be None")
+        self._websocket = websocket
+        self._leave_open = leave_open
+        self._closed = False
+
+    @property
+    def has_more_frames(self) -> bool:
+        """
+        Check if more frames are available.
+
+        Returns True if the WebSocket is open or in CloseSent state.
+        """
+        return not self._websocket.closed
+
+    def read_frame(self) -> Optional[bytes]:
+        """
+        Read a complete frame from the WebSocket synchronously.
+
+        Note: WebSocket is inherently async, so this runs the async
+        version. Prefer read_frame_async for better performance.
+
+        Returns:
+            Complete frame data, or None if connection closed
+
+        Raises:
+            RuntimeError: If source is closed
+        """
+        if self._closed:
+            raise RuntimeError("WebSocketFrameSource is closed")
+
+        try:
+            loop = asyncio.get_running_loop()
+            future = asyncio.run_coroutine_threadsafe(self.read_frame_async(), loop)
+            return future.result()
+        except RuntimeError:
+            return asyncio.run(self.read_frame_async())
+
+    async def read_frame_async(self) -> Optional[bytes]:
+        """
+        Read a complete frame from the WebSocket asynchronously.
+
+        Returns:
+            Complete frame data, or None if connection closed
+
+        Raises:
+            RuntimeError: If source is closed
+            ValueError: If received non-binary message
+        """
+        if self._closed:
+            raise RuntimeError("WebSocketFrameSource is closed")
+
+        if not self.has_more_frames:
+            return None
+
+        try:
+            # websockets library handles message framing automatically
+            message = await self._websocket.recv()
+
+            # Ensure we got binary data
+            if isinstance(message, str):
+                raise ValueError("Expected binary message, got text")
+
+            return message
+
+        except Exception:
+            # Connection closed or error
+            return None
+
+    def close(self) -> None:
+        """Close the source and release resources."""
+        if self._closed:
+            return
+        self._closed = True
+
+        if not self._leave_open and not self._websocket.closed:
+            try:
+                loop = asyncio.get_running_loop()
+                future = asyncio.run_coroutine_threadsafe(self.close_async(), loop)
+                future.result()
+            except RuntimeError:
+                asyncio.run(self._close_websocket())
+
+    async def close_async(self) -> None:
+        """Close the source and release resources asynchronously."""
+        if self._closed:
+            return
+        self._closed = True
+
+        await self._close_websocket()
+
+    async def _close_websocket(self) -> None:
+        """Internal async close helper."""
+        if not self._leave_open and not self._websocket.closed:
+            try:  # noqa: SIM105
+                await self._websocket.close()
+            except Exception:
+                # Best effort close
+                pass
+
+
+async def connect_websocket_sink(url: str, leave_open: bool = False) -> WebSocketFrameSink:
+    """
+    Connect to a WebSocket server and return a frame sink.
+
+    Args:
+        url: WebSocket URL (ws:// or wss://)
+        leave_open: If True, doesn't close WebSocket on disposal
+
+    Returns:
+        Connected WebSocketFrameSink
+    """
+    try:
+        import websockets
+    except ImportError as e:
+        raise ImportError(
+            "websockets package is required for WebSocket transport. "
+            "Install with: pip install websockets"
+        ) from e
+
+    websocket = await websockets.connect(url)
+    return WebSocketFrameSink(websocket, leave_open)
+
+
+async def connect_websocket_source(url: str, leave_open: bool = False) -> WebSocketFrameSource:
+    """
+    Connect to a WebSocket server and return a frame source.
+
+    Args:
+        url: WebSocket URL (ws:// or wss://)
+        leave_open: If True, doesn't close WebSocket on disposal
+
+    Returns:
+        Connected WebSocketFrameSource
+    """
+    try:
+        import websockets
+    except ImportError as e:
+        raise ImportError(
+            "websockets package is required for WebSocket transport. "
+            "Install with: pip install websockets"
+        ) from e
+
+    websocket = await websockets.connect(url)
+    return WebSocketFrameSource(websocket, leave_open)

rocket_welder_sdk/varint.py

@@ -0,0 +1,213 @@
+"""
+Core varint and ZigZag encoding/decoding algorithms.
+Matches C# Varint static class from RocketWelder.SDK.Protocols.
+
+Single source of truth for all varint operations in the SDK.
+Compatible with Protocol Buffers varint encoding.
+
+Varint encoding uses 7 bits per byte with MSB as continuation flag.
+ZigZag encoding maps signed integers to unsigned for efficient varint encoding
+of values near zero (both positive and negative).
+"""
+
+from __future__ import annotations
+
+from typing import Tuple
+
+# Maximum bytes needed for a uint32 varint
+MAX_BYTES_UINT32 = 5
+
+
+def zigzag_encode(value: int) -> int:
+    """
+    ZigZag encode a signed integer to unsigned.
+
+    Maps negative numbers to odd positives: 0->0, -1->1, 1->2, -2->3, 2->4, etc.
+    This allows efficient varint encoding of signed values near zero.
+
+    Args:
+        value: Signed integer to encode
+
+    Returns:
+        Unsigned integer (ZigZag encoded)
+    """
+    return (value << 1) ^ (value >> 31)
+
+
+def zigzag_decode(value: int) -> int:
+    """
+    ZigZag decode an unsigned integer to signed.
+
+    Reverses the ZigZag encoding: 0->0, 1->-1, 2->1, 3->-2, 4->2, etc.
+
+    Args:
+        value: Unsigned integer (ZigZag encoded)
+
+    Returns:
+        Signed integer (decoded)
+    """
+    return (value >> 1) ^ -(value & 1)
+
+
+def get_byte_count(value: int) -> int:
+    """
+    Calculate the number of bytes needed to encode a value as varint.
+
+    Args:
+        value: Unsigned integer value
+
+    Returns:
+        Number of bytes needed (1-5)
+    """
+    if value < 0x80:
+        return 1
+    if value < 0x4000:
+        return 2
+    if value < 0x200000:
+        return 3
+    if value < 0x10000000:
+        return 4
+    return 5
+
+
+def write_varint(buffer: bytearray, offset: int, value: int) -> int:
+    """
+    Write a varint to a buffer at the given offset.
+
+    Args:
+        buffer: Destination buffer (must have at least 5 bytes from offset)
+        offset: Starting offset in buffer
+        value: Unsigned value to encode
+
+    Returns:
+        Number of bytes written (1-5)
+    """
+    i = 0
+    while value >= 0x80:
+        buffer[offset + i] = (value & 0x7F) | 0x80
+        value >>= 7
+        i += 1
+    buffer[offset + i] = value
+    return i + 1
+
+
+def write_zigzag(buffer: bytearray, offset: int, value: int) -> int:
+    """
+    Write a ZigZag-encoded signed integer as varint.
+
+    Args:
+        buffer: Destination buffer (must have at least 5 bytes from offset)
+        offset: Starting offset in buffer
+        value: Signed value to encode
+
+    Returns:
+        Number of bytes written (1-5)
+    """
+    return write_varint(buffer, offset, zigzag_encode(value))
+
+
+def read_varint(data: bytes, offset: int) -> Tuple[int, int]:
+    """
+    Read a varint from bytes at the given offset.
+
+    Args:
+        data: Source buffer
+        offset: Starting offset in buffer
+
+    Returns:
+        Tuple of (decoded_value, bytes_read)
+
+    Raises:
+        EOFError: If buffer ends before varint completes
+        ValueError: If varint is malformed (too long)
+    """
+    result = 0
+    shift = 0
+    i = 0
+
+    while True:
+        if offset + i >= len(data):
+            raise EOFError("Unexpected end of varint")
+
+        b = data[offset + i]
+        result |= (b & 0x7F) << shift
+        i += 1
+
+        if (b & 0x80) == 0:
+            break
+
+        shift += 7
+        if shift >= 35:
+            raise ValueError("Varint too long (corrupted data)")
+
+    return result, i
+
+
+def read_zigzag(data: bytes, offset: int) -> Tuple[int, int]:
+    """
+    Read a ZigZag-encoded signed integer.
+
+    Args:
+        data: Source buffer
+        offset: Starting offset in buffer
+
+    Returns:
+        Tuple of (decoded_signed_value, bytes_read)
+    """
+    encoded, bytes_read = read_varint(data, offset)
+    return zigzag_decode(encoded), bytes_read
+
+
+def try_read_varint(data: bytes, offset: int) -> Tuple[bool, int, int]:
+    """
+    Try to read a varint, returning False if not enough data.
+
+    Args:
+        data: Source buffer
+        offset: Starting offset in buffer
+
+    Returns:
+        Tuple of (success, value, bytes_read)
+        If success is False, value and bytes_read are 0
+    """
+    result = 0
+    shift = 0
+
+    for i in range(min(5, len(data) - offset)):
+        b = data[offset + i]
+        result |= (b & 0x7F) << shift
+
+        if (b & 0x80) == 0:
+            return True, result, i + 1
+
+        shift += 7
+
+    return False, 0, 0
+
+
+def encode_varint(value: int) -> bytes:
+    """
+    Convenience function to encode a value to varint bytes.
+
+    Args:
+        value: Unsigned value to encode
+
+    Returns:
+        Bytes containing the varint encoding
+    """
+    buffer = bytearray(MAX_BYTES_UINT32)
+    length = write_varint(buffer, 0, value)
+    return bytes(buffer[:length])
+
+
+def encode_zigzag(value: int) -> bytes:
+    """
+    Convenience function to encode a signed value to ZigZag varint bytes.
+
+    Args:
+        value: Signed value to encode
+
+    Returns:
+        Bytes containing the ZigZag varint encoding
+    """
+    return encode_varint(zigzag_encode(value))

{rocket_welder_sdk-1.1.43.dist-info → rocket_welder_sdk-1.1.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rocket-welder-sdk
-Version: 1.1.43
+Version: 1.1.45
 Summary: High-performance video streaming SDK for RocketWelder services using ZeroBuffer IPC
 Home-page: https://github.com/modelingevolution/rocket-welder-sdk
 Author: ModelingEvolution
@@ -32,8 +32,6 @@ Requires-Dist: zerobuffer-ipc>=1.1.17
 Requires-Dist: pydantic>=2.5.0
 Requires-Dist: py-micro-plumberd>=0.1.8
 Requires-Dist: typing-extensions>=4.0.0
-Provides-Extra: nng
-Requires-Dist: pynng>=0.7.2; extra == "nng"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -42,7 +40,6 @@ Requires-Dist: black>=22.0; extra == "dev"
 Requires-Dist: mypy>=1.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: types-setuptools; extra == "dev"
-Requires-Dist: pynng>=0.7.2; extra == "dev"
 Dynamic: author
 Dynamic: home-page
 Dynamic: requires-python

rocket_welder_sdk-1.1.45.dist-info/RECORD

@@ -0,0 +1,51 @@
+rocket_welder_sdk/__init__.py,sha256=5hcsNb0zu8dtRHD9sgCAi4YbWJe-1g6cl9jSuLQZk_U,3889
+rocket_welder_sdk/binary_frame_reader.py,sha256=5IyYO7yv07gLpQ9Toyw1zLkTrnqHLjxIeMVRn8B40-E,6270
+rocket_welder_sdk/binary_frame_writer.py,sha256=2-VEJNHw0fL30TXsCBHyhHltvgx7KUahmbamwdSU8sw,6658
+rocket_welder_sdk/bytes_size.py,sha256=Myl29-wyWCIYdbMmgaxXebT8Dz8_Fwcr3fnfaNW81P0,7463
+rocket_welder_sdk/confidence.py,sha256=AlgVM7gNDff3UxcQHhA5sJlTb4VeOMFAraF3W59AeSI,6498
+rocket_welder_sdk/connection_string.py,sha256=NIC6OiOXF-DeBFCWzgMFOWsenrSS45hY81j_HLMSpgo,9974
+rocket_welder_sdk/controllers.py,sha256=uuVyKsNHtpaIzQt8pXCAu7SywoFa7cfww8VSa4LNi_E,33130
+rocket_welder_sdk/delta_frame.py,sha256=51RFWI2odKVak-d3qhv7S8DiXbk4M5f-bbuTT1unXfk,4518
+rocket_welder_sdk/frame_metadata.py,sha256=TMLIY47cIdIlxqk9xj7I3M8FZFmZ3GcVoLZht7prjQM,3929
+rocket_welder_sdk/gst_metadata.py,sha256=6Ov-DekGsKNuAo3UIc-g9fh4_SAPdHYQTnnPqCK3Ks0,16180
+rocket_welder_sdk/keypoints_protocol.py,sha256=kN8ok6Ptpgl4txoQE9DpKhMoI7zr73vTw9CTvCICtgE,36921
+rocket_welder_sdk/opencv_controller.py,sha256=MDM6_yFBB9BaMa5jnZRqw7xZZB-WuLr7EPrrfHQ2DK4,9905
+rocket_welder_sdk/periodic_timer.py,sha256=hnObybmrnf3J47QrNKJhYAytLKwria016123NvPRfQ0,9369
+rocket_welder_sdk/py.typed,sha256=0cXFZXmes4Y-vnl4lO3HtyyyWaFNw85B7tJdFeCtHDc,67
+rocket_welder_sdk/rocket_welder_client.py,sha256=iSyMiIx_5GgL5VI3W4G6o7JlG3A9G8JDlsTwLhQApVU,28609
+rocket_welder_sdk/segmentation_result.py,sha256=b3xpv6AZyWzm924cd1RfXwCuEwdkPL5TUA0gzT3HpBA,29153
+rocket_welder_sdk/session_id.py,sha256=YgnDwmdOcdJTXIObjkrzIkxU2gbMzNko1h1ms4lNIfU,1928
+rocket_welder_sdk/varint.py,sha256=SmffemQCXToRzs3lb7hWQWDY7NmKv4XG_Wb0oeMrb_I,5058
+rocket_welder_sdk/external_controls/__init__.py,sha256=ldOLGhLLS5BQL8m4VKFYV0SvsNNlV2tghlc7rkqadU8,699
+rocket_welder_sdk/external_controls/contracts.py,sha256=3DU6pdpteN50gF2fsS7C2279dGjDa0tZLrLntkBa2LM,2607
+rocket_welder_sdk/external_controls/contracts_old.py,sha256=XWriuXJZu5caTSS0bcTIOZcKnj-IRCm96voA4gqLBfU,2980
+rocket_welder_sdk/graphics/__init__.py,sha256=4sKaqeu391WfVX1c_TDxAbucy7OJF8Aw8CG77NeggFA,1230
+rocket_welder_sdk/graphics/layer_canvas.py,sha256=FcgrrCaI-2XlVOs4qYTGvpJQdVw_NP2V7D4a1LgLtS4,4580
+rocket_welder_sdk/graphics/protocol.py,sha256=57GOx9rlKGojm7jnXdM2t3bpa4Ykii1o3wQtQ5IO-Hs,1357
+rocket_welder_sdk/graphics/rgb_color.py,sha256=do6y362CTROiLMqbQwdvJF07L8wMWRv3n7-PVWP-Flk,3497
+rocket_welder_sdk/graphics/stage.py,sha256=2hgkKGCxLxcZ64cHBKgxxFHSZOlLue236x5f43cmYk0,15538
+rocket_welder_sdk/graphics/vector_graphics_encoder.py,sha256=lD3cIOAVL_JvKZayIQ_TaQ5fa8S6d9Q45C91PubHMbk,16483
+rocket_welder_sdk/high_level/__init__.py,sha256=OKbI3l0PFo1Cb_v0kbv16Wr05urz8heVGps0dJcTcG4,1507
+rocket_welder_sdk/high_level/client.py,sha256=rVnnrn68PEvc68p5acuOBZfEjobWWed8XcssTRzxNr8,11502
+rocket_welder_sdk/high_level/connection_strings.py,sha256=1Hp72V5qDngHGXyjBRFMckz365BMpGVjb3PMSGvCtow,12531
+rocket_welder_sdk/high_level/data_context.py,sha256=SXJvDpDBFi8Lm4XqSRSHK7YUUHuugXGo4ZRCb6_z5l0,4833
+rocket_welder_sdk/high_level/frame_sink_factory.py,sha256=tLhMV_qnY-ZUtffIzhycM9znNjYguRumba4vphpNx7E,3493
+rocket_welder_sdk/high_level/schema.py,sha256=2Vv0rDwahtGswWB_ceaCdc7JDtmbkx4wE2jQePzeTpU,5367
+rocket_welder_sdk/high_level/transport_protocol.py,sha256=pdl7l1Tu9b7IYb95q6kzDY7-g1fbhSnhdV_gGhLeYzk,2943
+rocket_welder_sdk/transport/__init__.py,sha256=J1iMvmIwC89PO8VZwd-qxKoAoB6BOxEY82aB9wLdB5c,950
+rocket_welder_sdk/transport/frame_sink.py,sha256=--uL0kqxoz10Qya3eKpH6vjbMuSZHP0C9q6uwmbEo38,3332
+rocket_welder_sdk/transport/frame_source.py,sha256=pgWFmqSLoIjGx8vW6Uv5uYCpcC49_iBSVU0oJZHDuPw,2171
+rocket_welder_sdk/transport/stream_transport.py,sha256=FhxFlZT-CTo6aPq6VclM1A_ecqfeHcwR4Ty1vmlt3W0,5886
+rocket_welder_sdk/transport/tcp_transport.py,sha256=Tui6nKgu50C1KV_UDANQKgVK3M52XN7zrkZTcWIpGmY,4745
+rocket_welder_sdk/transport/unix_socket_transport.py,sha256=t44Q2Fj6fMv53Ll561hN35-ZbHPdAQt0t9tUAXoL0rY,12245
+rocket_welder_sdk/transport/websocket_transport.py,sha256=ti-Vr2I90JvgJgRfjqo2PfTYk5B86SYZhNofuxpwdBo,9591
+rocket_welder_sdk/ui/__init__.py,sha256=5-fCkv3vG0VVVZkselrifkMmx8d51EJp3nNT9mt4JK4,886
+rocket_welder_sdk/ui/controls.py,sha256=cRBxdUDWMOYlCxtw1PV11fTlte6qLxSfCGpr9bQiLcE,11162
+rocket_welder_sdk/ui/icons.py,sha256=DcDklZkPmiEzlOD4IR7VTJOtGPCuuh_OM_WN7ScghWE,8934592
+rocket_welder_sdk/ui/ui_events_projection.py,sha256=siiNhjLEBOPfTKw1ZhOPGkwIN5rLDH7V9VCZTNrhEtQ,7836
+rocket_welder_sdk/ui/ui_service.py,sha256=uRdpyJGoCQmtOli_HKSrxLwhZYG-XRuHIYdkmFz1zNk,12026
+rocket_welder_sdk/ui/value_types.py,sha256=f7OA_9zgXEDPoITc8v8SfAR23I4XeFhE3E2_GcAbR6k,1616
+rocket_welder_sdk-1.1.45.dist-info/METADATA,sha256=Kw6yzgaMHhKdQ5iskkBWSXP54zGr1vMpgz0mv_PQsvY,24739
+rocket_welder_sdk-1.1.45.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+rocket_welder_sdk-1.1.45.dist-info/top_level.txt,sha256=2iZvBjnwVCUW-uDE23-eJld5PZ9-mlPI69QiXM5IrTA,18
+rocket_welder_sdk-1.1.45.dist-info/RECORD,,

{rocket_welder_sdk-1.1.43.dist-info → rocket_welder_sdk-1.1.45.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any