Merge branch 'main' into main

Author: yeager

Doc/library/profile.rst

@@ -28,7 +28,7 @@ The Python standard library provides three different profiling implementations:
 
 **Statistical Profiler:**
 
-1. :mod:`profile.sample` provides statistical profiling of running Python processes
+1. :mod:`!profiling.sampling` provides statistical profiling of running Python processes
    using periodic stack sampling. It can attach to any running Python process without
    requiring code modification or restart, making it ideal for production debugging.
 
@@ -55,26 +55,26 @@ The Python standard library provides three different profiling implementations:
 
 **Profiler Comparison:**
 
-+-------------------+----------------------+----------------------+----------------------+
-| Feature           | Statistical          | Deterministic        | Deterministic        |
-|                   | (``profile.sample``) | (``cProfile``)       | (``profile``)        |
-+===================+======================+======================+======================+
-| **Target**        | Running process      | Code you run         | Code you run         |
-+-------------------+----------------------+----------------------+----------------------+
-| **Overhead**      | Virtually none       | Moderate             | High                 |
-+-------------------+----------------------+----------------------+----------------------+
-| **Accuracy**      | Statistical approx.  | Exact call counts    | Exact call counts    |
-+-------------------+----------------------+----------------------+----------------------+
-| **Setup**         | Attach to any PID    | Instrument code      | Instrument code      |
-+-------------------+----------------------+----------------------+----------------------+
-| **Use Case**      | Production debugging | Development/testing  | Profiler extension   |
-+-------------------+----------------------+----------------------+----------------------+
-| **Implementation**| C extension          | C extension          | Pure Python          |
-+-------------------+----------------------+----------------------+----------------------+
++-------------------+--------------------------+----------------------+----------------------+
+| Feature           | Statistical              | Deterministic        | Deterministic        |
+|                   | (``profiling.sampling``) | (``cProfile``)       | (``profile``)        |
++===================+==========================+======================+======================+
+| **Target**        | Running process          | Code you run         | Code you run         |
++-------------------+--------------------------+----------------------+----------------------+
+| **Overhead**      | Virtually none           | Moderate             | High                 |
++-------------------+--------------------------+----------------------+----------------------+
+| **Accuracy**      | Statistical approx.      | Exact call counts    | Exact call counts    |
++-------------------+--------------------------+----------------------+----------------------+
+| **Setup**         | Attach to any PID        | Instrument code      | Instrument code      |
++-------------------+--------------------------+----------------------+----------------------+
+| **Use Case**      | Production debugging     | Development/testing  | Profiler extension   |
++-------------------+--------------------------+----------------------+----------------------+
+| **Implementation**| C extension              | C extension          | Pure Python          |
++-------------------+--------------------------+----------------------+----------------------+
 
 .. note::
 
-   The statistical profiler (:mod:`profile.sample`) is recommended for most production
+   The statistical profiler (:mod:`!profiling.sampling`) is recommended for most production
    use cases due to its extremely low overhead and ability to profile running processes
    without modification. It can attach to any Python process and collect performance
    data with minimal impact on execution speed, making it ideal for debugging
@@ -138,11 +138,11 @@ on an existing application.
 
 To profile an existing running process::
 
-   python -m profile.sample 1234
+   python -m profiling.sampling 1234
 
 To profile with custom settings::
 
-   python -m profile.sample -i 50 -d 30 1234
+   python -m profiling.sampling -i 50 -d 30 1234
 
 **Deterministic Profiling (Development/Testing):**
 
@@ -218,34 +218,34 @@ them in various ways.
 Statistical Profiler Command Line Interface
 ===========================================
 
-.. program:: profile.sample
+.. program:: profiling.sampling
 
-The :mod:`profile.sample` module can be invoked as a script to profile running processes::
+The :mod:`!profiling.sampling` module can be invoked as a script to profile running processes::
 
-   python -m profile.sample [options] PID
+   python -m profiling.sampling [options] PID
 
 **Basic Usage Examples:**
 
 Profile process 1234 for 10 seconds with default settings::
 
-   python -m profile.sample 1234
+   python -m profiling.sampling 1234
 
 Profile with custom interval and duration, save to file::
 
-   python -m profile.sample -i 50 -d 30 -o profile.stats 1234
+   python -m profiling.sampling -i 50 -d 30 -o profile.stats 1234
 
 Generate collapsed stacks to use with tools like `flamegraph.pl
 <https://github.com/brendangregg/FlameGraph>`_::
 
-   python -m profile.sample --collapsed 1234
+   python -m profiling.sampling --collapsed 1234
 
 Profile all threads, sort by total time::
 
-   python -m profile.sample -a --sort-tottime 1234
+   python -m profiling.sampling -a --sort-tottime 1234
 
 Profile with real-time sampling statistics::
 
-   python -m profile.sample --realtime-stats 1234
+   python -m profiling.sampling --realtime-stats 1234
 
 **Command Line Options:**
 
@@ -339,13 +339,13 @@ The statistical profiler produces output similar to deterministic profilers but
 
 .. _profile-cli:
 
-:mod:`profile.sample` Module Reference
+:mod:`!profiling.sampling` Module Reference
 =======================================================
 
-.. module:: profile.sample
+.. module:: profiling.sampling
    :synopsis: Python statistical profiler.
 
-This section documents the programmatic interface for the :mod:`profile.sample` module.
+This section documents the programmatic interface for the :mod:`!profiling.sampling` module.
 For command-line usage, see :ref:`sampling-profiler-cli`. For conceptual information
 about statistical profiling, see :ref:`statistical-profiling`
 
@@ -373,14 +373,14 @@ about statistical profiling, see :ref:`statistical-profiling`
    Examples::
 
        # Basic usage - profile process 1234 for 10 seconds
-       import profile.sample
-       profile.sample.sample(1234)
+       import profiling.sampling
+       profiling.sampling.sample(1234)
 
        # Profile with custom settings
-       profile.sample.sample(1234, duration_sec=30, sample_interval_usec=50, all_threads=True)
+       profiling.sampling.sample(1234, duration_sec=30, sample_interval_usec=50, all_threads=True)
 
        # Generate collapsed stack traces for flamegraph.pl
-       profile.sample.sample(1234, output_format='collapsed', filename='profile.collapsed')
+       profiling.sampling.sample(1234, output_format='collapsed', filename='profile.collapsed')
 
 .. class:: SampleProfiler(pid, sample_interval_usec, all_threads)
 
@@ -856,7 +856,7 @@ What Is Deterministic Profiling?
 call*, *function return*, and *exception* events are monitored, and precise
 timings are made for the intervals between these events (during which time the
 user's code is executing).  In contrast, :dfn:`statistical profiling` (which is
-provided by the :mod:`profile.sample` module) periodically samples the effective instruction pointer, and
+provided by the :mod:`!profiling.sampling` module) periodically samples the effective instruction pointer, and
 deduces where time is being spent.  The latter technique traditionally involves
 less overhead (as the code does not need to be instrumented), but provides only
 relative indications of where time is being spent.

Doc/library/winreg.rst

@@ -173,6 +173,24 @@ This module offers the following functions:
       See :ref:`above <exception-changed>`.
 
 
+.. function:: DeleteTree(key, sub_key=None)
+
+   Deletes the specified key and all its subkeys and values recursively.
+
+   *key* is an already open key, or one of the predefined
+   :ref:`HKEY_* constants <hkey-constants>`.
+
+   *sub_key* is a string that names the subkey to delete. If ``None``,
+   deletes all subkeys and values of the specified key.
+
+   This function deletes a key and all its descendants. If *sub_key* is
+   ``None``, all subkeys and values of the specified key are deleted.
+
+   .. audit-event:: winreg.DeleteTree key,sub_key winreg.DeleteTree
+
+   .. versionadded:: next
+
+
 .. function:: DeleteValue(key, value)
 
    Removes a named value from a registry key.

Doc/reference/compound_stmts.rst

@@ -416,12 +416,14 @@ clauses.
 --------------------------
 
 If :keyword:`!finally` is present, it specifies a 'cleanup' handler.  The
-:keyword:`try` clause is executed, including any :keyword:`except` and
-:keyword:`else` clauses.  If an exception occurs in any of the clauses and is
-not handled, the exception is temporarily saved. The :keyword:`!finally` clause
-is executed.  If there is a saved exception it is re-raised at the end of the
-:keyword:`!finally` clause.  If the :keyword:`!finally` clause raises another
-exception, the saved exception is set as the context of the new exception.
+:keyword:`try` clause is executed, including any :keyword:`except`
+and :keyword:`else <except_else>` clauses.
+If an exception occurs in any of the clauses and is not handled,
+the exception is temporarily saved.
+The :keyword:`!finally` clause is executed.  If there is a saved exception
+it is re-raised at the end of the :keyword:`!finally` clause.
+If the :keyword:`!finally` clause raises another exception, the saved exception
+is set as the context of the new exception.
 If the :keyword:`!finally` clause executes a :keyword:`return`, :keyword:`break`
 or :keyword:`continue` statement, the saved exception is discarded. For example,
 this function returns 42.

Doc/reference/lexical_analysis.rst

@@ -628,10 +628,10 @@ to indicate that an ending quote ends the literal.
    STRING:          [`stringprefix`] (`stringcontent`)
    stringprefix:    <("r" | "u" | "b" | "br" | "rb"), case-insensitive>
    stringcontent:
-      | "'" ( !"'" `stringitem`)* "'"
-      | '"' ( !'"' `stringitem`)* '"'
       | "'''" ( !"'''" `longstringitem`)* "'''"
       | '"""' ( !'"""' `longstringitem`)* '"""'
+      | "'" ( !"'" `stringitem`)* "'"
+      | '"' ( !'"' `stringitem`)* '"'
    stringitem:      `stringchar` | `stringescapeseq`
    stringchar:      <any `source_character`, except backslash and newline>
    longstringitem:  `stringitem` | newline

Doc/whatsnew/3.15.rst

@@ -75,8 +75,8 @@ New features
 High frequency statistical sampling profiler
 --------------------------------------------
 
-A new statistical sampling profiler has been added to the :mod:`profile` module as
-:mod:`profile.sample`. This profiler enables low-overhead performance analysis of
+A new statistical sampling profiler has been added to the new :mod:`!profiling` module as
+:mod:`!profiling.sampling`. This profiler enables low-overhead performance analysis of
 running Python processes without requiring code modification or process restart.
 
 Unlike deterministic profilers (:mod:`cProfile` and :mod:`profile`) that instrument
@@ -97,19 +97,19 @@ Key features include:
 
 Profile process 1234 for 10 seconds with default settings::
 
-  python -m profile.sample 1234
+  python -m profiling.sampling 1234
 
 Profile with custom interval and duration, save to file::
 
-  python -m profile.sample -i 50 -d 30 -o profile.stats 1234
+  python -m profiling.sampling -i 50 -d 30 -o profile.stats 1234
 
 Generate collapsed stacks for flamegraph::
 
-  python -m profile.sample --collapsed 1234
+  python -m profiling.sampling --collapsed 1234
 
 Profile all threads and sort by total time::
 
-  python -m profile.sample -a --sort-tottime 1234
+  python -m profiling.sampling -a --sort-tottime 1234
 
 The profiler generates statistical estimates of where time is spent::
 

Lib/test/test_grammar.py

@@ -1554,6 +1554,8 @@ def check(test):
         check('[None [i, j]]')
         check('[True [i, j]]')
         check('[... [i, j]]')
+        check('[t"{x}" [i, j]]')
+        check('[t"x={x}" [i, j]]')
 
         msg=r'indices must be integers or slices, not tuple; perhaps you missed a comma\?'
         check('[(1, 2) [i, j]]')
@@ -1564,8 +1566,6 @@ def check(test):
         check('[f"x={x}" [i, j]]')
         check('["abc" [i, j]]')
         check('[b"abc" [i, j]]')
-        check('[t"{x}" [i, j]]')
-        check('[t"x={x}" [i, j]]')
 
         msg=r'indices must be integers or slices, not tuple;'
         check('[[1, 2] [3, 4]]')
@@ -1586,6 +1586,7 @@ def check(test):
         check('[[1, 2] [f"{x}"]]')
         check('[[1, 2] [f"x={x}"]]')
         check('[[1, 2] ["abc"]]')
+        msg=r'indices must be integers or slices, not string.templatelib.Template;'
         check('[[1, 2] [t"{x}"]]')
         check('[[1, 2] [t"x={x}"]]')
         msg=r'indices must be integers or slices, not'

Lib/test/test_io/test_general.py

@@ -5029,12 +5029,12 @@ def write(self, b: bytes):
             pass
 
     def test_reader_subclass(self):
-        self.assertIsSubclass(MyReader, io.Reader[bytes])
-        self.assertNotIsSubclass(str, io.Reader[bytes])
+        self.assertIsSubclass(self.MyReader, io.Reader)
+        self.assertNotIsSubclass(str, io.Reader)
 
     def test_writer_subclass(self):
-        self.assertIsSubclass(MyWriter, io.Writer[bytes])
-        self.assertNotIsSubclass(str, io.Writer[bytes])
+        self.assertIsSubclass(self.MyWriter, io.Writer)
+        self.assertNotIsSubclass(str, io.Writer)
 
 
 def load_tests(loader, tests, pattern):
@@ -5048,6 +5048,7 @@ def load_tests(loader, tests, pattern):
              CTextIOWrapperTest, PyTextIOWrapperTest,
              CMiscIOTest, PyMiscIOTest,
              CSignalsTest, PySignalsTest, TestIOCTypes,
+             ProtocolsTest,
              )
 
     # Put the namespaces of the IO module we are testing and some useful mock

Lib/test/test_long.py

@@ -1693,5 +1693,21 @@ class MyInt(int):
         # GH-117195 -- This shouldn't crash
         object.__sizeof__(1)
 
+    def test_hash(self):
+        # gh-136599
+        self.assertEqual(hash(-1), -2)
+        self.assertEqual(hash(0), 0)
+        self.assertEqual(hash(10), 10)
+
+        self.assertEqual(hash(sys.hash_info.modulus - 2), sys.hash_info.modulus - 2)
+        self.assertEqual(hash(sys.hash_info.modulus - 1), sys.hash_info.modulus - 1)
+        self.assertEqual(hash(sys.hash_info.modulus), 0)
+        self.assertEqual(hash(sys.hash_info.modulus + 1), 1)
+
+        self.assertEqual(hash(-sys.hash_info.modulus - 2), -2)
+        self.assertEqual(hash(-sys.hash_info.modulus - 1), -2)
+        self.assertEqual(hash(-sys.hash_info.modulus), 0)
+        self.assertEqual(hash(-sys.hash_info.modulus + 1), -sys.hash_info.modulus + 1)
+
 if __name__ == "__main__":
     unittest.main()