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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-osc
-Version: 1.10.0
+Version: 1.10.3
 Summary: Open Sound Control server and client implementations in pure Python
 Keywords: osc,sound,midi,music
 Author: attwad
@@ -114,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())
@@ -158,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.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.0.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

@@ -1,5 +1,6 @@
 """Maps OSC addresses to handler functions"""
 
+import asyncio
 import collections
 import inspect
 import logging
@@ -80,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
@@ -87,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,
@@ -102,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(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]]: ...
 
-        ``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)]:``
+        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
@@ -240,8 +294,8 @@ class Dispatcher(object):
         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
@@ -272,7 +326,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)
@@ -309,46 +363,13 @@ 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:
             pass

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

@@ -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, None]
+# 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:
@@ -193,12 +199,17 @@ 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:
+    """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

@@ -2,6 +2,7 @@
 
 import asyncio
 import os
+import socket
 import socketserver
 from socket import socket as _socket
 from typing import Any, Coroutine, Tuple, Union, cast
@@ -58,11 +59,16 @@ 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],
         dispatcher: Dispatcher,
         bind_and_activate: bool = True,
+        timeout: float | None = None,
+        family: socket.AddressFamily | None = None,
     ) -> None:
         """Initialize
 
@@ -70,9 +76,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

pythonosc/osc_tcp_server.py

@@ -33,67 +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.
@@ -105,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
                 )
@@ -120,47 +88,44 @@ 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],
         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 self.mode == MODE_1_0:
-            super().__init__(server_address, _TCPHandler1_0)
-        else:
-            super().__init__(server_address, _TCPHandler1_1)
-        self._dispatcher = dispatcher
+        self.dispatcher = dispatcher
+        self.framing = get_framing(mode)
 
-    @property
-    def dispatcher(self):
-        """Dispatcher accessor for handlers to dispatch osc messages."""
-        return self._dispatcher
+        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
+
+        super().__init__(server_address, TCPHandler)
 
 
 class BlockingOSCTCPServer(OSCTCPServer):
@@ -210,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
@@ -225,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()
 
@@ -235,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
                 )
@@ -322,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()