python-libei 0.5.1__py3-none-any.whl → 0.6.0__py3-none-any.whl

libei/__init__.py

@@ -31,6 +31,6 @@ the full breakdown, including which features need which libei version.
 Beta: the API is not frozen.
 """
 
-__version__ = "0.5.1"
+__version__ = "0.6.0"
 
 __all__ = ["__version__"]

libei/_capi/__init__.py

@@ -1,5 +1,8 @@
-"""Low-level ctypes bindings. Not part of the public API -- use
-``libei.ei``, ``libei.eis`` and ``libei.oeffis`` instead."""
+"""Low-level ctypes bindings.
+
+Not part of the public API -- use ``libei.ei``, ``libei.eis`` and
+``libei.oeffis`` instead.
+"""
 
 from . import libei, libeis, liboeffis
 

libei/_capi/loader.py

@@ -25,12 +25,18 @@ class LazyLibrary:
     """A ctypes.CDLL that only opens the library on first real use."""
 
     def __init__(self, soname: str) -> None:
+        """Remember the soname; nothing is opened until first use."""
         self._soname = soname
         self._lib: ctypes.CDLL | None = None
         self._load_error: OSError | None = None
         self._lock = threading.Lock()
 
     def _ensure_loaded(self) -> ctypes.CDLL:
+        """Return the opened library, opening it on first call.
+
+        Raises LibraryNotFoundError on every later call too after a failure:
+        the failed load is cached rather than retried.
+        """
         # Double-checked: the unlocked read is the fast path taken by every
         # call after the first, and the repeated check inside the lock is
         # what makes it safe -- two threads can both fall through the first
@@ -91,6 +97,7 @@ class LazyLibrary:
         cache: dict[str, Any] = {}
 
         def call(*args: Any) -> Any:
+            """Resolve the C function on first call, then pass straight through."""
             # Resolution happens here, on first call, not at bind time --
             # that is the whole point of this module (see its docstring).
             bound = cache.get("f")

libei/_cobject.py

@@ -66,6 +66,7 @@ class CObject:
     _instances_lock: ClassVar[threading.RLock]
 
     def __init_subclass__(cls, **kwargs: Any) -> None:
+        """Give each wrapper hierarchy one identity cache, shared by subclasses."""
         super().__init_subclass__(**kwargs)
         # One cache per wrapper *hierarchy*, not per class. Only a root
         # wrapper class -- one whose only CObject ancestor is CObject
@@ -98,6 +99,7 @@ class CObject:
             cls._instances_lock = threading.RLock()
 
     def __init__(self, pointer: int, *, _adopt: bool = False) -> None:
+        """Take a reference on a non-NULL pointer and cache this wrapper for it."""
         if not pointer:
             raise ValueError(f"{type(self).__name__} cannot wrap a NULL pointer")
         self._pointer = pointer
@@ -121,6 +123,7 @@ class CObject:
 
     @property
     def _as_parameter_(self) -> int:
+        """The raw pointer ctypes passes to C -- an error once it is released."""
         if self._pointer == 0:
             raise RuntimeError(
                 f"{type(self).__name__} has already been released; "
@@ -159,6 +162,7 @@ class CObject:
 
     @classmethod
     def _get_or_create(cls: type[T], pointer: int | None, *, adopt: bool) -> T | None:
+        """The wrapper already caching this pointer, or a new one; None for NULL."""
         if not pointer:
             return None
         if not cls._wrappable:
@@ -232,6 +236,7 @@ class CObject:
         return cls._get_or_create(pointer, adopt=True)
 
     def __eq__(self, other: object) -> bool:
+        """Equal when the types match and the wrapped pointers are the same."""
         if not isinstance(other, CObject):
             return NotImplemented
         if type(self) is not type(other):
@@ -245,6 +250,7 @@ class CObject:
         return self._pointer == other._pointer
 
     def __hash__(self) -> int:
+        """Stable for the object's life: the original pointer, not the live one."""
         # Deliberately keyed on _hash_key, not _pointer: release() zeroes
         # _pointer, and an object whose hash changes mid-life vanishes
         # from any set or dict it was placed in. Two wrappers can share a

libei/ei.py

@@ -67,6 +67,7 @@ _emulating_sequence = itertools.count(1)
 
 
 def _next_emulating_sequence() -> int:
+    """The next emulating-event sequence number: 32-bit, and never 0."""
     # Masked into uint32 to match the C parameter. libei asks callers to
     # keep wraparound detection "reasonable"; skipping 0 keeps the value
     # away from anything that might read as unset.
@@ -87,6 +88,7 @@ class Error(Exception):
     """
 
     def __init__(self, message: str, errno: int | None = None) -> None:
+        """Record the failure message and, where libei reported one, errno."""
         super().__init__(message)
         self.message = message
         self.errno = errno
@@ -191,6 +193,8 @@ class KeymapType(enum.IntEnum):
 
 
 class _LogPriority(enum.IntEnum):
+    """The log levels, as the integers the C library passes to its handler."""
+
     DEBUG = 10
     INFO = 20
     WARNING = 30
@@ -199,6 +203,12 @@ class _LogPriority(enum.IntEnum):
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class XkbModifiersEvent:
+    """XKB modifier state from a KEYBOARD_MODIFIERS event.
+
+    ``depressed``/``latched``/``locked`` are XKB's own mod-state bitmasks;
+    ``group`` is the active keyboard layout group.
+    """
+
     depressed: int
     latched: int
     locked: int
@@ -207,48 +217,76 @@ class XkbModifiersEvent:
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class KeyEvent:
+    """Key code and press state from a KEYBOARD_KEY event.
+
+    ``key`` is a Linux ``KEY_*`` code, the same numbering
+    :meth:`Device.keyboard_key` sends.
+    """
+
     key: int
     is_press: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ButtonEvent:
+    """Button code and press state from a BUTTON_BUTTON event.
+
+    ``button`` is a Linux ``BTN_*`` code, the same numbering
+    :meth:`Device.button` sends.
+    """
+
     button: int
     is_press: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class PointerEvent:
+    """Relative motion deltas, in logical pixels, from a POINTER_MOTION event."""
+
     dx: float
     dy: float
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class PointerAbsoluteEvent:
+    """Absolute position from a POINTER_MOTION_ABSOLUTE event.
+
+    In the logical pixel space of the :class:`Region` the emitting device
+    covers -- see :meth:`Event.pointer_absolute_event`.
+    """
+
     x: float
     y: float
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ScrollEvent:
+    """Smooth scroll deltas from a SCROLL_DELTA event."""
+
     dx: float
     dy: float
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ScrollDiscreteEvent:
+    """Detent scroll deltas (120 per detent) from a SCROLL_DISCRETE event."""
+
     dx: int
     dy: int
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ScrollStopEvent:
+    """Which axes stopped scrolling, from a SCROLL_STOP/SCROLL_CANCEL event."""
+
     stop_x: bool
     stop_y: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TouchEvent:
+    """Touch id and position from a TOUCH_DOWN or TOUCH_MOTION event."""
+
     touchid: int
     x: float
     y: float
@@ -256,17 +294,26 @@ class TouchEvent:
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TouchUpEvent:
+    """Touch id and cancellation flag from a TOUCH_UP event.
+
+    See :meth:`Event.touch_up_event` for when ``is_cancel`` is trustworthy.
+    """
+
     touchid: int
     is_cancel: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TextUtf8Event:
+    """UTF-8 text carried by a TEXT_UTF8 event."""
+
     text: str
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TextKeysymEvent:
+    """Keysym and press state from a TEXT_KEYSYM event."""
+
     keysym: int
     is_press: bool
 
@@ -285,6 +332,7 @@ class Region(CObject):
     _unref_func = staticmethod(_capi.libei.region_unref)
 
     def __repr__(self) -> str:
+        """The size and position, as WxH+X+Y."""
         w, h = self.dimension
         x, y = self.position
         return f"<Region {w}x{h}+{x}+{y}>"
@@ -466,6 +514,7 @@ class Device(CObject):
     _unref_func = staticmethod(_capi.libei.device_unref)
 
     def __repr__(self) -> str:
+        """Name, device type and capabilities -- what tells two devices apart."""
         caps = "|".join(c.name or str(c.value) for c in self.capabilities)
         return f"<Device {self.name!r} {self.device_type.name} {caps}>"
 
@@ -545,9 +594,10 @@ class Device(CObject):
         return self
 
     def frame(self, timestamp: int | None = None) -> Device:
-        """Commit the events queued since the last frame as one logical
-        hardware event. ``timestamp`` defaults to the context's current
-        time."""
+        """Commit the events queued since the last frame as one logical hardware event.
+
+        ``timestamp`` defaults to the context's current time.
+        """
         if timestamp is None:
             timestamp = _capi.libei.now(_capi.libei.device_get_context(self))
         _capi.libei.device_frame(self, timestamp)
@@ -564,8 +614,10 @@ class Device(CObject):
         return self
 
     def button(self, button: int, is_press: bool) -> Device:
-        """Queue a button press or release. ``button`` is a Linux
-        ``BTN_*`` code (e.g. ``0x110`` for ``BTN_LEFT``)."""
+        """Queue a button press or release.
+
+        ``button`` is a Linux ``BTN_*`` code (e.g. ``0x110`` for ``BTN_LEFT``).
+        """
         _capi.libei.device_button_button(self, button, is_press)
         return self
 
@@ -645,6 +697,7 @@ class Seat(CObject):
     _unref_func = staticmethod(_capi.libei.seat_unref)
 
     def __repr__(self) -> str:
+        """The seat's name and capabilities."""
         caps = "|".join(c.name or str(c.value) for c in self.capabilities)
         return f"<Seat {self.name!r} {caps}>"
 
@@ -727,6 +780,7 @@ class Ping(CObject):
     _unref_func = staticmethod(_capi.libei.ping_unref)
 
     def __repr__(self) -> str:
+        """The ping's id, which is all a ping carries."""
         return f"<Ping {self.id}>"
 
     @property
@@ -754,14 +808,18 @@ class Event(CObject):
     _unref_func = staticmethod(_capi.libei.event_unref)
 
     def __repr__(self) -> str:
+        """The event type by name, or the raw value for one we do not model."""
         event_type = self.event_type
         label = event_type.name if isinstance(event_type, EventType) else event_type
         return f"<Event {label}>"
 
     @property
     def event_type(self) -> EventType | int:
-        """The event's type, or a raw int for a value newer than this
-        package's :class:`EventType` table -- see its docstring."""
+        """The event's type.
+
+        Returns a raw int for a value newer than this package's
+        :class:`EventType` table -- see its docstring.
+        """
         raw = _capi.libei.event_get_type(self)
         try:
             return EventType(raw)
@@ -958,6 +1016,11 @@ class Event(CObject):
 
 
 def _log_callback(_ei: int, priority: int, message: bytes, _context: int) -> None:
+    """Forward libei's log lines into the logging module.
+
+    Runs inside a ctypes callback, where an exception is printed to stderr
+    and then dropped, so every lookup below falls back rather than raising.
+    """
     # Look up the raw int, not _LogPriority(priority): constructing the
     # enum from an unrecognized value raises ValueError immediately, which
     # would happen *before* .get()'s default ever gets a chance to apply
@@ -1009,11 +1072,14 @@ class Context(CObject):
     _wrappable = False
 
     def __init__(self, pointer: int, *, _adopt: bool = False) -> None:
-        # _adopt is accepted and forwarded for signature consistency with
-        # CObject, but with _wrappable = False, _get_or_create() never
-        # actually reaches this constructor -- Context (and Sender/
-        # Receiver) are always built directly via cls(cls._new()) in
-        # create_for_fd()/create_for_socket().
+        """Wrap a freshly created ``struct ei *`` and arm its log handler.
+
+        _adopt is accepted and forwarded for signature consistency with
+        CObject, but with _wrappable = False, _get_or_create() never
+        actually reaches this constructor -- Context (and Sender/
+        Receiver) are always built directly via cls(cls._new()) in
+        create_for_fd()/create_for_socket().
+        """
         super().__init__(pointer, _adopt=_adopt)
         self._name: str | None = None
         _capi.libei.log_set_handler(self, _log_handler)
@@ -1081,7 +1147,8 @@ class Context(CObject):
         """Use an already-connected socket as the transport.
 
         libei takes ownership of a raw int fd and closes it itself; a file
-        object is duplicated first, so the caller's own object stays valid."""
+        object is duplicated first, so the caller's own object stays valid.
+        """
         # ei_setup_backend_fd() takes ownership of the fd and will close it
         # itself. A raw int is assumed to already be one the caller is
         # handing off (matching what eis.Eis.add_client()/oeffis.eis_fd
@@ -1099,7 +1166,8 @@ class Context(CObject):
         """Connect to an EIS socket by path.
 
         ``None`` uses ``$LIBEI_SOCKET``; a relative path is resolved
-        against ``$XDG_RUNTIME_DIR``."""
+        against ``$XDG_RUNTIME_DIR``.
+        """
         encoded = os.fspath(path).encode("utf-8") if path else None
         err = _capi.libei.setup_backend_socket(self, encoded)
         if err < 0:
@@ -1162,7 +1230,8 @@ class Context(CObject):
         """Read from the connection and queue any events that arrive.
 
         Call this before iterating :attr:`events`, which only drains what
-        is already queued."""
+        is already queued.
+        """
         _capi.libei.dispatch(self)
 
 
@@ -1171,6 +1240,7 @@ class Sender(Context):
 
     @classmethod
     def _new(cls) -> int:
+        """A new sender from the C library, or an error if it returned NULL."""
         pointer = _capi.libei.new_sender(c_void_p(None))
         if not pointer:
             raise Error("ei_new_sender() returned NULL")
@@ -1194,6 +1264,7 @@ class Receiver(Context):
 
     @classmethod
     def _new(cls) -> int:
+        """A new receiver from the C library, or an error if it returned NULL."""
         pointer = _capi.libei.new_receiver(c_void_p(None))
         if not pointer:
             raise Error("ei_new_receiver() returned NULL")
@@ -1224,6 +1295,10 @@ __all__ = [
     "KeyEvent",
     "Keymap",
     "KeymapType",
+    # Imported rather than defined here: every call bound through
+    # _capi.libei can raise it, so a caller importing from this module
+    # catches it from here too -- see docs/troubleshooting.md.
+    "LibraryNotFoundError",
     "Ping",
     "PointerAbsoluteEvent",
     "PointerEvent",

libei/eis.py

@@ -55,6 +55,7 @@ class Error(Exception):
     """
 
     def __init__(self, message: str, errno: int | None = None) -> None:
+        """Record the failure message and, where libeis reported one, errno."""
         super().__init__(message)
         self.message = message
         self.errno = errno
@@ -158,6 +159,8 @@ class Flag(enum.IntEnum):
 
 
 class _LogPriority(enum.IntEnum):
+    """The log levels, as the integers libeis passes to its log handler."""
+
     DEBUG = 10
     INFO = 20
     WARNING = 30
@@ -166,48 +169,75 @@ class _LogPriority(enum.IntEnum):
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class KeyEvent:
+    """Key code and press state received on a KEYBOARD_KEY event.
+
+    ``key`` is a Linux ``KEY_*`` code, as sent by the client's
+    ``ei.Device.keyboard_key``.
+    """
+
     key: int
     is_press: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ButtonEvent:
+    """Button code and press state received on a BUTTON_BUTTON event.
+
+    ``button`` is a Linux ``BTN_*`` code, as sent by the client's
+    ``ei.Device.button``.
+    """
+
     button: int
     is_press: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class PointerEvent:
+    """Relative motion deltas, in logical pixels, from a POINTER_MOTION event."""
+
     dx: float
     dy: float
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class PointerAbsoluteEvent:
+    """Absolute position from a POINTER_MOTION_ABSOLUTE event.
+
+    In the logical pixel space of the region the sending device covers.
+    """
+
     x: float
     y: float
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ScrollEvent:
+    """Smooth scroll deltas from a SCROLL_DELTA event."""
+
     dx: float
     dy: float
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ScrollDiscreteEvent:
+    """Detent scroll deltas (120 per detent) from a SCROLL_DISCRETE event."""
+
     dx: int
     dy: int
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class ScrollStopEvent:
+    """Which axes stopped scrolling, from a SCROLL_STOP/SCROLL_CANCEL event."""
+
     stop_x: bool
     stop_y: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TouchEvent:
+    """Touch id and position from a TOUCH_DOWN or TOUCH_MOTION event."""
+
     touchid: int
     x: float
     y: float
@@ -215,17 +245,23 @@ class TouchEvent:
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TouchUpEvent:
+    """Touch id and cancellation flag from a TOUCH_UP event."""
+
     touchid: int
     is_cancel: bool
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TextUtf8Event:
+    """UTF-8 text carried by a TEXT_UTF8 event."""
+
     text: str
 
 
 @dataclasses.dataclass(frozen=True, slots=True)
 class TextKeysymEvent:
+    """Keysym and press state from a TEXT_KEYSYM event."""
+
     keysym: int
     is_press: bool
 
@@ -422,6 +458,7 @@ class Device(CObject):
     _unref_func = staticmethod(_capi.libeis.device_unref)
 
     def __repr__(self) -> str:
+        """Name, device type and capabilities -- what tells two devices apart."""
         caps = "|".join(c.name or str(c.value) for c in self.capabilities)
         return f"<Device {self.name!r} {self.device_type.name} {caps}>"
 
@@ -576,8 +613,10 @@ class Device(CObject):
         return self
 
     def frame(self, timestamp: int | None = None) -> Device:
-        """Commit the events queued since the last frame as one logical
-        hardware event. ``timestamp`` defaults to the context's current time."""
+        """Commit the events queued since the last frame as one logical hardware event.
+
+        ``timestamp`` defaults to the context's current time.
+        """
         if timestamp is None:
             timestamp = _capi.libeis.now(_capi.libeis.device_get_context(self))
         _capi.libeis.device_frame(self, timestamp)
@@ -673,6 +712,7 @@ class Seat(CObject):
     _unref_func = staticmethod(_capi.libeis.seat_unref)
 
     def __repr__(self) -> str:
+        """The seat's name and capabilities."""
         caps = "|".join(c.name or str(c.value) for c in self.capabilities)
         return f"<Seat {self.name!r} {caps}>"
 
@@ -734,6 +774,7 @@ class Client(CObject):
     _unref_func = staticmethod(_capi.libeis.client_unref)
 
     def __repr__(self) -> str:
+        """The client's name and which side of the protocol it is on."""
         return f"<Client {self.name!r} sender={self.is_sender}>"
 
     @property
@@ -804,6 +845,7 @@ class Ping(CObject):
     _unref_func = staticmethod(_capi.libeis.ping_unref)
 
     def __repr__(self) -> str:
+        """The ping's id, which is all a ping carries."""
         return f"<Ping {self.id}>"
 
     @property
@@ -831,14 +873,18 @@ class Event(CObject):
     _unref_func = staticmethod(_capi.libeis.event_unref)
 
     def __repr__(self) -> str:
+        """The event type by name, or the raw value for one we do not model."""
         event_type = self.event_type
         label = event_type.name if isinstance(event_type, EventType) else event_type
         return f"<Event {label}>"
 
     @property
     def event_type(self) -> EventType | int:
-        """The event's type, or a raw int for a value newer than this
-        package's :class:`EventType` table -- see its docstring."""
+        """The event's type.
+
+        Returns a raw int for a value newer than this package's
+        :class:`EventType` table -- see its docstring.
+        """
         raw = _capi.libeis.event_get_type(self)
         try:
             return EventType(raw)
@@ -1040,6 +1086,11 @@ class Event(CObject):
 
 
 def _log_callback(_eis: int, priority: int, message: bytes, _context: int) -> None:
+    """Forward libeis's log lines into the logging module.
+
+    The same constraint as ei.py's callback of that name: it runs inside a
+    ctypes callback, so it falls back rather than raising.
+    """
     # See ei.py's _log_callback: look up the raw int, not
     # _LogPriority(priority), which would raise ValueError before .get()'s
     # default could apply -- silently, since this runs inside a ctypes
@@ -1069,10 +1120,13 @@ class Eis(CObject):
     _wrappable = False
 
     def __init__(self, pointer: int, *, _adopt: bool = False) -> None:
-        # _adopt is accepted and forwarded for signature consistency with
-        # CObject, but with _wrappable = False, _get_or_create() never
-        # actually reaches this constructor -- Eis is always built directly
-        # via cls(cls._new()) in create_for_fd().
+        """Wrap a freshly created ``struct eis *`` and arm its log handler.
+
+        _adopt is accepted and forwarded for signature consistency with
+        CObject, but with _wrappable = False, _get_or_create() never
+        actually reaches this constructor -- Eis is always built directly
+        via cls(cls._new()) in create_for_fd().
+        """
         super().__init__(pointer, _adopt=_adopt)
         _capi.libeis.log_set_handler(self, _log_handler)
         _capi.libeis.log_set_priority(self, _LogPriority.DEBUG)
@@ -1146,7 +1200,8 @@ class Eis(CObject):
         """Read from the connection and queue any events that arrive.
 
         Call this before iterating :attr:`events`, which only drains what
-        is already queued."""
+        is already queued.
+        """
         _capi.libeis.dispatch(self)
 
     def add_client(self) -> int:
@@ -1165,6 +1220,7 @@ class Eis(CObject):
 
     @classmethod
     def _new(cls) -> int:
+        """A new server from the C library, or an error if it returned NULL."""
         pointer = _capi.libeis.new(c_void_p(None))
         if not pointer:
             raise Error("eis_new() returned NULL")
@@ -1172,14 +1228,16 @@ class Eis(CObject):
 
     @classmethod
     def create_for_fd(cls, flags: Sequence[Flag] = ()) -> Eis:
-        """Create a server using the fd backend -- the one real compositors
-        use, since it keeps each client's fd private rather than exposing a
-        connectable socket path. Call :meth:`add_client` once per
-        connection you want to accept.
+        """Create a server using the fd backend.
+
+        The one real compositors use, since it keeps each client's fd
+        private rather than exposing a connectable socket path. Call
+        :meth:`add_client` once per connection you want to accept.
 
         ``flags`` are applied here rather than left to the caller because
         :meth:`set_flag` has to run before the backend is set up, and this
-        method does both."""
+        method does both.
+        """
         server = cls(cls._new())
         for flag in flags:
             server.set_flag(flag)
@@ -1190,9 +1248,12 @@ class Eis(CObject):
 
     @classmethod
     def create_for_socket(cls, path: Path, flags: Sequence[Flag] = ()) -> Eis:
-        """Create a server listening on a Unix socket, as a compositor
-        would (this is the path a real ``ei_setup_backend_socket()`` client
-        connects to). See :meth:`create_for_fd` on ``flags``."""
+        """Create a server listening on a Unix socket.
+
+        As a compositor would (this is the path a real
+        ``ei_setup_backend_socket()`` client connects to). See
+        :meth:`create_for_fd` on ``flags``.
+        """
         server = cls(cls._new())
         for flag in flags:
             server.set_flag(flag)
@@ -1217,6 +1278,10 @@ __all__ = [
     "KeyEvent",
     "Keymap",
     "KeymapType",
+    # Imported rather than defined here: every call bound through
+    # _capi.libeis can raise it, so a caller importing from this module
+    # catches it from here too -- see docs/troubleshooting.md.
+    "LibraryNotFoundError",
     "Ping",
     "PointerAbsoluteEvent",
     "PointerEvent",

libei/oeffis.py

@@ -1,10 +1,12 @@
-"""Pythonic wrapper around liboeffis -- negotiates an EIS connection through
-the ``org.freedesktop.portal.RemoteDesktop`` XDG desktop portal.
+"""Pythonic wrapper around liboeffis.
+
+Negotiates an EIS connection through the
+``org.freedesktop.portal.RemoteDesktop`` XDG desktop portal.
 
 This is the path a sandboxed or otherwise non-privileged client uses to get
 an EI socket: it asks the portal, the user is shown a consent dialog, and on
 approval this hands back a file descriptor to pass to
-:meth:`libei.ei.Sender.create_for_fd`.
+:meth:`libei.ei.Sender.create_for_fd`::
 
     oeffis = Oeffis.create(devices=DeviceType.POINTER)
     while True:
@@ -39,6 +41,7 @@ import logging
 import os
 
 from . import _capi
+from ._capi.loader import LibraryNotFoundError
 
 logger = logging.getLogger("libei.oeffis")
 
@@ -52,6 +55,7 @@ class DisconnectedError(Exception):
     """The portal session ended unexpectedly (error, or denied by the user)."""
 
     def __init__(self, message: str | None) -> None:
+        """Record why the session ended."""
         super().__init__(message)
         self.message = message
 
@@ -60,6 +64,7 @@ class SessionClosedError(DisconnectedError):
     """The portal explicitly closed the session (not necessarily an error)."""
 
     def __init__(self) -> None:
+        """Build the fixed "Session closed" message."""
         super().__init__(message="Session closed")
 
 
@@ -100,6 +105,7 @@ class Oeffis:
     """
 
     def __init__(self) -> None:
+        """Create the underlying liboeffis context (no portal call yet)."""
         pointer = _capi.liboeffis.new(None)
         if not pointer:
             raise DisconnectedError("oeffis_new() returned NULL")
@@ -117,6 +123,11 @@ class Oeffis:
         self._state = _EventType.NONE
 
     def __del__(self) -> None:
+        """Release the session, closing the EIS fd if nobody claimed it.
+
+        Safe on a half-built object: __init__ can raise before every
+        attribute exists, and this still runs.
+        """
         # getattr() with defaults rather than plain attribute access:
         # __init__ raises DisconnectedError when oeffis_new() returns NULL,
         # and Python still calls __del__ on the half-built object, where
@@ -232,6 +243,11 @@ class Oeffis:
 __all__ = [
     "DeviceType",
     "DisconnectedError",
+    # Imported rather than defined here: every call bound through
+    # _capi.liboeffis can raise it -- Oeffis.create() on a machine with no
+    # liboeffis is the ordinary one -- so a caller importing from this
+    # module catches it from here too. See docs/troubleshooting.md.
+    "LibraryNotFoundError",
     "Oeffis",
     "SessionClosedError",
     "is_available",

libei/portal.py

@@ -1,5 +1,7 @@
-"""Negotiate an EIS connection by driving a portal directly over D-Bus,
-rather than through :mod:`libei.oeffis`.
+"""Negotiate an EIS connection by driving a portal directly over D-Bus.
+
+Not through :mod:`libei.oeffis` -- see that module instead for the simpler,
+liboeffis-backed path.
 
 Two portals, two directions. :class:`RemoteDesktopSession` negotiates
 ``org.freedesktop.portal.RemoteDesktop`` to *inject* input; below it,
@@ -19,7 +21,7 @@ should be handled by an application talking to DBus directly"
 (https://libinput.pages.freedesktop.org/libei/api/group__liboeffis.html).
 This module is that: the ``CreateSession`` -> ``SelectDevices`` -> ``Start``
 -> ``ConnectToEIS`` sequence driven directly, with ``persist_mode`` and
-``restore_token`` exposed as real parameters.
+``restore_token`` exposed as real parameters::
 
     with RemoteDesktopSession.negotiate(
         devices=DeviceType.POINTER | DeviceType.KEYBOARD,
@@ -69,6 +71,7 @@ Three things worth knowing before building on this:
 
 from __future__ import annotations
 
+import contextlib
 import enum
 import logging
 import os
@@ -104,7 +107,7 @@ _MIN_REMOTE_DESKTOP_VERSION = 2  # ConnectToEIS needs v2+
 _MIN_INPUT_CAPTURE_VERSION = 2  # CreateSession2 is a v2-only method
 
 _DEFAULT_TIMEOUT = 60.0
-"""Seconds to wait for one portal round trip. Generous, because a human has
+"""Seconds to wait for one portal round trip. Generous, because a user has
 to see and answer the consent dialog `Start` raises -- but bounded, because
 the alternative is a caller wedged forever if the portal dies after
 accepting the call and before sending its `Response`."""
@@ -156,11 +159,12 @@ class PortalTimeoutError(PortalError):
 
     Distinct from a decline: the portal accepted the call and then never
     sent its ``Response`` signal. Most often the consent dialog is simply
-    still waiting for a human, so raise the timeout rather than treating
+    still waiting for a user, so raise the timeout rather than treating
     this as a failure if that is expected.
     """
 
     def __init__(self, step: str, timeout: float) -> None:
+        """Name which step timed out and after how long."""
         super().__init__(f"{step} did not answer within {timeout:g}s")
         self.step = step
         self.timeout = timeout
@@ -175,6 +179,7 @@ class PortalDeniedError(PortalError):
     """
 
     def __init__(self, step: str, message: str | None = None) -> None:
+        """Name which step was refused and, where the portal gave one, why."""
         super().__init__(message or f"{step} was not approved")
         self.step = step
         self.message = message
@@ -422,18 +427,21 @@ def _request(
         params: Any,
         *_a: Any,
     ) -> None:
+        """Record the first reply and quit the loop; later replies are ignored."""
         if result:  # both subscriptions may fire; the first reply wins
             return
         result["code"], result["results"] = params.unpack()
         loop.quit()
 
     def on_timeout() -> bool:
+        """Stop the loop and record that it timed out rather than finished."""
         nonlocal timed_out
         timed_out = True
         loop.quit()
         return False  # one-shot; GLib removes the source when this is False
 
     def subscribe(path: str) -> None:
+        """Subscribe to Response on one path, keeping the handle alive."""
         subscriptions.append(
             connection.signal_subscribe(
                 busname,
@@ -481,10 +489,16 @@ def _request(
             try:
                 loop.run()
             finally:
-                # Removing an already-fired one-shot source is harmless
-                # (GLib warns at most); leaking a live one holds a reference
-                # to this closure and fires it into a dead loop later.
-                GLib.source_remove(timeout_source)
+                # on_timeout() returns False, which is GLib's own signal to
+                # deregister a fired one-shot source -- removing it again
+                # here trips a real "Source ID N was not found when
+                # attempting to remove it" warning, the same bug already
+                # fixed for _wait_for_signal below. Only remove it when the
+                # *Response* woke the loop instead; leaving a live source in
+                # that case holds a reference to this closure and fires it
+                # into a dead loop on some later request.
+                if not timed_out:
+                    GLib.source_remove(timeout_source)
     finally:
         for subscription in subscriptions:
             connection.signal_unsubscribe(subscription)
@@ -584,6 +598,11 @@ class RemoteDesktopSession:
         session_handle: str | None = None,
         busname: str = _BUS_NAME,
     ) -> None:
+        """Hold a negotiated session's handle, connection and EIS fd.
+
+        Not for direct use -- built by :meth:`negotiate` once ``Start`` and
+        ``ConnectToEIS`` have both already succeeded.
+        """
         self._connection = connection
         self._eis_fd: int | None = eis_fd
         self._session_handle = session_handle
@@ -669,12 +688,20 @@ class RemoteDesktopSession:
             self._connection = None
 
     def __enter__(self) -> RemoteDesktopSession:
+        """Return self: entering performs no action of its own."""
         return self
 
     def __exit__(self, *_exc: Any) -> None:
+        """Close the session on the way out, whatever happened."""
         self.close()
 
     def __del__(self) -> None:
+        """Close the fd only: __del__ can run during interpreter shutdown.
+
+        A synchronous D-Bus round trip there may hang or fail with nothing
+        left able to report it, so the D-Bus half of close() is deliberately
+        not attempted.
+        """
         # Deliberately only the fd, not the D-Bus half of close(): __del__
         # can run during interpreter shutdown, where a synchronous D-Bus
         # round trip may hang or fail in ways nothing can report. Closing an
@@ -687,10 +714,9 @@ class RemoteDesktopSession:
             return
         eis_fd = getattr(self, "_eis_fd", None)
         if eis_fd is not None:
-            try:
+            # an exception here is only printed to stderr anyway
+            with contextlib.suppress(OSError):
                 os.close(eis_fd)
-            except OSError:
-                pass  # an exception here is only printed to stderr anyway
 
     @classmethod
     def negotiate(
@@ -819,7 +845,7 @@ class RemoteDesktopSession:
                 timeout=timeout,
             )
         except BaseException:
-            # BaseException, not Exception: `Start` blocks on a human
+            # BaseException, not Exception: `Start` blocks on a user
             # answering a consent dialog, so Ctrl-C during that wait is a
             # routine way out of this function -- and it strands an
             # approved session exactly as a decline does.
@@ -980,10 +1006,10 @@ def _wait_for_signal(
     busname: str,
     interface: str,
     signal: str,
-    path: str,
+    session_handle: str,
     timeout: float | None,
 ) -> tuple[Any, ...]:
-    """Block for one emission of ``signal`` on ``path``, unpacked.
+    """Block for one emission of ``signal`` for ``session_handle``, unpacked.
 
     Unlike `_request`, nothing here *triggers* the signal: ``Activated`` and
     ``Deactivated`` fire whenever the compositor decides a pointer barrier
@@ -991,7 +1017,23 @@ def _wait_for_signal(
     before this is even called (a long-enabled session, subscribed to
     late) or not for a long time. ``timeout=None`` waits indefinitely --
     the read a caller wants when there is nothing else useful to do but
-    wait for a human to move the pointer.
+    wait for a user to move the pointer.
+
+    **These signals are emitted on the portal object, not on the session
+    object.** Subscribing with the session handle as the D-Bus object path
+    -- the obvious reading of "a signal for this session", and what this
+    did until 2026-09-09 -- matches nothing, delivers nothing, and is
+    indistinguishable from a compositor that never fires the signal at all:
+    it cost this project a live investigation across two GNOME versions, a
+    standalone C reproducer and an upstream Mutter bug report before an
+    xdg-desktop-portal developer pointed out the mistake. The session is
+    identified by the signal's own first argument instead (``o
+    session_handle``, per the portal spec), so the subscription is on
+    `_OBJECT_PATH` and the filtering happens here, on the payload. It is
+    deliberately not done with ``signal_subscribe``'s ``arg0`` filter: the
+    D-Bus specification restricts plain ``arg0=`` match rules to arguments
+    of type STRING, and this one is an OBJECT_PATH, which is the same shape
+    of silent non-delivery all over again.
     """
     loop = GLib.MainLoop()
     result: dict[str, Any] = {}
@@ -1006,12 +1048,29 @@ def _wait_for_signal(
         params: Any,
         *_a: Any,
     ) -> None:
+        """Record the first matching signal; anything else is logged and dropped."""
         if result:  # a subscription that outlives its own wait can fire twice
             return
-        result["args"] = params.unpack()
+        args = params.unpack()
+        if args[0] != session_handle:
+            # Logged, not silently dropped: this filter can hide a signal
+            # that *did* arrive just as effectively as the wrong-path
+            # subscription above did, and the two are indistinguishable
+            # from the outside -- both look exactly like a compositor that
+            # never fired. One debug line is what tells them apart.
+            logger.debug(
+                "ignoring %s for session %s while waiting for %s",
+                signal,
+                args[0],
+                session_handle,
+            )
+            return
+        logger.debug("received %s for session %s", signal, session_handle)
+        result["args"] = args
         loop.quit()
 
     def on_timeout() -> bool:
+        """Stop the loop and record that it timed out rather than finished."""
         nonlocal timed_out
         timed_out = True
         loop.quit()
@@ -1021,12 +1080,20 @@ def _wait_for_signal(
         busname,
         interface,
         signal,
-        path,
+        _OBJECT_PATH,
         None,
         Gio.DBusSignalFlags.NONE,
         on_signal,
         None,
     )
+    logger.debug(
+        "waiting up to %s for %s.%s on %s for session %s",
+        "forever" if timeout is None else f"{timeout:g}s",
+        interface,
+        signal,
+        _OBJECT_PATH,
+        session_handle,
+    )
     try:
         if not result:
             timeout_source = None
@@ -1035,7 +1102,16 @@ def _wait_for_signal(
             try:
                 loop.run()
             finally:
-                if timeout_source is not None:
+                # A fired timeout source has already deregistered itself --
+                # on_timeout() returns False, which is GLib's signal to
+                # remove it -- so only remove it here when the *signal*
+                # woke the loop instead. Removing it unconditionally trips
+                # a real GLib warning ("Source ID N was not found when
+                # attempting to remove it"), confirmed live: it fired on
+                # every real timeout this session hit, never against
+                # test_portal.py's fake GLib.source_remove, which just
+                # clears pending_timeout with no complaint either way.
+                if timeout_source is not None and not timed_out:
                     GLib.source_remove(timeout_source)
     finally:
         connection.signal_unsubscribe(subscription)
@@ -1049,8 +1125,9 @@ def _wait_for_signal(
 
 
 class Activation(NamedTuple):
-    """One ``Activated`` signal's payload -- see
-    :meth:`InputCaptureSession.wait_for_activation`.
+    """One ``Activated`` signal's payload.
+
+    See :meth:`InputCaptureSession.wait_for_activation`.
     """
 
     activation_id: int
@@ -1077,8 +1154,8 @@ class InputCaptureSession:
     direction: instead of injecting synthetic input, this receives real
     input from the user's own devices once the compositor decides to divert
     it here. That decision is the whole point of the protocol and is never
-    this session's to make -- see :meth:`enable` and :meth:`
-    wait_for_activation`.
+    this session's to make -- see :meth:`enable` and
+    :meth:`wait_for_activation`.
 
     **Capturing is exclusive.** Once the compositor activates a capture,
     the events it captures stop reaching the desktop entirely and are sent
@@ -1101,10 +1178,10 @@ class InputCaptureSession:
 
     **Never live-tested.** Every other class in this module that talks to a
     real portal carries a hand-verification note in its own docstring; this
-    one does not, because verifying it means a human clicking through the
-    consent dialog *and* accepting that their pointer will be diverted away
-    from their own desktop for the length of the test -- not something to
-    trigger without asking first, unlike everything else here. Designed
+    one does not, because verifying it means a developer clicking through
+    the consent dialog *and* accepting that their pointer will be diverted
+    away from their own desktop for the length of the test -- not something
+    to trigger without asking first, unlike everything else here. Designed
     against ``/usr/share/dbus-1/interfaces/org.freedesktop.portal.
     InputCapture.xml`` (the shipped portal spec, not the header alone) and
     unit-tested against a fake connection reproducing that spec's documented
@@ -1120,6 +1197,11 @@ class InputCaptureSession:
         restore_token: str | None,
         busname: str = _BUS_NAME,
     ) -> None:
+        """Hold a negotiated capture session's handle, connection and EIS fd.
+
+        Not for direct use -- built by :meth:`negotiate` once ``ConnectToEIS``
+        has already succeeded.
+        """
         self._connection = connection
         self._session_handle: str | None = session_handle
         self._eis_fd: int | None = eis_fd
@@ -1320,13 +1402,24 @@ class InputCaptureSession:
         )
         if code != 0:
             raise PortalDeniedError("SetPointerBarriers")
-        return list(results.get("failed_barriers", []))
+        failed = list(results.get("failed_barriers", []))
+        # A partially-refused set is the quiet failure here: the call
+        # succeeds, some barriers stand, and an edge the caller believes is
+        # armed simply never triggers. Callers see only the returned list,
+        # which they may or may not act on -- this says it either way.
+        logger.debug(
+            "SetPointerBarriers: %d requested %s, refused: %s",
+            len(barriers),
+            [b[0] for b in barriers],
+            failed or "none",
+        )
+        return failed
 
     def wait_for_activation(self, timeout: float | None = None) -> Activation:
         """Block until the compositor activates capture, or ``timeout``.
 
         Only returns once a real barrier crossing has been reported --
-        which, on hardware, means a human moved a physical pointer across
+        which, on hardware, means a user moved a physical pointer across
         one. There is no way to trigger this synthetically (see the class
         docstring's third paragraph), so this call can legitimately hang
         until someone does that, and `timeout=None` -- the default -- waits
@@ -1407,21 +1500,22 @@ class InputCaptureSession:
             self._connection = None
 
     def __enter__(self) -> InputCaptureSession:
+        """Return self: entering performs no action of its own."""
         return self
 
     def __exit__(self, *_exc: Any) -> None:
+        """Close the session on the way out, whatever happened."""
         self.close()
 
     def __del__(self) -> None:
+        """Close the fd only, for the reason RemoteDesktopSession.__del__ gives."""
         # See RemoteDesktopSession.__del__ for why this closes only the fd.
         if getattr(self, "_eis_fd_claimed", True):
             return
         eis_fd = getattr(self, "_eis_fd", None)
         if eis_fd is not None:
-            try:
+            with contextlib.suppress(OSError):
                 os.close(eis_fd)
-            except OSError:
-                pass
 
     @classmethod
     def negotiate(
@@ -1590,7 +1684,7 @@ class InputCaptureSession:
                 timeout,
             )
         except BaseException:
-            # BaseException, not Exception: Start blocks on a human
+            # BaseException, not Exception: Start blocks on a user
             # answering a consent dialog, so Ctrl-C during that wait is a
             # routine way out of this function -- and it strands an
             # approved session exactly as a decline does.

{python_libei-0.5.1.dist-info → python_libei-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-libei
-Version: 0.5.1
+Version: 0.6.0
 Summary: Inject and receive input on Wayland from Python: ctypes bindings for libei, libeis and liboeffis
 Author: Dennis K. Paulsen
 License-Expression: MIT
@@ -37,6 +37,10 @@ Dynamic: license-file
 
 # python-libei
 
+[![CI](https://github.com/ctrondlp/python-libei/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/ctrondlp/python-libei/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/python-libei)](https://pypi.org/project/python-libei/)
+[![License](https://img.shields.io/pypi/l/python-libei)](https://github.com/ctrondlp/python-libei/blob/main/LICENSE)
+
 Python bindings for [libei, libeis and liboeffis](https://libinput.pages.freedesktop.org/libei/) —
 the Wayland input-emulation libraries. Use this to **move the pointer, click,
 type, or scroll on a Wayland desktop** from Python, the way `xdotool` did on
@@ -103,11 +107,15 @@ to get permission, then `ei` to inject.
 | **Get permission**, and not be asked again | `libei.portal` | Same handshake over D-Bus directly, with `persist_mode` / `restore_token`. Needs PyGObject |
 | **Be the server**, for tests or a compositor | `libei.eis` | Drives your client code with no real compositor and no consent dialog |
 
-Each module has `is_available()`, an `Error` exception, and an `EventType` /
-`DeviceCapability` enum. `ei` and `eis` also share the shapes around them:
-`Device`, `Seat`, `Region`, `Keymap`, `Touch`, `Ping`, `Event`, and the frozen
-dataclasses its accessors return. The package ships `py.typed`, so callers
-type-check against real annotations rather than `Any`.
+Each module has `is_available()`. `ei` and `eis` share the shapes around them:
+an `Error` exception, an `EventType` and `DeviceCapability` enum, and `Device`,
+`Seat`, `Region`, `Keymap`, `Touch`, `Ping`, `Event` with the frozen dataclasses
+its accessors return. `oeffis` and `portal` are smaller — `DeviceType`, no
+`EventType` or `DeviceCapability`, `Activation` as the one frozen result a
+portal wait hands back, and their own exception classes rather than an `Error`.
+[docs/troubleshooting.md](docs/troubleshooting.md) names every class they raise.
+The package ships `py.typed`, so callers type-check against real
+annotations rather than `Any`.
 
 ## What's implemented
 
@@ -149,14 +157,16 @@ Beyond sending input, the wrapper also covers ping/pong round trips
 (`Device.keymap`), region mapping ids and coordinate conversion,
 `Context.disconnect()`, `Context.peek_event_type()`, and
 `Seat.request_device()`. On the server side, `libei.eis` mirrors all of it and
-adds `Eis.set_flag()` and `Client.pid`. Underneath, the ctypes layer binds 250
+adds `Eis.set_flag()` (with the `Flag` values it takes), `Client.pid`, and
+`Device.configure()` with the `ConfigureRegion` descriptions it accepts.
+Underneath, the ctypes layer binds 250
 of the 302 functions the three libraries export as of 1.6.0; what is left out,
 and why, is in
 [docs/developers/architecture.md](docs/developers/architecture.md#what-is-bound-and-what-is-deliberately-not).
 
 ## Status
 
-Beta (`0.5.1`), published on [PyPI](https://pypi.org/project/python-libei/)
+Beta (`0.6.0`), published on [PyPI](https://pypi.org/project/python-libei/)
 since `0.1.0`, and **the API is not frozen** — expect renames before 1.0.
 
 The injection path is exercised end to end against the real libraries by the
@@ -187,11 +197,11 @@ Exactly what was run, when, and against which versions:
   portal paths are the part likeliest to come up short off Linux, since
   they need an xdg-desktop-portal RemoteDesktop backend to talk to.
 - CPython 3.10 or newer (tested on 3.13)
-- The native libraries: on Fedora, `sudo dnf install libei libeis liboeffis`;
-  on FreeBSD, `pkg install libei` (the `x11/libei` port), which supplies all
-  three sonames including `liboeffis`
-- `libei.portal` only: PyGObject (`pip install 'python-libei[portal]'`), plus
-  whatever GObject-introspection libraries your distro needs for `Gio` --
+- The native `libei`, `libeis` and `liboeffis` libraries, which `pip` cannot
+  supply. Which package provides them on your distribution — and what to do
+  when the name does not match — is in [docs/install.md](docs/install.md).
+- `libei.portal` only: PyGObject, via the `portal` extra, plus whatever
+  GObject-introspection libraries your distribution needs for `Gio`, since
   PyPI's PyGObject wheel supplies the Python side only. Not needed for
   `libei.ei`, `libei.eis` or `libei.oeffis`.
 - libei 1.0.0 or newer for the core: connecting, binding a seat, and
@@ -224,22 +234,11 @@ Exactly what was run, when, and against which versions:
 
 ## Install
 
-From [PyPI](https://pypi.org/project/python-libei/):
-
 ```sh
 pip install python-libei
 ```
 
-The distribution is named `python-libei`, the import is `libei` -- so
-`pip show python-libei`, but `from libei import ei`.
-
-Pure Python, no build step: the wheel is `py3-none-any` and ctypes talks to
-the native libraries directly, so there is no compiler, no headers and no
-`libei-devel` involved at install time. What `pip` does *not* bring is the
-native libraries themselves -- see [Requirements](#requirements) above; on
-Fedora, `sudo dnf install libei libeis liboeffis`.
-
-To track `main` instead, or to hack on it, install from a checkout:
+From a checkout instead, to track `main` or to work on the package:
 
 ```sh
 git clone https://github.com/ctrondlp/python-libei.git
@@ -247,15 +246,11 @@ cd python-libei
 pip install .          # or `pip install -e '.[dev]'` to develop
 ```
 
-Importing is always safe, even where the native libraries are missing — they
-are loaded on first use, not at import. Check before you rely on them:
-
-```python
-from libei import ei
-
-if not ei.is_available():
-    ...  # fall back to another input backend
-```
+That is the half `pip` can do. The native `libei`/`libeis`/`liboeffis`
+libraries it cannot supply, the `portal` extra, and how to check what actually
+loaded are all in [docs/install.md](docs/install.md) — see
+[Requirements](#requirements) above for the version floors. Importing is safe
+without any of it: those libraries are loaded on first *use*, not at import.
 
 ## Concepts
 
@@ -409,8 +404,10 @@ a list of error messages. Start there when nothing happens.
   happens" checklist
 - [docs/vs-snegg.md](docs/vs-snegg.md) — how this differs from the reference
   bindings, and two signature issues found by cross-checking the C source
-- [docs/developers/](docs/developers/) — the four-layer architecture, and what
-  has actually been verified against which libei versions
+- [docs/developers/architecture.md](docs/developers/architecture.md) and
+  [docs/developers/verification.md](docs/developers/verification.md) — the
+  four-layer architecture, and what has actually been verified against which
+  libei versions
 - [CONTRIBUTING.md](CONTRIBUTING.md) — setup, checks, testing against an old
   libei, releasing
 

python_libei-0.6.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+libei/__init__.py,sha256=ypdFYwFMulRHAB3iYKc2NfCvMRvAq9TUFuwQN9b3PWw,1858
+libei/_cobject.py,sha256=XjbUNJpZ87jAyPWh6dmRslk6cMy831oMRFhWmfjLDFo,13344
+libei/ei.py,sha256=W4akKc_BNVfL0FroSXLGD1Z_L3OmYjZT5QDHNnEtMP8,49367
+libei/eis.py,sha256=X_umAaAAbAMC9d2RdnMReeJZI61WsnKz3cySY5YrGr0,45841
+libei/oeffis.py,sha256=gJHR90s9VhQrgkjWUMDx-lxZ8qKxkttnqbx_xo-7oxs,10035
+libei/portal.py,sha256=eTYzNkA_65VaUlbSkATiXmOA8c6_uUDle2c2lUgZZHY,69698
+libei/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+libei/_capi/__init__.py,sha256=raISSWSV9hAcE92DcLCz-vUb1IPcsmxRZaS-iAoQJBE,211
+libei/_capi/libei.py,sha256=gpp42bhqPonhVD2zmFWCl4rdk_lm4XvD_7W2Rw5RsuI,11308
+libei/_capi/libeis.py,sha256=jQR0Z0YN9qa71mAcSJ__-UaoF8PsVsBs8OXwjfqstFk,13080
+libei/_capi/liboeffis.py,sha256=V8jdmJm3qOQUzzNiCAXt4Jr2JY11Y4-w6NIfIxbxGI4,1218
+libei/_capi/loader.py,sha256=QD1xQJo05q4eSWhOCRpAWOlzHD5fcnHtI6yQyy4rKs0,5052
+python_libei-0.6.0.dist-info/licenses/LICENSE,sha256=l6xbMU6Y-JZDzmBciBj-J5t6h6jNg_Bcyp4bHxDepqU,1074
+python_libei-0.6.0.dist-info/METADATA,sha256=NC7ygbrH78TjzREhLvF7-FSz8kNgf8tPE21NZQiykp4,20963
+python_libei-0.6.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_libei-0.6.0.dist-info/top_level.txt,sha256=_DQXzGjDsUBENI_cNkiOxPB4xi8coCbQS1lq18FMudQ,6
+python_libei-0.6.0.dist-info/RECORD,,

python_libei-0.5.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-libei/__init__.py,sha256=ZknUZWRNN4JfCH08NGpbBhqr_e2YZjHnk8B1aXe2J9Y,1858
-libei/_cobject.py,sha256=msrbviABSWjc5fKsXHSCg7nQ0Y4Etcq_Dkh0fblW-sY,12845
-libei/ei.py,sha256=Da3ezXnFPXtejlcJFH8bcE5f4pxKZXXqb6ltCh2zAdE,46704
-libei/eis.py,sha256=aYWOCN1NlRchcWd6NjIUi1eYMFWJbp0UHMcQFEJ0ii4,43642
-libei/oeffis.py,sha256=UcnDwLErFxB0xuktNpIzAK01ylpl6ZrmaGnWiUOcFOo,9302
-libei/portal.py,sha256=LGRINrYQ-x46i0pzGOzpM6ZT3xek_AoExNIgR2BZRB8,64498
-libei/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-libei/_capi/__init__.py,sha256=3VxixYYlr_ZcuiK0GwrCpbE3VvEv_O990mJzdIJ8i74,209
-libei/_capi/libei.py,sha256=gpp42bhqPonhVD2zmFWCl4rdk_lm4XvD_7W2Rw5RsuI,11308
-libei/_capi/libeis.py,sha256=jQR0Z0YN9qa71mAcSJ__-UaoF8PsVsBs8OXwjfqstFk,13080
-libei/_capi/liboeffis.py,sha256=V8jdmJm3qOQUzzNiCAXt4Jr2JY11Y4-w6NIfIxbxGI4,1218
-libei/_capi/loader.py,sha256=k7fb_Nz0fg5QkuLJ_duKXj8bESSktLQ2ZyS5LNQ5v2I,4689
-python_libei-0.5.1.dist-info/licenses/LICENSE,sha256=l6xbMU6Y-JZDzmBciBj-J5t6h6jNg_Bcyp4bHxDepqU,1074
-python_libei-0.5.1.dist-info/METADATA,sha256=Bg1meYzLmMAp9HqeMWbU4SzZZOurlSGzIR49ZmoJNgo,20475
-python_libei-0.5.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-python_libei-0.5.1.dist-info/top_level.txt,sha256=_DQXzGjDsUBENI_cNkiOxPB4xi8coCbQS1lq18FMudQ,6
-python_libei-0.5.1.dist-info/RECORD,,