Merge branch 'master' of https://github.com/python-xlib/python-xlib into type-comments

Avasam · Avasam · commit 1c163a27a796 · 2022-12-27T15:24:54.000-05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,19 @@
 NEWS for Python X Library
 
+Version 0.33
+============
+
+Bug Fixes
+---------
+
+- Removed unused imports (thanks @Avasam).
+- Avoid to use fcntl module on some environments (thanks @i2y).
+- Change a test behavior for `unix_connect.get_socket` (thanks @i2y).
+- Fix accidental data change (thanks @Avasam).
+- Prefer `bool` over `Literal[0, 1, None]` (thanks @Avasam).
+- Change parentheses to brackets in LICENSE (thanks @mtelka).
+
+---
 Version 0.32
 ============
 
diff --git a/LICENSE b/LICENSE
@@ -6,9 +6,9 @@
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
-(This is the first released version of the Lesser GPL.  It also counts
+[This is the first released version of the Lesser GPL.  It also counts
  as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.)
+ the version number 2.1.]
 
                             Preamble
 
diff --git a/Xlib/__init__.py b/Xlib/__init__.py
@@ -19,7 +19,7 @@
 #    Suite 330,
 #    Boston, MA 02111-1307 USA
 
-__version__ = (0, 32)
+__version__ = (0, 33)
 
 __version_extra__ = ''
 
diff --git a/Xlib/display.py b/Xlib/display.py
@@ -94,7 +94,7 @@ def __init__(self, *args, **keys):
         protocol_display.Display.__init__(self, *args, **keys)
         self._atom_cache = {}
 
-    def get_atom(self, atomname, only_if_exists=0):
+    def get_atom(self, atomname, only_if_exists=False):
         # type: (str, bool) -> int
         if atomname in self._atom_cache:
             return self._atom_cache[atomname]
@@ -554,7 +554,7 @@ def rebind_string(self, keysym, newstring):
     ### X requests
     ###
 
-    def intern_atom(self, name, only_if_exists = 0):
+    def intern_atom(self, name, only_if_exists = False):
         # type: (str, bool) -> int
         """Intern the string name, returning its atom number. If
         only_if_exists is true and the atom does not already exist, it
@@ -564,7 +564,7 @@ def intern_atom(self, name, only_if_exists = 0):
                                only_if_exists = only_if_exists)
         return r.atom
 
-    def get_atom(self, atom, only_if_exists = 0):
+    def get_atom(self, atom, only_if_exists = False):
         # type: (str, bool) -> int
         """Alias for intern_atom, using internal cache"""
         return self.display.get_atom(atom, only_if_exists)
@@ -586,7 +586,7 @@ def get_selection_owner(self, selection):
                                       selection = selection)
         return r.owner
 
-    def send_event(self, destination, event, event_mask = 0, propagate = 0,
+    def send_event(self, destination, event, event_mask = 0, propagate = False,
                    onerror = None):
         # type: (int, rq.Event, int, bool, _ErrorHandler[object] | None) -> None
         """Send a synthetic event to the window destination which can be
diff --git a/Xlib/error.py b/Xlib/error.py
@@ -84,7 +84,7 @@ class XError(rq.GetAttrData, Exception):
 
     def __init__(self, display, data):
         # type: (display.Display, _SliceableBuffer) -> None
-        self._data, data = self._fields.parse_binary(data, display, rawdict = 1)
+        self._data, _ = self._fields.parse_binary(data, display, rawdict = True)
 
     def __str__(self):
         s = []
diff --git a/Xlib/ext/composite.py b/Xlib/ext/composite.py
@@ -33,7 +33,6 @@
 graphics.
 """
 
-from Xlib import X
 from Xlib.protocol import rq
 from Xlib.xobject import drawable
 
diff --git a/Xlib/ext/dpms.py b/Xlib/ext/dpms.py
@@ -27,7 +27,6 @@
 Documentation: https://www.x.org/releases/X11R7.7/doc/xextproto/dpms.html
 '''
 
-from Xlib import X
 from Xlib.protocol import rq
 from Xlib.display import Display
 from Xlib.xobject import resource
diff --git a/Xlib/ext/randr.py b/Xlib/ext/randr.py
@@ -34,15 +34,13 @@
 """
 
 
-from tkinter import W
 from Xlib import X
-from Xlib.protocol import rq, structs
+from Xlib.protocol import rq
 try:
     from typing import TYPE_CHECKING
 except ImportError:
     TYPE_CHECKING = False
 if TYPE_CHECKING:
-    from Xlib import error
     from Xlib.display import Display
     from Xlib.protocol import request
     from Xlib.xobject import resource, drawable
diff --git a/Xlib/ext/record.py b/Xlib/ext/record.py
@@ -19,7 +19,6 @@
 #    Suite 330,
 #    Boston, MA 02111-1307 USA
 
-from Xlib import X
 from Xlib.protocol import rq
 
 try:
diff --git a/Xlib/ext/xfixes.py b/Xlib/ext/xfixes.py
@@ -25,7 +25,6 @@
 ShowCursor requests and SelectionNotify events are provided.
 '''
 
-from Xlib import X
 from Xlib.protocol import rq, request
 from Xlib.display import Display
 from Xlib.xobject import resource, drawable
diff --git a/Xlib/ext/xinerama.py b/Xlib/ext/xinerama.py
@@ -35,7 +35,6 @@
 returns the state information - because that's what libXinerama does."""
 
 
-from Xlib import X
 from Xlib.protocol import rq, structs
 from Xlib.display import Display
 from Xlib.xobject import resource, drawable
diff --git a/Xlib/protocol/display.py b/Xlib/protocol/display.py
@@ -255,7 +255,7 @@ def next_event(self):
 
             # Call send_and_recv, which will return when
             # something has occured
-            self.send_and_recv(event = 1)
+            self.send_and_recv(event = True)
 
             # Before looping around, lock the event queue against
             # modifications.
@@ -281,7 +281,7 @@ def pending_events(self):
 
         # Make a send_and_recv pass, receiving any events
         self.send_recv_lock.acquire()
-        self.send_and_recv(recv = 1)
+        self.send_and_recv(recv = True)
 
         # Lock the queue, get the event count, and unlock again.
         self.event_queue_write_lock.acquire()
@@ -293,7 +293,7 @@ def pending_events(self):
     def flush(self):
         self.check_for_error()
         self.send_recv_lock.acquire()
-        self.send_and_recv(flush = 1)
+        self.send_and_recv(flush = True)
 
     def close(self):
         self.flush()
@@ -478,7 +478,7 @@ def close_internal(self, whom):
         self.socket_error_lock.release()
 
 
-    def send_and_recv(self, flush = None, event = None, request = None, recv = None):
+    def send_and_recv(self, flush = False, event = False, request = None, recv = False):
         # type: (bool, bool, int | None, bool) -> None
         """send_and_recv(flush = None, event = None, request = None, recv = None)
 
@@ -785,8 +785,8 @@ def parse_response(self, request):
             return self.parse_connection_setup()
 
         # Parse ordinary server response
-        gotreq = 0
-        while 1:
+        gotreq = False
+        while True:
             if self.data_recv:
                 # Check the first byte to find out what kind of response it is
                 rtype = byte2int(self.data_recv)
@@ -869,7 +869,7 @@ def parse_error_response(self, request):
             else:
                 self.default_error_handler(e)
 
-            return 0
+            return False
 
 
     def default_error_handler(self, err):
@@ -1038,7 +1038,7 @@ def parse_connection_setup(self):
         # Only the ConnectionSetupRequest has been sent so far
         r = self.sent_requests[0]
 
-        while 1:
+        while True:
             # print 'data_send:', repr(self.data_send)
             # print 'data_recv:', repr(self.data_recv)
 
@@ -1047,7 +1047,7 @@ def parse_connection_setup(self):
 
                 # The full response haven't arrived yet
                 if len(self.data_recv) < alen:
-                    return 0
+                    return False
 
                 # Connection failed or further authentication is needed.
                 # Set reason to the reason string
@@ -1057,22 +1057,22 @@ def parse_connection_setup(self):
                 # Else connection succeeded, parse the reply
                 else:
                     x, d = r._success_reply.parse_binary(self.data_recv[:alen],
-                                                         self, rawdict = 1)
+                                                         self, rawdict = True)
                     r._data.update(x)
 
                 del self.sent_requests[0]
 
                 self.data_recv = self.data_recv[alen:]
 
-                return 1
+                return True
 
             else:
                 # The base reply is 8 bytes long
                 if len(self.data_recv) < 8:
-                    return 0
+                    return False
 
                 r._data, d = r._reply.parse_binary(self.data_recv[:8],
-                                                   self, rawdict = 1)
+                                                   self, rawdict = True)
                 self.data_recv = self.data_recv[8:]
 
                 # Loop around to see if we have got the additional data
@@ -1168,7 +1168,7 @@ def __init__(self, display, *args, **keys):
         # Don't bother about locking, since no other threads have
         # access to the display yet
 
-        display.request_queue.append((self, 1))
+        display.request_queue.append((self, True))
 
         # However, we must lock send_and_recv, but we don't have
         # to loop.
diff --git a/Xlib/protocol/rq.py b/Xlib/protocol/rq.py
@@ -139,7 +139,7 @@ class Field(object):
     check_value = None  # type: Callable[[Any], Any] | None
     parse_value = None  # type: Callable[[Any, Any], Any] | None
 
-    keyword_args = 0
+    keyword_args = False
 
     def __init__(self):
         pass
@@ -816,7 +816,7 @@ def pack_value(self, value):
 
 class ValueList(Field):
     structcode = None
-    keyword_args = 1
+    keyword_args = True
     default = 'usekeywords'
 
     def __init__(self, name, mask, pad, *fields):
@@ -1214,7 +1214,7 @@ def parse_value(self, val, display, rawdict):
         def parse_value(self, val, display, rawdict = False):
             # type: (_SliceableBuffer, display.Display | None, Literal[False]) -> DictWrapper
             pass
-    def parse_value(self, val, display, rawdict = 0):
+    def parse_value(self, val, display, rawdict = False):
         # type: (_SliceableBuffer, display.Display | None, bool) -> dict[str, Any] | DictWrapper
 
         """This function is used by List and Object fields to convert
@@ -1267,10 +1267,10 @@ def parse_binary(self, data, display, rawdict):
         def parse_binary(self, data, display, rawdict = False):
             # type: (_SliceableBuffer, display.Display | None, Literal[False]) -> tuple[DictWrapper , _SliceableBuffer]
             pass
-    def parse_binary(self, data, display, rawdict = 0):
+    def parse_binary(self, data, display, rawdict = False):
         # type: (_SliceableBuffer, display.Display | None, bool) -> tuple[DictWrapper | dict[str, Any], _SliceableBuffer]
 
-        """values, remdata = s.parse_binary(data, display, rawdict = 0)
+        """values, remdata = s.parse_binary(data, display, rawdict = False)
 
         Convert a binary representation of the structure into Python values.
 
@@ -1510,7 +1510,7 @@ def _set_error(self, error):
             return 0
 
 class ReplyRequest(GetAttrData):
-    def __init__(self, display, defer = 0, *args, **keys):
+    def __init__(self, display, defer = False, *args, **keys):
         # type: (display.Display, bool, object, object) -> None
         self._display = display
         self._binary = self._request.to_binary(*args, **keys)
@@ -1520,7 +1520,7 @@ def __init__(self, display, defer = 0, *args, **keys):
 
         self._response_lock = lock.allocate_lock()
 
-        self._display.send_request(self, 1)
+        self._display.send_request(self, True)
         if not defer:
             self.reply()
 
@@ -1546,7 +1546,7 @@ def reply(self):
 
     def _parse_response(self, data):
         self._response_lock.acquire()
-        self._data, d = self._reply.parse_binary(data, self._display, rawdict = 1)
+        self._data, d = self._reply.parse_binary(data, self._display, rawdict = True)
         self._response_lock.release()
 
     def _set_error(self, error):
@@ -1566,7 +1566,7 @@ def __init__(self, binarydata = None, display = None,
         if binarydata:
             self._binary = binarydata
             self._data, data = self._fields.parse_binary(binarydata, display,
-                                                         rawdict = 1)
+                                                         rawdict = True)
             # split event type into type and send_event bit
             self._data['send_event'] = not not self._data['type'] & 0x80
             self._data['type'] = self._data['type'] & 0x7f
diff --git a/Xlib/support/unix_connect.py b/Xlib/support/unix_connect.py
@@ -24,16 +24,6 @@
 import os
 import platform
 import socket
-
-try:
-    import fcntl
-
-    FD_CLOEXEC = getattr(fcntl, 'FD_CLOEXEC', 1)
-    F_SETFD = getattr(fcntl, 'F_SETFD', 2)
-except ImportError:
-    FD_CLOEXEC = 1
-    F_SETFD = 2
-
 from Xlib import error, xauth
 
 
@@ -95,11 +85,13 @@ def _get_tcp_socket(host, dno):
     s.connect((host, 6000 + dno))
     return s
 
+
 def _get_unix_socket(address):
     s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     s.connect(address)
     return s
 
+
 def get_socket(dname, protocol, host, dno):
     # type: (_Address, _Protocol, _Address | None, int) -> socket.socket
     assert protocol in SUPPORTED_PROTOCOLS
@@ -130,11 +122,37 @@ def get_socket(dname, protocol, host, dno):
         raise error.DisplayConnectionError(dname, str(val))
 
     # Make sure that the connection isn't inherited in child processes.
-    fcntl.fcntl(s.fileno(), F_SETFD, FD_CLOEXEC)
+    _ensure_not_inheritable(s)
 
     return s
 
 
+def _ensure_not_inheritable(sock):
+    # According to PEP446, in Python 3.4 and above,
+    # it is not inherited in child processes by default.
+    # However, just in case, we explicitly make it non-inheritable.
+    # Also, we don't use the code like the following,
+    # because there would be no possibility of backporting to past versions.
+    #   if sys.version_info.major == 3 and sys.version_info.minor >= 4:
+    #       sock.set_inheritable(False)
+    #       return
+    # We just check if the socket has `set_inheritable`.
+    if hasattr(sock, 'set_inheritable'):
+        sock.set_inheritable(False)
+        return
+
+    # On Windows,
+    # Python doesn't support fcntl module because Windows doesn't have fcntl API.
+    # At least by not importing fcntl, we will be able to import python-xlib on Windows.
+    if platform.system() == 'Windows':
+        # so.. unfortunately, for Python 3.3 and below, on Windows,
+        # we can't make sure that the connection isn't inherited in child processes for now.
+        return
+
+    import fcntl
+    fcntl.fcntl(sock.fileno(), fcntl.F_SETFD, fcntl.FD_CLOEXEC)
+
+
 def new_get_auth(sock, dname, protocol, host, dno):
     # type: (socket.socket, object, _Protocol, object, int) -> tuple[bytes, bytes]
     assert protocol in SUPPORTED_PROTOCOLS
diff --git a/Xlib/xobject/drawable.py b/Xlib/xobject/drawable.py
diff --git a/test/test_unix_connect.py b/test/test_unix_connect.py
