python-osc 1.10.2__py3-none-any.whl → 1.10.3__py3-none-any.whl

{python_osc-1.10.2.dist-info → python_osc-1.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-osc
-Version: 1.10.2
+Version: 1.10.3
 Summary: Open Sound Control server and client implementations in pure Python
 Keywords: osc,sound,midi,music
 Author: attwad

python_osc-1.10.3.dist-info/RECORD

@@ -0,0 +1,36 @@
+pythonosc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonosc/dispatcher.py,sha256=L1d_jm33uwsSHrNlfaLhTXflc70apcK5FwRTJTuEf3Q,15051
+pythonosc/osc_bundle.py,sha256=k8CR9K-MFr8iKj3pYSj72PE2nyhZsIle-GnVpqSrcvM,4151
+pythonosc/osc_bundle_builder.py,sha256=1m1K1bC3NIbUNjNo8lRFQ-Hciyq4hzWEPQm48c1W8DA,2113
+pythonosc/osc_message.py,sha256=GlWwFMhquvt6JuKo8hC4q_S9aSHYTGsfTUUPvO-5uaQ,4797
+pythonosc/osc_message_builder.py,sha256=CHgpPdU9mfTZ52Dt10J0nrvG85OzP474lAhzKGSU_dE,8080
+pythonosc/osc_packet.py,sha256=72LVRxaPaTwkkih7tsPWgWJlyeHxO7xt3SOOK8YMh50,2778
+pythonosc/osc_server.py,sha256=j-cwrZYeiZJTrbYXaW01JiH0H0IFRQLqXrfv0BsdxTY,7445
+pythonosc/osc_tcp_server.py,sha256=Bh_WJHjrtWMtU1gOpY7X1jZEpZNJN5hztllx_UoHT1M,7141
+pythonosc/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonosc/parsing/framing.py,sha256=P31sXt9_mO9bUUNjd6bBlS7T3EGUEh129PZ93QzeOhs,4492
+pythonosc/parsing/ntp.py,sha256=9lpFonFynAVYtW5J2ttgnbjM0ej8mTl0BFsm82Ud8Ek,1877
+pythonosc/parsing/osc_types.py,sha256=-YfmtM0q-WVliJwXJaYEcY5MfGYzp0xyTu2eZ6z9GSE,15008
+pythonosc/parsing/slip.py,sha256=KhEBQ3v21A3liulQWMiBYw3oVY_BtEb1wZj1q3tnrIk,3676
+pythonosc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonosc/tcp_client.py,sha256=ywJaAMWSF_a3kuNAYEe_of-jccwXsnOHM84G7cuHDmc,8039
+pythonosc/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonosc/test/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pythonosc/test/parsing/test_framing.py,sha256=IYvt_FgLUkeFabbleSuxVqcMiRToy38ugxYaMBTcL9o,5048
+pythonosc/test/parsing/test_ntp.py,sha256=KY4XiArsNZtni46Glq0F6dR3psVDbOROdOjFupTWVuI,605
+pythonosc/test/parsing/test_osc_types.py,sha256=TQz0-yCT7FCN3DjpR3e22tiLpX829rGeogj1tuim-P8,13805
+pythonosc/test/test_dispatcher.py,sha256=C0TsHqoino_2_Dnu10WCBROtB9zi4a2pjft4NvFO7Ps,9367
+pythonosc/test/test_empty_string_messages.py,sha256=F6OpZP5xJP3RY_leWigJd6MdQF6Cdm_v5js3_U8Ba6Q,3768
+pythonosc/test/test_osc_bundle.py,sha256=eXsIl_Jpo9lVmcDVG9o4rWlpTyo7XfBG294_uXp-6Vg,4837
+pythonosc/test/test_osc_bundle_builder.py,sha256=7P2DPBun2TrT_4gUq2_haEJiNC8dbGHwzaRF5MJzJHs,1534
+pythonosc/test/test_osc_message.py,sha256=sDU73FGbEKL5tLYyD04FUsC4aJ1jWxJJmoAaRoWTuuI,13250
+pythonosc/test/test_osc_message_builder.py,sha256=RaFPH9biU6P7LZ-p3N7H5Cfg5w6d2BBxVrwGA9EWwCw,3982
+pythonosc/test/test_osc_packet.py,sha256=GCK7mYKv0bzOwCuhwbA7eaxPOjsn-pTzTbpMzWTXo-s,2163
+pythonosc/test/test_osc_server.py,sha256=MtPJ6ZdEIArRrZxkIPF2_0Dlic0Ct3beQlHZpFgIOaQ,6738
+pythonosc/test/test_osc_tcp_server.py,sha256=Yhj5EGsYMpSwsxuHIMFyi5GEZIpPKxSA-LstWVJXhJs,13972
+pythonosc/test/test_tcp_client.py,sha256=BxRhzaiSoiY5Iz_cYlO45WWKejpdLT7HFciMpu5zXX4,2605
+pythonosc/test/test_udp_client.py,sha256=qLP5SPem6T40JbAoRlf5_N258pTvLzgu3BAqC6PkzMI,3487
+pythonosc/udp_client.py,sha256=4E9GU8dPV3RilCskedzzx2jVcgK6EGp1UXrGjYV3ZaI,5105
+python_osc-1.10.3.dist-info/WHEEL,sha256=3OmCxFA0ffBIsX4x0o8CdfSvZAOvO3mzEG8U_z5TvV4,80
+python_osc-1.10.3.dist-info/METADATA,sha256=vpKkB59PbIqVCpXGHAI3iN0K05Ql7_TMyw6UPLndAAk,6387
+python_osc-1.10.3.dist-info/RECORD,,

{python_osc-1.10.2.dist-info → python_osc-1.10.3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.11.3
+Generator: uv 0.13.8
 Root-Is-Purelib: true
 Tag: py3-none-any

pythonosc/dispatcher.py

@@ -154,13 +154,15 @@ class Dispatcher(object):
 
         The callback function must have one of the following signatures:
 
-        ``def some_cb(address: str, *osc_args: List[Any]) -> Union[None, AnyStr, Tuple(str, ArgValue)]:``
-        ``def some_cb(address: str, fixed_args: List[Any], *osc_args: List[Any]) -> Union[None, AnyStr,
-                                                                                          Tuple(str, ArgValue)]:``
+        .. code-block:: python
 
-        ``def some_cb(client_address: Tuple[str, int], address: str, *osc_args: List[Any]) -> Union[None, AnyStr,
-                                                                                                    Tuple(str, ArgValue)]:``
-        ``def some_cb(client_address: Tuple[str, int], address: str, fixed_args: List[Any], *osc_args: List[Any]) -> Union[None, AnyStr, Tuple(str, ArgValue)]:``
+            def some_cb(address: str, *osc_args: ArgValue) -> Union[None, str, Tuple[str, ArgValue]]: ...
+            def some_cb(address: str, fixed_args: List[Any], *osc_args: ArgValue) -> Union[None, str, Tuple[str, ArgValue]]: ...
+            def some_cb(client_address: Tuple[str, int], address: str, *osc_args: ArgValue) -> Union[None, str, Tuple[str, ArgValue]]: ...
+            def some_cb(client_address: Tuple[str, int], address: str, fixed_args: List[Any], *osc_args: ArgValue) -> Union[None, str, Tuple[str, ArgValue]]: ...
+
+        Each variadic OSC argument is a single ArgValue, not a list of all arguments.
+        Any fixed arguments passed to map() are collected into the separate fixed_args list.
 
         The callback function can return None, or a string representing an OSC address to be returned to the client,
         or a tuple that includes the address and ArgValue which will be converted to an OSC message and returned to

pythonosc/osc_bundle.py

@@ -50,6 +50,12 @@ class OscBundle(object):
             while self._dgram[index:]:
                 # Get the sub content size.
                 content_size, index = osc_types.get_int(self._dgram, index)
+                if content_size <= 0 or content_size % 4:
+                    raise ParseError(
+                        "Invalid bundle element size: {}".format(content_size)
+                    )
+                if content_size > len(self._dgram) - index:
+                    raise ParseError("Bundle element exceeds the datagram length")
                 # Get the datagram for the sub content.
                 content_dgram = self._dgram[index : index + content_size]
                 # Increment our position index up to the next possible content.

pythonosc/osc_message_builder.py

@@ -200,13 +200,16 @@ class OscMessageBuilder(object):
 
 
 def build_msg(
-    address: str, value: Union[ArgValue, Iterable[ArgValue]] = ""
+    address: str, value: Union[ArgValue, Iterable[ArgValue]] = ()
 ) -> osc_message.OscMessage:
+    """Build a message from a scalar value or an iterable of arguments.
+
+    Omit the value or pass an empty iterable for a message with no arguments.
+    An explicitly supplied empty string is retained as a string argument.
+    """
     builder = OscMessageBuilder(address=address)
     values: Iterable[Any]
-    if value == "":
-        values = []
-    elif not isinstance(value, Iterable) or isinstance(value, (str, bytes)):
+    if not isinstance(value, Iterable) or isinstance(value, (str, bytes)):
         values = [value]
     else:
         values = value

pythonosc/osc_server.py

@@ -59,6 +59,9 @@ def _is_valid_request(request: _RequestType) -> bool:
 class OSCUDPServer(socketserver.UDPServer):
     """Superclass for different flavors of OSC UDP servers"""
 
+    # Receive complete UDP datagrams instead of socketserver's 8192-byte default.
+    max_packet_size = 65535
+
     def __init__(
         self,
         server_address: Tuple[str, int],

pythonosc/osc_tcp_server.py

@@ -33,68 +33,37 @@ loop.run_forever()
 # mypy: disable-error-code="attr-defined"
 
 import asyncio
-import logging
 import os
 import socket
 import socketserver
-import struct
-from typing import List, Tuple
+from typing import Tuple
 
-from pythonosc import osc_message_builder, slip
+from pythonosc import osc_message_builder
 from pythonosc.dispatcher import Dispatcher
+from pythonosc.parsing.framing import (
+    BINARY_LENGTH_FRAMING,
+    SLIP_FRAMING,
+    Framing,
+    FramingParser,
+)
 
-LOG = logging.getLogger()
 MODE_1_0 = "1.0"
 MODE_1_1 = "1.1"
+FRAMING_BY_MODE: dict[str, Framing] = {
+    MODE_1_0: BINARY_LENGTH_FRAMING,
+    MODE_1_1: SLIP_FRAMING,
+}
 
 
-class _TCPHandler1_0(socketserver.BaseRequestHandler):
-    """Handles correct OSC1.0 messages.
+def get_framing(mode: str) -> Framing:
+    try:
+        return FRAMING_BY_MODE[mode]
+    except KeyError:
+        raise ValueError(f"Unsupported OSC mode: {mode}") from None
 
-    Whether this will be run on its own thread, the server's or a whole new
-    process depends on the server you instantiated, look at their documentation.
 
-    This method is called after a basic sanity check was done on the datagram,
-    basically whether this datagram looks like an osc message or bundle,
-    if not the server won't even bother to call it and so no new
-    threads/processes will be spawned.
-    """
-
-    def handle(self) -> None:
-        LOG.debug("handle OSC 1.0 protocol")
-        while True:
-            lengthbuf = self.recvall(4)
-            if lengthbuf == b"":
-                break
-            (length,) = struct.unpack("!I", lengthbuf)
-            data = self.recvall(length)
-            if data == b"":
-                break
-
-            resp = self.server.dispatcher.call_handlers_for_packet(
-                data, self.client_address
-            )
-            # resp = _call_handlers_for_packet(data, self.server.dispatcher)
-            for r in resp:
-                if not isinstance(r, tuple):
-                    r = [r]
-                msg = osc_message_builder.build_msg(r[0], r[1:])
-                b = struct.pack("!I", len(msg.dgram))
-                self.request.sendall(b + msg.dgram)
-
-    def recvall(self, count: int) -> bytes:
-        buf = b""
-        while count > 0:
-            newbuf = self.request.recv(count)
-            if not newbuf:
-                return b""
-            buf += newbuf
-            count -= len(newbuf)
-        return buf
-
-
-class _TCPHandler1_1(socketserver.BaseRequestHandler):
-    """Handles correct OSC1.1 messages.
+class TCPHandler(socketserver.BaseRequestHandler):
+    """Handles correct OSC messages.
 
     Whether this will be run on its own thread, the server's or a whole new
     process depends on the server you instantiated, look at their documentation.
@@ -106,14 +75,12 @@ class _TCPHandler1_1(socketserver.BaseRequestHandler):
     """
 
     def handle(self) -> None:
-        LOG.debug("handle OSC 1.1 protocol")
-        while True:
-            packets = self.recvall()
-            if not packets:
-                break
-
-            for p in packets:
-                # resp = _call_handlers_for_packet(p, self.server.dispatcher)
+        assert isinstance(self.server, OSCTCPServer)
+
+        parser = FramingParser(self.server.framing)
+
+        while chunk := self.request.recv(16384):
+            for p in parser.feed(chunk):
                 resp = self.server.dispatcher.call_handlers_for_packet(
                     p, self.client_address
                 )
@@ -121,27 +88,15 @@ class _TCPHandler1_1(socketserver.BaseRequestHandler):
                     if not isinstance(r, tuple):
                         r = [r]
                     msg = osc_message_builder.build_msg(r[0], r[1:])
-                    self.request.sendall(slip.encode(msg.dgram))
-
-    def recvall(self) -> List[bytes]:
-        buf = self.request.recv(4096)
-        if not buf:
-            return []
-        # If the last byte is not an END marker there could be more data coming
-        while buf[-1] != 192:
-            newbuf = self.request.recv(4096)
-            if not newbuf:
-                # Maybe should raise an exception here?
-                break
-            buf += newbuf
-
-        packets = [slip.decode(p) for p in buf.split(slip.END_END)]
-        return packets
+                    self.request.sendall(self.server.framing.encode(msg.dgram))
 
 
 class OSCTCPServer(socketserver.TCPServer):
     """Superclass for different flavors of OSCTCPServer"""
 
+    dispatcher: Dispatcher
+    framing: Framing
+
     def __init__(
         self,
         server_address: Tuple[str | bytes | bytearray, int],
@@ -150,9 +105,8 @@ class OSCTCPServer(socketserver.TCPServer):
         family: socket.AddressFamily | None = None,
     ):
         self.request_queue_size = 300
-        self.mode = mode
-        if mode not in [MODE_1_0, MODE_1_1]:
-            raise ValueError("OSC Mode must be '1.0' or '1.1'")
+        self.dispatcher = dispatcher
+        self.framing = get_framing(mode)
 
         if family is not None:
             self.address_family = family
@@ -171,16 +125,7 @@ class OSCTCPServer(socketserver.TCPServer):
                 # Fallback to default if resolution fails
                 pass
 
-        if self.mode == MODE_1_0:
-            super().__init__(server_address, _TCPHandler1_0)
-        else:
-            super().__init__(server_address, _TCPHandler1_1)
-        self._dispatcher = dispatcher
-
-    @property
-    def dispatcher(self):
-        """Dispatcher accessor for handlers to dispatch osc messages."""
-        return self._dispatcher
+        super().__init__(server_address, TCPHandler)
 
 
 class BlockingOSCTCPServer(OSCTCPServer):
@@ -230,8 +175,8 @@ class AsyncOSCTCPServer:
         """
         self._port = port
         self._server_address = server_address
-        self._dispatcher = dispatcher
-        self._mode = mode
+        self.dispatcher = dispatcher
+        self.framing = get_framing(mode)
 
     async def __aenter__(self):
         return self
@@ -245,9 +190,6 @@ class AsyncOSCTCPServer:
             self.handle, self._server_address, self._port
         )
 
-        addrs = ", ".join(str(sock.getsockname()) for sock in self._server.sockets)
-        LOG.debug(f"Serving on {addrs}")
-
         async with self._server:
             await self._server.serve_forever()
 
@@ -255,86 +197,28 @@ class AsyncOSCTCPServer:
         self._server.close()
         await self._server.wait_closed()
 
-    @property
-    def dispatcher(self):
-        return self._dispatcher
-
     async def handle(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
     ) -> None:
+        try:
+            await self._handle(reader, writer)
+        finally:
+            if writer.can_write_eof():
+                writer.write_eof()
+            writer.close()
+            await writer.wait_closed()
+
+    async def _handle(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> None:
+        parser = FramingParser(self.framing)
         client_address = ("", 0)
         sock = writer.transport.get_extra_info("socket")
         if sock is not None:
             client_address = sock.getpeername()
 
-        if self._mode == MODE_1_1:
-            await self.handle_1_1(reader, writer, client_address)
-        else:
-            await self.handle1_0(reader, writer, client_address)
-        writer.write_eof()
-        LOG.debug("Close the connection")
-        writer.close()
-        await writer.wait_closed()
-
-    async def handle1_0(
-        self,
-        reader: asyncio.StreamReader,
-        writer: asyncio.StreamWriter,
-        client_address: Tuple[str, int],
-    ) -> None:
-        LOG.debug("Incoming socket open 1.0")
-        while True:
-            try:
-                buf = await reader.read(4)
-            except Exception as e:
-                LOG.exception("Read error", e)
-                return
-            if buf == b"":
-                break
-            (length,) = struct.unpack("!I", buf)
-            buf = b""
-            while length > 0:
-                newbuf = await reader.read(length)
-                if not newbuf:
-                    break
-                buf += newbuf
-                length -= len(newbuf)
-
-            result = await self.dispatcher.async_call_handlers_for_packet(
-                buf, client_address
-            )
-            for r in result:
-                if not isinstance(r, tuple):
-                    r = [r]
-                msg = osc_message_builder.build_msg(r[0], r[1:])
-                b = struct.pack("!I", len(msg.dgram))
-                writer.write(b + msg.dgram)
-                await writer.drain()
-
-    async def handle_1_1(
-        self,
-        reader: asyncio.StreamReader,
-        writer: asyncio.StreamWriter,
-        client_address: Tuple[str, int],
-    ) -> None:
-        LOG.debug("Incoming socket open 1.1")
-        while True:
-            try:
-                buf = await reader.read(4096)
-            except Exception as e:
-                LOG.exception("Read error", e)
-                return
-            if buf == b"":
-                break
-            while len(buf) > 0 and buf[-1] != 192:
-                newbuf = await reader.read(4096)
-                if not newbuf:
-                    # Maybe should raise an exception here?
-                    break
-                buf += newbuf
-
-            packets = [slip.decode(p) for p in buf.split(slip.END_END)]
-            for p in packets:
+        while chunk := await reader.read(16384):
+            for p in parser.feed(chunk):
                 result = await self.dispatcher.async_call_handlers_for_packet(
                     p, client_address
                 )
@@ -342,5 +226,5 @@ class AsyncOSCTCPServer:
                     if not isinstance(r, tuple):
                         r = [r]
                     msg = osc_message_builder.build_msg(r[0], r[1:])
-                    writer.write(slip.encode(msg.dgram))
+                    writer.write(self.framing.encode(msg.dgram))
                     await writer.drain()

pythonosc/parsing/framing.py

@@ -0,0 +1,166 @@
+"""OSC message codecs for different framing strategies."""
+
+from abc import ABCMeta, abstractmethod
+from struct import pack, unpack_from
+
+from pythonosc.parsing.slip import (
+    END,
+    decode as slip_decode,
+    encode as slip_encode,
+)
+
+
+class Framing(metaclass=ABCMeta):
+    """Base class for OSC stream framing strategies."""
+
+    @abstractmethod
+    def encode(self, dgram: bytes) -> bytes:
+        """Encode a single OSC datagram for transmission on a byte stream.
+
+        Args:
+            dgram: Raw OSC datagram bytes.
+
+        Returns:
+            The framed byte sequence to write to the stream.
+        """
+
+    @abstractmethod
+    def decode_stream(
+        self, buf: bytes | bytearray, start: int = 0
+    ) -> tuple[list[bytes], int]:
+        """Decode complete OSC datagrams from a byte buffer.
+
+        Args:
+            buf: Bytes received from a stream.
+            start: The index in ``buf`` to start decoding from.
+
+        Returns:
+            A tuple ``(messages, bytes consumed)``.
+        """
+
+
+class SLIPFraming(Framing):
+    """SLIP (RFC 1055) framing for OSC 1.1.
+
+    See the "OSC Delivery Specification 1.1" section from the 2009 NIME paper for details.
+    """
+
+    def encode(self, dgram: bytes) -> bytes:
+        return slip_encode(dgram)
+
+    def decode_stream(
+        self, buf: bytes | bytearray, start: int = 0
+    ) -> tuple[list[bytes], int]:
+        pos = start
+        messages = []
+
+        scan = start
+        while (end := buf.find(END, scan)) >= 0:
+            if end > scan:
+                messages.append(slip_decode(bytes(buf[scan:end])))
+                pos = end + len(END)
+            scan = end + len(END)
+
+        # Consume trailing delimiters, but retain an incomplete packet.
+        if scan == len(buf):
+            pos = scan
+
+        return messages, pos - start
+
+
+class BinaryLengthFraming(Framing):
+    """Length-prefixed framing for OSC 1.0.
+
+    See the "OSC Packets" section from OSC 1.0 Specification for details.
+    """
+
+    def encode(self, dgram: bytes) -> bytes:
+        if dgram:
+            return pack("!I", len(dgram)) + dgram
+        return b""
+
+    def decode_stream(
+        self, buf: bytes | bytearray, start: int = 0
+    ) -> tuple[list[bytes], int]:
+        messages = []
+        pos = start
+
+        while (data_pos := pos + 4) < len(buf):
+            (length,) = unpack_from("!I", buf, pos)
+            end = data_pos + length
+
+            if end > len(buf):
+                break
+
+            messages.append(bytes(buf[data_pos:end]))
+
+            pos = end
+
+        return messages, pos - start
+
+
+class FramingParser:
+    """Stateful stream decoder for (framed) OSC byte stream.
+
+    Not safe for concurrent use.
+
+    Args:
+        framing: Strategy used to decode buffered stream data.
+        max_buffer_size: Maximum size of the internal buffer.
+    """
+
+    __slots__ = ("buf", "start", "framing", "max_buffer_size")
+
+    def __init__(self, framing: Framing, max_buffer_size: int = 1048576) -> None:
+        self.buf = bytearray()
+        self.start = 0
+        self.framing = framing
+        self.max_buffer_size = max_buffer_size
+
+    def feed(self, chunk: bytes | bytearray | memoryview) -> list[bytes]:
+        """Append stream data to the internal buffer and return any complete OSC datagrams.
+
+        Args:
+            chunk: Newly received bytes from the stream.
+
+        Returns:
+            A list of complete, decoded OSC datagrams.
+        """
+
+        new_buf_len = len(self.buf) + len(chunk)
+
+        if (pending := new_buf_len - self.start) > self.max_buffer_size:
+            raise ValueError(f"Buffer is too large: {pending} > {self.max_buffer_size}")
+
+        if new_buf_len > self.max_buffer_size:
+            del self.buf[: self.start]
+            self.start = 0
+
+        self.buf.extend(chunk)
+
+        messages, consumed = self.framing.decode_stream(self.buf, self.start)
+        available = len(self.buf) - self.start
+
+        assert 0 <= consumed <= available, (
+            f"misbehaving framing decoder: {consumed=} {available=}"
+        )
+
+        self.start += consumed
+
+        return messages
+
+    @property
+    def remaining(self) -> bytes:
+        """Return any unparsed bytes."""
+
+        return bytes(self.buf[self.start :])
+
+    def reset(self) -> None:
+        """Clear the internal buffer (discard unparsed data)."""
+
+        del self.buf[:]
+        self.start = 0
+
+
+SLIP_FRAMING: Framing = SLIPFraming()
+BINARY_LENGTH_FRAMING: Framing = BinaryLengthFraming()

pythonosc/parsing/osc_types.py

@@ -86,6 +86,8 @@ def get_string(dgram: bytes, start_index: int) -> Tuple[str, int]:
 
         data_str = dgram[start_index : start_index + offset]
         return data_str.decode("utf-8"), start_index + total_len
+    except UnicodeDecodeError as error:
+        raise ParseError(f"Could not decode OSC string: {error}") from error
     except IndexError as ie:
         raise ParseError(f"Could not parse datagram {ie}")
     except TypeError as te:
@@ -307,7 +309,7 @@ def get_blob(dgram: bytes, start_index: int) -> Tuple[bytes, int]:
 
     Args:
       dgram: A datagram packet.
-      start_index: An index where the float starts in the datagram.
+      start_index: An index where the blob starts in the datagram.
 
     Returns:
       A tuple containing the blob and the new end index.
@@ -315,13 +317,17 @@ def get_blob(dgram: bytes, start_index: int) -> Tuple[bytes, int]:
     Raises:
       ParseError if the datagram could not be parsed.
     """
-    size, int_offset = get_int(dgram, start_index)
-    # Make the size a multiple of 32 bits.
-    total_size = size + (-size % _BLOB_DGRAM_PAD)
-    end_index = int_offset + size
-    if end_index - start_index > len(dgram[start_index:]):
+    if start_index < 0:
+        raise ParseError("start_index < 0")
+    size, payload_start = get_int(dgram, start_index)
+    if size < 0:
+        raise ParseError("Blob length cannot be negative")
+
+    payload_end = payload_start + size
+    next_index = payload_end + (-size % _BLOB_DGRAM_PAD)
+    if next_index > len(dgram):
         raise ParseError("Datagram is too short.")
-    return dgram[int_offset : int_offset + size], int_offset + total_size
+    return dgram[payload_start:payload_end], next_index
 
 
 def write_blob(val: bytes) -> bytes: