python-osc 1.9.3__tar.gz → 1.10.2__tar.gz

{python_osc-1.9.3/python_osc.egg-info → python_osc-1.10.2}/PKG-INFO

@@ -1,35 +1,34 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: python-osc
-Version: 1.9.3
+Version: 1.10.2
 Summary: Open Sound Control server and client implementations in pure Python
+Keywords: osc,sound,midi,music
+Author: attwad
 Author-email: attwad <tmusoft@gmail.com>
 License: This is free and unencumbered software released into the public domain.
-        
-        Anyone is free to copy, modify, publish, use, compile, sell, or
-        distribute this software, either in source code form or as a compiled
-        binary, for any purpose, commercial or non-commercial, and by any
-        means.
-        
-        In jurisdictions that recognize copyright laws, the author or authors
-        of this software dedicate any and all copyright interest in the
-        software to the public domain. We make this dedication for the benefit
-        of the public at large and to the detriment of our heirs and
-        successors. We intend this dedication to be an overt act of
-        relinquishment in perpetuity of all present and future rights to this
-        software under copyright law.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-        EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-        MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-        IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-        OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-        ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-        OTHER DEALINGS IN THE SOFTWARE.
-        
-        For more information, please refer to <http://unlicense.org/>
-        
-Project-URL: Repository, https://github.com/attwad/python-osc
-Keywords: osc,sound,midi,music
+         
+         Anyone is free to copy, modify, publish, use, compile, sell, or
+         distribute this software, either in source code form or as a compiled
+         binary, for any purpose, commercial or non-commercial, and by any
+         means.
+         
+         In jurisdictions that recognize copyright laws, the author or authors
+         of this software dedicate any and all copyright interest in the
+         software to the public domain. We make this dedication for the benefit
+         of the public at large and to the detriment of our heirs and
+         successors. We intend this dedication to be an overt act of
+         relinquishment in perpetuity of all present and future rights to this
+         software under copyright law.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+         EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+         MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+         IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+         OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+         ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+         OTHER DEALINGS IN THE SOFTWARE.
+         
+         For more information, please refer to <http://unlicense.org/>
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: Freely Distributable
@@ -37,8 +36,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Multimedia :: Sound/Audio
 Classifier: Topic :: System :: Networking
 Requires-Python: >=3.10
+Project-URL: Repository, https://github.com/attwad/python-osc
 Description-Content-Type: text/x-rst
-License-File: LICENSE.txt
 
 ==========
 python-osc
@@ -115,7 +114,7 @@ Simple client
         help="The port the OSC server is listening on")
     args = parser.parse_args()
 
-    client = udp_client.SimpleUDPClient(args.ip, args.port)
+    client = udp_client.SimpleUDPClient(args.ip, args.port, timeout=10)
 
     for x in range(10):
       client.send_message("/filter", random.random())
@@ -159,7 +158,7 @@ Simple server
     dispatcher.map("/logvolume", print_compute_handler, "Log volume", math.log)
 
     server = osc_server.ThreadingOSCUDPServer(
-        (args.ip, args.port), dispatcher)
+        (args.ip, args.port), dispatcher, timeout=10)
     print("Serving on {}".format(server.server_address))
     server.serve_forever()
 

{python_osc-1.9.3 → python_osc-1.10.2}/README.rst

@@ -73,7 +73,7 @@ Simple client
         help="The port the OSC server is listening on")
     args = parser.parse_args()
 
-    client = udp_client.SimpleUDPClient(args.ip, args.port)
+    client = udp_client.SimpleUDPClient(args.ip, args.port, timeout=10)
 
     for x in range(10):
       client.send_message("/filter", random.random())
@@ -117,7 +117,7 @@ Simple server
     dispatcher.map("/logvolume", print_compute_handler, "Log volume", math.log)
 
     server = osc_server.ThreadingOSCUDPServer(
-        (args.ip, args.port), dispatcher)
+        (args.ip, args.port), dispatcher, timeout=10)
     print("Serving on {}".format(server.server_address))
     server.serve_forever()
 

{python_osc-1.9.3 → python_osc-1.10.2}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"
+requires = ["uv-build"]
+build-backend = "uv_build"
 
 [project]
 name = "python-osc"
-version = "1.9.3"
+version = "1.10.2"
 description = "Open Sound Control server and client implementations in pure Python"
 readme = "README.rst"
 requires-python = ">=3.10"
@@ -21,10 +21,24 @@ classifiers = [
     "Topic :: Multimedia :: Sound/Audio",
     "Topic :: System :: Networking",
 ]
+dependencies = []
 
 [project.urls]
 Repository = "https://github.com/attwad/python-osc"
 
+[dependency-groups]
+dev = [
+    "pytest",
+    "mypy",
+    "ruff",
+    "pytest-cov",
+    "pre-commit",
+]
+
+[tool.uv.build-backend]
+module-name = "pythonosc"
+module-root = "."
+
 [tool.mypy]
 # Would be great to turn this on, however there's too many cases it would break
 # right now.

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/dispatcher.py

@@ -1,6 +1,6 @@
-"""Maps OSC addresses to handler functions
-"""
+"""Maps OSC addresses to handler functions"""
 
+import asyncio
 import collections
 import inspect
 import logging
@@ -81,6 +81,46 @@ class Handler(object):
             else:
                 return self.callback(message.address, *message)
 
+    async def async_invoke(
+        self, client_address: Tuple[str, int], message: OscMessage
+    ) -> Union[None, AnyStr, Tuple[AnyStr, ArgValue]]:
+        """Invokes the associated callback function (asynchronously)
+
+        Args:
+            client_address: Address match that causes the invocation
+            message: Message causing invocation
+        Returns:
+            The result of the handler function can be None, a string OSC address, or a tuple of the OSC address
+            and arguments.
+        """
+        cb = self.callback
+        is_async = inspect.iscoroutinefunction(cb)
+
+        if self.needs_reply_address:
+            if self.args:
+                if is_async:
+                    return await cb(
+                        client_address, message.address, self.args, *message
+                    )
+                else:
+                    return cb(client_address, message.address, self.args, *message)
+            else:
+                if is_async:
+                    return await cb(client_address, message.address, *message)
+                else:
+                    return cb(client_address, message.address, *message)
+        else:
+            if self.args:
+                if is_async:
+                    return await cb(message.address, self.args, *message)
+                else:
+                    return cb(message.address, self.args, *message)
+            else:
+                if is_async:
+                    return await cb(message.address, *message)
+                else:
+                    return cb(message.address, *message)
+
 
 class Dispatcher(object):
     """Maps Handlers to OSC addresses and dispatches messages to the handler on matched addresses
@@ -88,9 +128,20 @@ class Dispatcher(object):
     Maps OSC addresses to handler functions and invokes the correct handler when a message comes in.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, strict_timing: bool = True) -> None:
+        """Initialize the dispatcher.
+
+        Args:
+            strict_timing: Whether to automatically schedule messages with future timetags.
+                If True (default), the dispatcher will wait (using sleep) until the specified
+                timetag before invoking handlers.
+                If False, messages are dispatched immediately regardless of their timetag.
+                Disabling this can prevent memory/thread accumulation issues when receiving
+                many future-dated messages.
+        """
         self._map: DefaultDict[str, List[Handler]] = collections.defaultdict(list)
         self._default_handler: Optional[Handler] = None
+        self._strict_timing = strict_timing
 
     def map(
         self,
@@ -183,32 +234,66 @@ class Dispatcher(object):
     ) -> Generator[Handler, None, None]:
         """Yields handlers matching an address
 
-
         Args:
             address_pattern: Address to match
 
         Returns:
             Generator yielding Handlers matching address_pattern
         """
-        # First convert the address_pattern into a matchable regexp.
-        # '?' in the OSC Address Pattern matches any single character.
-        # Let's consider numbers and _ "characters" too here, it's not said
-        # explicitly in the specification but it sounds good.
-        escaped_address_pattern = re.escape(address_pattern)
-        pattern = escaped_address_pattern.replace("\\?", "\\w?")
-        # '*' in the OSC Address Pattern matches any sequence of zero or more
-        # characters.
-        pattern = pattern.replace("\\*", "[\\w|\\+]*")
-        # The rest of the syntax in the specification is like the re module so
-        # we're fine.
-        pattern = f"{pattern}$"
-        patterncompiled = re.compile(pattern)
-        matched = False
+        # Convert OSC Address Pattern to a Python regular expression.
+        # Spec: https://opensoundcontrol.stanford.edu/spec-1_0.html#osc-address-patterns
+
+        pattern = "^"
+        i = 0
+        while i < len(address_pattern):
+            c = address_pattern[i]
+            if c == "*":
+                pattern += "[^/]*"
+            elif c == "?":
+                pattern += "[^/]"
+            elif c == "[":
+                pattern += "["
+                i += 1
+                if i < len(address_pattern) and address_pattern[i] == "!":
+                    pattern += "^"
+                    i += 1
+                while i < len(address_pattern) and address_pattern[i] != "]":
+                    if address_pattern[i] in r"\^$.|()+*?":
+                        pattern += "\\"
+                    pattern += address_pattern[i]
+                    i += 1
+                pattern += "]"
+            elif c == "{":
+                pattern += "("
+                i += 1
+                while i < len(address_pattern) and address_pattern[i] != "}":
+                    char = address_pattern[i]
+                    if char == ",":
+                        pattern += "|"
+                    elif char in r"\^$.|()[]+*?":
+                        pattern += "\\" + char
+                    else:
+                        pattern += char
+                    i += 1
+                pattern += ")"
+            elif c in r"\^$.|()[]+?":
+                pattern += "\\" + c
+            else:
+                pattern += c
+            i += 1
+        pattern += "$"
+
+        try:
+            patterncompiled = re.compile(pattern)
+        except re.error:
+            # If the pattern is invalid, it won't match anything.
+            return
 
+        matched = False
         for addr, handlers in self._map.items():
             if patterncompiled.match(addr) or (
-                ("*" in addr)
-                and re.match(addr.replace("*", "[^/]*?/*"), address_pattern)
+                "*" in addr
+                and re.match(addr.replace("*", ".*?") + "$", address_pattern)
             ):
                 yield from handlers
                 matched = True
@@ -239,7 +324,7 @@ class Dispatcher(object):
                 if not handlers:
                     continue
                 # If the message is to be handled later, then so be it.
-                if timed_msg.time > now:
+                if self._strict_timing and timed_msg.time > now:
                     time.sleep(timed_msg.time - now)
                 for handler in handlers:
                     result = handler.invoke(client_address, timed_msg.message)
@@ -276,48 +361,15 @@ class Dispatcher(object):
                 if not handlers:
                     continue
                 # If the message is to be handled later, then so be it.
-                if timed_msg.time > now:
-                    time.sleep(timed_msg.time - now)
+                if self._strict_timing and timed_msg.time > now:
+                    await asyncio.sleep(timed_msg.time - now)
                 for handler in handlers:
-                    if inspect.iscoroutinefunction(handler.callback):
-                        if handler.needs_reply_address:
-                            result = await handler.callback(
-                                client_address,
-                                timed_msg.message.address,
-                                handler.args,
-                                *timed_msg.message,
-                            )
-                        elif handler.args:
-                            result = await handler.callback(
-                                timed_msg.message.address,
-                                handler.args,
-                                *timed_msg.message,
-                            )
-                        else:
-                            result = await handler.callback(
-                                timed_msg.message.address, *timed_msg.message
-                            )
-                    else:
-                        if handler.needs_reply_address:
-                            result = handler.callback(
-                                client_address,
-                                timed_msg.message.address,
-                                handler.args,
-                                *timed_msg.message,
-                            )
-                        elif handler.args:
-                            result = handler.callback(
-                                timed_msg.message.address,
-                                handler.args,
-                                *timed_msg.message,
-                            )
-                        else:
-                            result = handler.callback(
-                                timed_msg.message.address, *timed_msg.message
-                            )
-                    if result:
+                    result = await handler.async_invoke(
+                        client_address, timed_msg.message
+                    )
+                    if result is not None:
                         results.append(result)
-        except osc_packet.ParseError as e:
+        except osc_packet.ParseError:
             pass
         return results
 

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/osc_bundle_builder.py

@@ -25,9 +25,11 @@ class OscBundleBuilder(object):
                        seconds since the epoch in UTC or IMMEDIATELY.
         """
         self._timestamp = timestamp
-        self._contents: List[osc_bundle.OscBundle] = []
+        self._contents: List[osc_bundle.OscBundle | osc_message.OscMessage] = []
 
-    def add_content(self, content: osc_bundle.OscBundle) -> None:
+    def add_content(
+        self, content: osc_bundle.OscBundle | osc_message.OscMessage
+    ) -> None:
         """Add a new content to this bundle.
 
         Args:

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/osc_message.py

@@ -34,8 +34,12 @@ class OscMessage(object):
 
             # Get the parameters types.
             type_tag, index = osc_types.get_string(self._dgram, index)
-            if type_tag.startswith(","):
-                type_tag = type_tag[1:]
+            if not type_tag.startswith(","):
+                raise ParseError(
+                    f"OSC Type Tag String must start with a comma, got: {type_tag}"
+                )
+
+            type_tag = type_tag[1:]
 
             params = []  # type: List[Any]
             param_stack = [params]

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/osc_message_builder.py

@@ -5,7 +5,11 @@ from typing import Any, Iterable, List, Optional, Tuple, Union
 from pythonosc import osc_message
 from pythonosc.parsing import osc_types
 
-ArgValue = Union[str, bytes, bool, int, float, osc_types.MidiPacket, list]
+# Represents a single OSC argument value.
+# Can be a primitive type, a MIDI packet, or a list/tuple for nested OSC arrays.
+ArgValue = Union[
+    str, bytes, bool, int, float, osc_types.MidiPacket, List[Any], Tuple[Any, ...], None
+]
 
 
 class BuildError(Exception):
@@ -68,9 +72,9 @@ class OscMessageBuilder(object):
         """Returns the (type, value) arguments list of this message."""
         return self._args
 
-    def _valid_type(self, arg_type: str) -> bool:
-        if arg_type in self._SUPPORTED_ARG_TYPES:
-            return True
+    def _valid_type(self, arg_type: Union[str, List[Any]]) -> bool:
+        if isinstance(arg_type, str):
+            return arg_type in self._SUPPORTED_ARG_TYPES
         elif isinstance(arg_type, list):
             for sub_type in arg_type:
                 if not self._valid_type(sub_type):
@@ -78,7 +82,9 @@ class OscMessageBuilder(object):
             return True
         return False
 
-    def add_arg(self, arg_value: ArgValue, arg_type: Optional[str] = None) -> None:
+    def add_arg(
+        self, arg_value: ArgValue, arg_type: Optional[Union[str, List[Any]]] = None
+    ) -> None:
         """Add a typed argument to this message.
 
         Args:
@@ -96,7 +102,7 @@ class OscMessageBuilder(object):
             arg_type = self._get_arg_type(arg_value)
         if isinstance(arg_type, list):
             self._args.append((self.ARG_TYPE_ARRAY_START, None))
-            for v, t in zip(arg_value, arg_type):  # type: ignore[var-annotated, arg-type]
+            for v, t in zip(arg_value, arg_type):  # type: ignore[arg-type]
                 self.add_arg(v, t)
             self._args.append((self.ARG_TYPE_ARRAY_STOP, None))
         else:
@@ -121,7 +127,7 @@ class OscMessageBuilder(object):
         elif arg_value is False:
             arg_type = self.ARG_TYPE_FALSE
         elif isinstance(arg_value, int):
-            if arg_value.bit_length() > 32:
+            if arg_value.bit_length() > 31:
                 arg_type = self.ARG_TYPE_INT64
             else:
                 arg_type = self.ARG_TYPE_INT
@@ -134,7 +140,7 @@ class OscMessageBuilder(object):
         elif arg_value is None:
             arg_type = self.ARG_TYPE_NIL
         else:
-            raise ValueError("Infered arg_value type is not supported")
+            raise ValueError("Inferred arg_value type is not supported")
         return arg_type
 
     def build(self) -> osc_message.OscMessage:
@@ -193,9 +199,11 @@ class OscMessageBuilder(object):
             raise BuildError(f"Could not build the message: {be}")
 
 
-def build_msg(address: str, value: ArgValue = "") -> osc_message.OscMessage:
+def build_msg(
+    address: str, value: Union[ArgValue, Iterable[ArgValue]] = ""
+) -> osc_message.OscMessage:
     builder = OscMessageBuilder(address=address)
-    values: ArgValue
+    values: Iterable[Any]
     if value == "":
         values = []
     elif not isinstance(value, Iterable) or isinstance(value, (str, bytes)):

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/osc_packet.py

@@ -72,8 +72,7 @@ class OscPacket(object):
             else:
                 # Empty packet, should not happen as per the spec but heh, UDP...
                 raise ParseError(
-                    "OSC Packet should at least contain an OscMessage or an "
-                    "OscBundle."
+                    "OSC Packet should at least contain an OscMessage or an OscBundle."
                 )
         except (osc_bundle.ParseError, osc_message.ParseError) as pe:
             raise ParseError(f"Could not parse packet {pe}")

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/osc_server.py

@@ -1,8 +1,8 @@
-"""OSC Servers that receive UDP packets and invoke handlers accordingly.
-"""
+"""OSC Servers that receive UDP packets and invoke handlers accordingly."""
 
 import asyncio
 import os
+import socket
 import socketserver
 from socket import socket as _socket
 from typing import Any, Coroutine, Tuple, Union, cast
@@ -64,6 +64,8 @@ class OSCUDPServer(socketserver.UDPServer):
         server_address: Tuple[str, int],
         dispatcher: Dispatcher,
         bind_and_activate: bool = True,
+        timeout: float | None = None,
+        family: socket.AddressFamily | None = None,
     ) -> None:
         """Initialize
 
@@ -71,9 +73,29 @@ class OSCUDPServer(socketserver.UDPServer):
             server_address: IP and port of server
             dispatcher: Dispatcher this server will use
             (optional) bind_and_activate: default=True defines if the server has to start on call of constructor
+            (optional) timeout: Default timeout in seconds for socket operations
+            (optional) family: socket.AF_INET or socket.AF_INET6. If None, it will be inferred from server_address.
         """
+        if family is not None:
+            self.address_family = family
+        else:
+            # Try to infer address family from server_address
+            try:
+                infos = socket.getaddrinfo(
+                    server_address[0],
+                    server_address[1],
+                    type=socket.SOCK_DGRAM,
+                    family=socket.AF_UNSPEC,
+                )
+                if infos:
+                    self.address_family = infos[0][0]
+            except (socket.gaierror, IndexError):
+                # Fallback to default if resolution fails
+                pass
+
         super().__init__(server_address, _UDPHandler, bind_and_activate)
         self._dispatcher = dispatcher
+        self.timeout = timeout
 
     def verify_request(
         self, request: _RequestType, client_address: _AddressType

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/osc_tcp_server.py

@@ -35,6 +35,7 @@ loop.run_forever()
 import asyncio
 import logging
 import os
+import socket
 import socketserver
 import struct
 from typing import List, Tuple
@@ -75,7 +76,7 @@ class _TCPHandler1_0(socketserver.BaseRequestHandler):
             )
             # resp = _call_handlers_for_packet(data, self.server.dispatcher)
             for r in resp:
-                if not isinstance(r, list):
+                if not isinstance(r, tuple):
                     r = [r]
                 msg = osc_message_builder.build_msg(r[0], r[1:])
                 b = struct.pack("!I", len(msg.dgram))
@@ -117,7 +118,7 @@ class _TCPHandler1_1(socketserver.BaseRequestHandler):
                     p, self.client_address
                 )
                 for r in resp:
-                    if not isinstance(r, list):
+                    if not isinstance(r, tuple):
                         r = [r]
                     msg = osc_message_builder.build_msg(r[0], r[1:])
                     self.request.sendall(slip.encode(msg.dgram))
@@ -146,11 +147,30 @@ class OSCTCPServer(socketserver.TCPServer):
         server_address: Tuple[str | bytes | bytearray, int],
         dispatcher: Dispatcher,
         mode: str = MODE_1_1,
+        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'")
+
+        if family is not None:
+            self.address_family = family
+        elif isinstance(server_address[0], str):
+            # Try to infer address family from server_address
+            try:
+                infos = socket.getaddrinfo(
+                    server_address[0],
+                    server_address[1],
+                    type=socket.SOCK_STREAM,
+                    family=socket.AF_UNSPEC,
+                )
+                if infos:
+                    self.address_family = infos[0][0]
+            except (socket.gaierror, IndexError):
+                # Fallback to default if resolution fails
+                pass
+
         if self.mode == MODE_1_0:
             super().__init__(server_address, _TCPHandler1_0)
         else:
@@ -284,7 +304,7 @@ class AsyncOSCTCPServer:
                 buf, client_address
             )
             for r in result:
-                if not isinstance(r, list):
+                if not isinstance(r, tuple):
                     r = [r]
                 msg = osc_message_builder.build_msg(r[0], r[1:])
                 b = struct.pack("!I", len(msg.dgram))
@@ -319,7 +339,7 @@ class AsyncOSCTCPServer:
                     p, client_address
                 )
                 for r in result:
-                    if not isinstance(r, list):
+                    if not isinstance(r, tuple):
                         r = [r]
                     msg = osc_message_builder.build_msg(r[0], r[1:])
                     writer.write(slip.encode(msg.dgram))

{python_osc-1.9.3 → python_osc-1.10.2}/pythonosc/parsing/osc_types.py

@@ -71,24 +71,21 @@ def get_string(dgram: bytes, start_index: int) -> Tuple[str, int]:
         raise ParseError("start_index < 0")
     offset = 0
     try:
-        if (
-            len(dgram) > start_index + _STRING_DGRAM_PAD
-            and dgram[start_index + _STRING_DGRAM_PAD] == _EMPTY_STR_DGRAM
-        ):
-            return "", start_index + _STRING_DGRAM_PAD
         while dgram[start_index + offset] != 0:
             offset += 1
-        # Align to a byte word.
-        if (offset) % _STRING_DGRAM_PAD == 0:
-            offset += _STRING_DGRAM_PAD
-        else:
-            offset += -offset % _STRING_DGRAM_PAD
-        # Python slices do not raise an IndexError past the last index,
-        # do it ourselves.
-        if offset > len(dgram[start_index:]):
+
+        # OSC spec: "followed by a null, followed by 0-3 additional null characters
+        # to make the total number of bits a multiple of 32"
+        # This means the total length (including the first null) must be a multiple of 4.
+        total_len = offset + 1
+        if total_len % 4 != 0:
+            total_len += 4 - (total_len % 4)
+
+        if start_index + total_len > len(dgram):
             raise ParseError("Datagram is too short")
+
         data_str = dgram[start_index : start_index + offset]
-        return data_str.replace(b"\x00", b"").decode("utf-8"), start_index + offset
+        return data_str.decode("utf-8"), start_index + total_len
     except IndexError as ie:
         raise ParseError(f"Could not parse datagram {ie}")
     except TypeError as te:
@@ -214,11 +211,8 @@ def get_timetag(dgram: bytes, start_index: int) -> Tuple[Tuple[datetime, int], i
         timetag, _ = get_uint64(dgram, start_index)
         seconds, fraction = ntp.parse_timestamp(timetag)
 
-        hours, seconds = seconds // 3600, seconds % 3600
-        minutes, seconds = seconds // 60, seconds % 60
-
         utc = datetime.combine(ntp._NTP_EPOCH, datetime.min.time()) + timedelta(
-            hours=hours, minutes=minutes, seconds=seconds
+            seconds=seconds
         )
 
         return (utc, fraction), start_index + _TIMETAG_DGRAM_LEN