aioxlib 0.0.7__tar.gz → 0.0.8__tar.gz

{aioxlib-0.0.7 → aioxlib-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.0.7
+Version: 0.0.8
 Summary: Human friendly interface to XLib subsystems using asyncio python
 Author-email: Jose Tiago Macara Coutinho <coutinhotiago@gmail.com>
 License-Expression: GPL-3.0-or-later

{aioxlib-0.0.7 → aioxlib-0.0.8}/aioxlib/__init__.py

@@ -4,7 +4,7 @@
 # Copyright (c) 2026 Tiago Coutinho
 # Distributed under the GPLv3 license. See LICENSE for more info.
 
-__version__ = "0.0.7"
+__version__ = "0.0.8"
 
 import asyncio
 import enum
@@ -85,11 +85,6 @@ class EventMask(enum.IntFlag):
     OwnerGrabButton = 1 << 24
 
 
-class PacketType(enum.IntEnum):
-    Error = 0
-    Reply = 1
-
-
 class Event(enum.IntEnum):
     KeyPress = 2
     KeyRelease = 3
@@ -456,18 +451,20 @@ WINDOW_ATTR_ORDER = (
     ("cursor", CreateWindowAttributes.Cursor),
 )
 
+
+class StackMode(enum.IntEnum):
+    Above = 0
+    Below = 1
+    TopIf = 2
+    BottomIf = 3
+    Opposite = 4
+
+
 FirstExtensionError = 128
 LastExtensionError = 255
 InputOutput = 1
 InputOnly = 2
 
-CWX = 1 << 0
-CWY = 1 << 1
-CWWidth = 1 << 2
-CWHeight = 1 << 3
-CWBorderWidth = 1 << 4
-CWSibling = 1 << 5
-CWStackMode = 1 << 6
 
 ForgetGravity = 0
 NorthWestGravity = 1
@@ -492,11 +489,7 @@ SetModeDelete = 1
 DestroyAll = 0
 RetainPermanent = 1
 RetainTemporary = 2
-Above = 0
-Below = 1
-TopIf = 2
-BottomIf = 3
-Opposite = 4
+
 RaiseLowest = 0
 LowerHighest = 1
 
@@ -604,16 +597,38 @@ GC_ATTR_ORDER = (
     ("arc_mode", GCAttributes.ArcMode, "B3x"),
 )
 
-FontLeftToRight = 0
-FontRightToLeft = 1
-FontChange = 255
-
 
 class Allocate(enum.IntEnum):
     None_ = 0
     All = 1
 
 
+class ConfigureWindowAttributes(enum.IntFlag):
+    """Value-mask bits for ConfigureWindow (same as CW* constants)."""
+
+    X = 1 << 0
+    Y = 1 << 1
+    Width = 1 << 2
+    Height = 1 << 3
+    BorderWidth = 1 << 4
+    Sibling = 1 << 5
+    StackMode = 1 << 6
+
+
+CONFIGURE_WINDOW_ORDER = (
+    ("x", ConfigureWindowAttributes.X),
+    ("y", ConfigureWindowAttributes.Y),
+    ("width", ConfigureWindowAttributes.Width),
+    ("height", ConfigureWindowAttributes.Height),
+    ("border_width", ConfigureWindowAttributes.BorderWidth),
+    ("sibling", ConfigureWindowAttributes.Sibling),
+    ("stack_mode", ConfigureWindowAttributes.StackMode),
+)
+
+ontLeftToRight = 0
+FontRightToLeft = 1
+FontChange = 255
+
 DoRed = 1 << 0
 DoGreen = 1 << 1
 DoBlue = 1 << 2
@@ -777,34 +792,11 @@ def pack_setup(
     return struct.pack(fmt, byte_order, *protocol, n1, d1, auth_name, auth_data)
 
 
-async def read_setup(reader):
-    data = await reader.readexactly(1)
-    status = Status(ord(data))
-    if status == Status.Success:
-        head = "BxHHH"
-        head_len = struct.calcsize(head)
-        data += await reader.readexactly(head_len - 1)
-        status, proto_major, proto_minor, length = struct.unpack_from(head, data)
-        assert proto_major >= 11
-        length *= 4
-        data = await reader.readexactly(length)
-        return unpack_successfull_setup(data)[0]
-    elif status == Status.Failed:
-        head = "BBHHH"
-        head_len = struct.calcsize(head)
-        data += await reader.readexactly(head_len - 1)
-        status, _, proto_major, proto_minor, length = struct.unpack_from(head, data)
-        length *= 4
-        reason = (await reader.readexactly(length)).decode()
-        raise RuntimeError(reason)
-    elif status == Status.Authenticate:
-        head = "BxH"
-        head_len = struct.calcsize(head)
-        data = await reader.readexactly(head_len - 1)
-        status, length = struct.unpack_from(head, data)
-        n = ord(data[1]) * 4
-        reason = (await reader.readexactly(n)).decode()
-        raise ValueError(reason)
+def unpack_setup(data, offset=0):
+    _, proto_major, _, _ = struct.unpack_from("BxHHH", data, offset)
+    offset += 8
+    assert proto_major == PROTOCOL_MAJOR
+    return unpack_successfull_setup(data, offset)
 
 
 def unpack_successfull_setup(data, offset=0):
@@ -977,6 +969,35 @@ def pack_destroy_subwindows(wid) -> bytes:
     return struct.pack("BxHI", Command.DestroySubwindows, 2, wid)
 
 
+def pack_configure_window(window, **attrs) -> bytes:
+    """ConfigureWindow: change geometry and/or stacking of *window*.
+
+    Accepted keyword attributes (any subset)::
+
+        x, y, width, height, border_width, sibling, stack_mode
+
+    Values are sent in protocol order; each is a CARD32 (16-bit geometry
+    fields occupy the low 16 bits).
+    """
+    mask = ConfigureWindowAttributes(0)
+    values = []
+    for name, bit in CONFIGURE_WINDOW_ORDER:
+        if (val := attrs.get(name)) is None:
+            continue
+        mask |= bit
+        values.append(int(val))
+    length = 3 + len(values)
+    header = struct.pack(
+        "=BxHIH2x",
+        Command.ConfigureWindow,
+        length,
+        int(window),
+        int(mask),
+    )
+    body = b"".join(struct.pack("=I", v) for v in values)
+    return header + body
+
+
 def pack_list_properties(wid) -> bytes:
     return struct.pack("BxHI", Command.ListProperties, 2, wid)
 
@@ -1121,6 +1142,14 @@ def unpack_error(data: bytes, offset: int = 0):
     return result, offset
 
 
+def unpack_setup_error(data, offset=0):
+    *_, length = struct.unpack_from("BBHHH", data, offset)
+    length *= 4
+    offset += 8
+    error = data[offset : offset + length].strip(b"\x00").decode()
+    return error, offset + length
+
+
 def unpack_event(event_map, data: bytes, offset: int = 0):
     raw_event_type = data[0]
     # Skip bit 8, that is set if this event came from an SendEvent
@@ -1336,6 +1365,19 @@ def unpack_get_geometry(data, offset=0):
     return result, offset + 32
 
 
+def pack_reparent_window(window, parent, x, y) -> bytes:
+    """ReparentWindow: move *window* under *parent* at (x, y) in parent coords."""
+    return struct.pack(
+        "BxHIIhh",
+        Command.ReparentWindow,
+        4,
+        window,
+        parent,
+        x,
+        y,
+    )
+
+
 def get_auth_config(filename: str) -> list[dict]:
     with open(filename, "rb") as f:
         raw = f.read()
@@ -1409,7 +1451,7 @@ class Screen:
 
 
 class Resource:
-    def __init__(self, display, rid):
+    def __init__(self, display: "Display", rid):
         self.display = display
         self.id = rid
 
@@ -1559,6 +1601,33 @@ class Window(Drawable):
         """Allocate a colormap for *visual* on the screen of *window* (default: root)."""
         return await self.display.create_colormap(visual, window or self, alloc)
 
+    async def reparent(self, parent, x=0, y=0):
+        """Reparent this window under *parent* at (*x*, *y*) in parent coordinates.
+
+        The window should typically be unmapped first (X servers often require
+        it). After reparenting, map it again if it should be visible.
+        """
+        return await self.display.reparent_window(self, parent, x, y)
+
+    async def configure(self, **attrs):
+        return await self.display.configure_window(self, **attrs)
+
+    async def move(self, x, y):
+        """Move this window to (*x*, *y*) in parent coordinates."""
+        return await self.configure(x=x, y=y)
+
+    async def resize(self, width, height):
+        """Resize this window to *width* × *height*."""
+        return await self.configure(width=width, height=height)
+
+    async def raise_(self):
+        """Raise this window to the top of the stack in its parent."""
+        return await self.configure(stack_mode=StackMode.Above)
+
+    async def lower(self):
+        """Lower this window to the bottom of the stack in its parent."""
+        return await self.configure(stack_mode=StackMode.Below)
+
 
 class GC(Resource):
     def __init__(self, display, rid, drawable):
@@ -1626,9 +1695,6 @@ class Connection:
     async def read(self, n=-1):
         return await self.reader.read(n)
 
-    async def readexactly(self, n):
-        return await self.reader.readexactly(n)
-
 
 async def open_connection(config: dict) -> Connection:
     protocol = config["protocol"]
@@ -4073,7 +4139,7 @@ def unpack_render_query_pict_formats(data, offset=0):
         d["visuals"] = visuals[vi : vi + d["n_visuals"]]
         vi += d["n_visuals"]
     di = 0
-    for s, n in zip(screens, depth_headers):
+    for s, n in zip(screens, depth_headers, strict=True):
         s["depths"] = depths[di : di + n]
         di += n
 
@@ -4144,9 +4210,7 @@ def pack_render_set_picture_clip_rectangles(opcode, picture, x_origin, y_origin,
 
 
 def pack_render_free_picture(opcode, picture):
-    return struct.pack(
-        "BBHI", opcode, RenderCommand.FreePicture, 2, int(picture)
-    )
+    return struct.pack("BBHI", opcode, RenderCommand.FreePicture, 2, int(picture))
 
 
 def pack_render_composite(
@@ -4200,9 +4264,7 @@ def pack_render_fill_rectangles(opcode, op, dst, color, rects):
         0,
         dst,
     )
-    body = pack_render_color(*color) + b"".join(
-        struct.pack("hhHH", *r) for r in rects
-    )
+    body = pack_render_color(*color) + b"".join(struct.pack("hhHH", *r) for r in rects)
     return header + body
 
 
@@ -4242,9 +4304,7 @@ def pack_render_set_picture_filter(opcode, picture, name, values=()):
 
 
 def pack_render_query_filters(opcode, drawable):
-    return struct.pack(
-        "BBHI", opcode, RenderCommand.QueryFilters, 2, int(drawable)
-    )
+    return struct.pack("BBHI", opcode, RenderCommand.QueryFilters, 2, int(drawable))
 
 
 def unpack_render_query_filters(data, offset=0):
@@ -4299,9 +4359,7 @@ def pack_render_create_linear_gradient(opcode, pid, p1, p2, stops):
     return header + body
 
 
-def pack_render_create_radial_gradient(
-    opcode, pid, inner, outer, inner_radius, outer_radius, stops
-):
+def pack_render_create_radial_gradient(opcode, pid, inner, outer, inner_radius, outer_radius, stops):
     n = len(stops)
     length = 9 + n + n * 2
     header = struct.pack(
@@ -4424,9 +4482,7 @@ def pack_render_create_glyphset(opcode, gsid, format):
 
 
 def pack_render_free_glyphset(opcode, gsid):
-    return struct.pack(
-        "BBHI", opcode, RenderCommand.FreeGlyphSet, 2, gsid
-    )
+    return struct.pack("BBHI", opcode, RenderCommand.FreeGlyphSet, 2, gsid)
 
 
 def pack_render_add_glyphs(opcode, gsid, glyph_ids, glyph_infos, data):
@@ -4436,14 +4492,9 @@ def pack_render_add_glyphs(opcode, gsid, glyph_ids, glyph_infos, data):
     n = len(glyph_ids)
     if n != len(glyph_infos):
         raise ValueError("glyph_ids and glyph_infos length mismatch")
-    info_bytes = b"".join(
-        struct.pack("HHhh hh", *info) for info in glyph_infos
-    )
+    info_bytes = b"".join(struct.pack("HHhh hh", *info) for info in glyph_infos)
     # each GlyphInfo is 12 bytes
-    info_bytes = b"".join(
-        struct.pack("HHhhhh", w, h, x, y, xo, yo)
-        for (w, h, x, y, xo, yo) in glyph_infos
-    )
+    info_bytes = b"".join(struct.pack("HHhhhh", w, h, x, y, xo, yo) for (w, h, x, y, xo, yo) in glyph_infos)
     ids_bytes = b"".join(struct.pack("I", int(g)) for g in glyph_ids)
     # pad image data to 32-bit
     pad = (4 - (len(data) % 4)) % 4
@@ -4463,16 +4514,12 @@ def pack_render_add_glyphs(opcode, gsid, glyph_ids, glyph_infos, data):
 def pack_render_free_glyphs(opcode, gsid, glyph_ids):
     n = len(glyph_ids)
     length = 2 + n
-    header = struct.pack(
-        "BBHI", opcode, RenderCommand.FreeGlyphs, length, int(gsid)
-    )
+    header = struct.pack("BBHI", opcode, RenderCommand.FreeGlyphs, length, int(gsid))
     body = b"".join(struct.pack("I", int(g)) for g in glyph_ids)
     return header + body
 
 
-def pack_render_composite_glyphs8(
-    opcode, op, src, dst, mask_format, glyphset, src_x, src_y, elements
-):
+def pack_render_composite_glyphs8(opcode, op, src, dst, mask_format, glyphset, src_x, src_y, elements):
     """elements: sequence of (delta_x, delta_y, glyphs_bytes_or_str).
 
     Each element becomes an xGlyphElt: 1-byte length + deltas + glyph 8-bit ids,
@@ -4552,9 +4599,7 @@ class Render(Extension):
 
     async def query_pict_formats(self):
         payload = pack_render_query_pict_formats(self.code)
-        reply = await self.display.write_read(
-            payload, unpack_render_query_pict_formats
-        )
+        reply = await self.display.write_read(payload, unpack_render_query_pict_formats)
         self._formats = reply
         return reply
 
@@ -4584,9 +4629,7 @@ class Render(Extension):
         """Create a Picture for *drawable* using PictFormat *format*."""
         if pid is None:
             pid = self.display.resources.allocate()
-        payload = pack_render_create_picture(
-            self.code, pid, drawable, format, **attrs
-        )
+        payload = pack_render_create_picture(self.code, pid, drawable, format, **attrs)
         self.display.write(payload)
         return pid
 
@@ -4595,9 +4638,7 @@ class Render(Extension):
         self.display.write(payload)
 
     async def set_clip_rectangles(self, picture, x_origin, y_origin, rects):
-        payload = pack_render_set_picture_clip_rectangles(
-            self.code, picture, x_origin, y_origin, rects
-        )
+        payload = pack_render_set_picture_clip_rectangles(self.code, picture, x_origin, y_origin, rects)
         self.display.write(payload)
 
     async def free_picture(self, picture):
@@ -4651,9 +4692,7 @@ class Render(Extension):
 
     async def set_filter(self, picture, name, values=()):
         """Set filter name (e.g. ``\"bilinear\"``, ``\"nearest\"``) and params."""
-        payload = pack_render_set_picture_filter(
-            self.code, picture, name, values
-        )
+        payload = pack_render_set_picture_filter(self.code, picture, name, values)
         self.display.write(payload)
 
     async def query_filters(self, drawable):
@@ -4670,46 +4709,30 @@ class Render(Extension):
     async def create_linear_gradient(self, p1, p2, stops, pid=None):
         if pid is None:
             pid = self.display.resources.allocate()
-        payload = pack_render_create_linear_gradient(
-            self.code, pid, p1, p2, stops
-        )
+        payload = pack_render_create_linear_gradient(self.code, pid, p1, p2, stops)
         self.display.write(payload)
         return pid
 
-    async def create_radial_gradient(
-        self, inner, outer, inner_radius, outer_radius, stops, pid=None
-    ):
+    async def create_radial_gradient(self, inner, outer, inner_radius, outer_radius, stops, pid=None):
         if pid is None:
             pid = self.display.resources.allocate()
-        payload = pack_render_create_radial_gradient(
-            self.code, pid, inner, outer, inner_radius, outer_radius, stops
-        )
+        payload = pack_render_create_radial_gradient(self.code, pid, inner, outer, inner_radius, outer_radius, stops)
         self.display.write(payload)
         return pid
 
     async def create_conical_gradient(self, center, angle, stops, pid=None):
         if pid is None:
             pid = self.display.resources.allocate()
-        payload = pack_render_create_conical_gradient(
-            self.code, pid, center, angle, stops
-        )
+        payload = pack_render_create_conical_gradient(self.code, pid, center, angle, stops)
         self.display.write(payload)
         return pid
 
-    async def trapezoids(
-        self, op, src, dst, src_x, src_y, traps, mask_format=0
-    ):
-        payload = pack_render_trapezoids(
-            self.code, op, src, dst, mask_format, src_x, src_y, traps
-        )
+    async def trapezoids(self, op, src, dst, src_x, src_y, traps, mask_format=0):
+        payload = pack_render_trapezoids(self.code, op, src, dst, mask_format, src_x, src_y, traps)
         self.display.write(payload)
 
-    async def triangles(
-        self, op, src, dst, src_x, src_y, tris, mask_format=0
-    ):
-        payload = pack_render_triangles(
-            self.code, op, src, dst, mask_format, src_x, src_y, tris
-        )
+    async def triangles(self, op, src, dst, src_x, src_y, tris, mask_format=0):
+        payload = pack_render_triangles(self.code, op, src, dst, mask_format, src_x, src_y, tris)
         self.display.write(payload)
 
     async def create_glyphset(self, format, gsid=None):
@@ -4723,9 +4746,7 @@ class Render(Extension):
         self.display.write(pack_render_free_glyphset(self.code, gsid))
 
     async def add_glyphs(self, gsid, glyph_ids, glyph_infos, data):
-        payload = pack_render_add_glyphs(
-            self.code, gsid, glyph_ids, glyph_infos, data
-        )
+        payload = pack_render_add_glyphs(self.code, gsid, glyph_ids, glyph_infos, data)
         self.display.write(payload)
 
     async def free_glyphs(self, gsid, glyph_ids):
@@ -4842,9 +4863,6 @@ class Display:
     async def read(self, n=-1):
         return await self.connection.read(n)
 
-    async def readexactly(self, n):
-        return await self.connection.readexactly(n)
-
     def write_read(self, payload, callback):
         future = asyncio.Future()
         self.requests.put_nowait((callback, future))
@@ -4855,15 +4873,14 @@ class Display:
         await self.connection.flush()
 
     async def setup(self):
+        if self._task is None:
+            self._task = asyncio.create_task(self._loop())
         entry = auth(self.connection)
-        req = pack_setup(entry["name"], entry["data"])
-        self.write(req)
-        await self.flush()
-        info = await read_setup(self)
+        payload = pack_setup(entry["name"], entry["data"])
+        info = await self.write_read(payload, unpack_setup)
         self.info = info
         self.resources = ResourceManager(info["resource_id_base"], info["resource_id_mask"])
         self.screens = [Screen(self, sinfo) for sinfo in info["screens"]]
-        self._task = asyncio.create_task(self._loop())
         return info
 
     async def intern_atom(self, name, only_if_exists=False):
@@ -4937,6 +4954,15 @@ class Display:
         payload = pack_destroy_window(wnd)
         self.write(payload)
 
+    async def configure_window(self, window, **attrs):
+        """Configure geometry and/or stacking of *window*.
+
+        Keyword attributes: ``x``, ``y``, ``width``, ``height``,
+        ``border_width``, ``sibling``, ``stack_mode``.
+        """
+        payload = pack_configure_window(window, **attrs)
+        self.write(payload)
+
     async def list_properties(self, wnd):
         payload = pack_list_properties(wnd)
         reply = await self.write_read(payload, unpack_list_properties)
@@ -4997,6 +5023,11 @@ class Display:
     async def free_colormap(self, cid):
         self.write(pack_free_colormap(cid))
 
+    async def reparent_window(self, window, parent, x=0, y=0):
+        """Reparent *window* under *parent* at (*x*, *y*) in parent coordinates."""
+        payload = pack_reparent_window(window, parent, x, y)
+        self.write(payload)
+
     def add_listener(self, listener):
         self.listeners.add(listener)
 
@@ -5030,29 +5061,36 @@ class Display:
         return error
 
     async def _loop(self):
-        buffer = b""
+        buffer, decoder = b"", None
         while True:
-            if not (data := await self.read(16 * 1024)):
+            if not (data := await self.read(4 * 1024)):
                 log.info("Connection closed")
                 return
             buffer += data
             packet_type = buffer[0]
-            if packet_type in PacketType:
-                if packet_type == PacketType.Reply:
-                    size = 32 + 4 * int.from_bytes(buffer[4:8], BYTE_ORDER_TEXT)
+            if packet_type in Status:
+                if decoder is None:
+                    decoder = await self.requests.get()
+                decode, future = decoder
+                if packet_type == Status.Success:
+                    if decode == unpack_setup:
+                        size = 8 + 4 * int.from_bytes(buffer[6:8], BYTE_ORDER_TEXT)
+                    else:
+                        size = 32 + 4 * int.from_bytes(buffer[4:8], BYTE_ORDER_TEXT)
                     if len(buffer) < size:
                         continue
-                    decode, future = await self.requests.get()
                     reply, offset = decode(buffer, 0)
                     future.set_result(reply)
-                elif packet_type == PacketType.Error:
-                    error, offset = unpack_error(buffer)
-                    error = self._handle_error(error)
-                    log.warning("ERROR: %s", error)
-                    if self.requests.empty():
-                        continue
-                    _, future = self.requests.get_nowait()
-                    future.set_exception(X11Error(error))
+                elif packet_type == Status.Failed:
+                    if decode == unpack_setup:
+                        error, offset = unpack_setup_error(buffer)
+                        future.set_exception(RuntimeError(error))
+                    else:
+                        error, offset = unpack_error(buffer)
+                        error = self._handle_error(error)
+                        log.warning("ERROR: %s", error)
+                        future.set_exception(X11Error(error))
+                decoder = None
             else:
                 event, offset = unpack_event(self._events, buffer)
                 for listener in self.listeners:

{aioxlib-0.0.7 → aioxlib-0.0.8}/aioxlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioxlib
-Version: 0.0.7
+Version: 0.0.8
 Summary: Human friendly interface to XLib subsystems using asyncio python
 Author-email: Jose Tiago Macara Coutinho <coutinhotiago@gmail.com>
 License-Expression: GPL-3.0-or-later

{aioxlib-0.0.7 → aioxlib-0.0.8}/tests/test_aioxlib.py

@@ -96,7 +96,6 @@ from aioxlib import (
     pack_unmap_window,
     pad,
     parse_font_name,
-    read_setup,
     round_bytes,
     unpack_client_message,
     unpack_dbe_get_back_buffer_attributes,
@@ -1319,114 +1318,6 @@ def _make_reader(data: bytes) -> asyncio.StreamReader:
     return reader
 
 
-class TestReadSetup:
-    @pytest.mark.asyncio
-    async def test_success(self):
-        reply = build_success_reply()
-        reader = _make_reader(reply)
-        setup = await read_setup(reader)
-        assert setup["vendor"] == "XOrg"
-        assert setup["root_length"] == 1
-        assert len(setup["screens"]) == 1
-        assert setup["screens"][0]["width"] == 1920
-
-    @pytest.mark.asyncio
-    async def test_success_custom_body(self):
-        body = build_success_setup_body(vendor="XOrg", release=42)
-        reply = build_success_reply(body)
-        setup = await read_setup(_make_reader(reply))
-        assert setup["release"] == 42
-        assert setup["vendor"] == "XOrg"
-
-    @pytest.mark.asyncio
-    async def test_failed(self):
-        reason = "No protocol specified"
-        reason_b = reason.encode("latin-1")
-        # pad reason to 4-byte boundary for length field
-        padded = reason_b + b"\0" * pad(len(reason_b))
-        length_units = len(padded) // 4
-        # status(B) n(B) major(H) minor(H) length(H) then reason
-        header = struct.pack(
-            "=BBHHH",
-            Status.Failed,
-            len(reason_b),  # n = length of reason string (unpadded)
-            PROTOCOL_MAJOR,
-            PROTOCOL_MINOR,
-            length_units,
-        )
-        reply = header + padded
-        reader = _make_reader(reply)
-        with pytest.raises(RuntimeError, match="No protocol specified"):
-            await read_setup(reader)
-
-    @pytest.mark.asyncio
-    async def test_authenticate(self):
-        """Authenticate branch of read_setup.
-
-        Note: the current implementation replaces ``data`` with only
-        ``head_len - 1`` (3) bytes, then calls ``struct.unpack_from("BxH",
-        data)`` which needs 4 bytes. That is a library bug; this test
-        documents the actual behaviour (struct.error). When the library
-        is fixed to append/read 4 bytes, switch the expectation to
-        ValueError with the reason string.
-        """
-        reason = "Authorization required"
-        reason_b = reason.encode("latin-1")
-        padded = reason_b + b"\0" * pad(len(reason_b))
-        n_byte = len(padded) // 4
-        # status + 3-byte partial header + reason (matches current read size)
-        partial = bytes([0, n_byte, 0])
-        reply = bytes([Status.Authenticate]) + partial + padded
-        reader = _make_reader(reply)
-        with pytest.raises(struct.error):
-            await read_setup(reader)
-
-    @pytest.mark.asyncio
-    async def test_authenticate_with_enough_header_bytes(self):
-        """If the reader supplies a full 4-byte header after status, the
-        branch can still raise ValueError once unpack succeeds.
-
-        Current code: readexactly(3) only — so we cannot reach ValueError
-        without changing the library. This test keeps a clear target for
-        a future fix by using a custom reader that yields 4 bytes.
-        """
-        reason = "Authorization required"
-        reason_b = reason.encode("latin-1")
-        padded = reason_b + b"\0" * pad(len(reason_b))
-        n_byte = len(padded) // 4
-
-        class FakeReader:
-            def __init__(self):
-                self._chunks = [
-                    bytes([Status.Authenticate]),
-                    # pretend the library asked for 4 bytes (fixed behaviour)
-                    bytes([0, n_byte, 0, 0]),
-                    padded,
-                ]
-
-            async def readexactly(self, n):
-                chunk = self._chunks.pop(0)
-                if len(chunk) != n:
-                    # emulate real StreamReader: return exactly n if available
-                    if len(chunk) > n:
-                        self._chunks.insert(0, chunk[n:])
-                        return chunk[:n]
-                    raise asyncio.IncompleteReadError(chunk, n)
-                return chunk
-
-        # With the *current* library (reads 3 bytes), FakeReader still fails
-        # the same way. Assert that we get an error either way.
-        with pytest.raises((struct.error, ValueError, asyncio.IncompleteReadError)):
-            await read_setup(FakeReader())
-
-    @pytest.mark.asyncio
-    async def test_success_then_eof_is_ok(self):
-        reply = build_success_reply(build_success_setup_body(vendor="XOrg"))
-        reader = _make_reader(reply)
-        setup = await read_setup(reader)
-        assert "screens" in setup
-
-
 # ---------------------------------------------------------------------------
 # End-to-end: pack client setup ↔ shape of a server Success body
 # ---------------------------------------------------------------------------
@@ -1460,7 +1351,6 @@ def mock_connection():
     conn.write = MagicMock()
     conn.flush = AsyncMock()
     conn.read = AsyncMock(return_value=b"")
-    conn.readexactly = AsyncMock()
     conn.aclose = AsyncMock()
     conn.close = MagicMock()
     conn.config = {"protocol": "unix", "port": 0, "screen": 0, "uri": ":0"}
@@ -2105,56 +1995,6 @@ class TestDisplay:
         display._task.cancel.assert_called_once()
         display.connection.close.assert_called_once()
 
-    @pytest.mark.asyncio
-    async def test_setup_wires_resources_and_screens(self, mock_connection):
-        from aioxlib import unpack_successfull_setup
-
-        body = build_success_setup_body(vendor="XOrg")
-        length_units = len(body) // 4
-        header = struct.pack("=BxHHH", 1, 11, 0, length_units)
-        reply = header + body
-
-        buf = reply
-
-        async def readexactly(n):
-            nonlocal buf
-            if len(buf) < n:
-                raise asyncio.IncompleteReadError(buf, n)
-            chunk, buf = buf[:n], buf[n:]
-            return chunk
-
-        mock_connection.readexactly = readexactly
-        mock_connection.read = AsyncMock(return_value=b"")  # _loop exits immediately
-        mock_connection.flush = AsyncMock()
-        mock_connection.write = MagicMock()
-        mock_connection.config = {
-            "protocol": "unix",
-            "port": 0,
-            "screen": 0,
-            "uri": ":0",
-            "host": "",
-        }
-
-        d = Display(mock_connection, mock_connection.config)
-
-        with patch("aioxlib.auth") as mock_auth:
-            mock_auth.return_value = {
-                "name": b"MIT-MAGIC-COOKIE-1",
-                "data": b"\x00" * 16,
-            }
-            info = await d.setup()
-
-        assert info is d.info
-        assert d.resources is not None
-        assert len(d.screens) >= 1
-        assert isinstance(d.screens[0], Screen)
-        assert d._task is not None
-        # clean up background _loop task
-        await d.aclose()
-        rid = d.resources.allocate()
-        expected = unpack_successfull_setup(body)[0]
-        assert rid == expected["resource_id_base"]
-
 
 # ---------------------------------------------------------------------------
 # Pipeline
@@ -2394,13 +2234,6 @@ class TestConnection:
         assert await conn.read(3) == b"xyz"
         reader.read.assert_awaited_with(3)
 
-    @pytest.mark.asyncio
-    async def test_readexactly(self):
-        reader = MagicMock()
-        reader.readexactly = AsyncMock(return_value=b"ab")
-        conn = Connection(reader, MagicMock(), {})
-        assert await conn.readexactly(2) == b"ab"
-
     def test_socket_and_xfamily_unix(self):
         sock = MagicMock()
         sock.family = socket.AF_UNIX
@@ -3112,7 +2945,6 @@ def display_full():
     conn.write = MagicMock()
     conn.flush = AsyncMock()
     conn.read = AsyncMock(return_value=b"")
-    conn.readexactly = AsyncMock()
     conn.aclose = AsyncMock()
     conn.close = MagicMock()
     conn.config = {"protocol": "unix", "port": 0, "screen": 0, "uri": ":0", "host": ""}
@@ -3296,11 +3128,6 @@ class TestDisplayExtended:
         display_full.connection.read = AsyncMock(return_value=b"data")
         assert await display_full.read(4) == b"data"
 
-    @pytest.mark.asyncio
-    async def test_readexactly_delegates(self, display_full):
-        display_full.connection.readexactly = AsyncMock(return_value=b"xy")
-        assert await display_full.readexactly(2) == b"xy"
-
     @pytest.mark.asyncio
     async def test_loop_dispatches_reply(self, display_full):
         # Build a minimal reply packet (32 bytes, length=0)
@@ -3314,13 +3141,6 @@ class TestDisplayExtended:
         assert fut.done()
         assert fut.result() == {"ok": True}
 
-    @pytest.mark.asyncio
-    async def test_loop_dispatches_error(self, display_full):
-        err = struct.pack("=BBHIHB21x", 0, 3, 1, 0, 0, 1)  # BadWindow
-        display_full.connection.read = AsyncMock(side_effect=[err, b""])
-        # should not raise — just log
-        await display_full._loop()
-
     @pytest.mark.asyncio
     async def test_loop_dispatches_event_to_listeners(self, display_full):
         evt = _generic_event(Event.Expose)