bpo-41176: Resolve review issues

python · richardsheridan · Jul 3, 2020 · Jul 3, 2020 · Jul 3, 2020 · Jul 3, 2020
commit bf2776cae5cf7aae3c6aff2bb867640b0d7e8e7f
diff --git a/Doc/library/tkinter.rst b/Doc/library/tkinter.rst
@@ -88,6 +88,10 @@ so, usually, to use Tkinter all you need is a simple import statement::
 
    .. FIXME: The following keyword arguments are currently recognized:
 
+Below are a few of the methods provided by the :class:`Tk` class.
+
+.. sectionauthor:: Richard Sheridan
+
 .. method:: Tk.mainloop(threshold)
 
    Enters the main loop of Tkinter. This repeatedly dispatches Tcl events until either
@@ -112,6 +116,8 @@ so, usually, to use Tkinter all you need is a simple import statement::
    the main loop to be dispatching events. Some examples are: calling the :meth:`Tk.update` command,
    :meth:`_tkinter.tkapp.doonevent`, and the python command line EventHook.
 
+   .. versionadded:: 3.10
+
 .. function:: Tcl(screenName=None, baseName=None, className='Tk', useTk=0)
 
    The :func:`Tcl` function is a factory function which creates an object much like
@@ -122,59 +128,6 @@ so, usually, to use Tkinter all you need is a simple import statement::
    created by the :func:`Tcl` object can have a Toplevel window created (and the Tk
    subsystem initialized) by calling its :meth:`loadtk` method.
 
-.. TODO: Not a class, a module. how do I inline another module into this RST file?
-
-.. class:: _tkinter
-
-   This module contains the low-level interface to Tk, and should rarely be
-   used directly by application programmers. It is usually a shared library
-   (or DLL), but might in some cases be statically linked with the Python
-   interpreter.
-
-.. method:: _tkinter.create(screenName=None, baseName="", className="Tk", interactive=False, wantobjects=False, wantTk=True, sync=False, use=None)
-
-   This method is not for general use, but it is responsible for creating the
-   :class:`_tkinter.tkapp` object that can be found as the attribute
-   :attr:`Tk.tk`.
-
-.. class:: _tkinter.tkapp
-
-   This object contains most of the low-level interface to Tk, and should
-   rarely be used directly by application programmers.
-
-.. method:: _tkinter.tkapp.call(*args)
-
-   This method is the core entry point to Tcl/Tk. All Tkinter methods that
-   correspond to Tcl commands flow through here. This function is thread-safe,
-   meaning it can be used to issue commands to the Tcl interpreter in the main
-   thread from any other thread. If called from a thread, it will wait up to
-   one second for :meth:`Tk.mainloop` to be called, and then throw an error.
-   This error after one second is deprecated behavior, in the future it will
-   wait indefinitely for :meth:`Tk.mainloop`, :meth:`Tk.update`, or
-   :meth:`_tkinter.tkapp.dooneevent` to dispatch the event.
-
-.. method:: _tkinter.tkapp.willdispatch()
-
-   This method circumvents the thread waiting behavior of :meth:`_tkinter.tkapp.call`
-   until after the next call to :meth:`Tk.mainloop` returns. Instead of throwing
-   an error after one second, :meth:`_tkinter.tkapp.call` will wait indefinitely
-   for :meth:`Tk.mainloop` to come up, or for some other entity to dispatch the
-   call. This method is essentially a promise to the thread that you "will dispatch" soon.
-   This method is deprecated and future behavior will be equivialent to calling this
-   function on load and after each invocation of :meth:`Tk.mainloop`.
-
-.. method:: _tkinter.tkapp.setmainloopwaitattempts(num=10)
-
-   This method sets the number of 100 ms wait attempts of :meth:`_tkinter.tkapp.call`.
-   You can trigger an error immediately by setting num to 0. This method is deprecated
-   and future behavior will be equivalent to setting an infinite number of attempts.
-
-.. method:: _tkinter.tkapp.dooneevent(flags=0)
-
-   Dispatches exactly one event from the Tcl event queue. Must be called from the same
-   thread as the Tcl interpreter. See Tcl documentation for Tcl_DoOneEvent() for information
-   on using the flags argument.
-
 Other modules that provide Tk support include:
 
 :mod:`tkinter.colorchooser`

diff --git a/Doc/whatsnew/3.10.rst b/Doc/whatsnew/3.10.rst
@@ -111,16 +111,16 @@ Added the *root_dir* and *dir_fd* parameters in :func:`~glob.glob` and
 (Contributed by Serhiy Storchaka in :issue:`38144`.)
 
 sys
----
+----
 
 Add :data:`sys.orig_argv` attribute: the list of the original command line
 arguments passed to the Python executable.
 (Contributed by Victor Stinner in :issue:`23427`.)
 
 tkinter
----
+----
 
-Added :meth:`tkinter.dispatching`, :meth:`tkinter.Misc.dispatching`, and
+XXX Added :meth:`tkinter.dispatching`, :meth:`tkinter.Misc.dispatching`, and
 :meth:`_tkinter.tkapp.dispatching`.
 You can reliably call these to determine if the tkinter mainloop is running.
 
@@ -130,7 +130,7 @@ correctness of the new dispatching methods.
 Added another new method :meth:`_tkinter.tkapp.setmainloopwaitattempts` which
 can be used to obtain future thread waiting behavior.
 
-(see also Deprications section)
+(see also Deprecated section)
 (Contributed by Richard Sheridan in :issue:`41176`.)
 
 
@@ -146,7 +146,7 @@ Optimizations
 Deprecated
 ==========
 
-The :mod:`tkinter` module has deprected the undocumented behavior where a
+XXX The :mod:`tkinter` module has deprected the undocumented behavior where a
 thread will implicitly wait up to one second for the main thread to enter
 the main loop and then fail.
 The undocumented :meth:`_tkinter.tkapp.willdispatch` method which sidesteps

diff --git a/Lib/tkinter/test/test_tkinter/test_misc.py b/Lib/tkinter/test/test_tkinter/test_misc.py
@@ -1,6 +1,6 @@
 import unittest
 import tkinter
-import threading, time
+import threading
 import time
 from test import support
 from tkinter.test.support import AbstractTkTest
@@ -244,19 +244,15 @@ def target():
                 # keep the main thread from calling root.mainloop()
                 ready_for_mainloop.set()
 
-            # Everything after the event set must go in this try
-            # to guarantee that root.quit() is called in finally
-            try:
-                # self.assertTrue(root.dispatching()) but patient
-                for i in range (1000):
-                    if root.dispatching():
-                        thread_dispatching_eventually = True
-                        break
-                    time.sleep(0.01)
-                else:  # if not break
-                    thread_dispatching_eventually = False
-            finally:
-                root.after(0, root.quit)
+            # self.assertTrue(root.dispatching()) but patient
+            for i in range(1000):
+                if root.dispatching():
+                    thread_dispatching_eventually = True
+                    break
+                time.sleep(0.01)
+            else:  # if not break
+                thread_dispatching_eventually = False
+            root.after(0, root.quit)
 
         root = self.root
 
@@ -265,7 +261,7 @@ def target():
 
         try:
             ready_for_mainloop = threading.Event()
-            thread = threading.Thread(target=target, daemon=True)
+            thread = threading.Thread(target=target)
             self.assertFalse(root.dispatching())
             thread.start()
             ready_for_mainloop.wait()

diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
@@ -366,7 +366,7 @@ static int mainloopwaitattempts = 10; // 1 second
 static int
 WaitForMainloop(TkappObject* self)
 {
-    int i = 0;
+    int i;
     int max_attempts = mainloopwaitattempts;
     if (self->dispatching)
     {