Merge branch 'origin/main' into pythongh-127266-type-slots-ts

Author: nascheme

Doc/library/fcntl.rst

@@ -82,65 +82,82 @@ descriptor.
 The module defines the following functions:
 
 
-.. function:: fcntl(fd, cmd, arg=0)
+.. function:: fcntl(fd, cmd, arg=0, /)
 
    Perform the operation *cmd* on file descriptor *fd* (file objects providing
    a :meth:`~io.IOBase.fileno` method are accepted as well).  The values used
    for *cmd* are operating system dependent, and are available as constants
    in the :mod:`fcntl` module, using the same names as used in the relevant C
-   header files. The argument *arg* can either be an integer value, or a
-   :class:`bytes` object. With an integer value, the return value of this
-   function is the integer return value of the C :c:func:`fcntl` call.  When
-   the argument is bytes it represents a binary structure, e.g. created by
-   :func:`struct.pack`. The binary data is copied to a buffer whose address is
+   header files. The argument *arg* can either be an integer value, a
+   :class:`bytes` object, or a string.
+   The type and size of *arg* must match the type and size of
+   the argument of the operation as specified in the relevant C documentation.
+
+   When *arg* is an integer, the function returns the integer
+   return value of the C :c:func:`fcntl` call.
+
+   When the argument is bytes, it represents a binary structure,
+   for example, created by :func:`struct.pack`.
+   A string value is encoded to binary using the UTF-8 encoding.
+   The binary data is copied to a buffer whose address is
    passed to the C :c:func:`fcntl` call.  The return value after a successful
    call is the contents of the buffer, converted to a :class:`bytes` object.
    The length of the returned object will be the same as the length of the
-   *arg* argument. This is limited to 1024 bytes. If the information returned
-   in the buffer by the operating system is larger than 1024 bytes, this is
-   most likely to result in a segmentation violation or a more subtle data
-   corruption.
+   *arg* argument. This is limited to 1024 bytes.
 
    If the :c:func:`fcntl` call fails, an :exc:`OSError` is raised.
 
+   .. note::
+      If the type or the size of *arg* does not match the type or size
+      of the argument of the operation (for example, if an integer is
+      passed when a pointer is expected, or the information returned in
+      the buffer by the operating system is larger than 1024 bytes),
+      this is most likely to result in a segmentation violation or
+      a more subtle data corruption.
+
    .. audit-event:: fcntl.fcntl fd,cmd,arg fcntl.fcntl
 
 
-.. function:: ioctl(fd, request, arg=0, mutate_flag=True)
+.. function:: ioctl(fd, request, arg=0, mutate_flag=True, /)
 
    This function is identical to the :func:`~fcntl.fcntl` function, except
    that the argument handling is even more complicated.
 
-   The *request* parameter is limited to values that can fit in 32-bits.
+   The *request* parameter is limited to values that can fit in 32-bits
+   or 64-bits, depending on the platform.
    Additional constants of interest for use as the *request* argument can be
    found in the :mod:`termios` module, under the same names as used in
    the relevant C header files.
 
-   The parameter *arg* can be one of an integer, an object supporting the
-   read-only buffer interface (like :class:`bytes`) or an object supporting
-   the read-write buffer interface (like :class:`bytearray`).
+   The parameter *arg* can be an integer, a :term:`bytes-like object`,
+   or a string.
+   The type and size of *arg* must match the type and size of
+   the argument of the operation as specified in the relevant C documentation.
 
-   In all but the last case, behaviour is as for the :func:`~fcntl.fcntl`
+   If *arg* does not support the read-write buffer interface or
+   the *mutate_flag* is false, behavior is as for the :func:`~fcntl.fcntl`
    function.
 
-   If a mutable buffer is passed, then the behaviour is determined by the value of
-   the *mutate_flag* parameter.
-
-   If it is false, the buffer's mutability is ignored and behaviour is as for a
-   read-only buffer, except that the 1024 byte limit mentioned above is avoided --
-   so long as the buffer you pass is at least as long as what the operating system
-   wants to put there, things should work.
-
-   If *mutate_flag* is true (the default), then the buffer is (in effect) passed
-   to the underlying :func:`ioctl` system call, the latter's return code is
+   If *arg* supports the read-write buffer interface (like :class:`bytearray`)
+   and *mutate_flag* is true (the default), then the buffer is (in effect) passed
+   to the underlying :c:func:`!ioctl` system call, the latter's return code is
    passed back to the calling Python, and the buffer's new contents reflect the
-   action of the :func:`ioctl`.  This is a slight simplification, because if the
+   action of the :c:func:`ioctl`.  This is a slight simplification, because if the
    supplied buffer is less than 1024 bytes long it is first copied into a static
    buffer 1024 bytes long which is then passed to :func:`ioctl` and copied back
    into the supplied buffer.
 
    If the :c:func:`ioctl` call fails, an :exc:`OSError` exception is raised.
 
+   .. note::
+      If the type or size of *arg* does not match the type or size
+      of the operation's argument (for example, if an integer is
+      passed when a pointer is expected, or the information returned in
+      the buffer by the operating system is larger than 1024 bytes,
+      or the size of the mutable bytes-like object is too small),
+      this is most likely to result in a segmentation violation or
+      a more subtle data corruption.
+
    An example::
 
       >>> import array, fcntl, struct, termios, os
@@ -157,7 +174,7 @@ The module defines the following functions:
    .. audit-event:: fcntl.ioctl fd,request,arg fcntl.ioctl
 
 
-.. function:: flock(fd, operation)
+.. function:: flock(fd, operation, /)
 
    Perform the lock operation *operation* on file descriptor *fd* (file objects providing
    a :meth:`~io.IOBase.fileno` method are accepted as well). See the Unix manual
@@ -169,7 +186,7 @@ The module defines the following functions:
    .. audit-event:: fcntl.flock fd,operation fcntl.flock
 
 
-.. function:: lockf(fd, cmd, len=0, start=0, whence=0)
+.. function:: lockf(fd, cmd, len=0, start=0, whence=0, /)
 
    This is essentially a wrapper around the :func:`~fcntl.fcntl` locking calls.
    *fd* is the file descriptor (file objects providing a :meth:`~io.IOBase.fileno`

Doc/library/multiprocessing.rst

@@ -670,6 +670,25 @@ The :mod:`multiprocessing` package mostly replicates the API of the
 
       .. versionadded:: 3.3
 
+   .. method:: interrupt()
+
+      Terminate the process. Works on POSIX using the :py:const:`~signal.SIGINT` signal.
+      Behavior on Windows is undefined.
+
+      By default, this terminates the child process by raising :exc:`KeyboardInterrupt`.
+      This behavior can be altered by setting the respective signal handler in the child
+      process :func:`signal.signal` for :py:const:`~signal.SIGINT`.
+
+      Note: if the child process catches and discards :exc:`KeyboardInterrupt`, the
+      process will not be terminated.
+
+      Note: the default behavior will also set :attr:`exitcode` to ``1`` as if an
+      uncaught exception was raised in the child process. To have a different
+      :attr:`exitcode` you may simply catch :exc:`KeyboardInterrupt` and call
+      ``exit(your_code)``.
+
+      .. versionadded:: next
+
    .. method:: terminate()
 
       Terminate the process.  On POSIX this is done using the :py:const:`~signal.SIGTERM` signal;

Doc/library/struct.rst

@@ -273,9 +273,9 @@ C11 standard) is supported, the following format characters are available:
 +--------+--------------------------+--------------------+----------------+------------+
 | Format | C Type                   | Python type        | Standard size  | Notes      |
 +========+==========================+====================+================+============+
-| ``E``  | :c:expr:`float complex`  | complex            | 8              | \(10)      |
+| ``F``  | :c:expr:`float complex`  | complex            | 8              | \(10)      |
 +--------+--------------------------+--------------------+----------------+------------+
-| ``C``  | :c:expr:`double complex` | complex            | 16             | \(10)      |
+| ``D``  | :c:expr:`double complex` | complex            | 16             | \(10)      |
 +--------+--------------------------+--------------------+----------------+------------+
 
 .. versionchanged:: 3.3
@@ -285,7 +285,7 @@ C11 standard) is supported, the following format characters are available:
    Added support for the ``'e'`` format.
 
 .. versionchanged:: 3.14
-   Added support for the ``'E'`` and ``'C'`` formats.
+   Added support for the ``'F'`` and ``'D'`` formats.
 
 
 Notes:

Doc/whatsnew/3.14.rst

@@ -264,6 +264,49 @@ is unchanged.
 Improved error messages
 -----------------------
 
+* The interpreter now provides helpful suggestions when it detects typos in Python
+  keywords. When a word that closely resembles a Python keyword is encountered,
+  the interpreter will suggest the correct keyword in the error message. This
+  feature helps programmers quickly identify and fix common typing mistakes. For
+  example:
+
+  .. code-block:: python
+
+     >>> whille True:
+     ...     pass
+     Traceback (most recent call last):
+       File "<stdin>", line 1
+         whille True:
+         ^^^^^^
+     SyntaxError: invalid syntax. Did you mean 'while'?
+
+     >>> asynch def fetch_data():
+     ...     pass
+     Traceback (most recent call last):
+       File "<stdin>", line 1
+         asynch def fetch_data():
+         ^^^^^^
+     SyntaxError: invalid syntax. Did you mean 'async'?
+
+     >>> async def foo():
+     ...     awaid fetch_data()
+     Traceback (most recent call last):
+       File "<stdin>", line 2
+         awaid fetch_data()
+         ^^^^^
+     SyntaxError: invalid syntax. Did you mean 'await'?
+
+     >>> raisee ValueError("Error")
+     Traceback (most recent call last):
+       File "<stdin>", line 1
+         raisee ValueError("Error")
+         ^^^^^^
+     SyntaxError: invalid syntax. Did you mean 'raise'?
+
+  While the feature focuses on the most common cases, some variations of
+  misspellings may still result in regular syntax errors.
+  (Contributed by Pablo Galindo in :gh:`132449`.)
+
 * When unpacking assignment fails due to incorrect number of variables, the
   error message prints the received number of values in more cases than before.
   (Contributed by Tushar Sadhwani in :gh:`122239`.)
@@ -972,6 +1015,10 @@ multiprocessing
   The :func:`set` in :func:`multiprocessing.Manager` method is now available.
   (Contributed by Mingyu Park in :gh:`129949`.)
 
+* Add :func:`multiprocessing.Process.interrupt` which terminates the child
+  process by sending :py:const:`~signal.SIGINT`. This enables "finally" clauses
+  and printing stack trace for the terminated process.
+  (Contributed by Artem Pulkin in :gh:`131913`.)
 
 operator
 --------
@@ -1126,7 +1173,7 @@ struct
 ------
 
 * Support the :c:expr:`float complex` and :c:expr:`double complex` C types in
-  the :mod:`struct` module (formatting characters ``'E'`` and ``'C'``,
+  the :mod:`struct` module (formatting characters ``'F'`` and ``'D'``,
   respectively) if the compiler has C11 complex arithmetic.
   (Contributed by Sergey B Kirpichev in :gh:`121249`.)
 

Lib/ctypes/__init__.py

@@ -209,13 +209,13 @@ class c_longdouble(_SimpleCData):
 
 try:
     class c_double_complex(_SimpleCData):
-        _type_ = "C"
+        _type_ = "D"
     _check_size(c_double_complex)
     class c_float_complex(_SimpleCData):
-        _type_ = "E"
+        _type_ = "F"
     _check_size(c_float_complex)
     class c_longdouble_complex(_SimpleCData):
-        _type_ = "F"
+        _type_ = "G"
 except AttributeError:
     pass
 

Lib/multiprocessing/popen_fork.py

@@ -54,6 +54,9 @@ def _send_signal(self, sig):
                 if self.wait(timeout=0.1) is None:
                     raise
 
+    def interrupt(self):
+        self._send_signal(signal.SIGINT)
+
     def terminate(self):
         self._send_signal(signal.SIGTERM)
 

Lib/multiprocessing/process.py

@@ -125,6 +125,13 @@ def start(self):
         del self._target, self._args, self._kwargs
         _children.add(self)
 
+    def interrupt(self):
+        '''
+        Terminate process; sends SIGINT signal
+        '''
+        self._check_closed()
+        self._popen.interrupt()
+
     def terminate(self):
         '''
         Terminate process; sends SIGTERM signal or uses TerminateProcess()

Lib/test/_test_multiprocessing.py

@@ -512,15 +512,20 @@ def _test_process_mainthread_native_id(cls, q):
     def _sleep_some(cls):
         time.sleep(100)
 
+    @classmethod
+    def _sleep_no_int_handler(cls):
+        signal.signal(signal.SIGINT, signal.SIG_DFL)
+        cls._sleep_some()
+
     @classmethod
     def _test_sleep(cls, delay):
         time.sleep(delay)
 
-    def _kill_process(self, meth):
+    def _kill_process(self, meth, target=None):
         if self.TYPE == 'threads':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
 
-        p = self.Process(target=self._sleep_some)
+        p = self.Process(target=target or self._sleep_some)
         p.daemon = True
         p.start()
 
@@ -567,6 +572,19 @@ def handler(*args):
 
         return p.exitcode
 
+    @unittest.skipIf(os.name == 'nt', "POSIX only")
+    def test_interrupt(self):
+        exitcode = self._kill_process(multiprocessing.Process.interrupt)
+        self.assertEqual(exitcode, 1)
+        # exit code 1 is hard-coded for uncaught exceptions
+        # (KeyboardInterrupt in this case)
+        # in multiprocessing.BaseProcess._bootstrap
+
+    @unittest.skipIf(os.name == 'nt', "POSIX only")
+    def test_interrupt_no_handler(self):
+        exitcode = self._kill_process(multiprocessing.Process.interrupt, target=self._sleep_no_int_handler)
+        self.assertEqual(exitcode, -signal.SIGINT)
+
     def test_terminate(self):
         exitcode = self._kill_process(multiprocessing.Process.terminate)
         self.assertEqual(exitcode, -signal.SIGTERM)
@@ -1498,6 +1516,7 @@ def _test_lock_locked_2processes(cls, lock, event, res):
         res.value = lock.locked()
         event.set()
 
+    @unittest.skipUnless(HAS_SHAREDCTYPES, 'needs sharedctypes')
     def test_lock_locked_2processes(self):
         if self.TYPE != 'processes':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))
@@ -1582,6 +1601,7 @@ def test_rlock(self):
         self.assertFalse(lock.locked())
         self.assertRaises((AssertionError, RuntimeError), lock.release)
 
+    @unittest.skipUnless(HAS_SHAREDCTYPES, 'needs sharedctypes')
     def test_rlock_locked_2processes(self):
         if self.TYPE != 'processes':
             self.skipTest('test not appropriate for {}'.format(self.TYPE))

Lib/test/support/os_helper.py

@@ -657,7 +657,7 @@ def fd_count():
     """
     if sys.platform.startswith(('linux', 'android', 'freebsd', 'emscripten')):
         fd_path = "/proc/self/fd"
-    elif sys.platform == "darwin":
+    elif support.is_apple:
         fd_path = "/dev/fd"
     else:
         fd_path = None

Lib/test/test_capi/test_abstract.py

@@ -460,7 +460,8 @@ def test_mapping_haskey(self):
             self.assertFalse(haskey({}, []))
             self.assertEqual(cm.unraisable.exc_type, TypeError)
             self.assertEqual(str(cm.unraisable.exc_value),
-                             "unhashable type: 'list'")
+                             "cannot use 'list' as a dict key "
+                             "(unhashable type: 'list')")
 
         with support.catch_unraisable_exception() as cm:
             self.assertFalse(haskey([], 1))

Lib/test/test_ctypes/test_c_simple_type_meta.py

@@ -160,11 +160,11 @@ def test_bad_type_message(self):
             class F(metaclass=PyCSimpleType):
                 _type_ = "\0"
         message = str(cm.exception)
-        expected_type_chars = list('cbBhHiIlLdCEFfuzZqQPXOv?g')
+        expected_type_chars = list('cbBhHiIlLdDFGfuzZqQPXOv?g')
         if not hasattr(ctypes, 'c_float_complex'):
-            expected_type_chars.remove('C')
-            expected_type_chars.remove('E')
             expected_type_chars.remove('F')
+            expected_type_chars.remove('D')
+            expected_type_chars.remove('G')
         if not MS_WINDOWS:
             expected_type_chars.remove('X')
         self.assertIn("'" + ''.join(expected_type_chars) + "'", message)