add padding function to imgScalePadding()

.CondaPkg/env/Lib/tkinter/__main__.py

@@ -1,7 +0,0 @@
-"""Main entry point"""
-
-import sys
-if sys.argv[0].endswith("__main__.py"):
-    sys.argv[0] = "python -m tkinter"
-from . import _test as main
-main()

.CondaPkg/env/Lib/tkinter/colorchooser.py

@@ -1,86 +0,0 @@
-# tk common color chooser dialogue
-#
-# this module provides an interface to the native color dialogue
-# available in Tk 4.2 and newer.
-#
-# written by Fredrik Lundh, May 1997
-#
-# fixed initialcolor handling in August 1998
-#
-
-
-from tkinter.commondialog import Dialog
-
-__all__ = ["Chooser", "askcolor"]
-
-
-class Chooser(Dialog):
-    """Create a dialog for the tk_chooseColor command.
-
-    Args:
-        master: The master widget for this dialog.  If not provided,
-            defaults to options['parent'] (if defined).
-        options: Dictionary of options for the tk_chooseColor call.
-            initialcolor: Specifies the selected color when the
-                dialog is first displayed.  This can be a tk color
-                string or a 3-tuple of ints in the range (0, 255)
-                for an RGB triplet.
-            parent: The parent window of the color dialog.  The
-                color dialog is displayed on top of this.
-            title: A string for the title of the dialog box.
-    """
-
-    command = "tk_chooseColor"
-
-    def _fixoptions(self):
-        """Ensure initialcolor is a tk color string.
-
-        Convert initialcolor from a RGB triplet to a color string.
-        """
-        try:
-            color = self.options["initialcolor"]
-            if isinstance(color, tuple):
-                # Assume an RGB triplet.
-                self.options["initialcolor"] = "#%02x%02x%02x" % color
-        except KeyError:
-            pass
-
-    def _fixresult(self, widget, result):
-        """Adjust result returned from call to tk_chooseColor.
-
-        Return both an RGB tuple of ints in the range (0, 255) and the
-        tk color string in the form #rrggbb.
-        """
-        # Result can be many things: an empty tuple, an empty string, or
-        # a _tkinter.Tcl_Obj, so this somewhat weird check handles that.
-        if not result or not str(result):
-            return None, None  # canceled
-
-        # To simplify application code, the color chooser returns
-        # an RGB tuple together with the Tk color string.
-        r, g, b = widget.winfo_rgb(result)
-        return (r//256, g//256, b//256), str(result)
-
-
-#
-# convenience stuff
-
-def askcolor(color=None, **options):
-    """Display dialog window for selection of a color.
-
-    Convenience wrapper for the Chooser class.  Displays the color
-    chooser dialog with color as the initial value.
-    """
-
-    if color:
-        options = options.copy()
-        options["initialcolor"] = color
-
-    return Chooser(**options).show()
-
-
-# --------------------------------------------------------------------
-# test stuff
-
-if __name__ == "__main__":
-    print("color", askcolor())

.CondaPkg/env/Lib/tkinter/commondialog.py

@@ -1,53 +0,0 @@
-# base class for tk common dialogues
-#
-# this module provides a base class for accessing the common
-# dialogues available in Tk 4.2 and newer.  use filedialog,
-# colorchooser, and messagebox to access the individual
-# dialogs.
-#
-# written by Fredrik Lundh, May 1997
-#
-
-__all__ = ["Dialog"]
-
-from tkinter import Frame, _get_temp_root, _destroy_temp_root
-
-
-class Dialog:
-
-    command = None
-
-    def __init__(self, master=None, **options):
-        if master is None:
-            master = options.get('parent')
-        self.master = master
-        self.options = options
-
-    def _fixoptions(self):
-        pass # hook
-
-    def _fixresult(self, widget, result):
-        return result # hook
-
-    def show(self, **options):
-
-        # update instance options
-        for k, v in options.items():
-            self.options[k] = v
-
-        self._fixoptions()
-
-        master = self.master
-        if master is None:
-            master = _get_temp_root()
-        try:
-            self._test_callback(master)  # The function below is replaced for some tests.
-            s = master.tk.call(self.command, *master._options(self.options))
-            s = self._fixresult(master, s)
-        finally:
-            _destroy_temp_root(master)
-
-        return s
-
-    def _test_callback(self, master):
-        pass

.CondaPkg/env/Lib/tkinter/constants.py

@@ -1,110 +0,0 @@
-# Symbolic constants for Tk
-
-# Booleans
-NO=FALSE=OFF=0
-YES=TRUE=ON=1
-
-# -anchor and -sticky
-N='n'
-S='s'
-W='w'
-E='e'
-NW='nw'
-SW='sw'
-NE='ne'
-SE='se'
-NS='ns'
-EW='ew'
-NSEW='nsew'
-CENTER='center'
-
-# -fill
-NONE='none'
-X='x'
-Y='y'
-BOTH='both'
-
-# -side
-LEFT='left'
-TOP='top'
-RIGHT='right'
-BOTTOM='bottom'
-
-# -relief
-RAISED='raised'
-SUNKEN='sunken'
-FLAT='flat'
-RIDGE='ridge'
-GROOVE='groove'
-SOLID = 'solid'
-
-# -orient
-HORIZONTAL='horizontal'
-VERTICAL='vertical'
-
-# -tabs
-NUMERIC='numeric'
-
-# -wrap
-CHAR='char'
-WORD='word'
-
-# -align
-BASELINE='baseline'
-
-# -bordermode
-INSIDE='inside'
-OUTSIDE='outside'
-
-# Special tags, marks and insert positions
-SEL='sel'
-SEL_FIRST='sel.first'
-SEL_LAST='sel.last'
-END='end'
-INSERT='insert'
-CURRENT='current'
-ANCHOR='anchor'
-ALL='all' # e.g. Canvas.delete(ALL)
-
-# Text widget and button states
-NORMAL='normal'
-DISABLED='disabled'
-ACTIVE='active'
-# Canvas state
-HIDDEN='hidden'
-
-# Menu item types
-CASCADE='cascade'
-CHECKBUTTON='checkbutton'
-COMMAND='command'
-RADIOBUTTON='radiobutton'
-SEPARATOR='separator'
-
-# Selection modes for list boxes
-SINGLE='single'
-BROWSE='browse'
-MULTIPLE='multiple'
-EXTENDED='extended'
-
-# Activestyle for list boxes
-# NONE='none' is also valid
-DOTBOX='dotbox'
-UNDERLINE='underline'
-
-# Various canvas styles
-PIESLICE='pieslice'
-CHORD='chord'
-ARC='arc'
-FIRST='first'
-LAST='last'
-BUTT='butt'
-PROJECTING='projecting'
-ROUND='round'
-BEVEL='bevel'
-MITER='miter'
-
-# Arguments to xview/yview
-MOVETO='moveto'
-SCROLL='scroll'
-UNITS='units'
-PAGES='pages'

.CondaPkg/env/Lib/tkinter/dialog.py

@@ -1,49 +0,0 @@
-# dialog.py -- Tkinter interface to the tk_dialog script.
-
-from tkinter import _cnfmerge, Widget, TclError, Button, Pack
-
-__all__ = ["Dialog"]
-
-DIALOG_ICON = 'questhead'
-
-
-class Dialog(Widget):
-    def __init__(self, master=None, cnf={}, **kw):
-        cnf = _cnfmerge((cnf, kw))
-        self.widgetName = '__dialog__'
-        self._setup(master, cnf)
-        self.num = self.tk.getint(
-                self.tk.call(
-                      'tk_dialog', self._w,
-                      cnf['title'], cnf['text'],
-                      cnf['bitmap'], cnf['default'],
-                      *cnf['strings']))
-        try: Widget.destroy(self)
-        except TclError: pass
-
-    def destroy(self): pass
-
-
-def _test():
-    d = Dialog(None, {'title': 'File Modified',
-                      'text':
-                      'File "Python.h" has been modified'
-                      ' since the last time it was saved.'
-                      ' Do you want to save it before'
-                      ' exiting the application.',
-                      'bitmap': DIALOG_ICON,
-                      'default': 0,
-                      'strings': ('Save File',
-                                  'Discard Changes',
-                                  'Return to Editor')})
-    print(d.num)
-
-
-if __name__ == '__main__':
-    t = Button(None, {'text': 'Test',
-                      'command': _test,
-                      Pack: {}})
-    q = Button(None, {'text': 'Quit',
-                      'command': t.quit,
-                      Pack: {}})
-    t.mainloop()

.CondaPkg/env/Lib/tkinter/dnd.py

@@ -1,324 +0,0 @@
-"""Drag-and-drop support for Tkinter.
-
-This is very preliminary.  I currently only support dnd *within* one
-application, between different windows (or within the same window).
-
-I am trying to make this as generic as possible -- not dependent on
-the use of a particular widget or icon type, etc.  I also hope that
-this will work with Pmw.
-
-To enable an object to be dragged, you must create an event binding
-for it that starts the drag-and-drop process. Typically, you should
-bind <ButtonPress> to a callback function that you write. The function
-should call Tkdnd.dnd_start(source, event), where 'source' is the
-object to be dragged, and 'event' is the event that invoked the call
-(the argument to your callback function).  Even though this is a class
-instantiation, the returned instance should not be stored -- it will
-be kept alive automatically for the duration of the drag-and-drop.
-
-When a drag-and-drop is already in process for the Tk interpreter, the
-call is *ignored*; this normally averts starting multiple simultaneous
-dnd processes, e.g. because different button callbacks all
-dnd_start().
-
-The object is *not* necessarily a widget -- it can be any
-application-specific object that is meaningful to potential
-drag-and-drop targets.
-
-Potential drag-and-drop targets are discovered as follows.  Whenever
-the mouse moves, and at the start and end of a drag-and-drop move, the
-Tk widget directly under the mouse is inspected.  This is the target
-widget (not to be confused with the target object, yet to be
-determined).  If there is no target widget, there is no dnd target
-object.  If there is a target widget, and it has an attribute
-dnd_accept, this should be a function (or any callable object).  The
-function is called as dnd_accept(source, event), where 'source' is the
-object being dragged (the object passed to dnd_start() above), and
-'event' is the most recent event object (generally a <Motion> event;
-it can also be <ButtonPress> or <ButtonRelease>).  If the dnd_accept()
-function returns something other than None, this is the new dnd target
-object.  If dnd_accept() returns None, or if the target widget has no
-dnd_accept attribute, the target widget's parent is considered as the
-target widget, and the search for a target object is repeated from
-there.  If necessary, the search is repeated all the way up to the
-root widget.  If none of the target widgets can produce a target
-object, there is no target object (the target object is None).
-
-The target object thus produced, if any, is called the new target
-object.  It is compared with the old target object (or None, if there
-was no old target widget).  There are several cases ('source' is the
-source object, and 'event' is the most recent event object):
-
-- Both the old and new target objects are None.  Nothing happens.
-
-- The old and new target objects are the same object.  Its method
-dnd_motion(source, event) is called.
-
-- The old target object was None, and the new target object is not
-None.  The new target object's method dnd_enter(source, event) is
-called.
-
-- The new target object is None, and the old target object is not
-None.  The old target object's method dnd_leave(source, event) is
-called.
-
-- The old and new target objects differ and neither is None.  The old
-target object's method dnd_leave(source, event), and then the new
-target object's method dnd_enter(source, event) is called.
-
-Once this is done, the new target object replaces the old one, and the
-Tk mainloop proceeds.  The return value of the methods mentioned above
-is ignored; if they raise an exception, the normal exception handling
-mechanisms take over.
-
-The drag-and-drop processes can end in two ways: a final target object
-is selected, or no final target object is selected.  When a final
-target object is selected, it will always have been notified of the
-potential drop by a call to its dnd_enter() method, as described
-above, and possibly one or more calls to its dnd_motion() method; its
-dnd_leave() method has not been called since the last call to
-dnd_enter().  The target is notified of the drop by a call to its
-method dnd_commit(source, event).
-
-If no final target object is selected, and there was an old target
-object, its dnd_leave(source, event) method is called to complete the
-dnd sequence.
-
-Finally, the source object is notified that the drag-and-drop process
-is over, by a call to source.dnd_end(target, event), specifying either
-the selected target object, or None if no target object was selected.
-The source object can use this to implement the commit action; this is
-sometimes simpler than to do it in the target's dnd_commit().  The
-target's dnd_commit() method could then simply be aliased to
-dnd_leave().
-
-At any time during a dnd sequence, the application can cancel the
-sequence by calling the cancel() method on the object returned by
-dnd_start().  This will call dnd_leave() if a target is currently
-active; it will never call dnd_commit().
-
-"""
-
-import tkinter
-
-__all__ = ["dnd_start", "DndHandler"]
-
-
-# The factory function
-
-def dnd_start(source, event):
-    h = DndHandler(source, event)
-    if h.root is not None:
-        return h
-    else:
-        return None
-
-
-# The class that does the work
-
-class DndHandler:
-
-    root = None
-
-    def __init__(self, source, event):
-        if event.num > 5:
-            return
-        root = event.widget._root()
-        try:
-            root.__dnd
-            return # Don't start recursive dnd
-        except AttributeError:
-            root.__dnd = self
-            self.root = root
-        self.source = source
-        self.target = None
-        self.initial_button = button = event.num
-        self.initial_widget = widget = event.widget
-        self.release_pattern = "<B%d-ButtonRelease-%d>" % (button, button)
-        self.save_cursor = widget['cursor'] or ""
-        widget.bind(self.release_pattern, self.on_release)
-        widget.bind("<Motion>", self.on_motion)
-        widget['cursor'] = "hand2"
-
-    def __del__(self):
-        root = self.root
-        self.root = None
-        if root is not None:
-            try:
-                del root.__dnd
-            except AttributeError:
-                pass
-
-    def on_motion(self, event):
-        x, y = event.x_root, event.y_root
-        target_widget = self.initial_widget.winfo_containing(x, y)
-        source = self.source
-        new_target = None
-        while target_widget is not None:
-            try:
-                attr = target_widget.dnd_accept
-            except AttributeError:
-                pass
-            else:
-                new_target = attr(source, event)
-                if new_target is not None:
-                    break
-            target_widget = target_widget.master
-        old_target = self.target
-        if old_target is new_target:
-            if old_target is not None:
-                old_target.dnd_motion(source, event)
-        else:
-            if old_target is not None:
-                self.target = None
-                old_target.dnd_leave(source, event)
-            if new_target is not None:
-                new_target.dnd_enter(source, event)
-                self.target = new_target
-
-    def on_release(self, event):
-        self.finish(event, 1)
-
-    def cancel(self, event=None):
-        self.finish(event, 0)
-
-    def finish(self, event, commit=0):
-        target = self.target
-        source = self.source
-        widget = self.initial_widget
-        root = self.root
-        try:
-            del root.__dnd
-            self.initial_widget.unbind(self.release_pattern)
-            self.initial_widget.unbind("<Motion>")
-            widget['cursor'] = self.save_cursor
-            self.target = self.source = self.initial_widget = self.root = None
-            if target is not None:
-                if commit:
-                    target.dnd_commit(source, event)
-                else:
-                    target.dnd_leave(source, event)
-        finally:
-            source.dnd_end(target, event)
-
-
-# ----------------------------------------------------------------------
-# The rest is here for testing and demonstration purposes only!
-
-class Icon:
-
-    def __init__(self, name):
-        self.name = name
-        self.canvas = self.label = self.id = None
-
-    def attach(self, canvas, x=10, y=10):
-        if canvas is self.canvas:
-            self.canvas.coords(self.id, x, y)
-            return
-        if self.canvas is not None:
-            self.detach()
-        if canvas is None:
-            return
-        label = tkinter.Label(canvas, text=self.name,
-                              borderwidth=2, relief="raised")
-        id = canvas.create_window(x, y, window=label, anchor="nw")
-        self.canvas = canvas
-        self.label = label
-        self.id = id
-        label.bind("<ButtonPress>", self.press)
-
-    def detach(self):
-        canvas = self.canvas
-        if canvas is None:
-            return
-        id = self.id
-        label = self.label
-        self.canvas = self.label = self.id = None
-        canvas.delete(id)
-        label.destroy()
-
-    def press(self, event):
-        if dnd_start(self, event):
-            # where the pointer is relative to the label widget:
-            self.x_off = event.x
-            self.y_off = event.y
-            # where the widget is relative to the canvas:
-            self.x_orig, self.y_orig = self.canvas.coords(self.id)
-
-    def move(self, event):
-        x, y = self.where(self.canvas, event)
-        self.canvas.coords(self.id, x, y)
-
-    def putback(self):
-        self.canvas.coords(self.id, self.x_orig, self.y_orig)
-
-    def where(self, canvas, event):
-        # where the corner of the canvas is relative to the screen:
-        x_org = canvas.winfo_rootx()
-        y_org = canvas.winfo_rooty()
-        # where the pointer is relative to the canvas widget:
-        x = event.x_root - x_org
-        y = event.y_root - y_org
-        # compensate for initial pointer offset
-        return x - self.x_off, y - self.y_off
-
-    def dnd_end(self, target, event):
-        pass
-
-
-class Tester:
-
-    def __init__(self, root):
-        self.top = tkinter.Toplevel(root)
-        self.canvas = tkinter.Canvas(self.top, width=100, height=100)
-        self.canvas.pack(fill="both", expand=1)
-        self.canvas.dnd_accept = self.dnd_accept
-
-    def dnd_accept(self, source, event):
-        return self
-
-    def dnd_enter(self, source, event):
-        self.canvas.focus_set() # Show highlight border
-        x, y = source.where(self.canvas, event)
-        x1, y1, x2, y2 = source.canvas.bbox(source.id)
-        dx, dy = x2-x1, y2-y1
-        self.dndid = self.canvas.create_rectangle(x, y, x+dx, y+dy)
-        self.dnd_motion(source, event)
-
-    def dnd_motion(self, source, event):
-        x, y = source.where(self.canvas, event)
-        x1, y1, x2, y2 = self.canvas.bbox(self.dndid)
-        self.canvas.move(self.dndid, x-x1, y-y1)
-
-    def dnd_leave(self, source, event):
-        self.top.focus_set() # Hide highlight border
-        self.canvas.delete(self.dndid)
-        self.dndid = None
-
-    def dnd_commit(self, source, event):
-        self.dnd_leave(source, event)
-        x, y = source.where(self.canvas, event)
-        source.attach(self.canvas, x, y)
-
-
-def test():
-    root = tkinter.Tk()
-    root.geometry("+1+1")
-    tkinter.Button(command=root.quit, text="Quit").pack()
-    t1 = Tester(root)
-    t1.top.geometry("+1+60")
-    t2 = Tester(root)
-    t2.top.geometry("+120+60")
-    t3 = Tester(root)
-    t3.top.geometry("+240+60")
-    i1 = Icon("ICON1")
-    i2 = Icon("ICON2")
-    i3 = Icon("ICON3")
-    i1.attach(t1.canvas)
-    i2.attach(t2.canvas)
-    i3.attach(t3.canvas)
-    root.mainloop()
-
-
-if __name__ == '__main__':
-    test()

.CondaPkg/env/Lib/tkinter/filedialog.py

@@ -1,493 +0,0 @@
-"""File selection dialog classes.
-
-Classes:
-
-- FileDialog
-- LoadFileDialog
-- SaveFileDialog
-
-This module also presents tk common file dialogues, it provides interfaces
-to the native file dialogues available in Tk 4.2 and newer, and the
-directory dialogue available in Tk 8.3 and newer.
-These interfaces were written by Fredrik Lundh, May 1997.
-"""
-__all__ = ["FileDialog", "LoadFileDialog", "SaveFileDialog",
-           "Open", "SaveAs", "Directory",
-           "askopenfilename", "asksaveasfilename", "askopenfilenames",
-           "askopenfile", "askopenfiles", "asksaveasfile", "askdirectory"]
-
-import fnmatch
-import os
-from tkinter import (
-    Frame, LEFT, YES, BOTTOM, Entry, TOP, Button, Tk, X,
-    Toplevel, RIGHT, Y, END, Listbox, BOTH, Scrollbar,
-)
-from tkinter.dialog import Dialog
-from tkinter import commondialog
-from tkinter.simpledialog import _setup_dialog
-
-
-dialogstates = {}
-
-
-class FileDialog:
-
-    """Standard file selection dialog -- no checks on selected file.
-
-    Usage:
-
-        d = FileDialog(master)
-        fname = d.go(dir_or_file, pattern, default, key)
-        if fname is None: ...canceled...
-        else: ...open file...
-
-    All arguments to go() are optional.
-
-    The 'key' argument specifies a key in the global dictionary
-    'dialogstates', which keeps track of the values for the directory
-    and pattern arguments, overriding the values passed in (it does
-    not keep track of the default argument!).  If no key is specified,
-    the dialog keeps no memory of previous state.  Note that memory is
-    kept even when the dialog is canceled.  (All this emulates the
-    behavior of the Macintosh file selection dialogs.)
-
-    """
-
-    title = "File Selection Dialog"
-
-    def __init__(self, master, title=None):
-        if title is None: title = self.title
-        self.master = master
-        self.directory = None
-
-        self.top = Toplevel(master)
-        self.top.title(title)
-        self.top.iconname(title)
-        _setup_dialog(self.top)
-
-        self.botframe = Frame(self.top)
-        self.botframe.pack(side=BOTTOM, fill=X)
-
-        self.selection = Entry(self.top)
-        self.selection.pack(side=BOTTOM, fill=X)
-        self.selection.bind('<Return>', self.ok_event)
-
-        self.filter = Entry(self.top)
-        self.filter.pack(side=TOP, fill=X)
-        self.filter.bind('<Return>', self.filter_command)
-
-        self.midframe = Frame(self.top)
-        self.midframe.pack(expand=YES, fill=BOTH)
-
-        self.filesbar = Scrollbar(self.midframe)
-        self.filesbar.pack(side=RIGHT, fill=Y)
-        self.files = Listbox(self.midframe, exportselection=0,
-                             yscrollcommand=(self.filesbar, 'set'))
-        self.files.pack(side=RIGHT, expand=YES, fill=BOTH)
-        btags = self.files.bindtags()
-        self.files.bindtags(btags[1:] + btags[:1])
-        self.files.bind('<ButtonRelease-1>', self.files_select_event)
-        self.files.bind('<Double-ButtonRelease-1>', self.files_double_event)
-        self.filesbar.config(command=(self.files, 'yview'))
-
-        self.dirsbar = Scrollbar(self.midframe)
-        self.dirsbar.pack(side=LEFT, fill=Y)
-        self.dirs = Listbox(self.midframe, exportselection=0,
-                            yscrollcommand=(self.dirsbar, 'set'))
-        self.dirs.pack(side=LEFT, expand=YES, fill=BOTH)
-        self.dirsbar.config(command=(self.dirs, 'yview'))
-        btags = self.dirs.bindtags()
-        self.dirs.bindtags(btags[1:] + btags[:1])
-        self.dirs.bind('<ButtonRelease-1>', self.dirs_select_event)
-        self.dirs.bind('<Double-ButtonRelease-1>', self.dirs_double_event)
-
-        self.ok_button = Button(self.botframe,
-                                 text="OK",
-                                 command=self.ok_command)
-        self.ok_button.pack(side=LEFT)
-        self.filter_button = Button(self.botframe,
-                                    text="Filter",
-                                    command=self.filter_command)
-        self.filter_button.pack(side=LEFT, expand=YES)
-        self.cancel_button = Button(self.botframe,
-                                    text="Cancel",
-                                    command=self.cancel_command)
-        self.cancel_button.pack(side=RIGHT)
-
-        self.top.protocol('WM_DELETE_WINDOW', self.cancel_command)
-        # XXX Are the following okay for a general audience?
-        self.top.bind('<Alt-w>', self.cancel_command)
-        self.top.bind('<Alt-W>', self.cancel_command)
-
-    def go(self, dir_or_file=os.curdir, pattern="*", default="", key=None):
-        if key and key in dialogstates:
-            self.directory, pattern = dialogstates[key]
-        else:
-            dir_or_file = os.path.expanduser(dir_or_file)
-            if os.path.isdir(dir_or_file):
-                self.directory = dir_or_file
-            else:
-                self.directory, default = os.path.split(dir_or_file)
-        self.set_filter(self.directory, pattern)
-        self.set_selection(default)
-        self.filter_command()
-        self.selection.focus_set()
-        self.top.wait_visibility() # window needs to be visible for the grab
-        self.top.grab_set()
-        self.how = None
-        self.master.mainloop()          # Exited by self.quit(how)
-        if key:
-            directory, pattern = self.get_filter()
-            if self.how:
-                directory = os.path.dirname(self.how)
-            dialogstates[key] = directory, pattern
-        self.top.destroy()
-        return self.how
-
-    def quit(self, how=None):
-        self.how = how
-        self.master.quit()              # Exit mainloop()
-
-    def dirs_double_event(self, event):
-        self.filter_command()
-
-    def dirs_select_event(self, event):
-        dir, pat = self.get_filter()
-        subdir = self.dirs.get('active')
-        dir = os.path.normpath(os.path.join(self.directory, subdir))
-        self.set_filter(dir, pat)
-
-    def files_double_event(self, event):
-        self.ok_command()
-
-    def files_select_event(self, event):
-        file = self.files.get('active')
-        self.set_selection(file)
-
-    def ok_event(self, event):
-        self.ok_command()
-
-    def ok_command(self):
-        self.quit(self.get_selection())
-
-    def filter_command(self, event=None):
-        dir, pat = self.get_filter()
-        try:
-            names = os.listdir(dir)
-        except OSError:
-            self.master.bell()
-            return
-        self.directory = dir
-        self.set_filter(dir, pat)
-        names.sort()
-        subdirs = [os.pardir]
-        matchingfiles = []
-        for name in names:
-            fullname = os.path.join(dir, name)
-            if os.path.isdir(fullname):
-                subdirs.append(name)
-            elif fnmatch.fnmatch(name, pat):
-                matchingfiles.append(name)
-        self.dirs.delete(0, END)
-        for name in subdirs:
-            self.dirs.insert(END, name)
-        self.files.delete(0, END)
-        for name in matchingfiles:
-            self.files.insert(END, name)
-        head, tail = os.path.split(self.get_selection())
-        if tail == os.curdir: tail = ''
-        self.set_selection(tail)
-
-    def get_filter(self):
-        filter = self.filter.get()
-        filter = os.path.expanduser(filter)
-        if filter[-1:] == os.sep or os.path.isdir(filter):
-            filter = os.path.join(filter, "*")
-        return os.path.split(filter)
-
-    def get_selection(self):
-        file = self.selection.get()
-        file = os.path.expanduser(file)
-        return file
-
-    def cancel_command(self, event=None):
-        self.quit()
-
-    def set_filter(self, dir, pat):
-        if not os.path.isabs(dir):
-            try:
-                pwd = os.getcwd()
-            except OSError:
-                pwd = None
-            if pwd:
-                dir = os.path.join(pwd, dir)
-                dir = os.path.normpath(dir)
-        self.filter.delete(0, END)
-        self.filter.insert(END, os.path.join(dir or os.curdir, pat or "*"))
-
-    def set_selection(self, file):
-        self.selection.delete(0, END)
-        self.selection.insert(END, os.path.join(self.directory, file))
-
-
-class LoadFileDialog(FileDialog):
-
-    """File selection dialog which checks that the file exists."""
-
-    title = "Load File Selection Dialog"
-
-    def ok_command(self):
-        file = self.get_selection()
-        if not os.path.isfile(file):
-            self.master.bell()
-        else:
-            self.quit(file)
-
-
-class SaveFileDialog(FileDialog):
-
-    """File selection dialog which checks that the file may be created."""
-
-    title = "Save File Selection Dialog"
-
-    def ok_command(self):
-        file = self.get_selection()
-        if os.path.exists(file):
-            if os.path.isdir(file):
-                self.master.bell()
-                return
-            d = Dialog(self.top,
-                       title="Overwrite Existing File Question",
-                       text="Overwrite existing file %r?" % (file,),
-                       bitmap='questhead',
-                       default=1,
-                       strings=("Yes", "Cancel"))
-            if d.num != 0:
-                return
-        else:
-            head, tail = os.path.split(file)
-            if not os.path.isdir(head):
-                self.master.bell()
-                return
-        self.quit(file)
-
-
-# For the following classes and modules:
-#
-# options (all have default values):
-#
-# - defaultextension: added to filename if not explicitly given
-#
-# - filetypes: sequence of (label, pattern) tuples.  the same pattern
-#   may occur with several patterns.  use "*" as pattern to indicate
-#   all files.
-#
-# - initialdir: initial directory.  preserved by dialog instance.
-#
-# - initialfile: initial file (ignored by the open dialog).  preserved
-#   by dialog instance.
-#
-# - parent: which window to place the dialog on top of
-#
-# - title: dialog title
-#
-# - multiple: if true user may select more than one file
-#
-# options for the directory chooser:
-#
-# - initialdir, parent, title: see above
-#
-# - mustexist: if true, user must pick an existing directory
-#
-
-
-class _Dialog(commondialog.Dialog):
-
-    def _fixoptions(self):
-        try:
-            # make sure "filetypes" is a tuple
-            self.options["filetypes"] = tuple(self.options["filetypes"])
-        except KeyError:
-            pass
-
-    def _fixresult(self, widget, result):
-        if result:
-            # keep directory and filename until next time
-            # convert Tcl path objects to strings
-            try:
-                result = result.string
-            except AttributeError:
-                # it already is a string
-                pass
-            path, file = os.path.split(result)
-            self.options["initialdir"] = path
-            self.options["initialfile"] = file
-        self.filename = result # compatibility
-        return result
-
-
-#
-# file dialogs
-
-class Open(_Dialog):
-    "Ask for a filename to open"
-
-    command = "tk_getOpenFile"
-
-    def _fixresult(self, widget, result):
-        if isinstance(result, tuple):
-            # multiple results:
-            result = tuple([getattr(r, "string", r) for r in result])
-            if result:
-                path, file = os.path.split(result[0])
-                self.options["initialdir"] = path
-                # don't set initialfile or filename, as we have multiple of these
-            return result
-        if not widget.tk.wantobjects() and "multiple" in self.options:
-            # Need to split result explicitly
-            return self._fixresult(widget, widget.tk.splitlist(result))
-        return _Dialog._fixresult(self, widget, result)
-
-
-class SaveAs(_Dialog):
-    "Ask for a filename to save as"
-
-    command = "tk_getSaveFile"
-
-
-# the directory dialog has its own _fix routines.
-class Directory(commondialog.Dialog):
-    "Ask for a directory"
-
-    command = "tk_chooseDirectory"
-
-    def _fixresult(self, widget, result):
-        if result:
-            # convert Tcl path objects to strings
-            try:
-                result = result.string
-            except AttributeError:
-                # it already is a string
-                pass
-            # keep directory until next time
-            self.options["initialdir"] = result
-        self.directory = result # compatibility
-        return result
-
-#
-# convenience stuff
-
-
-def askopenfilename(**options):
-    "Ask for a filename to open"
-
-    return Open(**options).show()
-
-
-def asksaveasfilename(**options):
-    "Ask for a filename to save as"
-
-    return SaveAs(**options).show()
-
-
-def askopenfilenames(**options):
-    """Ask for multiple filenames to open
-
-    Returns a list of filenames or empty list if
-    cancel button selected
-    """
-    options["multiple"]=1
-    return Open(**options).show()
-
-# FIXME: are the following  perhaps a bit too convenient?
-
-
-def askopenfile(mode = "r", **options):
-    "Ask for a filename to open, and returned the opened file"
-
-    filename = Open(**options).show()
-    if filename:
-        return open(filename, mode)
-    return None
-
-
-def askopenfiles(mode = "r", **options):
-    """Ask for multiple filenames and return the open file
-    objects
-
-    returns a list of open file objects or an empty list if
-    cancel selected
-    """
-
-    files = askopenfilenames(**options)
-    if files:
-        ofiles=[]
-        for filename in files:
-            ofiles.append(open(filename, mode))
-        files=ofiles
-    return files
-
-
-def asksaveasfile(mode = "w", **options):
-    "Ask for a filename to save as, and returned the opened file"
-
-    filename = SaveAs(**options).show()
-    if filename:
-        return open(filename, mode)
-    return None
-
-
-def askdirectory (**options):
-    "Ask for a directory, and return the file name"
-    return Directory(**options).show()
-
-
-# --------------------------------------------------------------------
-# test stuff
-
-def test():
-    """Simple test program."""
-    root = Tk()
-    root.withdraw()
-    fd = LoadFileDialog(root)
-    loadfile = fd.go(key="test")
-    fd = SaveFileDialog(root)
-    savefile = fd.go(key="test")
-    print(loadfile, savefile)
-
-    # Since the file name may contain non-ASCII characters, we need
-    # to find an encoding that likely supports the file name, and
-    # displays correctly on the terminal.
-
-    # Start off with UTF-8
-    enc = "utf-8"
-    import sys
-
-    # See whether CODESET is defined
-    try:
-        import locale
-        locale.setlocale(locale.LC_ALL,'')
-        enc = locale.nl_langinfo(locale.CODESET)
-    except (ImportError, AttributeError):
-        pass
-
-    # dialog for opening files
-
-    openfilename=askopenfilename(filetypes=[("all files", "*")])
-    try:
-        fp=open(openfilename,"r")
-        fp.close()
-    except:
-        print("Could not open File: ")
-        print(sys.exc_info()[1])
-
-    print("open", openfilename.encode(enc))
-
-    # dialog for saving files
-
-    saveasfilename=asksaveasfilename()
-    print("saveas", saveasfilename.encode(enc))
-
-
-if __name__ == '__main__':
-    test()

.CondaPkg/env/Lib/tkinter/font.py

@@ -1,239 +0,0 @@
-# Tkinter font wrapper
-#
-# written by Fredrik Lundh, February 1998
-#
-
-import itertools
-import tkinter
-
-__version__ = "0.9"
-__all__ = ["NORMAL", "ROMAN", "BOLD", "ITALIC",
-           "nametofont", "Font", "families", "names"]
-
-# weight/slant
-NORMAL = "normal"
-ROMAN = "roman"
-BOLD   = "bold"
-ITALIC = "italic"
-
-
-def nametofont(name, root=None):
-    """Given the name of a tk named font, returns a Font representation.
-    """
-    return Font(name=name, exists=True, root=root)
-
-
-class Font:
-    """Represents a named font.
-
-    Constructor options are:
-
-    font -- font specifier (name, system font, or (family, size, style)-tuple)
-    name -- name to use for this font configuration (defaults to a unique name)
-    exists -- does a named font by this name already exist?
-       Creates a new named font if False, points to the existing font if True.
-       Raises _tkinter.TclError if the assertion is false.
-
-       the following are ignored if font is specified:
-
-    family -- font 'family', e.g. Courier, Times, Helvetica
-    size -- font size in points
-    weight -- font thickness: NORMAL, BOLD
-    slant -- font slant: ROMAN, ITALIC
-    underline -- font underlining: false (0), true (1)
-    overstrike -- font strikeout: false (0), true (1)
-
-    """
-
-    counter = itertools.count(1)
-
-    def _set(self, kw):
-        options = []
-        for k, v in kw.items():
-            options.append("-"+k)
-            options.append(str(v))
-        return tuple(options)
-
-    def _get(self, args):
-        options = []
-        for k in args:
-            options.append("-"+k)
-        return tuple(options)
-
-    def _mkdict(self, args):
-        options = {}
-        for i in range(0, len(args), 2):
-            options[args[i][1:]] = args[i+1]
-        return options
-
-    def __init__(self, root=None, font=None, name=None, exists=False,
-                 **options):
-        if root is None:
-            root = tkinter._get_default_root('use font')
-        tk = getattr(root, 'tk', root)
-        if font:
-            # get actual settings corresponding to the given font
-            font = tk.splitlist(tk.call("font", "actual", font))
-        else:
-            font = self._set(options)
-        if not name:
-            name = "font" + str(next(self.counter))
-        self.name = name
-
-        if exists:
-            self.delete_font = False
-            # confirm font exists
-            if self.name not in tk.splitlist(tk.call("font", "names")):
-                raise tkinter._tkinter.TclError(
-                    "named font %s does not already exist" % (self.name,))
-            # if font config info supplied, apply it
-            if font:
-                tk.call("font", "configure", self.name, *font)
-        else:
-            # create new font (raises TclError if the font exists)
-            tk.call("font", "create", self.name, *font)
-            self.delete_font = True
-        self._tk = tk
-        self._split = tk.splitlist
-        self._call  = tk.call
-
-    def __str__(self):
-        return self.name
-
-    def __repr__(self):
-        return f"<{self.__class__.__module__}.{self.__class__.__qualname__}" \
-               f" object {self.name!r}>"
-
-    def __eq__(self, other):
-        if not isinstance(other, Font):
-            return NotImplemented
-        return self.name == other.name and self._tk == other._tk
-
-    def __getitem__(self, key):
-        return self.cget(key)
-
-    def __setitem__(self, key, value):
-        self.configure(**{key: value})
-
-    def __del__(self):
-        try:
-            if self.delete_font:
-                self._call("font", "delete", self.name)
-        except Exception:
-            pass
-
-    def copy(self):
-        "Return a distinct copy of the current font"
-        return Font(self._tk, **self.actual())
-
-    def actual(self, option=None, displayof=None):
-        "Return actual font attributes"
-        args = ()
-        if displayof:
-            args = ('-displayof', displayof)
-        if option:
-            args = args + ('-' + option, )
-            return self._call("font", "actual", self.name, *args)
-        else:
-            return self._mkdict(
-                self._split(self._call("font", "actual", self.name, *args)))
-
-    def cget(self, option):
-        "Get font attribute"
-        return self._call("font", "config", self.name, "-"+option)
-
-    def config(self, **options):
-        "Modify font attributes"
-        if options:
-            self._call("font", "config", self.name,
-                  *self._set(options))
-        else:
-            return self._mkdict(
-                self._split(self._call("font", "config", self.name)))
-
-    configure = config
-
-    def measure(self, text, displayof=None):
-        "Return text width"
-        args = (text,)
-        if displayof:
-            args = ('-displayof', displayof, text)
-        return self._tk.getint(self._call("font", "measure", self.name, *args))
-
-    def metrics(self, *options, **kw):
-        """Return font metrics.
-
-        For best performance, create a dummy widget
-        using this font before calling this method."""
-        args = ()
-        displayof = kw.pop('displayof', None)
-        if displayof:
-            args = ('-displayof', displayof)
-        if options:
-            args = args + self._get(options)
-            return self._tk.getint(
-                self._call("font", "metrics", self.name, *args))
-        else:
-            res = self._split(self._call("font", "metrics", self.name, *args))
-            options = {}
-            for i in range(0, len(res), 2):
-                options[res[i][1:]] = self._tk.getint(res[i+1])
-            return options
-
-
-def families(root=None, displayof=None):
-    "Get font families (as a tuple)"
-    if root is None:
-        root = tkinter._get_default_root('use font.families()')
-    args = ()
-    if displayof:
-        args = ('-displayof', displayof)
-    return root.tk.splitlist(root.tk.call("font", "families", *args))
-
-
-def names(root=None):
-    "Get names of defined fonts (as a tuple)"
-    if root is None:
-        root = tkinter._get_default_root('use font.names()')
-    return root.tk.splitlist(root.tk.call("font", "names"))
-
-
-# --------------------------------------------------------------------
-# test stuff
-
-if __name__ == "__main__":
-
-    root = tkinter.Tk()
-
-    # create a font
-    f = Font(family="times", size=30, weight=NORMAL)
-
-    print(f.actual())
-    print(f.actual("family"))
-    print(f.actual("weight"))
-
-    print(f.config())
-    print(f.cget("family"))
-    print(f.cget("weight"))
-
-    print(names())
-
-    print(f.measure("hello"), f.metrics("linespace"))
-
-    print(f.metrics(displayof=root))
-
-    f = Font(font=("Courier", 20, "bold"))
-    print(f.measure("hello"), f.metrics("linespace", displayof=root))
-
-    w = tkinter.Label(root, text="Hello, world", font=f)
-    w.pack()
-
-    w = tkinter.Button(root, text="Quit!", command=root.destroy)
-    w.pack()
-
-    fb = Font(font=w["font"]).copy()
-    fb.config(weight=BOLD)
-
-    w.config(font=fb)
-
-    tkinter.mainloop()

.CondaPkg/env/Lib/tkinter/messagebox.py

@@ -1,146 +0,0 @@
-# tk common message boxes
-#
-# this module provides an interface to the native message boxes
-# available in Tk 4.2 and newer.
-#
-# written by Fredrik Lundh, May 1997
-#
-
-#
-# options (all have default values):
-#
-# - default: which button to make default (one of the reply codes)
-#
-# - icon: which icon to display (see below)
-#
-# - message: the message to display
-#
-# - parent: which window to place the dialog on top of
-#
-# - title: dialog title
-#
-# - type: dialog type; that is, which buttons to display (see below)
-#
-
-from tkinter.commondialog import Dialog
-
-__all__ = ["showinfo", "showwarning", "showerror",
-           "askquestion", "askokcancel", "askyesno",
-           "askyesnocancel", "askretrycancel"]
-
-#
-# constants
-
-# icons
-ERROR = "error"
-INFO = "info"
-QUESTION = "question"
-WARNING = "warning"
-
-# types
-ABORTRETRYIGNORE = "abortretryignore"
-OK = "ok"
-OKCANCEL = "okcancel"
-RETRYCANCEL = "retrycancel"
-YESNO = "yesno"
-YESNOCANCEL = "yesnocancel"
-
-# replies
-ABORT = "abort"
-RETRY = "retry"
-IGNORE = "ignore"
-OK = "ok"
-CANCEL = "cancel"
-YES = "yes"
-NO = "no"
-
-
-#
-# message dialog class
-
-class Message(Dialog):
-    "A message box"
-
-    command  = "tk_messageBox"
-
-
-#
-# convenience stuff
-
-# Rename _icon and _type options to allow overriding them in options
-def _show(title=None, message=None, _icon=None, _type=None, **options):
-    if _icon and "icon" not in options:    options["icon"] = _icon
-    if _type and "type" not in options:    options["type"] = _type
-    if title:   options["title"] = title
-    if message: options["message"] = message
-    res = Message(**options).show()
-    # In some Tcl installations, yes/no is converted into a boolean.
-    if isinstance(res, bool):
-        if res:
-            return YES
-        return NO
-    # In others we get a Tcl_Obj.
-    return str(res)
-
-
-def showinfo(title=None, message=None, **options):
-    "Show an info message"
-    return _show(title, message, INFO, OK, **options)
-
-
-def showwarning(title=None, message=None, **options):
-    "Show a warning message"
-    return _show(title, message, WARNING, OK, **options)
-
-
-def showerror(title=None, message=None, **options):
-    "Show an error message"
-    return _show(title, message, ERROR, OK, **options)
-
-
-def askquestion(title=None, message=None, **options):
-    "Ask a question"
-    return _show(title, message, QUESTION, YESNO, **options)
-
-
-def askokcancel(title=None, message=None, **options):
-    "Ask if operation should proceed; return true if the answer is ok"
-    s = _show(title, message, QUESTION, OKCANCEL, **options)
-    return s == OK
-
-
-def askyesno(title=None, message=None, **options):
-    "Ask a question; return true if the answer is yes"
-    s = _show(title, message, QUESTION, YESNO, **options)
-    return s == YES
-
-
-def askyesnocancel(title=None, message=None, **options):
-    "Ask a question; return true if the answer is yes, None if cancelled."
-    s = _show(title, message, QUESTION, YESNOCANCEL, **options)
-    # s might be a Tcl index object, so convert it to a string
-    s = str(s)
-    if s == CANCEL:
-        return None
-    return s == YES
-
-
-def askretrycancel(title=None, message=None, **options):
-    "Ask if operation should be retried; return true if the answer is yes"
-    s = _show(title, message, WARNING, RETRYCANCEL, **options)
-    return s == RETRY
-
-
-# --------------------------------------------------------------------
-# test stuff
-
-if __name__ == "__main__":
-
-    print("info", showinfo("Spam", "Egg Information"))
-    print("warning", showwarning("Spam", "Egg Warning"))
-    print("error", showerror("Spam", "Egg Alert"))
-    print("question", askquestion("Spam", "Question?"))
-    print("proceed", askokcancel("Spam", "Proceed?"))
-    print("yes/no", askyesno("Spam", "Got it?"))
-    print("yes/no/cancel", askyesnocancel("Spam", "Want it?"))
-    print("try again", askretrycancel("Spam", "Try again?"))

.CondaPkg/env/Lib/tkinter/scrolledtext.py

@@ -1,56 +0,0 @@
-"""A ScrolledText widget feels like a text widget but also has a
-vertical scroll bar on its right.  (Later, options may be added to
-add a horizontal bar as well, to make the bars disappear
-automatically when not needed, to move them to the other side of the
-window, etc.)
-
-Configuration options are passed to the Text widget.
-A Frame widget is inserted between the master and the text, to hold
-the Scrollbar widget.
-Most methods calls are inherited from the Text widget; Pack, Grid and
-Place methods are redirected to the Frame widget however.
-"""
-
-from tkinter import Frame, Text, Scrollbar, Pack, Grid, Place
-from tkinter.constants import RIGHT, LEFT, Y, BOTH
-
-__all__ = ['ScrolledText']
-
-
-class ScrolledText(Text):
-    def __init__(self, master=None, **kw):
-        self.frame = Frame(master)
-        self.vbar = Scrollbar(self.frame)
-        self.vbar.pack(side=RIGHT, fill=Y)
-
-        kw.update({'yscrollcommand': self.vbar.set})
-        Text.__init__(self, self.frame, **kw)
-        self.pack(side=LEFT, fill=BOTH, expand=True)
-        self.vbar['command'] = self.yview
-
-        # Copy geometry methods of self.frame without overriding Text
-        # methods -- hack!
-        text_meths = vars(Text).keys()
-        methods = vars(Pack).keys() | vars(Grid).keys() | vars(Place).keys()
-        methods = methods.difference(text_meths)
-
-        for m in methods:
-            if m[0] != '_' and m != 'config' and m != 'configure':
-                setattr(self, m, getattr(self.frame, m))
-
-    def __str__(self):
-        return str(self.frame)
-
-
-def example():
-    from tkinter.constants import END
-
-    stext = ScrolledText(bg='white', height=10)
-    stext.insert(END, __doc__)
-    stext.pack(fill=BOTH, side=LEFT, expand=True)
-    stext.focus_set()
-    stext.mainloop()
-
-
-if __name__ == "__main__":
-    example()

.CondaPkg/env/Lib/tkinter/simpledialog.py

@@ -1,441 +0,0 @@
-#
-# An Introduction to Tkinter
-#
-# Copyright (c) 1997 by Fredrik Lundh
-#
-# This copyright applies to Dialog, askinteger, askfloat and asktring
-#
-# fredrik@pythonware.com
-# http://www.pythonware.com
-#
-"""This modules handles dialog boxes.
-
-It contains the following public symbols:
-
-SimpleDialog -- A simple but flexible modal dialog box
-
-Dialog -- a base class for dialogs
-
-askinteger -- get an integer from the user
-
-askfloat -- get a float from the user
-
-askstring -- get a string from the user
-"""
-
-from tkinter import *
-from tkinter import _get_temp_root, _destroy_temp_root
-from tkinter import messagebox
-
-
-class SimpleDialog:
-
-    def __init__(self, master,
-                 text='', buttons=[], default=None, cancel=None,
-                 title=None, class_=None):
-        if class_:
-            self.root = Toplevel(master, class_=class_)
-        else:
-            self.root = Toplevel(master)
-        if title:
-            self.root.title(title)
-            self.root.iconname(title)
-
-        _setup_dialog(self.root)
-
-        self.message = Message(self.root, text=text, aspect=400)
-        self.message.pack(expand=1, fill=BOTH)
-        self.frame = Frame(self.root)
-        self.frame.pack()
-        self.num = default
-        self.cancel = cancel
-        self.default = default
-        self.root.bind('<Return>', self.return_event)
-        for num in range(len(buttons)):
-            s = buttons[num]
-            b = Button(self.frame, text=s,
-                       command=(lambda self=self, num=num: self.done(num)))
-            if num == default:
-                b.config(relief=RIDGE, borderwidth=8)
-            b.pack(side=LEFT, fill=BOTH, expand=1)
-        self.root.protocol('WM_DELETE_WINDOW', self.wm_delete_window)
-        self.root.transient(master)
-        _place_window(self.root, master)
-
-    def go(self):
-        self.root.wait_visibility()
-        self.root.grab_set()
-        self.root.mainloop()
-        self.root.destroy()
-        return self.num
-
-    def return_event(self, event):
-        if self.default is None:
-            self.root.bell()
-        else:
-            self.done(self.default)
-
-    def wm_delete_window(self):
-        if self.cancel is None:
-            self.root.bell()
-        else:
-            self.done(self.cancel)
-
-    def done(self, num):
-        self.num = num
-        self.root.quit()
-
-
-class Dialog(Toplevel):
-
-    '''Class to open dialogs.
-
-    This class is intended as a base class for custom dialogs
-    '''
-
-    def __init__(self, parent, title = None):
-        '''Initialize a dialog.
-
-        Arguments:
-
-            parent -- a parent window (the application window)
-
-            title -- the dialog title
-        '''
-        master = parent
-        if master is None:
-            master = _get_temp_root()
-
-        Toplevel.__init__(self, master)
-
-        self.withdraw() # remain invisible for now
-        # If the parent is not viewable, don't
-        # make the child transient, or else it
-        # would be opened withdrawn
-        if parent is not None and parent.winfo_viewable():
-            self.transient(parent)
-
-        if title:
-            self.title(title)
-
-        _setup_dialog(self)
-
-        self.parent = parent
-
-        self.result = None
-
-        body = Frame(self)
-        self.initial_focus = self.body(body)
-        body.pack(padx=5, pady=5)
-
-        self.buttonbox()
-
-        if self.initial_focus is None:
-            self.initial_focus = self
-
-        self.protocol("WM_DELETE_WINDOW", self.cancel)
-
-        _place_window(self, parent)
-
-        self.initial_focus.focus_set()
-
-        # wait for window to appear on screen before calling grab_set
-        self.wait_visibility()
-        self.grab_set()
-        self.wait_window(self)
-
-    def destroy(self):
-        '''Destroy the window'''
-        self.initial_focus = None
-        Toplevel.destroy(self)
-        _destroy_temp_root(self.master)
-
-    #
-    # construction hooks
-
-    def body(self, master):
-        '''create dialog body.
-
-        return widget that should have initial focus.
-        This method should be overridden, and is called
-        by the __init__ method.
-        '''
-        pass
-
-    def buttonbox(self):
-        '''add standard button box.
-
-        override if you do not want the standard buttons
-        '''
-
-        box = Frame(self)
-
-        w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE)
-        w.pack(side=LEFT, padx=5, pady=5)
-        w = Button(box, text="Cancel", width=10, command=self.cancel)
-        w.pack(side=LEFT, padx=5, pady=5)
-
-        self.bind("<Return>", self.ok)
-        self.bind("<Escape>", self.cancel)
-
-        box.pack()
-
-    #
-    # standard button semantics
-
-    def ok(self, event=None):
-
-        if not self.validate():
-            self.initial_focus.focus_set() # put focus back
-            return
-
-        self.withdraw()
-        self.update_idletasks()
-
-        try:
-            self.apply()
-        finally:
-            self.cancel()
-
-    def cancel(self, event=None):
-
-        # put focus back to the parent window
-        if self.parent is not None:
-            self.parent.focus_set()
-        self.destroy()
-
-    #
-    # command hooks
-
-    def validate(self):
-        '''validate the data
-
-        This method is called automatically to validate the data before the
-        dialog is destroyed. By default, it always validates OK.
-        '''
-
-        return 1 # override
-
-    def apply(self):
-        '''process the data
-
-        This method is called automatically to process the data, *after*
-        the dialog is destroyed. By default, it does nothing.
-        '''
-
-        pass # override
-
-
-# Place a toplevel window at the center of parent or screen
-# It is a Python implementation of ::tk::PlaceWindow.
-def _place_window(w, parent=None):
-    w.wm_withdraw() # Remain invisible while we figure out the geometry
-    w.update_idletasks() # Actualize geometry information
-
-    minwidth = w.winfo_reqwidth()
-    minheight = w.winfo_reqheight()
-    maxwidth = w.winfo_vrootwidth()
-    maxheight = w.winfo_vrootheight()
-    if parent is not None and parent.winfo_ismapped():
-        x = parent.winfo_rootx() + (parent.winfo_width() - minwidth) // 2
-        y = parent.winfo_rooty() + (parent.winfo_height() - minheight) // 2
-        vrootx = w.winfo_vrootx()
-        vrooty = w.winfo_vrooty()
-        x = min(x, vrootx + maxwidth - minwidth)
-        x = max(x, vrootx)
-        y = min(y, vrooty + maxheight - minheight)
-        y = max(y, vrooty)
-        if w._windowingsystem == 'aqua':
-            # Avoid the native menu bar which sits on top of everything.
-            y = max(y, 22)
-    else:
-        x = (w.winfo_screenwidth() - minwidth) // 2
-        y = (w.winfo_screenheight() - minheight) // 2
-
-    w.wm_maxsize(maxwidth, maxheight)
-    w.wm_geometry('+%d+%d' % (x, y))
-    w.wm_deiconify() # Become visible at the desired location
-
-
-def _setup_dialog(w):
-    if w._windowingsystem == "aqua":
-        w.tk.call("::tk::unsupported::MacWindowStyle", "style",
-                  w, "moveableModal", "")
-    elif w._windowingsystem == "x11":
-        w.wm_attributes("-type", "dialog")
-
-# --------------------------------------------------------------------
-# convenience dialogues
-
-class _QueryDialog(Dialog):
-
-    def __init__(self, title, prompt,
-                 initialvalue=None,
-                 minvalue = None, maxvalue = None,
-                 parent = None):
-
-        self.prompt   = prompt
-        self.minvalue = minvalue
-        self.maxvalue = maxvalue
-
-        self.initialvalue = initialvalue
-
-        Dialog.__init__(self, parent, title)
-
-    def destroy(self):
-        self.entry = None
-        Dialog.destroy(self)
-
-    def body(self, master):
-
-        w = Label(master, text=self.prompt, justify=LEFT)
-        w.grid(row=0, padx=5, sticky=W)
-
-        self.entry = Entry(master, name="entry")
-        self.entry.grid(row=1, padx=5, sticky=W+E)
-
-        if self.initialvalue is not None:
-            self.entry.insert(0, self.initialvalue)
-            self.entry.select_range(0, END)
-
-        return self.entry
-
-    def validate(self):
-        try:
-            result = self.getresult()
-        except ValueError:
-            messagebox.showwarning(
-                "Illegal value",
-                self.errormessage + "\nPlease try again",
-                parent = self
-            )
-            return 0
-
-        if self.minvalue is not None and result < self.minvalue:
-            messagebox.showwarning(
-                "Too small",
-                "The allowed minimum value is %s. "
-                "Please try again." % self.minvalue,
-                parent = self
-            )
-            return 0
-
-        if self.maxvalue is not None and result > self.maxvalue:
-            messagebox.showwarning(
-                "Too large",
-                "The allowed maximum value is %s. "
-                "Please try again." % self.maxvalue,
-                parent = self
-            )
-            return 0
-
-        self.result = result
-
-        return 1
-
-
-class _QueryInteger(_QueryDialog):
-    errormessage = "Not an integer."
-
-    def getresult(self):
-        return self.getint(self.entry.get())
-
-
-def askinteger(title, prompt, **kw):
-    '''get an integer from the user
-
-    Arguments:
-
-        title -- the dialog title
-        prompt -- the label text
-        **kw -- see SimpleDialog class
-
-    Return value is an integer
-    '''
-    d = _QueryInteger(title, prompt, **kw)
-    return d.result
-
-
-class _QueryFloat(_QueryDialog):
-    errormessage = "Not a floating point value."
-
-    def getresult(self):
-        return self.getdouble(self.entry.get())
-
-
-def askfloat(title, prompt, **kw):
-    '''get a float from the user
-
-    Arguments:
-
-        title -- the dialog title
-        prompt -- the label text
-        **kw -- see SimpleDialog class
-
-    Return value is a float
-    '''
-    d = _QueryFloat(title, prompt, **kw)
-    return d.result
-
-
-class _QueryString(_QueryDialog):
-    def __init__(self, *args, **kw):
-        if "show" in kw:
-            self.__show = kw["show"]
-            del kw["show"]
-        else:
-            self.__show = None
-        _QueryDialog.__init__(self, *args, **kw)
-
-    def body(self, master):
-        entry = _QueryDialog.body(self, master)
-        if self.__show is not None:
-            entry.configure(show=self.__show)
-        return entry
-
-    def getresult(self):
-        return self.entry.get()
-
-
-def askstring(title, prompt, **kw):
-    '''get a string from the user
-
-    Arguments:
-
-        title -- the dialog title
-        prompt -- the label text
-        **kw -- see SimpleDialog class
-
-    Return value is a string
-    '''
-    d = _QueryString(title, prompt, **kw)
-    return d.result
-
-
-if __name__ == '__main__':
-
-    def test():
-        root = Tk()
-        def doit(root=root):
-            d = SimpleDialog(root,
-                         text="This is a test dialog.  "
-                              "Would this have been an actual dialog, "
-                              "the buttons below would have been glowing "
-                              "in soft pink light.\n"
-                              "Do you believe this?",
-                         buttons=["Yes", "No", "Cancel"],
-                         default=0,
-                         cancel=2,
-                         title="Test Dialog")
-            print(d.go())
-            print(askinteger("Spam", "Egg count", initialvalue=12*12))
-            print(askfloat("Spam", "Egg weight\n(in tons)", minvalue=1,
-                           maxvalue=100))
-            print(askstring("Spam", "Egg label"))
-        t = Button(root, text='Test', command=doit)
-        t.pack()
-        q = Button(root, text='Quit', command=t.quit)
-        q.pack()
-        t.mainloop()
-
-    test()

.CondaPkg/env/Lib/tkinter/test/README

@@ -1,14 +0,0 @@
-Writing new tests
-=================
-
-Precaution
-----------
-
-    New tests should always use only one Tk window at once, like all the
-    current tests do. This means that you have to destroy the current window
-    before creating another one, and clean up after the test. The motivation
-    behind this is that some tests may depend on having its window focused
-    while it is running to work properly, and it may be hard to force focus
-    on your window across platforms (right now only test_traversal at
-    test_ttk.test_widgets.NotebookTest depends on this).
-

.CondaPkg/env/Lib/tkinter/test/support.py

@@ -1,136 +0,0 @@
-import functools
-import re
-import tkinter
-import unittest
-
-class AbstractTkTest:
-
-    @classmethod
-    def setUpClass(cls):
-        cls._old_support_default_root = tkinter._support_default_root
-        destroy_default_root()
-        tkinter.NoDefaultRoot()
-        cls.root = tkinter.Tk()
-        cls.wantobjects = cls.root.wantobjects()
-        # De-maximize main window.
-        # Some window managers can maximize new windows.
-        cls.root.wm_state('normal')
-        try:
-            cls.root.wm_attributes('-zoomed', False)
-        except tkinter.TclError:
-            pass
-
-    @classmethod
-    def tearDownClass(cls):
-        cls.root.update_idletasks()
-        cls.root.destroy()
-        del cls.root
-        tkinter._default_root = None
-        tkinter._support_default_root = cls._old_support_default_root
-
-    def setUp(self):
-        self.root.deiconify()
-
-    def tearDown(self):
-        for w in self.root.winfo_children():
-            w.destroy()
-        self.root.withdraw()
-
-
-class AbstractDefaultRootTest:
-
-    def setUp(self):
-        self._old_support_default_root = tkinter._support_default_root
-        destroy_default_root()
-        tkinter._support_default_root = True
-        self.wantobjects = tkinter.wantobjects
-
-    def tearDown(self):
-        destroy_default_root()
-        tkinter._default_root = None
-        tkinter._support_default_root = self._old_support_default_root
-
-    def _test_widget(self, constructor):
-        # no master passing
-        x = constructor()
-        self.assertIsNotNone(tkinter._default_root)
-        self.assertIs(x.master, tkinter._default_root)
-        self.assertIs(x.tk, tkinter._default_root.tk)
-        x.destroy()
-        destroy_default_root()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, constructor)
-        self.assertFalse(hasattr(tkinter, '_default_root'))
-
-
-def destroy_default_root():
-    if getattr(tkinter, '_default_root', None):
-        tkinter._default_root.update_idletasks()
-        tkinter._default_root.destroy()
-        tkinter._default_root = None
-
-def simulate_mouse_click(widget, x, y):
-    """Generate proper events to click at the x, y position (tries to act
-    like an X server)."""
-    widget.event_generate('<Enter>', x=0, y=0)
-    widget.event_generate('<Motion>', x=x, y=y)
-    widget.event_generate('<ButtonPress-1>', x=x, y=y)
-    widget.event_generate('<ButtonRelease-1>', x=x, y=y)
-
-
-import _tkinter
-tcl_version = tuple(map(int, _tkinter.TCL_VERSION.split('.')))
-
-def requires_tcl(*version):
-    if len(version) <= 2:
-        return unittest.skipUnless(tcl_version >= version,
-            'requires Tcl version >= ' + '.'.join(map(str, version)))
-
-    def deco(test):
-        @functools.wraps(test)
-        def newtest(self):
-            if get_tk_patchlevel() < version:
-                self.skipTest('requires Tcl version >= ' +
-                                '.'.join(map(str, version)))
-            test(self)
-        return newtest
-    return deco
-
-_tk_patchlevel = None
-def get_tk_patchlevel():
-    global _tk_patchlevel
-    if _tk_patchlevel is None:
-        tcl = tkinter.Tcl()
-        _tk_patchlevel = tcl.info_patchlevel()
-    return _tk_patchlevel
-
-units = {
-    'c': 72 / 2.54,     # centimeters
-    'i': 72,            # inches
-    'm': 72 / 25.4,     # millimeters
-    'p': 1,             # points
-}
-
-def pixels_conv(value):
-    return float(value[:-1]) * units[value[-1:]]
-
-def tcl_obj_eq(actual, expected):
-    if actual == expected:
-        return True
-    if isinstance(actual, _tkinter.Tcl_Obj):
-        if isinstance(expected, str):
-            return str(actual) == expected
-    if isinstance(actual, tuple):
-        if isinstance(expected, tuple):
-            return (len(actual) == len(expected) and
-                    all(tcl_obj_eq(act, exp)
-                        for act, exp in zip(actual, expected)))
-    return False
-
-def widget_eq(actual, expected):
-    if actual == expected:
-        return True
-    if isinstance(actual, (str, tkinter.Widget)):
-        if isinstance(expected, (str, tkinter.Widget)):
-            return str(actual) == str(expected)
-    return False

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_colorchooser.py

@@ -1,68 +0,0 @@
-import unittest
-import tkinter
-from test.support import requires, swap_attr
-from tkinter.test.support import AbstractDefaultRootTest, AbstractTkTest
-from tkinter import colorchooser
-from tkinter.colorchooser import askcolor
-from tkinter.commondialog import Dialog
-
-requires('gui')
-
-
-class ChooserTest(AbstractTkTest, unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        AbstractTkTest.setUpClass.__func__(cls)
-        cls.cc = colorchooser.Chooser(initialcolor='dark blue slate')
-
-    def test_fixoptions(self):
-        cc = self.cc
-        cc._fixoptions()
-        self.assertEqual(cc.options['initialcolor'], 'dark blue slate')
-
-        cc.options['initialcolor'] = '#D2D269691E1E'
-        cc._fixoptions()
-        self.assertEqual(cc.options['initialcolor'], '#D2D269691E1E')
-
-        cc.options['initialcolor'] = (210, 105, 30)
-        cc._fixoptions()
-        self.assertEqual(cc.options['initialcolor'], '#d2691e')
-
-    def test_fixresult(self):
-        cc = self.cc
-        self.assertEqual(cc._fixresult(self.root, ()), (None, None))
-        self.assertEqual(cc._fixresult(self.root, ''), (None, None))
-        self.assertEqual(cc._fixresult(self.root, 'chocolate'),
-                         ((210, 105, 30), 'chocolate'))
-        self.assertEqual(cc._fixresult(self.root, '#4a3c8c'),
-                         ((74, 60, 140), '#4a3c8c'))
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_askcolor(self):
-        def test_callback(dialog, master):
-            nonlocal ismapped
-            master.update()
-            ismapped = master.winfo_ismapped()
-            raise ZeroDivisionError
-
-        with swap_attr(Dialog, '_test_callback', test_callback):
-            ismapped = None
-            self.assertRaises(ZeroDivisionError, askcolor)
-            #askcolor()
-            self.assertEqual(ismapped, False)
-
-            root = tkinter.Tk()
-            ismapped = None
-            self.assertRaises(ZeroDivisionError, askcolor)
-            self.assertEqual(ismapped, True)
-            root.destroy()
-
-            tkinter.NoDefaultRoot()
-            self.assertRaises(RuntimeError, askcolor)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_font.py

@@ -1,163 +0,0 @@
-import unittest
-import tkinter
-from tkinter import font
-from test.support import requires, gc_collect, ALWAYS_EQ
-from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest
-
-requires('gui')
-
-fontname = "TkDefaultFont"
-
-class FontTest(AbstractTkTest, unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        AbstractTkTest.setUpClass.__func__(cls)
-        try:
-            cls.font = font.Font(root=cls.root, name=fontname, exists=True)
-        except tkinter.TclError:
-            cls.font = font.Font(root=cls.root, name=fontname, exists=False)
-
-    def test_configure(self):
-        options = self.font.configure()
-        self.assertGreaterEqual(set(options),
-            {'family', 'size', 'weight', 'slant', 'underline', 'overstrike'})
-        for key in options:
-            self.assertEqual(self.font.cget(key), options[key])
-            self.assertEqual(self.font[key], options[key])
-        for key in 'family', 'weight', 'slant':
-            self.assertIsInstance(options[key], str)
-            self.assertIsInstance(self.font.cget(key), str)
-            self.assertIsInstance(self.font[key], str)
-        sizetype = int if self.wantobjects else str
-        for key in 'size', 'underline', 'overstrike':
-            self.assertIsInstance(options[key], sizetype)
-            self.assertIsInstance(self.font.cget(key), sizetype)
-            self.assertIsInstance(self.font[key], sizetype)
-
-    def test_unicode_family(self):
-        family = 'MS \u30b4\u30b7\u30c3\u30af'
-        try:
-            f = font.Font(root=self.root, family=family, exists=True)
-        except tkinter.TclError:
-            f = font.Font(root=self.root, family=family, exists=False)
-        self.assertEqual(f.cget('family'), family)
-        del f
-        gc_collect()
-
-    def test_actual(self):
-        options = self.font.actual()
-        self.assertGreaterEqual(set(options),
-            {'family', 'size', 'weight', 'slant', 'underline', 'overstrike'})
-        for key in options:
-            self.assertEqual(self.font.actual(key), options[key])
-        for key in 'family', 'weight', 'slant':
-            self.assertIsInstance(options[key], str)
-            self.assertIsInstance(self.font.actual(key), str)
-        sizetype = int if self.wantobjects else str
-        for key in 'size', 'underline', 'overstrike':
-            self.assertIsInstance(options[key], sizetype)
-            self.assertIsInstance(self.font.actual(key), sizetype)
-
-    def test_name(self):
-        self.assertEqual(self.font.name, fontname)
-        self.assertEqual(str(self.font), fontname)
-
-    def test_equality(self):
-        font1 = font.Font(root=self.root, name=fontname, exists=True)
-        font2 = font.Font(root=self.root, name=fontname, exists=True)
-        self.assertIsNot(font1, font2)
-        self.assertEqual(font1, font2)
-        self.assertNotEqual(font1, font1.copy())
-
-        self.assertNotEqual(font1, 0)
-        self.assertEqual(font1, ALWAYS_EQ)
-
-        root2 = tkinter.Tk()
-        self.addCleanup(root2.destroy)
-        font3 = font.Font(root=root2, name=fontname, exists=True)
-        self.assertEqual(str(font1), str(font3))
-        self.assertNotEqual(font1, font3)
-
-    def test_measure(self):
-        self.assertIsInstance(self.font.measure('abc'), int)
-
-    def test_metrics(self):
-        metrics = self.font.metrics()
-        self.assertGreaterEqual(set(metrics),
-            {'ascent', 'descent', 'linespace', 'fixed'})
-        for key in metrics:
-            self.assertEqual(self.font.metrics(key), metrics[key])
-            self.assertIsInstance(metrics[key], int)
-            self.assertIsInstance(self.font.metrics(key), int)
-
-    def test_families(self):
-        families = font.families(self.root)
-        self.assertIsInstance(families, tuple)
-        self.assertTrue(families)
-        for family in families:
-            self.assertIsInstance(family, str)
-            self.assertTrue(family)
-
-    def test_names(self):
-        names = font.names(self.root)
-        self.assertIsInstance(names, tuple)
-        self.assertTrue(names)
-        for name in names:
-            self.assertIsInstance(name, str)
-            self.assertTrue(name)
-        self.assertIn(fontname, names)
-
-    def test_nametofont(self):
-        testfont = font.nametofont(fontname, root=self.root)
-        self.assertIsInstance(testfont, font.Font)
-        self.assertEqual(testfont.name, fontname)
-
-    def test_repr(self):
-        self.assertEqual(
-            repr(self.font), f'<tkinter.font.Font object {fontname!r}>'
-        )
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_families(self):
-        self.assertRaises(RuntimeError, font.families)
-        root = tkinter.Tk()
-        families = font.families()
-        self.assertIsInstance(families, tuple)
-        self.assertTrue(families)
-        for family in families:
-            self.assertIsInstance(family, str)
-            self.assertTrue(family)
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, font.families)
-
-    def test_names(self):
-        self.assertRaises(RuntimeError, font.names)
-        root = tkinter.Tk()
-        names = font.names()
-        self.assertIsInstance(names, tuple)
-        self.assertTrue(names)
-        for name in names:
-            self.assertIsInstance(name, str)
-            self.assertTrue(name)
-        self.assertIn(fontname, names)
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, font.names)
-
-    def test_nametofont(self):
-        self.assertRaises(RuntimeError, font.nametofont, fontname)
-        root = tkinter.Tk()
-        testfont = font.nametofont(fontname)
-        self.assertIsInstance(testfont, font.Font)
-        self.assertEqual(testfont.name, fontname)
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, font.nametofont, fontname)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_geometry_managers.py

@@ -1,899 +0,0 @@
-import unittest
-import re
-import tkinter
-from tkinter import TclError
-from test.support import requires
-
-from tkinter.test.support import pixels_conv
-from tkinter.test.widget_tests import AbstractWidgetTest
-
-requires('gui')
-
-
-class PackTest(AbstractWidgetTest, unittest.TestCase):
-
-    test_keys = None
-
-    def create2(self):
-        pack = tkinter.Toplevel(self.root, name='pack')
-        pack.wm_geometry('300x200+0+0')
-        pack.wm_minsize(1, 1)
-        a = tkinter.Frame(pack, name='a', width=20, height=40, bg='red')
-        b = tkinter.Frame(pack, name='b', width=50, height=30, bg='blue')
-        c = tkinter.Frame(pack, name='c', width=80, height=80, bg='green')
-        d = tkinter.Frame(pack, name='d', width=40, height=30, bg='yellow')
-        return pack, a, b, c, d
-
-    def test_pack_configure_after(self):
-        pack, a, b, c, d = self.create2()
-        with self.assertRaisesRegex(TclError, 'window "%s" isn\'t packed' % b):
-            a.pack_configure(after=b)
-        with self.assertRaisesRegex(TclError, 'bad window path name ".foo"'):
-            a.pack_configure(after='.foo')
-        a.pack_configure(side='top')
-        b.pack_configure(side='top')
-        c.pack_configure(side='top')
-        d.pack_configure(side='top')
-        self.assertEqual(pack.pack_slaves(), [a, b, c, d])
-        a.pack_configure(after=b)
-        self.assertEqual(pack.pack_slaves(), [b, a, c, d])
-        a.pack_configure(after=a)
-        self.assertEqual(pack.pack_slaves(), [b, a, c, d])
-
-    def test_pack_configure_anchor(self):
-        pack, a, b, c, d = self.create2()
-        def check(anchor, geom):
-            a.pack_configure(side='top', ipadx=5, padx=10, ipady=15, pady=20,
-                             expand=True, anchor=anchor)
-            self.root.update()
-            self.assertEqual(a.winfo_geometry(), geom)
-        check('n', '30x70+135+20')
-        check('ne', '30x70+260+20')
-        check('e', '30x70+260+65')
-        check('se', '30x70+260+110')
-        check('s', '30x70+135+110')
-        check('sw', '30x70+10+110')
-        check('w', '30x70+10+65')
-        check('nw', '30x70+10+20')
-        check('center', '30x70+135+65')
-
-    def test_pack_configure_before(self):
-        pack, a, b, c, d = self.create2()
-        with self.assertRaisesRegex(TclError, 'window "%s" isn\'t packed' % b):
-            a.pack_configure(before=b)
-        with self.assertRaisesRegex(TclError, 'bad window path name ".foo"'):
-            a.pack_configure(before='.foo')
-        a.pack_configure(side='top')
-        b.pack_configure(side='top')
-        c.pack_configure(side='top')
-        d.pack_configure(side='top')
-        self.assertEqual(pack.pack_slaves(), [a, b, c, d])
-        a.pack_configure(before=d)
-        self.assertEqual(pack.pack_slaves(), [b, c, a, d])
-        a.pack_configure(before=a)
-        self.assertEqual(pack.pack_slaves(), [b, c, a, d])
-
-    def test_pack_configure_expand(self):
-        pack, a, b, c, d = self.create2()
-        def check(*geoms):
-            self.root.update()
-            self.assertEqual(a.winfo_geometry(), geoms[0])
-            self.assertEqual(b.winfo_geometry(), geoms[1])
-            self.assertEqual(c.winfo_geometry(), geoms[2])
-            self.assertEqual(d.winfo_geometry(), geoms[3])
-        a.pack_configure(side='left')
-        b.pack_configure(side='top')
-        c.pack_configure(side='right')
-        d.pack_configure(side='bottom')
-        check('20x40+0+80', '50x30+135+0', '80x80+220+75', '40x30+100+170')
-        a.pack_configure(side='left', expand='yes')
-        b.pack_configure(side='top', expand='on')
-        c.pack_configure(side='right', expand=True)
-        d.pack_configure(side='bottom', expand=1)
-        check('20x40+40+80', '50x30+175+35', '80x80+180+110', '40x30+100+135')
-        a.pack_configure(side='left', expand='yes', fill='both')
-        b.pack_configure(side='top', expand='on', fill='both')
-        c.pack_configure(side='right', expand=True, fill='both')
-        d.pack_configure(side='bottom', expand=1, fill='both')
-        check('100x200+0+0', '200x100+100+0', '160x100+140+100', '40x100+100+100')
-
-    def test_pack_configure_in(self):
-        pack, a, b, c, d = self.create2()
-        a.pack_configure(side='top')
-        b.pack_configure(side='top')
-        c.pack_configure(side='top')
-        d.pack_configure(side='top')
-        a.pack_configure(in_=pack)
-        self.assertEqual(pack.pack_slaves(), [b, c, d, a])
-        a.pack_configure(in_=c)
-        self.assertEqual(pack.pack_slaves(), [b, c, d])
-        self.assertEqual(c.pack_slaves(), [a])
-        with self.assertRaisesRegex(TclError,
-                                    'can\'t pack %s inside itself' % (a,)):
-            a.pack_configure(in_=a)
-        with self.assertRaisesRegex(TclError, 'bad window path name ".foo"'):
-            a.pack_configure(in_='.foo')
-
-    def test_pack_configure_padx_ipadx_fill(self):
-        pack, a, b, c, d = self.create2()
-        def check(geom1, geom2, **kwargs):
-            a.pack_forget()
-            b.pack_forget()
-            a.pack_configure(**kwargs)
-            b.pack_configure(expand=True, fill='both')
-            self.root.update()
-            self.assertEqual(a.winfo_geometry(), geom1)
-            self.assertEqual(b.winfo_geometry(), geom2)
-        check('20x40+260+80', '240x200+0+0', side='right', padx=20)
-        check('20x40+250+80', '240x200+0+0', side='right', padx=(10, 30))
-        check('60x40+240+80', '240x200+0+0', side='right', ipadx=20)
-        check('30x40+260+80', '250x200+0+0', side='right', ipadx=5, padx=10)
-        check('20x40+260+80', '240x200+0+0', side='right', padx=20, fill='x')
-        check('20x40+249+80', '240x200+0+0',
-              side='right', padx=(9, 31), fill='x')
-        check('60x40+240+80', '240x200+0+0', side='right', ipadx=20, fill='x')
-        check('30x40+260+80', '250x200+0+0',
-              side='right', ipadx=5, padx=10, fill='x')
-        check('30x40+255+80', '250x200+0+0',
-              side='right', ipadx=5, padx=(5, 15), fill='x')
-        check('20x40+140+0', '300x160+0+40', side='top', padx=20)
-        check('20x40+120+0', '300x160+0+40', side='top', padx=(0, 40))
-        check('60x40+120+0', '300x160+0+40', side='top', ipadx=20)
-        check('30x40+135+0', '300x160+0+40', side='top', ipadx=5, padx=10)
-        check('30x40+130+0', '300x160+0+40', side='top', ipadx=5, padx=(5, 15))
-        check('260x40+20+0', '300x160+0+40', side='top', padx=20, fill='x')
-        check('260x40+25+0', '300x160+0+40',
-              side='top', padx=(25, 15), fill='x')
-        check('300x40+0+0', '300x160+0+40', side='top', ipadx=20, fill='x')
-        check('280x40+10+0', '300x160+0+40',
-              side='top', ipadx=5, padx=10, fill='x')
-        check('280x40+5+0', '300x160+0+40',
-              side='top', ipadx=5, padx=(5, 15), fill='x')
-        a.pack_configure(padx='1c')
-        self.assertEqual(a.pack_info()['padx'],
-                         self._str(pack.winfo_pixels('1c')))
-        a.pack_configure(ipadx='1c')
-        self.assertEqual(a.pack_info()['ipadx'],
-                         self._str(pack.winfo_pixels('1c')))
-
-    def test_pack_configure_pady_ipady_fill(self):
-        pack, a, b, c, d = self.create2()
-        def check(geom1, geom2, **kwargs):
-            a.pack_forget()
-            b.pack_forget()
-            a.pack_configure(**kwargs)
-            b.pack_configure(expand=True, fill='both')
-            self.root.update()
-            self.assertEqual(a.winfo_geometry(), geom1)
-            self.assertEqual(b.winfo_geometry(), geom2)
-        check('20x40+280+80', '280x200+0+0', side='right', pady=20)
-        check('20x40+280+70', '280x200+0+0', side='right', pady=(10, 30))
-        check('20x80+280+60', '280x200+0+0', side='right', ipady=20)
-        check('20x50+280+75', '280x200+0+0', side='right', ipady=5, pady=10)
-        check('20x40+280+80', '280x200+0+0', side='right', pady=20, fill='x')
-        check('20x40+280+69', '280x200+0+0',
-              side='right', pady=(9, 31), fill='x')
-        check('20x80+280+60', '280x200+0+0', side='right', ipady=20, fill='x')
-        check('20x50+280+75', '280x200+0+0',
-              side='right', ipady=5, pady=10, fill='x')
-        check('20x50+280+70', '280x200+0+0',
-              side='right', ipady=5, pady=(5, 15), fill='x')
-        check('20x40+140+20', '300x120+0+80', side='top', pady=20)
-        check('20x40+140+0', '300x120+0+80', side='top', pady=(0, 40))
-        check('20x80+140+0', '300x120+0+80', side='top', ipady=20)
-        check('20x50+140+10', '300x130+0+70', side='top', ipady=5, pady=10)
-        check('20x50+140+5', '300x130+0+70', side='top', ipady=5, pady=(5, 15))
-        check('300x40+0+20', '300x120+0+80', side='top', pady=20, fill='x')
-        check('300x40+0+25', '300x120+0+80',
-              side='top', pady=(25, 15), fill='x')
-        check('300x80+0+0', '300x120+0+80', side='top', ipady=20, fill='x')
-        check('300x50+0+10', '300x130+0+70',
-              side='top', ipady=5, pady=10, fill='x')
-        check('300x50+0+5', '300x130+0+70',
-              side='top', ipady=5, pady=(5, 15), fill='x')
-        a.pack_configure(pady='1c')
-        self.assertEqual(a.pack_info()['pady'],
-                         self._str(pack.winfo_pixels('1c')))
-        a.pack_configure(ipady='1c')
-        self.assertEqual(a.pack_info()['ipady'],
-                         self._str(pack.winfo_pixels('1c')))
-
-    def test_pack_configure_side(self):
-        pack, a, b, c, d = self.create2()
-        def check(side, geom1, geom2):
-            a.pack_configure(side=side)
-            self.assertEqual(a.pack_info()['side'], side)
-            b.pack_configure(expand=True, fill='both')
-            self.root.update()
-            self.assertEqual(a.winfo_geometry(), geom1)
-            self.assertEqual(b.winfo_geometry(), geom2)
-        check('top', '20x40+140+0', '300x160+0+40')
-        check('bottom', '20x40+140+160', '300x160+0+0')
-        check('left', '20x40+0+80', '280x200+20+0')
-        check('right', '20x40+280+80', '280x200+0+0')
-
-    def test_pack_forget(self):
-        pack, a, b, c, d = self.create2()
-        a.pack_configure()
-        b.pack_configure()
-        c.pack_configure()
-        self.assertEqual(pack.pack_slaves(), [a, b, c])
-        b.pack_forget()
-        self.assertEqual(pack.pack_slaves(), [a, c])
-        b.pack_forget()
-        self.assertEqual(pack.pack_slaves(), [a, c])
-        d.pack_forget()
-
-    def test_pack_info(self):
-        pack, a, b, c, d = self.create2()
-        with self.assertRaisesRegex(TclError, 'window "%s" isn\'t packed' % a):
-            a.pack_info()
-        a.pack_configure()
-        b.pack_configure(side='right', in_=a, anchor='s', expand=True, fill='x',
-                         ipadx=5, padx=10, ipady=2, pady=(5, 15))
-        info = a.pack_info()
-        self.assertIsInstance(info, dict)
-        self.assertEqual(info['anchor'], 'center')
-        self.assertEqual(info['expand'], self._str(0))
-        self.assertEqual(info['fill'], 'none')
-        self.assertEqual(info['in'], pack)
-        self.assertEqual(info['ipadx'], self._str(0))
-        self.assertEqual(info['ipady'], self._str(0))
-        self.assertEqual(info['padx'], self._str(0))
-        self.assertEqual(info['pady'], self._str(0))
-        self.assertEqual(info['side'], 'top')
-        info = b.pack_info()
-        self.assertIsInstance(info, dict)
-        self.assertEqual(info['anchor'], 's')
-        self.assertEqual(info['expand'], self._str(1))
-        self.assertEqual(info['fill'], 'x')
-        self.assertEqual(info['in'], a)
-        self.assertEqual(info['ipadx'], self._str(5))
-        self.assertEqual(info['ipady'], self._str(2))
-        self.assertEqual(info['padx'], self._str(10))
-        self.assertEqual(info['pady'], self._str((5, 15)))
-        self.assertEqual(info['side'], 'right')
-
-    def test_pack_propagate(self):
-        pack, a, b, c, d = self.create2()
-        pack.configure(width=300, height=200)
-        a.pack_configure()
-        pack.pack_propagate(False)
-        self.root.update()
-        self.assertEqual(pack.winfo_reqwidth(), 300)
-        self.assertEqual(pack.winfo_reqheight(), 200)
-        pack.pack_propagate(True)
-        self.root.update()
-        self.assertEqual(pack.winfo_reqwidth(), 20)
-        self.assertEqual(pack.winfo_reqheight(), 40)
-
-    def test_pack_slaves(self):
-        pack, a, b, c, d = self.create2()
-        self.assertEqual(pack.pack_slaves(), [])
-        a.pack_configure()
-        self.assertEqual(pack.pack_slaves(), [a])
-        b.pack_configure()
-        self.assertEqual(pack.pack_slaves(), [a, b])
-
-
-class PlaceTest(AbstractWidgetTest, unittest.TestCase):
-
-    test_keys = None
-
-    def create2(self):
-        t = tkinter.Toplevel(self.root, width=300, height=200, bd=0)
-        t.wm_geometry('300x200+0+0')
-        f = tkinter.Frame(t, width=154, height=84, bd=2, relief='raised')
-        f.place_configure(x=48, y=38)
-        f2 = tkinter.Frame(t, width=30, height=60, bd=2, relief='raised')
-        self.root.update()
-        return t, f, f2
-
-    def test_place_configure_in(self):
-        t, f, f2 = self.create2()
-        self.assertEqual(f2.winfo_manager(), '')
-        with self.assertRaisesRegex(TclError, "can't place %s relative to "
-                                    "itself" % re.escape(str(f2))):
-            f2.place_configure(in_=f2)
-        self.assertEqual(f2.winfo_manager(), '')
-        with self.assertRaisesRegex(TclError, 'bad window path name'):
-            f2.place_configure(in_='spam')
-        f2.place_configure(in_=f)
-        self.assertEqual(f2.winfo_manager(), 'place')
-
-    def test_place_configure_x(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f)
-        self.assertEqual(f2.place_info()['x'], '0')
-        self.root.update()
-        self.assertEqual(f2.winfo_x(), 50)
-        f2.place_configure(x=100)
-        self.assertEqual(f2.place_info()['x'], '100')
-        self.root.update()
-        self.assertEqual(f2.winfo_x(), 150)
-        f2.place_configure(x=-10, relx=1)
-        self.assertEqual(f2.place_info()['x'], '-10')
-        self.root.update()
-        self.assertEqual(f2.winfo_x(), 190)
-        with self.assertRaisesRegex(TclError, 'bad screen distance "spam"'):
-            f2.place_configure(in_=f, x='spam')
-
-    def test_place_configure_y(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f)
-        self.assertEqual(f2.place_info()['y'], '0')
-        self.root.update()
-        self.assertEqual(f2.winfo_y(), 40)
-        f2.place_configure(y=50)
-        self.assertEqual(f2.place_info()['y'], '50')
-        self.root.update()
-        self.assertEqual(f2.winfo_y(), 90)
-        f2.place_configure(y=-10, rely=1)
-        self.assertEqual(f2.place_info()['y'], '-10')
-        self.root.update()
-        self.assertEqual(f2.winfo_y(), 110)
-        with self.assertRaisesRegex(TclError, 'bad screen distance "spam"'):
-            f2.place_configure(in_=f, y='spam')
-
-    def test_place_configure_relx(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f)
-        self.assertEqual(f2.place_info()['relx'], '0')
-        self.root.update()
-        self.assertEqual(f2.winfo_x(), 50)
-        f2.place_configure(relx=0.5)
-        self.assertEqual(f2.place_info()['relx'], '0.5')
-        self.root.update()
-        self.assertEqual(f2.winfo_x(), 125)
-        f2.place_configure(relx=1)
-        self.assertEqual(f2.place_info()['relx'], '1')
-        self.root.update()
-        self.assertEqual(f2.winfo_x(), 200)
-        with self.assertRaisesRegex(TclError, 'expected floating-point number '
-                                    'but got "spam"'):
-            f2.place_configure(in_=f, relx='spam')
-
-    def test_place_configure_rely(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f)
-        self.assertEqual(f2.place_info()['rely'], '0')
-        self.root.update()
-        self.assertEqual(f2.winfo_y(), 40)
-        f2.place_configure(rely=0.5)
-        self.assertEqual(f2.place_info()['rely'], '0.5')
-        self.root.update()
-        self.assertEqual(f2.winfo_y(), 80)
-        f2.place_configure(rely=1)
-        self.assertEqual(f2.place_info()['rely'], '1')
-        self.root.update()
-        self.assertEqual(f2.winfo_y(), 120)
-        with self.assertRaisesRegex(TclError, 'expected floating-point number '
-                                    'but got "spam"'):
-            f2.place_configure(in_=f, rely='spam')
-
-    def test_place_configure_anchor(self):
-        f = tkinter.Frame(self.root)
-        with self.assertRaisesRegex(TclError, 'bad anchor "j"'):
-            f.place_configure(anchor='j')
-        with self.assertRaisesRegex(TclError, 'ambiguous anchor ""'):
-            f.place_configure(anchor='')
-        for value in 'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center':
-            f.place_configure(anchor=value)
-            self.assertEqual(f.place_info()['anchor'], value)
-
-    def test_place_configure_width(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f, width=120)
-        self.root.update()
-        self.assertEqual(f2.winfo_width(), 120)
-        f2.place_configure(width='')
-        self.root.update()
-        self.assertEqual(f2.winfo_width(), 30)
-        with self.assertRaisesRegex(TclError, 'bad screen distance "abcd"'):
-            f2.place_configure(width='abcd')
-
-    def test_place_configure_height(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f, height=120)
-        self.root.update()
-        self.assertEqual(f2.winfo_height(), 120)
-        f2.place_configure(height='')
-        self.root.update()
-        self.assertEqual(f2.winfo_height(), 60)
-        with self.assertRaisesRegex(TclError, 'bad screen distance "abcd"'):
-            f2.place_configure(height='abcd')
-
-    def test_place_configure_relwidth(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f, relwidth=0.5)
-        self.root.update()
-        self.assertEqual(f2.winfo_width(), 75)
-        f2.place_configure(relwidth='')
-        self.root.update()
-        self.assertEqual(f2.winfo_width(), 30)
-        with self.assertRaisesRegex(TclError, 'expected floating-point number '
-                                    'but got "abcd"'):
-            f2.place_configure(relwidth='abcd')
-
-    def test_place_configure_relheight(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f, relheight=0.5)
-        self.root.update()
-        self.assertEqual(f2.winfo_height(), 40)
-        f2.place_configure(relheight='')
-        self.root.update()
-        self.assertEqual(f2.winfo_height(), 60)
-        with self.assertRaisesRegex(TclError, 'expected floating-point number '
-                                    'but got "abcd"'):
-            f2.place_configure(relheight='abcd')
-
-    def test_place_configure_bordermode(self):
-        f = tkinter.Frame(self.root)
-        with self.assertRaisesRegex(TclError, 'bad bordermode "j"'):
-            f.place_configure(bordermode='j')
-        with self.assertRaisesRegex(TclError, 'ambiguous bordermode ""'):
-            f.place_configure(bordermode='')
-        for value in 'inside', 'outside', 'ignore':
-            f.place_configure(bordermode=value)
-            self.assertEqual(f.place_info()['bordermode'], value)
-
-    def test_place_forget(self):
-        foo = tkinter.Frame(self.root)
-        foo.place_configure(width=50, height=50)
-        self.root.update()
-        foo.place_forget()
-        self.root.update()
-        self.assertFalse(foo.winfo_ismapped())
-        with self.assertRaises(TypeError):
-            foo.place_forget(0)
-
-    def test_place_info(self):
-        t, f, f2 = self.create2()
-        f2.place_configure(in_=f, x=1, y=2, width=3, height=4,
-                           relx=0.1, rely=0.2, relwidth=0.3, relheight=0.4,
-                           anchor='se', bordermode='outside')
-        info = f2.place_info()
-        self.assertIsInstance(info, dict)
-        self.assertEqual(info['x'], '1')
-        self.assertEqual(info['y'], '2')
-        self.assertEqual(info['width'], '3')
-        self.assertEqual(info['height'], '4')
-        self.assertEqual(info['relx'], '0.1')
-        self.assertEqual(info['rely'], '0.2')
-        self.assertEqual(info['relwidth'], '0.3')
-        self.assertEqual(info['relheight'], '0.4')
-        self.assertEqual(info['anchor'], 'se')
-        self.assertEqual(info['bordermode'], 'outside')
-        self.assertEqual(info['x'], '1')
-        self.assertEqual(info['x'], '1')
-        with self.assertRaises(TypeError):
-            f2.place_info(0)
-
-    def test_place_slaves(self):
-        foo = tkinter.Frame(self.root)
-        bar = tkinter.Frame(self.root)
-        self.assertEqual(foo.place_slaves(), [])
-        bar.place_configure(in_=foo)
-        self.assertEqual(foo.place_slaves(), [bar])
-        with self.assertRaises(TypeError):
-            foo.place_slaves(0)
-
-
-class GridTest(AbstractWidgetTest, unittest.TestCase):
-
-    test_keys = None
-
-    def tearDown(self):
-        cols, rows = self.root.grid_size()
-        for i in range(cols + 1):
-            self.root.grid_columnconfigure(i, weight=0, minsize=0, pad=0, uniform='')
-        for i in range(rows + 1):
-            self.root.grid_rowconfigure(i, weight=0, minsize=0, pad=0, uniform='')
-        self.root.grid_propagate(1)
-        self.root.grid_anchor('nw')
-        super().tearDown()
-
-    def test_grid_configure(self):
-        b = tkinter.Button(self.root)
-        self.assertEqual(b.grid_info(), {})
-        b.grid_configure()
-        self.assertEqual(b.grid_info()['in'], self.root)
-        self.assertEqual(b.grid_info()['column'], self._str(0))
-        self.assertEqual(b.grid_info()['row'], self._str(0))
-        b.grid_configure({'column': 1}, row=2)
-        self.assertEqual(b.grid_info()['column'], self._str(1))
-        self.assertEqual(b.grid_info()['row'], self._str(2))
-
-    def test_grid_configure_column(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad column value "-1": '
-                                    'must be a non-negative integer'):
-            b.grid_configure(column=-1)
-        b.grid_configure(column=2)
-        self.assertEqual(b.grid_info()['column'], self._str(2))
-
-    def test_grid_configure_columnspan(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad columnspan value "0": '
-                                    'must be a positive integer'):
-            b.grid_configure(columnspan=0)
-        b.grid_configure(columnspan=2)
-        self.assertEqual(b.grid_info()['columnspan'], self._str(2))
-
-    def test_grid_configure_in(self):
-        f = tkinter.Frame(self.root)
-        b = tkinter.Button(self.root)
-        self.assertEqual(b.grid_info(), {})
-        b.grid_configure()
-        self.assertEqual(b.grid_info()['in'], self.root)
-        b.grid_configure(in_=f)
-        self.assertEqual(b.grid_info()['in'], f)
-        b.grid_configure({'in': self.root})
-        self.assertEqual(b.grid_info()['in'], self.root)
-
-    def test_grid_configure_ipadx(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad ipadx value "-1": '
-                                    'must be positive screen distance'):
-            b.grid_configure(ipadx=-1)
-        b.grid_configure(ipadx=1)
-        self.assertEqual(b.grid_info()['ipadx'], self._str(1))
-        b.grid_configure(ipadx='.5c')
-        self.assertEqual(b.grid_info()['ipadx'],
-                         self._str(round(pixels_conv('.5c') * self.scaling)))
-
-    def test_grid_configure_ipady(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad ipady value "-1": '
-                                    'must be positive screen distance'):
-            b.grid_configure(ipady=-1)
-        b.grid_configure(ipady=1)
-        self.assertEqual(b.grid_info()['ipady'], self._str(1))
-        b.grid_configure(ipady='.5c')
-        self.assertEqual(b.grid_info()['ipady'],
-                         self._str(round(pixels_conv('.5c') * self.scaling)))
-
-    def test_grid_configure_padx(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad pad value "-1": '
-                                    'must be positive screen distance'):
-            b.grid_configure(padx=-1)
-        b.grid_configure(padx=1)
-        self.assertEqual(b.grid_info()['padx'], self._str(1))
-        b.grid_configure(padx=(10, 5))
-        self.assertEqual(b.grid_info()['padx'], self._str((10, 5)))
-        b.grid_configure(padx='.5c')
-        self.assertEqual(b.grid_info()['padx'],
-                         self._str(round(pixels_conv('.5c') * self.scaling)))
-
-    def test_grid_configure_pady(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad pad value "-1": '
-                                    'must be positive screen distance'):
-            b.grid_configure(pady=-1)
-        b.grid_configure(pady=1)
-        self.assertEqual(b.grid_info()['pady'], self._str(1))
-        b.grid_configure(pady=(10, 5))
-        self.assertEqual(b.grid_info()['pady'], self._str((10, 5)))
-        b.grid_configure(pady='.5c')
-        self.assertEqual(b.grid_info()['pady'],
-                         self._str(round(pixels_conv('.5c') * self.scaling)))
-
-    def test_grid_configure_row(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad (row|grid) value "-1": '
-                                    'must be a non-negative integer'):
-            b.grid_configure(row=-1)
-        b.grid_configure(row=2)
-        self.assertEqual(b.grid_info()['row'], self._str(2))
-
-    def test_grid_configure_rownspan(self):
-        b = tkinter.Button(self.root)
-        with self.assertRaisesRegex(TclError, 'bad rowspan value "0": '
-                                    'must be a positive integer'):
-            b.grid_configure(rowspan=0)
-        b.grid_configure(rowspan=2)
-        self.assertEqual(b.grid_info()['rowspan'], self._str(2))
-
-    def test_grid_configure_sticky(self):
-        f = tkinter.Frame(self.root, bg='red')
-        with self.assertRaisesRegex(TclError, 'bad stickyness value "glue"'):
-            f.grid_configure(sticky='glue')
-        f.grid_configure(sticky='ne')
-        self.assertEqual(f.grid_info()['sticky'], 'ne')
-        f.grid_configure(sticky='n,s,e,w')
-        self.assertEqual(f.grid_info()['sticky'], 'nesw')
-
-    def test_grid_columnconfigure(self):
-        with self.assertRaises(TypeError):
-            self.root.grid_columnconfigure()
-        self.assertEqual(self.root.grid_columnconfigure(0),
-                         {'minsize': 0, 'pad': 0, 'uniform': None, 'weight': 0})
-        with self.assertRaisesRegex(TclError, 'bad option "-foo"'):
-            self.root.grid_columnconfigure(0, 'foo')
-        self.root.grid_columnconfigure((0, 3), weight=2)
-        with self.assertRaisesRegex(TclError,
-                                    'must specify a single element on retrieval'):
-            self.root.grid_columnconfigure((0, 3))
-        b = tkinter.Button(self.root)
-        b.grid_configure(column=0, row=0)
-        self.root.grid_columnconfigure('all', weight=3)
-        with self.assertRaisesRegex(TclError, 'expected integer but got "all"'):
-            self.root.grid_columnconfigure('all')
-        self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 3)
-        self.assertEqual(self.root.grid_columnconfigure(3, 'weight'), 2)
-        self.assertEqual(self.root.grid_columnconfigure(265, 'weight'), 0)
-        self.root.grid_columnconfigure(b, weight=4)
-        self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 4)
-
-    def test_grid_columnconfigure_minsize(self):
-        with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
-            self.root.grid_columnconfigure(0, minsize='foo')
-        self.root.grid_columnconfigure(0, minsize=10)
-        self.assertEqual(self.root.grid_columnconfigure(0, 'minsize'), 10)
-        self.assertEqual(self.root.grid_columnconfigure(0)['minsize'], 10)
-
-    def test_grid_columnconfigure_weight(self):
-        with self.assertRaisesRegex(TclError, 'expected integer but got "bad"'):
-            self.root.grid_columnconfigure(0, weight='bad')
-        with self.assertRaisesRegex(TclError, 'invalid arg "-weight": '
-                                    'should be non-negative'):
-            self.root.grid_columnconfigure(0, weight=-3)
-        self.root.grid_columnconfigure(0, weight=3)
-        self.assertEqual(self.root.grid_columnconfigure(0, 'weight'), 3)
-        self.assertEqual(self.root.grid_columnconfigure(0)['weight'], 3)
-
-    def test_grid_columnconfigure_pad(self):
-        with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
-            self.root.grid_columnconfigure(0, pad='foo')
-        with self.assertRaisesRegex(TclError, 'invalid arg "-pad": '
-                                    'should be non-negative'):
-            self.root.grid_columnconfigure(0, pad=-3)
-        self.root.grid_columnconfigure(0, pad=3)
-        self.assertEqual(self.root.grid_columnconfigure(0, 'pad'), 3)
-        self.assertEqual(self.root.grid_columnconfigure(0)['pad'], 3)
-
-    def test_grid_columnconfigure_uniform(self):
-        self.root.grid_columnconfigure(0, uniform='foo')
-        self.assertEqual(self.root.grid_columnconfigure(0, 'uniform'), 'foo')
-        self.assertEqual(self.root.grid_columnconfigure(0)['uniform'], 'foo')
-
-    def test_grid_rowconfigure(self):
-        with self.assertRaises(TypeError):
-            self.root.grid_rowconfigure()
-        self.assertEqual(self.root.grid_rowconfigure(0),
-                         {'minsize': 0, 'pad': 0, 'uniform': None, 'weight': 0})
-        with self.assertRaisesRegex(TclError, 'bad option "-foo"'):
-            self.root.grid_rowconfigure(0, 'foo')
-        self.root.grid_rowconfigure((0, 3), weight=2)
-        with self.assertRaisesRegex(TclError,
-                                    'must specify a single element on retrieval'):
-            self.root.grid_rowconfigure((0, 3))
-        b = tkinter.Button(self.root)
-        b.grid_configure(column=0, row=0)
-        self.root.grid_rowconfigure('all', weight=3)
-        with self.assertRaisesRegex(TclError, 'expected integer but got "all"'):
-            self.root.grid_rowconfigure('all')
-        self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 3)
-        self.assertEqual(self.root.grid_rowconfigure(3, 'weight'), 2)
-        self.assertEqual(self.root.grid_rowconfigure(265, 'weight'), 0)
-        self.root.grid_rowconfigure(b, weight=4)
-        self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 4)
-
-    def test_grid_rowconfigure_minsize(self):
-        with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
-            self.root.grid_rowconfigure(0, minsize='foo')
-        self.root.grid_rowconfigure(0, minsize=10)
-        self.assertEqual(self.root.grid_rowconfigure(0, 'minsize'), 10)
-        self.assertEqual(self.root.grid_rowconfigure(0)['minsize'], 10)
-
-    def test_grid_rowconfigure_weight(self):
-        with self.assertRaisesRegex(TclError, 'expected integer but got "bad"'):
-            self.root.grid_rowconfigure(0, weight='bad')
-        with self.assertRaisesRegex(TclError, 'invalid arg "-weight": '
-                                    'should be non-negative'):
-            self.root.grid_rowconfigure(0, weight=-3)
-        self.root.grid_rowconfigure(0, weight=3)
-        self.assertEqual(self.root.grid_rowconfigure(0, 'weight'), 3)
-        self.assertEqual(self.root.grid_rowconfigure(0)['weight'], 3)
-
-    def test_grid_rowconfigure_pad(self):
-        with self.assertRaisesRegex(TclError, 'bad screen distance "foo"'):
-            self.root.grid_rowconfigure(0, pad='foo')
-        with self.assertRaisesRegex(TclError, 'invalid arg "-pad": '
-                                    'should be non-negative'):
-            self.root.grid_rowconfigure(0, pad=-3)
-        self.root.grid_rowconfigure(0, pad=3)
-        self.assertEqual(self.root.grid_rowconfigure(0, 'pad'), 3)
-        self.assertEqual(self.root.grid_rowconfigure(0)['pad'], 3)
-
-    def test_grid_rowconfigure_uniform(self):
-        self.root.grid_rowconfigure(0, uniform='foo')
-        self.assertEqual(self.root.grid_rowconfigure(0, 'uniform'), 'foo')
-        self.assertEqual(self.root.grid_rowconfigure(0)['uniform'], 'foo')
-
-    def test_grid_forget(self):
-        b = tkinter.Button(self.root)
-        c = tkinter.Button(self.root)
-        b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
-                         padx=3, pady=4, sticky='ns')
-        self.assertEqual(self.root.grid_slaves(), [b])
-        b.grid_forget()
-        c.grid_forget()
-        self.assertEqual(self.root.grid_slaves(), [])
-        self.assertEqual(b.grid_info(), {})
-        b.grid_configure(row=0, column=0)
-        info = b.grid_info()
-        self.assertEqual(info['row'], self._str(0))
-        self.assertEqual(info['column'], self._str(0))
-        self.assertEqual(info['rowspan'], self._str(1))
-        self.assertEqual(info['columnspan'], self._str(1))
-        self.assertEqual(info['padx'], self._str(0))
-        self.assertEqual(info['pady'], self._str(0))
-        self.assertEqual(info['sticky'], '')
-
-    def test_grid_remove(self):
-        b = tkinter.Button(self.root)
-        c = tkinter.Button(self.root)
-        b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
-                         padx=3, pady=4, sticky='ns')
-        self.assertEqual(self.root.grid_slaves(), [b])
-        b.grid_remove()
-        c.grid_remove()
-        self.assertEqual(self.root.grid_slaves(), [])
-        self.assertEqual(b.grid_info(), {})
-        b.grid_configure(row=0, column=0)
-        info = b.grid_info()
-        self.assertEqual(info['row'], self._str(0))
-        self.assertEqual(info['column'], self._str(0))
-        self.assertEqual(info['rowspan'], self._str(2))
-        self.assertEqual(info['columnspan'], self._str(2))
-        self.assertEqual(info['padx'], self._str(3))
-        self.assertEqual(info['pady'], self._str(4))
-        self.assertEqual(info['sticky'], 'ns')
-
-    def test_grid_info(self):
-        b = tkinter.Button(self.root)
-        self.assertEqual(b.grid_info(), {})
-        b.grid_configure(row=2, column=2, rowspan=2, columnspan=2,
-                         padx=3, pady=4, sticky='ns')
-        info = b.grid_info()
-        self.assertIsInstance(info, dict)
-        self.assertEqual(info['in'], self.root)
-        self.assertEqual(info['row'], self._str(2))
-        self.assertEqual(info['column'], self._str(2))
-        self.assertEqual(info['rowspan'], self._str(2))
-        self.assertEqual(info['columnspan'], self._str(2))
-        self.assertEqual(info['padx'], self._str(3))
-        self.assertEqual(info['pady'], self._str(4))
-        self.assertEqual(info['sticky'], 'ns')
-
-    def test_grid_anchor(self):
-        with self.assertRaisesRegex(TclError, 'bad anchor "x"'):
-            self.root.grid_anchor('x')
-        with self.assertRaisesRegex(TclError, 'ambiguous anchor ""'):
-            self.root.grid_anchor('')
-        with self.assertRaises(TypeError):
-            self.root.grid_anchor('se', 'nw')
-        self.root.grid_anchor('se')
-        self.assertEqual(self.root.tk.call('grid', 'anchor', self.root), 'se')
-
-    def test_grid_bbox(self):
-        self.assertEqual(self.root.grid_bbox(), (0, 0, 0, 0))
-        self.assertEqual(self.root.grid_bbox(0, 0), (0, 0, 0, 0))
-        self.assertEqual(self.root.grid_bbox(0, 0, 1, 1), (0, 0, 0, 0))
-        with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
-            self.root.grid_bbox('x', 0)
-        with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
-            self.root.grid_bbox(0, 'x')
-        with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
-            self.root.grid_bbox(0, 0, 'x', 0)
-        with self.assertRaisesRegex(TclError, 'expected integer but got "x"'):
-            self.root.grid_bbox(0, 0, 0, 'x')
-        with self.assertRaises(TypeError):
-            self.root.grid_bbox(0, 0, 0, 0, 0)
-        t = self.root
-        # de-maximize
-        t.wm_geometry('1x1+0+0')
-        t.wm_geometry('')
-        f1 = tkinter.Frame(t, width=75, height=75, bg='red')
-        f2 = tkinter.Frame(t, width=90, height=90, bg='blue')
-        f1.grid_configure(row=0, column=0)
-        f2.grid_configure(row=1, column=1)
-        self.root.update()
-        self.assertEqual(t.grid_bbox(), (0, 0, 165, 165))
-        self.assertEqual(t.grid_bbox(0, 0), (0, 0, 75, 75))
-        self.assertEqual(t.grid_bbox(0, 0, 1, 1), (0, 0, 165, 165))
-        self.assertEqual(t.grid_bbox(1, 1), (75, 75, 90, 90))
-        self.assertEqual(t.grid_bbox(10, 10, 0, 0), (0, 0, 165, 165))
-        self.assertEqual(t.grid_bbox(-2, -2, -1, -1), (0, 0, 0, 0))
-        self.assertEqual(t.grid_bbox(10, 10, 12, 12), (165, 165, 0, 0))
-
-    def test_grid_location(self):
-        with self.assertRaises(TypeError):
-            self.root.grid_location()
-        with self.assertRaises(TypeError):
-            self.root.grid_location(0)
-        with self.assertRaises(TypeError):
-            self.root.grid_location(0, 0, 0)
-        with self.assertRaisesRegex(TclError, 'bad screen distance "x"'):
-            self.root.grid_location('x', 'y')
-        with self.assertRaisesRegex(TclError, 'bad screen distance "y"'):
-            self.root.grid_location('1c', 'y')
-        t = self.root
-        # de-maximize
-        t.wm_geometry('1x1+0+0')
-        t.wm_geometry('')
-        f = tkinter.Frame(t, width=200, height=100,
-                          highlightthickness=0, bg='red')
-        self.assertEqual(f.grid_location(10, 10), (-1, -1))
-        f.grid_configure()
-        self.root.update()
-        self.assertEqual(t.grid_location(-10, -10), (-1, -1))
-        self.assertEqual(t.grid_location(-10, 0), (-1, 0))
-        self.assertEqual(t.grid_location(-1, 0), (-1, 0))
-        self.assertEqual(t.grid_location(0, -10), (0, -1))
-        self.assertEqual(t.grid_location(0, -1), (0, -1))
-        self.assertEqual(t.grid_location(0, 0), (0, 0))
-        self.assertEqual(t.grid_location(200, 0), (0, 0))
-        self.assertEqual(t.grid_location(201, 0), (1, 0))
-        self.assertEqual(t.grid_location(0, 100), (0, 0))
-        self.assertEqual(t.grid_location(0, 101), (0, 1))
-        self.assertEqual(t.grid_location(201, 101), (1, 1))
-
-    def test_grid_propagate(self):
-        self.assertEqual(self.root.grid_propagate(), True)
-        with self.assertRaises(TypeError):
-            self.root.grid_propagate(False, False)
-        self.root.grid_propagate(False)
-        self.assertFalse(self.root.grid_propagate())
-        f = tkinter.Frame(self.root, width=100, height=100, bg='red')
-        f.grid_configure(row=0, column=0)
-        self.root.update()
-        self.assertEqual(f.winfo_width(), 100)
-        self.assertEqual(f.winfo_height(), 100)
-        f.grid_propagate(False)
-        g = tkinter.Frame(self.root, width=75, height=85, bg='green')
-        g.grid_configure(in_=f, row=0, column=0)
-        self.root.update()
-        self.assertEqual(f.winfo_width(), 100)
-        self.assertEqual(f.winfo_height(), 100)
-        f.grid_propagate(True)
-        self.root.update()
-        self.assertEqual(f.winfo_width(), 75)
-        self.assertEqual(f.winfo_height(), 85)
-
-    def test_grid_size(self):
-        with self.assertRaises(TypeError):
-            self.root.grid_size(0)
-        self.assertEqual(self.root.grid_size(), (0, 0))
-        f = tkinter.Scale(self.root)
-        f.grid_configure(row=0, column=0)
-        self.assertEqual(self.root.grid_size(), (1, 1))
-        f.grid_configure(row=4, column=5)
-        self.assertEqual(self.root.grid_size(), (6, 5))
-
-    def test_grid_slaves(self):
-        self.assertEqual(self.root.grid_slaves(), [])
-        a = tkinter.Label(self.root)
-        a.grid_configure(row=0, column=1)
-        b = tkinter.Label(self.root)
-        b.grid_configure(row=1, column=0)
-        c = tkinter.Label(self.root)
-        c.grid_configure(row=1, column=1)
-        d = tkinter.Label(self.root)
-        d.grid_configure(row=1, column=1)
-        self.assertEqual(self.root.grid_slaves(), [d, c, b, a])
-        self.assertEqual(self.root.grid_slaves(row=0), [a])
-        self.assertEqual(self.root.grid_slaves(row=1), [d, c, b])
-        self.assertEqual(self.root.grid_slaves(column=0), [b])
-        self.assertEqual(self.root.grid_slaves(column=1), [d, c, a])
-        self.assertEqual(self.root.grid_slaves(row=1, column=1), [d, c])
-
-
-tests_gui = (
-    PackTest, PlaceTest, GridTest,
-)
-
-if __name__ == '__main__':
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_images.py

@@ -1,380 +0,0 @@
-import unittest
-import tkinter
-from test import support
-from test.support import os_helper
-from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest, requires_tcl
-
-support.requires('gui')
-
-
-class MiscTest(AbstractTkTest, unittest.TestCase):
-
-    def test_image_types(self):
-        image_types = self.root.image_types()
-        self.assertIsInstance(image_types, tuple)
-        self.assertIn('photo', image_types)
-        self.assertIn('bitmap', image_types)
-
-    def test_image_names(self):
-        image_names = self.root.image_names()
-        self.assertIsInstance(image_names, tuple)
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_image_types(self):
-        self.assertRaises(RuntimeError, tkinter.image_types)
-        root = tkinter.Tk()
-        image_types = tkinter.image_types()
-        self.assertIsInstance(image_types, tuple)
-        self.assertIn('photo', image_types)
-        self.assertIn('bitmap', image_types)
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, tkinter.image_types)
-
-    def test_image_names(self):
-        self.assertRaises(RuntimeError, tkinter.image_names)
-        root = tkinter.Tk()
-        image_names = tkinter.image_names()
-        self.assertIsInstance(image_names, tuple)
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, tkinter.image_names)
-
-    def test_image_create_bitmap(self):
-        self.assertRaises(RuntimeError, tkinter.BitmapImage)
-        root = tkinter.Tk()
-        image = tkinter.BitmapImage()
-        self.assertIn(image.name, tkinter.image_names())
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, tkinter.BitmapImage)
-
-    def test_image_create_photo(self):
-        self.assertRaises(RuntimeError, tkinter.PhotoImage)
-        root = tkinter.Tk()
-        image = tkinter.PhotoImage()
-        self.assertIn(image.name, tkinter.image_names())
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, tkinter.PhotoImage)
-
-
-class BitmapImageTest(AbstractTkTest, unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        AbstractTkTest.setUpClass.__func__(cls)
-        cls.testfile = support.findfile('python.xbm', subdir='imghdrdata')
-
-    def test_create_from_file(self):
-        image = tkinter.BitmapImage('::img::test', master=self.root,
-                                    foreground='yellow', background='blue',
-                                    file=self.testfile)
-        self.assertEqual(str(image), '::img::test')
-        self.assertEqual(image.type(), 'bitmap')
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-        self.assertIn('::img::test', self.root.image_names())
-        del image
-        support.gc_collect()  # For PyPy or other GCs.
-        self.assertNotIn('::img::test', self.root.image_names())
-
-    def test_create_from_data(self):
-        with open(self.testfile, 'rb') as f:
-            data = f.read()
-        image = tkinter.BitmapImage('::img::test', master=self.root,
-                                    foreground='yellow', background='blue',
-                                    data=data)
-        self.assertEqual(str(image), '::img::test')
-        self.assertEqual(image.type(), 'bitmap')
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-        self.assertIn('::img::test', self.root.image_names())
-        del image
-        support.gc_collect()  # For PyPy or other GCs.
-        self.assertNotIn('::img::test', self.root.image_names())
-
-    def assertEqualStrList(self, actual, expected):
-        self.assertIsInstance(actual, str)
-        self.assertEqual(self.root.splitlist(actual), expected)
-
-    def test_configure_data(self):
-        image = tkinter.BitmapImage('::img::test', master=self.root)
-        self.assertEqual(image['data'], '-data {} {} {} {}')
-        with open(self.testfile, 'rb') as f:
-            data = f.read()
-        image.configure(data=data)
-        self.assertEqualStrList(image['data'],
-                                ('-data', '', '', '', data.decode('ascii')))
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-
-        self.assertEqual(image['maskdata'], '-maskdata {} {} {} {}')
-        image.configure(maskdata=data)
-        self.assertEqualStrList(image['maskdata'],
-                                ('-maskdata', '', '', '', data.decode('ascii')))
-
-    def test_configure_file(self):
-        image = tkinter.BitmapImage('::img::test', master=self.root)
-        self.assertEqual(image['file'], '-file {} {} {} {}')
-        image.configure(file=self.testfile)
-        self.assertEqualStrList(image['file'],
-                                ('-file', '', '', '',self.testfile))
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-
-        self.assertEqual(image['maskfile'], '-maskfile {} {} {} {}')
-        image.configure(maskfile=self.testfile)
-        self.assertEqualStrList(image['maskfile'],
-                                ('-maskfile', '', '', '', self.testfile))
-
-    def test_configure_background(self):
-        image = tkinter.BitmapImage('::img::test', master=self.root)
-        self.assertEqual(image['background'], '-background {} {} {} {}')
-        image.configure(background='blue')
-        self.assertEqual(image['background'], '-background {} {} {} blue')
-
-    def test_configure_foreground(self):
-        image = tkinter.BitmapImage('::img::test', master=self.root)
-        self.assertEqual(image['foreground'],
-                         '-foreground {} {} #000000 #000000')
-        image.configure(foreground='yellow')
-        self.assertEqual(image['foreground'],
-                         '-foreground {} {} #000000 yellow')
-
-
-class PhotoImageTest(AbstractTkTest, unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        AbstractTkTest.setUpClass.__func__(cls)
-        cls.testfile = support.findfile('python.gif', subdir='imghdrdata')
-
-    def create(self):
-        return tkinter.PhotoImage('::img::test', master=self.root,
-                                  file=self.testfile)
-
-    def colorlist(self, *args):
-        if tkinter.TkVersion >= 8.6 and self.wantobjects:
-            return args
-        else:
-            return tkinter._join(args)
-
-    def check_create_from_file(self, ext):
-        testfile = support.findfile('python.' + ext, subdir='imghdrdata')
-        image = tkinter.PhotoImage('::img::test', master=self.root,
-                                   file=testfile)
-        self.assertEqual(str(image), '::img::test')
-        self.assertEqual(image.type(), 'photo')
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-        self.assertEqual(image['data'], '')
-        self.assertEqual(image['file'], testfile)
-        self.assertIn('::img::test', self.root.image_names())
-        del image
-        support.gc_collect()  # For PyPy or other GCs.
-        self.assertNotIn('::img::test', self.root.image_names())
-
-    def check_create_from_data(self, ext):
-        testfile = support.findfile('python.' + ext, subdir='imghdrdata')
-        with open(testfile, 'rb') as f:
-            data = f.read()
-        image = tkinter.PhotoImage('::img::test', master=self.root,
-                                   data=data)
-        self.assertEqual(str(image), '::img::test')
-        self.assertEqual(image.type(), 'photo')
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-        self.assertEqual(image['data'], data if self.wantobjects
-                                        else data.decode('latin1'))
-        self.assertEqual(image['file'], '')
-        self.assertIn('::img::test', self.root.image_names())
-        del image
-        support.gc_collect()  # For PyPy or other GCs.
-        self.assertNotIn('::img::test', self.root.image_names())
-
-    def test_create_from_ppm_file(self):
-        self.check_create_from_file('ppm')
-
-    def test_create_from_ppm_data(self):
-        self.check_create_from_data('ppm')
-
-    def test_create_from_pgm_file(self):
-        self.check_create_from_file('pgm')
-
-    def test_create_from_pgm_data(self):
-        self.check_create_from_data('pgm')
-
-    def test_create_from_gif_file(self):
-        self.check_create_from_file('gif')
-
-    def test_create_from_gif_data(self):
-        self.check_create_from_data('gif')
-
-    @requires_tcl(8, 6)
-    def test_create_from_png_file(self):
-        self.check_create_from_file('png')
-
-    @requires_tcl(8, 6)
-    def test_create_from_png_data(self):
-        self.check_create_from_data('png')
-
-    def test_configure_data(self):
-        image = tkinter.PhotoImage('::img::test', master=self.root)
-        self.assertEqual(image['data'], '')
-        with open(self.testfile, 'rb') as f:
-            data = f.read()
-        image.configure(data=data)
-        self.assertEqual(image['data'], data if self.wantobjects
-                                        else data.decode('latin1'))
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-
-    def test_configure_format(self):
-        image = tkinter.PhotoImage('::img::test', master=self.root)
-        self.assertEqual(image['format'], '')
-        image.configure(file=self.testfile, format='gif')
-        self.assertEqual(image['format'], ('gif',) if self.wantobjects
-                                          else 'gif')
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-
-    def test_configure_file(self):
-        image = tkinter.PhotoImage('::img::test', master=self.root)
-        self.assertEqual(image['file'], '')
-        image.configure(file=self.testfile)
-        self.assertEqual(image['file'], self.testfile)
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-
-    def test_configure_gamma(self):
-        image = tkinter.PhotoImage('::img::test', master=self.root)
-        self.assertEqual(image['gamma'], '1.0')
-        image.configure(gamma=2.0)
-        self.assertEqual(image['gamma'], '2.0')
-
-    def test_configure_width_height(self):
-        image = tkinter.PhotoImage('::img::test', master=self.root)
-        self.assertEqual(image['width'], '0')
-        self.assertEqual(image['height'], '0')
-        image.configure(width=20)
-        image.configure(height=10)
-        self.assertEqual(image['width'], '20')
-        self.assertEqual(image['height'], '10')
-        self.assertEqual(image.width(), 20)
-        self.assertEqual(image.height(), 10)
-
-    def test_configure_palette(self):
-        image = tkinter.PhotoImage('::img::test', master=self.root)
-        self.assertEqual(image['palette'], '')
-        image.configure(palette=256)
-        self.assertEqual(image['palette'], '256')
-        image.configure(palette='3/4/2')
-        self.assertEqual(image['palette'], '3/4/2')
-
-    def test_blank(self):
-        image = self.create()
-        image.blank()
-        self.assertEqual(image.width(), 16)
-        self.assertEqual(image.height(), 16)
-        self.assertEqual(image.get(4, 6), self.colorlist(0, 0, 0))
-
-    def test_copy(self):
-        image = self.create()
-        image2 = image.copy()
-        self.assertEqual(image2.width(), 16)
-        self.assertEqual(image2.height(), 16)
-        self.assertEqual(image.get(4, 6), image.get(4, 6))
-
-    def test_subsample(self):
-        image = self.create()
-        image2 = image.subsample(2, 3)
-        self.assertEqual(image2.width(), 8)
-        self.assertEqual(image2.height(), 6)
-        self.assertEqual(image2.get(2, 2), image.get(4, 6))
-
-        image2 = image.subsample(2)
-        self.assertEqual(image2.width(), 8)
-        self.assertEqual(image2.height(), 8)
-        self.assertEqual(image2.get(2, 3), image.get(4, 6))
-
-    def test_zoom(self):
-        image = self.create()
-        image2 = image.zoom(2, 3)
-        self.assertEqual(image2.width(), 32)
-        self.assertEqual(image2.height(), 48)
-        self.assertEqual(image2.get(8, 18), image.get(4, 6))
-        self.assertEqual(image2.get(9, 20), image.get(4, 6))
-
-        image2 = image.zoom(2)
-        self.assertEqual(image2.width(), 32)
-        self.assertEqual(image2.height(), 32)
-        self.assertEqual(image2.get(8, 12), image.get(4, 6))
-        self.assertEqual(image2.get(9, 13), image.get(4, 6))
-
-    def test_put(self):
-        image = self.create()
-        image.put('{red green} {blue yellow}', to=(4, 6))
-        self.assertEqual(image.get(4, 6), self.colorlist(255, 0, 0))
-        self.assertEqual(image.get(5, 6),
-                         self.colorlist(0, 128 if tkinter.TkVersion >= 8.6
-                                           else 255, 0))
-        self.assertEqual(image.get(4, 7), self.colorlist(0, 0, 255))
-        self.assertEqual(image.get(5, 7), self.colorlist(255, 255, 0))
-
-        image.put((('#f00', '#00ff00'), ('#000000fff', '#ffffffff0000')))
-        self.assertEqual(image.get(0, 0), self.colorlist(255, 0, 0))
-        self.assertEqual(image.get(1, 0), self.colorlist(0, 255, 0))
-        self.assertEqual(image.get(0, 1), self.colorlist(0, 0, 255))
-        self.assertEqual(image.get(1, 1), self.colorlist(255, 255, 0))
-
-    def test_get(self):
-        image = self.create()
-        self.assertEqual(image.get(4, 6), self.colorlist(62, 116, 162))
-        self.assertEqual(image.get(0, 0), self.colorlist(0, 0, 0))
-        self.assertEqual(image.get(15, 15), self.colorlist(0, 0, 0))
-        self.assertRaises(tkinter.TclError, image.get, -1, 0)
-        self.assertRaises(tkinter.TclError, image.get, 0, -1)
-        self.assertRaises(tkinter.TclError, image.get, 16, 15)
-        self.assertRaises(tkinter.TclError, image.get, 15, 16)
-
-    def test_write(self):
-        image = self.create()
-        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
-
-        image.write(os_helper.TESTFN)
-        image2 = tkinter.PhotoImage('::img::test2', master=self.root,
-                                    format='ppm',
-                                    file=os_helper.TESTFN)
-        self.assertEqual(str(image2), '::img::test2')
-        self.assertEqual(image2.type(), 'photo')
-        self.assertEqual(image2.width(), 16)
-        self.assertEqual(image2.height(), 16)
-        self.assertEqual(image2.get(0, 0), image.get(0, 0))
-        self.assertEqual(image2.get(15, 8), image.get(15, 8))
-
-        image.write(os_helper.TESTFN, format='gif', from_coords=(4, 6, 6, 9))
-        image3 = tkinter.PhotoImage('::img::test3', master=self.root,
-                                    format='gif',
-                                    file=os_helper.TESTFN)
-        self.assertEqual(str(image3), '::img::test3')
-        self.assertEqual(image3.type(), 'photo')
-        self.assertEqual(image3.width(), 2)
-        self.assertEqual(image3.height(), 3)
-        self.assertEqual(image3.get(0, 0), image.get(4, 6))
-        self.assertEqual(image3.get(1, 2), image.get(5, 8))
-
-    def test_transparency(self):
-        image = self.create()
-        self.assertEqual(image.transparency_get(0, 0), True)
-        self.assertEqual(image.transparency_get(4, 6), False)
-        image.transparency_set(4, 6, True)
-        self.assertEqual(image.transparency_get(4, 6), True)
-        image.transparency_set(4, 6, False)
-        self.assertEqual(image.transparency_get(4, 6), False)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_loadtk.py

@@ -1,46 +0,0 @@
-import os
-import sys
-import unittest
-import test.support as test_support
-from test.support import os_helper
-from tkinter import Tcl, TclError
-
-test_support.requires('gui')
-
-class TkLoadTest(unittest.TestCase):
-
-    @unittest.skipIf('DISPLAY' not in os.environ, 'No $DISPLAY set.')
-    def testLoadTk(self):
-        tcl = Tcl()
-        self.assertRaises(TclError,tcl.winfo_geometry)
-        tcl.loadtk()
-        self.assertEqual('1x1+0+0', tcl.winfo_geometry())
-        tcl.destroy()
-
-    def testLoadTkFailure(self):
-        old_display = None
-        if sys.platform.startswith(('win', 'darwin', 'cygwin')):
-            # no failure possible on windows?
-
-            # XXX Maybe on tk older than 8.4.13 it would be possible,
-            # see tkinter.h.
-            return
-        with os_helper.EnvironmentVarGuard() as env:
-            if 'DISPLAY' in os.environ:
-                del env['DISPLAY']
-                # on some platforms, deleting environment variables
-                # doesn't actually carry through to the process level
-                # because they don't support unsetenv
-                # If that's the case, abort.
-                with os.popen('echo $DISPLAY') as pipe:
-                    display = pipe.read().strip()
-                if display:
-                    return
-
-            tcl = Tcl()
-            self.assertRaises(TclError, tcl.winfo_geometry)
-            self.assertRaises(TclError, tcl.loadtk)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_messagebox.py

@@ -1,36 +0,0 @@
-import unittest
-import tkinter
-from test.support import requires, swap_attr
-from tkinter.test.support import AbstractDefaultRootTest
-from tkinter.commondialog import Dialog
-from tkinter.messagebox import showinfo
-
-requires('gui')
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_showinfo(self):
-        def test_callback(dialog, master):
-            nonlocal ismapped
-            master.update()
-            ismapped = master.winfo_ismapped()
-            raise ZeroDivisionError
-
-        with swap_attr(Dialog, '_test_callback', test_callback):
-            ismapped = None
-            self.assertRaises(ZeroDivisionError, showinfo, "Spam", "Egg Information")
-            self.assertEqual(ismapped, False)
-
-            root = tkinter.Tk()
-            ismapped = None
-            self.assertRaises(ZeroDivisionError, showinfo, "Spam", "Egg Information")
-            self.assertEqual(ismapped, True)
-            root.destroy()
-
-            tkinter.NoDefaultRoot()
-            self.assertRaises(RuntimeError, showinfo, "Spam", "Egg Information")
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_misc.py

@@ -1,430 +0,0 @@
-import functools
-import unittest
-import tkinter
-import enum
-from test import support
-from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest
-
-support.requires('gui')
-
-class MiscTest(AbstractTkTest, unittest.TestCase):
-
-    def test_all(self):
-        self.assertIn("Widget", tkinter.__all__)
-        # Check that variables from tkinter.constants are also in tkinter.__all__
-        self.assertIn("CASCADE", tkinter.__all__)
-        self.assertIsNotNone(tkinter.CASCADE)
-        # Check that sys, re, and constants are not in tkinter.__all__
-        self.assertNotIn("re", tkinter.__all__)
-        self.assertNotIn("sys", tkinter.__all__)
-        self.assertNotIn("constants", tkinter.__all__)
-        # Check that an underscored functions is not in tkinter.__all__
-        self.assertNotIn("_tkerror", tkinter.__all__)
-        # Check that wantobjects is not in tkinter.__all__
-        self.assertNotIn("wantobjects", tkinter.__all__)
-
-    def test_repr(self):
-        t = tkinter.Toplevel(self.root, name='top')
-        f = tkinter.Frame(t, name='child')
-        self.assertEqual(repr(f), '<tkinter.Frame object .top.child>')
-
-    def test_generated_names(self):
-        t = tkinter.Toplevel(self.root)
-        f = tkinter.Frame(t)
-        f2 = tkinter.Frame(t)
-        b = tkinter.Button(f2)
-        for name in str(b).split('.'):
-            self.assertFalse(name.isidentifier(), msg=repr(name))
-
-    def test_tk_setPalette(self):
-        root = self.root
-        root.tk_setPalette('black')
-        self.assertEqual(root['background'], 'black')
-        root.tk_setPalette('white')
-        self.assertEqual(root['background'], 'white')
-        self.assertRaisesRegex(tkinter.TclError,
-                '^unknown color name "spam"$',
-                root.tk_setPalette, 'spam')
-
-        root.tk_setPalette(background='black')
-        self.assertEqual(root['background'], 'black')
-        root.tk_setPalette(background='blue', highlightColor='yellow')
-        self.assertEqual(root['background'], 'blue')
-        self.assertEqual(root['highlightcolor'], 'yellow')
-        root.tk_setPalette(background='yellow', highlightColor='blue')
-        self.assertEqual(root['background'], 'yellow')
-        self.assertEqual(root['highlightcolor'], 'blue')
-        self.assertRaisesRegex(tkinter.TclError,
-                '^unknown color name "spam"$',
-                root.tk_setPalette, background='spam')
-        self.assertRaisesRegex(tkinter.TclError,
-                '^must specify a background color$',
-                root.tk_setPalette, spam='white')
-        self.assertRaisesRegex(tkinter.TclError,
-                '^must specify a background color$',
-                root.tk_setPalette, highlightColor='blue')
-
-    def test_after(self):
-        root = self.root
-
-        def callback(start=0, step=1):
-            nonlocal count
-            count = start + step
-
-        # Without function, sleeps for ms.
-        self.assertIsNone(root.after(1))
-
-        # Set up with callback with no args.
-        count = 0
-        timer1 = root.after(0, callback)
-        self.assertIn(timer1, root.tk.call('after', 'info'))
-        (script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
-        root.update()  # Process all pending events.
-        self.assertEqual(count, 1)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call(script)
-
-        # Set up with callback with args.
-        count = 0
-        timer1 = root.after(0, callback, 42, 11)
-        root.update()  # Process all pending events.
-        self.assertEqual(count, 53)
-
-        # Cancel before called.
-        timer1 = root.after(1000, callback)
-        self.assertIn(timer1, root.tk.call('after', 'info'))
-        (script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
-        root.after_cancel(timer1)  # Cancel this event.
-        self.assertEqual(count, 53)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call(script)
-
-        # Call with a callable class
-        count = 0
-        timer1 = root.after(0, functools.partial(callback, 42, 11))
-        root.update()  # Process all pending events.
-        self.assertEqual(count, 53)
-
-    def test_after_idle(self):
-        root = self.root
-
-        def callback(start=0, step=1):
-            nonlocal count
-            count = start + step
-
-        # Set up with callback with no args.
-        count = 0
-        idle1 = root.after_idle(callback)
-        self.assertIn(idle1, root.tk.call('after', 'info'))
-        (script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
-        root.update_idletasks()  # Process all pending events.
-        self.assertEqual(count, 1)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call(script)
-
-        # Set up with callback with args.
-        count = 0
-        idle1 = root.after_idle(callback, 42, 11)
-        root.update_idletasks()  # Process all pending events.
-        self.assertEqual(count, 53)
-
-        # Cancel before called.
-        idle1 = root.after_idle(callback)
-        self.assertIn(idle1, root.tk.call('after', 'info'))
-        (script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
-        root.after_cancel(idle1)  # Cancel this event.
-        self.assertEqual(count, 53)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call(script)
-
-    def test_after_cancel(self):
-        root = self.root
-
-        def callback():
-            nonlocal count
-            count += 1
-
-        timer1 = root.after(5000, callback)
-        idle1 = root.after_idle(callback)
-
-        # No value for id raises a ValueError.
-        with self.assertRaises(ValueError):
-            root.after_cancel(None)
-
-        # Cancel timer event.
-        count = 0
-        (script, _) = root.tk.splitlist(root.tk.call('after', 'info', timer1))
-        root.tk.call(script)
-        self.assertEqual(count, 1)
-        root.after_cancel(timer1)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call(script)
-        self.assertEqual(count, 1)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call('after', 'info', timer1)
-
-        # Cancel same event - nothing happens.
-        root.after_cancel(timer1)
-
-        # Cancel idle event.
-        count = 0
-        (script, _) = root.tk.splitlist(root.tk.call('after', 'info', idle1))
-        root.tk.call(script)
-        self.assertEqual(count, 1)
-        root.after_cancel(idle1)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call(script)
-        self.assertEqual(count, 1)
-        with self.assertRaises(tkinter.TclError):
-            root.tk.call('after', 'info', idle1)
-
-    def test_clipboard(self):
-        root = self.root
-        root.clipboard_clear()
-        root.clipboard_append('Ùñî')
-        self.assertEqual(root.clipboard_get(), 'Ùñî')
-        root.clipboard_append('çōđě')
-        self.assertEqual(root.clipboard_get(), 'Ùñîçōđě')
-        root.clipboard_clear()
-        with self.assertRaises(tkinter.TclError):
-            root.clipboard_get()
-
-    def test_clipboard_astral(self):
-        root = self.root
-        root.clipboard_clear()
-        root.clipboard_append('𝔘𝔫𝔦')
-        self.assertEqual(root.clipboard_get(), '𝔘𝔫𝔦')
-        root.clipboard_append('𝔠𝔬𝔡𝔢')
-        self.assertEqual(root.clipboard_get(), '𝔘𝔫𝔦𝔠𝔬𝔡𝔢')
-        root.clipboard_clear()
-        with self.assertRaises(tkinter.TclError):
-            root.clipboard_get()
-
-    def test_winfo_rgb(self):
-
-        def assertApprox(col1, col2):
-            # A small amount of flexibility is required (bpo-45496)
-            # 33 is ~0.05% of 65535, which is a reasonable margin
-            for col1_channel, col2_channel in zip(col1, col2):
-                self.assertAlmostEqual(col1_channel, col2_channel, delta=33)
-
-        root = self.root
-        rgb = root.winfo_rgb
-
-        # Color name.
-        self.assertEqual(rgb('red'), (65535, 0, 0))
-        self.assertEqual(rgb('dark slate blue'), (18504, 15677, 35723))
-        # #RGB - extends each 4-bit hex value to be 16-bit.
-        self.assertEqual(rgb('#F0F'), (0xFFFF, 0x0000, 0xFFFF))
-        # #RRGGBB - extends each 8-bit hex value to be 16-bit.
-        assertApprox(rgb('#4a3c8c'), (0x4a4a, 0x3c3c, 0x8c8c))
-        # #RRRRGGGGBBBB
-        assertApprox(rgb('#dede14143939'), (0xdede, 0x1414, 0x3939))
-        # Invalid string.
-        with self.assertRaises(tkinter.TclError):
-            rgb('#123456789a')
-        # RGB triplet is invalid input.
-        with self.assertRaises(tkinter.TclError):
-            rgb((111, 78, 55))
-
-    def test_event_repr_defaults(self):
-        e = tkinter.Event()
-        e.serial = 12345
-        e.num = '??'
-        e.height = '??'
-        e.keycode = '??'
-        e.state = 0
-        e.time = 123456789
-        e.width = '??'
-        e.x = '??'
-        e.y = '??'
-        e.char = ''
-        e.keysym = '??'
-        e.keysym_num = '??'
-        e.type = '100'
-        e.widget = '??'
-        e.x_root = '??'
-        e.y_root = '??'
-        e.delta = 0
-        self.assertEqual(repr(e), '<100 event>')
-
-    def test_event_repr(self):
-        e = tkinter.Event()
-        e.serial = 12345
-        e.num = 3
-        e.focus = True
-        e.height = 200
-        e.keycode = 65
-        e.state = 0x30405
-        e.time = 123456789
-        e.width = 300
-        e.x = 10
-        e.y = 20
-        e.char = 'A'
-        e.send_event = True
-        e.keysym = 'Key-A'
-        e.keysym_num = ord('A')
-        e.type = tkinter.EventType.Configure
-        e.widget = '.text'
-        e.x_root = 1010
-        e.y_root = 1020
-        e.delta = -1
-        self.assertEqual(repr(e),
-                         "<Configure event send_event=True"
-                         " state=Shift|Control|Button3|0x30000"
-                         " keysym=Key-A keycode=65 char='A'"
-                         " num=3 delta=-1 focus=True"
-                         " x=10 y=20 width=300 height=200>")
-
-    def test_eventtype_enum(self):
-        class CheckedEventType(enum.StrEnum):
-            KeyPress = '2'
-            Key = KeyPress
-            KeyRelease = '3'
-            ButtonPress = '4'
-            Button = ButtonPress
-            ButtonRelease = '5'
-            Motion = '6'
-            Enter = '7'
-            Leave = '8'
-            FocusIn = '9'
-            FocusOut = '10'
-            Keymap = '11'           # undocumented
-            Expose = '12'
-            GraphicsExpose = '13'   # undocumented
-            NoExpose = '14'         # undocumented
-            Visibility = '15'
-            Create = '16'
-            Destroy = '17'
-            Unmap = '18'
-            Map = '19'
-            MapRequest = '20'
-            Reparent = '21'
-            Configure = '22'
-            ConfigureRequest = '23'
-            Gravity = '24'
-            ResizeRequest = '25'
-            Circulate = '26'
-            CirculateRequest = '27'
-            Property = '28'
-            SelectionClear = '29'   # undocumented
-            SelectionRequest = '30' # undocumented
-            Selection = '31'        # undocumented
-            Colormap = '32'
-            ClientMessage = '33'    # undocumented
-            Mapping = '34'          # undocumented
-            VirtualEvent = '35'     # undocumented
-            Activate = '36'
-            Deactivate = '37'
-            MouseWheel = '38'
-        enum._test_simple_enum(CheckedEventType, tkinter.EventType)
-
-    def test_getboolean(self):
-        for v in 'true', 'yes', 'on', '1', 't', 'y', 1, True:
-            self.assertIs(self.root.getboolean(v), True)
-        for v in 'false', 'no', 'off', '0', 'f', 'n', 0, False:
-            self.assertIs(self.root.getboolean(v), False)
-        self.assertRaises(ValueError, self.root.getboolean, 'yea')
-        self.assertRaises(ValueError, self.root.getboolean, '')
-        self.assertRaises(TypeError, self.root.getboolean, None)
-        self.assertRaises(TypeError, self.root.getboolean, ())
-
-    def test_mainloop(self):
-        log = []
-        def callback():
-            log.append(1)
-            self.root.after(100, self.root.quit)
-        self.root.after(100, callback)
-        self.root.mainloop(1)
-        self.assertEqual(log, [])
-        self.root.mainloop(0)
-        self.assertEqual(log, [1])
-        self.assertTrue(self.root.winfo_exists())
-
-    def test_info_patchlevel(self):
-        vi = self.root.info_patchlevel()
-        f = tkinter.Frame(self.root)
-        self.assertEqual(f.info_patchlevel(), vi)
-        # The following is almost a copy of tests for sys.version_info.
-        self.assertIsInstance(vi[:], tuple)
-        self.assertEqual(len(vi), 5)
-        self.assertIsInstance(vi[0], int)
-        self.assertIsInstance(vi[1], int)
-        self.assertIsInstance(vi[2], int)
-        self.assertIn(vi[3], ("alpha", "beta", "candidate", "final"))
-        self.assertIsInstance(vi[4], int)
-        self.assertIsInstance(vi.major, int)
-        self.assertIsInstance(vi.minor, int)
-        self.assertIsInstance(vi.micro, int)
-        self.assertIn(vi.releaselevel, ("alpha", "beta", "final"))
-        self.assertIsInstance(vi.serial, int)
-        self.assertEqual(vi[0], vi.major)
-        self.assertEqual(vi[1], vi.minor)
-        self.assertEqual(vi[2], vi.micro)
-        self.assertEqual(vi[3], vi.releaselevel)
-        self.assertEqual(vi[4], vi.serial)
-        self.assertTrue(vi > (1,0,0))
-        if vi.releaselevel == 'final':
-            self.assertEqual(vi.serial, 0)
-        else:
-            self.assertEqual(vi.micro, 0)
-        self.assertTrue(str(vi).startswith(f'{vi.major}.{vi.minor}'))
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_default_root(self):
-        self.assertIs(tkinter._support_default_root, True)
-        self.assertIsNone(tkinter._default_root)
-        root = tkinter.Tk()
-        root2 = tkinter.Tk()
-        root3 = tkinter.Tk()
-        self.assertIs(tkinter._default_root, root)
-        root2.destroy()
-        self.assertIs(tkinter._default_root, root)
-        root.destroy()
-        self.assertIsNone(tkinter._default_root)
-        root3.destroy()
-        self.assertIsNone(tkinter._default_root)
-
-    def test_no_default_root(self):
-        self.assertIs(tkinter._support_default_root, True)
-        self.assertIsNone(tkinter._default_root)
-        root = tkinter.Tk()
-        self.assertIs(tkinter._default_root, root)
-        tkinter.NoDefaultRoot()
-        self.assertIs(tkinter._support_default_root, False)
-        self.assertFalse(hasattr(tkinter, '_default_root'))
-        # repeated call is no-op
-        tkinter.NoDefaultRoot()
-        self.assertIs(tkinter._support_default_root, False)
-        self.assertFalse(hasattr(tkinter, '_default_root'))
-        root.destroy()
-        self.assertIs(tkinter._support_default_root, False)
-        self.assertFalse(hasattr(tkinter, '_default_root'))
-        root = tkinter.Tk()
-        self.assertIs(tkinter._support_default_root, False)
-        self.assertFalse(hasattr(tkinter, '_default_root'))
-        root.destroy()
-
-    def test_getboolean(self):
-        self.assertRaises(RuntimeError, tkinter.getboolean, '1')
-        root = tkinter.Tk()
-        self.assertIs(tkinter.getboolean('1'), True)
-        self.assertRaises(ValueError, tkinter.getboolean, 'yea')
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, tkinter.getboolean, '1')
-
-    def test_mainloop(self):
-        self.assertRaises(RuntimeError, tkinter.mainloop)
-        root = tkinter.Tk()
-        root.after_idle(root.quit)
-        tkinter.mainloop()
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, tkinter.mainloop)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_simpledialog.py

@@ -1,35 +0,0 @@
-import unittest
-import tkinter
-from test.support import requires, swap_attr
-from tkinter.test.support import AbstractDefaultRootTest
-from tkinter.simpledialog import Dialog, askinteger
-
-requires('gui')
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_askinteger(self):
-        @staticmethod
-        def mock_wait_window(w):
-            nonlocal ismapped
-            ismapped = w.master.winfo_ismapped()
-            w.destroy()
-
-        with swap_attr(Dialog, 'wait_window', mock_wait_window):
-            ismapped = None
-            askinteger("Go To Line", "Line number")
-            self.assertEqual(ismapped, False)
-
-            root = tkinter.Tk()
-            ismapped = None
-            askinteger("Go To Line", "Line number")
-            self.assertEqual(ismapped, True)
-            root.destroy()
-
-            tkinter.NoDefaultRoot()
-            self.assertRaises(RuntimeError, askinteger, "Go To Line", "Line number")
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_text.py

@@ -1,97 +0,0 @@
-import unittest
-import tkinter
-from test.support import requires
-from tkinter.test.support import AbstractTkTest
-
-requires('gui')
-
-class TextTest(AbstractTkTest, unittest.TestCase):
-
-    def setUp(self):
-        super().setUp()
-        self.text = tkinter.Text(self.root)
-
-    def test_debug(self):
-        text = self.text
-        olddebug = text.debug()
-        try:
-            text.debug(0)
-            self.assertEqual(text.debug(), 0)
-            text.debug(1)
-            self.assertEqual(text.debug(), 1)
-        finally:
-            text.debug(olddebug)
-            self.assertEqual(text.debug(), olddebug)
-
-    def test_search(self):
-        text = self.text
-
-        # pattern and index are obligatory arguments.
-        self.assertRaises(tkinter.TclError, text.search, None, '1.0')
-        self.assertRaises(tkinter.TclError, text.search, 'a', None)
-        self.assertRaises(tkinter.TclError, text.search, None, None)
-
-        # Invalid text index.
-        self.assertRaises(tkinter.TclError, text.search, '', 0)
-
-        # Check if we are getting the indices as strings -- you are likely
-        # to get Tcl_Obj under Tk 8.5 if Tkinter doesn't convert it.
-        text.insert('1.0', 'hi-test')
-        self.assertEqual(text.search('-test', '1.0', 'end'), '1.2')
-        self.assertEqual(text.search('test', '1.0', 'end'), '1.3')
-
-    def test_count(self):
-        # XXX Some assertions do not check against the intended result,
-        # but instead check the current result to prevent regression.
-        text = self.text
-        text.insert('1.0',
-            'Lorem ipsum dolor sit amet,\n'
-            'consectetur adipiscing elit,\n'
-            'sed do eiusmod tempor incididunt\n'
-            'ut labore et dolore magna aliqua.')
-
-        options = ('chars', 'indices', 'lines',
-                   'displaychars', 'displayindices', 'displaylines',
-                   'xpixels', 'ypixels')
-        if self.wantobjects:
-            self.assertEqual(len(text.count('1.0', 'end', *options)), 8)
-        else:
-            text.count('1.0', 'end', *options)
-        self.assertEqual(text.count('1.0', 'end', 'chars', 'lines'), (124, 4)
-                         if self.wantobjects else '124 4')
-        self.assertEqual(text.count('1.3', '4.5', 'chars', 'lines'), (92, 3)
-                         if self.wantobjects else '92 3')
-        self.assertEqual(text.count('4.5', '1.3', 'chars', 'lines'), (-92, -3)
-                         if self.wantobjects else '-92 -3')
-        self.assertEqual(text.count('1.3', '1.3', 'chars', 'lines'), (0, 0)
-                         if self.wantobjects else '0 0')
-        self.assertEqual(text.count('1.0', 'end', 'lines'), (4,)
-                         if self.wantobjects else ('4',))
-        self.assertEqual(text.count('end', '1.0', 'lines'), (-4,)
-                         if self.wantobjects else ('-4',))
-        self.assertEqual(text.count('1.3', '1.5', 'lines'), None
-                         if self.wantobjects else ('0',))
-        self.assertEqual(text.count('1.3', '1.3', 'lines'), None
-                         if self.wantobjects else ('0',))
-        self.assertEqual(text.count('1.0', 'end'), (124,)  # 'indices' by default
-                         if self.wantobjects else ('124',))
-        self.assertRaises(tkinter.TclError, text.count, '1.0', 'end', 'spam')
-        self.assertRaises(tkinter.TclError, text.count, '1.0', 'end', '-lines')
-
-        self.assertIsInstance(text.count('1.3', '1.5', 'ypixels'), tuple)
-        self.assertIsInstance(text.count('1.3', '1.5', 'update', 'ypixels'), int
-                              if self.wantobjects else str)
-        self.assertEqual(text.count('1.3', '1.3', 'update', 'ypixels'), None
-                         if self.wantobjects else '0')
-        self.assertEqual(text.count('1.3', '1.5', 'update', 'indices'), 2
-                         if self.wantobjects else '2')
-        self.assertEqual(text.count('1.3', '1.3', 'update', 'indices'), None
-                         if self.wantobjects else '0')
-        self.assertEqual(text.count('1.3', '1.5', 'update'), (2,)
-                         if self.wantobjects else ('2',))
-        self.assertEqual(text.count('1.3', '1.3', 'update'), None
-                         if self.wantobjects else ('0',))
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_tkinter/test_variables.py

@@ -1,342 +0,0 @@
-import unittest
-from test import support
-
-import gc
-import tkinter
-from tkinter import (Variable, StringVar, IntVar, DoubleVar, BooleanVar, Tcl,
-                     TclError)
-from test.support import ALWAYS_EQ
-from tkinter.test.support import AbstractDefaultRootTest
-
-
-class Var(Variable):
-
-    _default = "default"
-    side_effect = False
-
-    def set(self, value):
-        self.side_effect = True
-        super().set(value)
-
-
-class TestBase(unittest.TestCase):
-
-    def setUp(self):
-        self.root = Tcl()
-
-    def tearDown(self):
-        del self.root
-
-
-class TestVariable(TestBase):
-
-    def info_exists(self, *args):
-        return self.root.getboolean(self.root.call("info", "exists", *args))
-
-    def test_default(self):
-        v = Variable(self.root)
-        self.assertEqual("", v.get())
-        self.assertRegex(str(v), r"^PY_VAR(\d+)$")
-
-    def test_name_and_value(self):
-        v = Variable(self.root, "sample string", "varname")
-        self.assertEqual("sample string", v.get())
-        self.assertEqual("varname", str(v))
-
-    def test___del__(self):
-        self.assertFalse(self.info_exists("varname"))
-        v = Variable(self.root, "sample string", "varname")
-        self.assertTrue(self.info_exists("varname"))
-        del v
-        support.gc_collect()  # For PyPy or other GCs.
-        self.assertFalse(self.info_exists("varname"))
-
-    def test_dont_unset_not_existing(self):
-        self.assertFalse(self.info_exists("varname"))
-        v1 = Variable(self.root, name="name")
-        v2 = Variable(self.root, name="name")
-        del v1
-        support.gc_collect()  # For PyPy or other GCs.
-        self.assertFalse(self.info_exists("name"))
-        # shouldn't raise exception
-        del v2
-        support.gc_collect()  # For PyPy or other GCs.
-        self.assertFalse(self.info_exists("name"))
-
-    def test_equality(self):
-        # values doesn't matter, only class and name are checked
-        v1 = Variable(self.root, name="abc")
-        v2 = Variable(self.root, name="abc")
-        self.assertIsNot(v1, v2)
-        self.assertEqual(v1, v2)
-
-        v3 = Variable(self.root, name="cba")
-        self.assertNotEqual(v1, v3)
-
-        v4 = StringVar(self.root, name="abc")
-        self.assertEqual(str(v1), str(v4))
-        self.assertNotEqual(v1, v4)
-
-        V = type('Variable', (), {})
-        self.assertNotEqual(v1, V())
-
-        self.assertNotEqual(v1, object())
-        self.assertEqual(v1, ALWAYS_EQ)
-
-        root2 = tkinter.Tk()
-        self.addCleanup(root2.destroy)
-        v5 = Variable(root2, name="abc")
-        self.assertEqual(str(v1), str(v5))
-        self.assertNotEqual(v1, v5)
-
-    def test_invalid_name(self):
-        with self.assertRaises(TypeError):
-            Variable(self.root, name=123)
-
-    def test_null_in_name(self):
-        with self.assertRaises(ValueError):
-            Variable(self.root, name='var\x00name')
-        with self.assertRaises(ValueError):
-            self.root.globalsetvar('var\x00name', "value")
-        with self.assertRaises(ValueError):
-            self.root.globalsetvar(b'var\x00name', "value")
-        with self.assertRaises(ValueError):
-            self.root.setvar('var\x00name', "value")
-        with self.assertRaises(ValueError):
-            self.root.setvar(b'var\x00name', "value")
-
-    def test_initialize(self):
-        v = Var(self.root)
-        self.assertFalse(v.side_effect)
-        v.set("value")
-        self.assertTrue(v.side_effect)
-
-    def test_trace_old(self):
-        # Old interface
-        v = Variable(self.root)
-        vname = str(v)
-        trace = []
-        def read_tracer(*args):
-            trace.append(('read',) + args)
-        def write_tracer(*args):
-            trace.append(('write',) + args)
-        cb1 = v.trace_variable('r', read_tracer)
-        cb2 = v.trace_variable('wu', write_tracer)
-        self.assertEqual(sorted(v.trace_vinfo()), [('r', cb1), ('wu', cb2)])
-        self.assertEqual(trace, [])
-
-        v.set('spam')
-        self.assertEqual(trace, [('write', vname, '', 'w')])
-
-        trace = []
-        v.get()
-        self.assertEqual(trace, [('read', vname, '', 'r')])
-
-        trace = []
-        info = sorted(v.trace_vinfo())
-        v.trace_vdelete('w', cb1)  # Wrong mode
-        self.assertEqual(sorted(v.trace_vinfo()), info)
-        with self.assertRaises(TclError):
-            v.trace_vdelete('r', 'spam')  # Wrong command name
-        self.assertEqual(sorted(v.trace_vinfo()), info)
-        v.trace_vdelete('r', (cb1, 43)) # Wrong arguments
-        self.assertEqual(sorted(v.trace_vinfo()), info)
-        v.get()
-        self.assertEqual(trace, [('read', vname, '', 'r')])
-
-        trace = []
-        v.trace_vdelete('r', cb1)
-        self.assertEqual(v.trace_vinfo(), [('wu', cb2)])
-        v.get()
-        self.assertEqual(trace, [])
-
-        trace = []
-        del write_tracer
-        gc.collect()
-        v.set('eggs')
-        self.assertEqual(trace, [('write', vname, '', 'w')])
-
-        trace = []
-        del v
-        gc.collect()
-        self.assertEqual(trace, [('write', vname, '', 'u')])
-
-    def test_trace(self):
-        v = Variable(self.root)
-        vname = str(v)
-        trace = []
-        def read_tracer(*args):
-            trace.append(('read',) + args)
-        def write_tracer(*args):
-            trace.append(('write',) + args)
-        tr1 = v.trace_add('read', read_tracer)
-        tr2 = v.trace_add(['write', 'unset'], write_tracer)
-        self.assertEqual(sorted(v.trace_info()), [
-                         (('read',), tr1),
-                         (('write', 'unset'), tr2)])
-        self.assertEqual(trace, [])
-
-        v.set('spam')
-        self.assertEqual(trace, [('write', vname, '', 'write')])
-
-        trace = []
-        v.get()
-        self.assertEqual(trace, [('read', vname, '', 'read')])
-
-        trace = []
-        info = sorted(v.trace_info())
-        v.trace_remove('write', tr1)  # Wrong mode
-        self.assertEqual(sorted(v.trace_info()), info)
-        with self.assertRaises(TclError):
-            v.trace_remove('read', 'spam')  # Wrong command name
-        self.assertEqual(sorted(v.trace_info()), info)
-        v.get()
-        self.assertEqual(trace, [('read', vname, '', 'read')])
-
-        trace = []
-        v.trace_remove('read', tr1)
-        self.assertEqual(v.trace_info(), [(('write', 'unset'), tr2)])
-        v.get()
-        self.assertEqual(trace, [])
-
-        trace = []
-        del write_tracer
-        gc.collect()
-        v.set('eggs')
-        self.assertEqual(trace, [('write', vname, '', 'write')])
-
-        trace = []
-        del v
-        gc.collect()
-        self.assertEqual(trace, [('write', vname, '', 'unset')])
-
-
-class TestStringVar(TestBase):
-
-    def test_default(self):
-        v = StringVar(self.root)
-        self.assertEqual("", v.get())
-
-    def test_get(self):
-        v = StringVar(self.root, "abc", "name")
-        self.assertEqual("abc", v.get())
-        self.root.globalsetvar("name", "value")
-        self.assertEqual("value", v.get())
-
-    def test_get_null(self):
-        v = StringVar(self.root, "abc\x00def", "name")
-        self.assertEqual("abc\x00def", v.get())
-        self.root.globalsetvar("name", "val\x00ue")
-        self.assertEqual("val\x00ue", v.get())
-
-
-class TestIntVar(TestBase):
-
-    def test_default(self):
-        v = IntVar(self.root)
-        self.assertEqual(0, v.get())
-
-    def test_get(self):
-        v = IntVar(self.root, 123, "name")
-        self.assertEqual(123, v.get())
-        self.root.globalsetvar("name", "345")
-        self.assertEqual(345, v.get())
-        self.root.globalsetvar("name", "876.5")
-        self.assertEqual(876, v.get())
-
-    def test_invalid_value(self):
-        v = IntVar(self.root, name="name")
-        self.root.globalsetvar("name", "value")
-        with self.assertRaises((ValueError, TclError)):
-            v.get()
-
-
-class TestDoubleVar(TestBase):
-
-    def test_default(self):
-        v = DoubleVar(self.root)
-        self.assertEqual(0.0, v.get())
-
-    def test_get(self):
-        v = DoubleVar(self.root, 1.23, "name")
-        self.assertAlmostEqual(1.23, v.get())
-        self.root.globalsetvar("name", "3.45")
-        self.assertAlmostEqual(3.45, v.get())
-
-    def test_get_from_int(self):
-        v = DoubleVar(self.root, 1.23, "name")
-        self.assertAlmostEqual(1.23, v.get())
-        self.root.globalsetvar("name", "3.45")
-        self.assertAlmostEqual(3.45, v.get())
-        self.root.globalsetvar("name", "456")
-        self.assertAlmostEqual(456, v.get())
-
-    def test_invalid_value(self):
-        v = DoubleVar(self.root, name="name")
-        self.root.globalsetvar("name", "value")
-        with self.assertRaises((ValueError, TclError)):
-            v.get()
-
-
-class TestBooleanVar(TestBase):
-
-    def test_default(self):
-        v = BooleanVar(self.root)
-        self.assertIs(v.get(), False)
-
-    def test_get(self):
-        v = BooleanVar(self.root, True, "name")
-        self.assertIs(v.get(), True)
-        self.root.globalsetvar("name", "0")
-        self.assertIs(v.get(), False)
-        self.root.globalsetvar("name", 42 if self.root.wantobjects() else 1)
-        self.assertIs(v.get(), True)
-        self.root.globalsetvar("name", 0)
-        self.assertIs(v.get(), False)
-        self.root.globalsetvar("name", "on")
-        self.assertIs(v.get(), True)
-
-    def test_set(self):
-        true = 1 if self.root.wantobjects() else "1"
-        false = 0 if self.root.wantobjects() else "0"
-        v = BooleanVar(self.root, name="name")
-        v.set(True)
-        self.assertEqual(self.root.globalgetvar("name"), true)
-        v.set("0")
-        self.assertEqual(self.root.globalgetvar("name"), false)
-        v.set(42)
-        self.assertEqual(self.root.globalgetvar("name"), true)
-        v.set(0)
-        self.assertEqual(self.root.globalgetvar("name"), false)
-        v.set("on")
-        self.assertEqual(self.root.globalgetvar("name"), true)
-
-    def test_invalid_value_domain(self):
-        false = 0 if self.root.wantobjects() else "0"
-        v = BooleanVar(self.root, name="name")
-        with self.assertRaises(TclError):
-            v.set("value")
-        self.assertEqual(self.root.globalgetvar("name"), false)
-        self.root.globalsetvar("name", "value")
-        with self.assertRaises(ValueError):
-            v.get()
-        self.root.globalsetvar("name", "1.0")
-        with self.assertRaises(ValueError):
-            v.get()
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_variable(self):
-        self.assertRaises(RuntimeError, Variable)
-        root = tkinter.Tk()
-        v = Variable()
-        v.set("value")
-        self.assertEqual(v.get(), "value")
-        root.destroy()
-        tkinter.NoDefaultRoot()
-        self.assertRaises(RuntimeError, Variable)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_ttk/test_extensions.py

@@ -1,328 +0,0 @@
-import sys
-import unittest
-import tkinter
-from tkinter import ttk
-from test.support import requires, gc_collect
-from tkinter.test.support import AbstractTkTest, AbstractDefaultRootTest
-
-requires('gui')
-
-class LabeledScaleTest(AbstractTkTest, unittest.TestCase):
-
-    def tearDown(self):
-        self.root.update_idletasks()
-        super().tearDown()
-
-    def test_widget_destroy(self):
-        # automatically created variable
-        x = ttk.LabeledScale(self.root)
-        var = x._variable._name
-        x.destroy()
-        gc_collect()  # For PyPy or other GCs.
-        self.assertRaises(tkinter.TclError, x.tk.globalgetvar, var)
-
-        # manually created variable
-        myvar = tkinter.DoubleVar(self.root)
-        name = myvar._name
-        x = ttk.LabeledScale(self.root, variable=myvar)
-        x.destroy()
-        if self.wantobjects:
-            self.assertEqual(x.tk.globalgetvar(name), myvar.get())
-        else:
-            self.assertEqual(float(x.tk.globalgetvar(name)), myvar.get())
-        del myvar
-        gc_collect()  # For PyPy or other GCs.
-        self.assertRaises(tkinter.TclError, x.tk.globalgetvar, name)
-
-        # checking that the tracing callback is properly removed
-        myvar = tkinter.IntVar(self.root)
-        # LabeledScale will start tracing myvar
-        x = ttk.LabeledScale(self.root, variable=myvar)
-        x.destroy()
-        # Unless the tracing callback was removed, creating a new
-        # LabeledScale with the same var will cause an error now. This
-        # happens because the variable will be set to (possibly) a new
-        # value which causes the tracing callback to be called and then
-        # it tries calling instance attributes not yet defined.
-        ttk.LabeledScale(self.root, variable=myvar)
-        if hasattr(sys, 'last_type'):
-            self.assertNotEqual(sys.last_type, tkinter.TclError)
-
-    def test_initialization(self):
-        # master passing
-        master = tkinter.Frame(self.root)
-        x = ttk.LabeledScale(master)
-        self.assertEqual(x.master, master)
-        x.destroy()
-
-        # variable initialization/passing
-        passed_expected = (('0', 0), (0, 0), (10, 10),
-            (-1, -1), (sys.maxsize + 1, sys.maxsize + 1),
-            (2.5, 2), ('2.5', 2))
-        for pair in passed_expected:
-            x = ttk.LabeledScale(self.root, from_=pair[0])
-            self.assertEqual(x.value, pair[1])
-            x.destroy()
-        x = ttk.LabeledScale(self.root, from_=None)
-        self.assertRaises((ValueError, tkinter.TclError), x._variable.get)
-        x.destroy()
-        # variable should have its default value set to the from_ value
-        myvar = tkinter.DoubleVar(self.root, value=20)
-        x = ttk.LabeledScale(self.root, variable=myvar)
-        self.assertEqual(x.value, 0)
-        x.destroy()
-        # check that it is really using a DoubleVar
-        x = ttk.LabeledScale(self.root, variable=myvar, from_=0.5)
-        self.assertEqual(x.value, 0.5)
-        self.assertEqual(x._variable._name, myvar._name)
-        x.destroy()
-
-        # widget positionment
-        def check_positions(scale, scale_pos, label, label_pos):
-            self.assertEqual(scale.pack_info()['side'], scale_pos)
-            self.assertEqual(label.place_info()['anchor'], label_pos)
-        x = ttk.LabeledScale(self.root, compound='top')
-        check_positions(x.scale, 'bottom', x.label, 'n')
-        x.destroy()
-        x = ttk.LabeledScale(self.root, compound='bottom')
-        check_positions(x.scale, 'top', x.label, 's')
-        x.destroy()
-        # invert default positions
-        x = ttk.LabeledScale(self.root, compound='unknown')
-        check_positions(x.scale, 'top', x.label, 's')
-        x.destroy()
-        x = ttk.LabeledScale(self.root) # take default positions
-        check_positions(x.scale, 'bottom', x.label, 'n')
-        x.destroy()
-
-        # extra, and invalid, kwargs
-        self.assertRaises(tkinter.TclError, ttk.LabeledScale, master, a='b')
-
-
-    def test_horizontal_range(self):
-        lscale = ttk.LabeledScale(self.root, from_=0, to=10)
-        lscale.pack()
-        lscale.update()
-
-        linfo_1 = lscale.label.place_info()
-        prev_xcoord = lscale.scale.coords()[0]
-        self.assertEqual(prev_xcoord, int(linfo_1['x']))
-        # change range to: from -5 to 5. This should change the x coord of
-        # the scale widget, since 0 is at the middle of the new
-        # range.
-        lscale.scale.configure(from_=-5, to=5)
-        # The following update is needed since the test doesn't use mainloop,
-        # at the same time this shouldn't affect test outcome
-        lscale.update()
-        curr_xcoord = lscale.scale.coords()[0]
-        self.assertNotEqual(prev_xcoord, curr_xcoord)
-        # the label widget should have been repositioned too
-        linfo_2 = lscale.label.place_info()
-        self.assertEqual(lscale.label['text'], 0 if self.wantobjects else '0')
-        self.assertEqual(curr_xcoord, int(linfo_2['x']))
-        # change the range back
-        lscale.scale.configure(from_=0, to=10)
-        self.assertNotEqual(prev_xcoord, curr_xcoord)
-        self.assertEqual(prev_xcoord, int(linfo_1['x']))
-
-        lscale.destroy()
-
-
-    def test_variable_change(self):
-        x = ttk.LabeledScale(self.root)
-        x.pack()
-        x.update()
-
-        curr_xcoord = x.scale.coords()[0]
-        newval = x.value + 1
-        x.value = newval
-        # The following update is needed since the test doesn't use mainloop,
-        # at the same time this shouldn't affect test outcome
-        x.update()
-        self.assertEqual(x.value, newval)
-        self.assertEqual(x.label['text'],
-                         newval if self.wantobjects else str(newval))
-        self.assertEqual(float(x.scale.get()), newval)
-        self.assertGreater(x.scale.coords()[0], curr_xcoord)
-        self.assertEqual(x.scale.coords()[0],
-            int(x.label.place_info()['x']))
-
-        # value outside range
-        if self.wantobjects:
-            conv = lambda x: x
-        else:
-            conv = int
-        x.value = conv(x.scale['to']) + 1 # no changes shouldn't happen
-        x.update()
-        self.assertEqual(x.value, newval)
-        self.assertEqual(conv(x.label['text']), newval)
-        self.assertEqual(float(x.scale.get()), newval)
-        self.assertEqual(x.scale.coords()[0],
-            int(x.label.place_info()['x']))
-
-        # non-integer value
-        x.value = newval = newval + 1.5
-        x.update()
-        self.assertEqual(x.value, int(newval))
-        self.assertEqual(conv(x.label['text']), int(newval))
-        self.assertEqual(float(x.scale.get()), newval)
-
-        x.destroy()
-
-
-    def test_resize(self):
-        x = ttk.LabeledScale(self.root)
-        x.pack(expand=True, fill='both')
-        gc_collect()  # For PyPy or other GCs.
-        x.update()
-
-        width, height = x.master.winfo_width(), x.master.winfo_height()
-        width_new, height_new = width * 2, height * 2
-
-        x.value = 3
-        x.update()
-        x.master.wm_geometry("%dx%d" % (width_new, height_new))
-        self.assertEqual(int(x.label.place_info()['x']),
-            x.scale.coords()[0])
-
-        # Reset geometry
-        x.master.wm_geometry("%dx%d" % (width, height))
-        x.destroy()
-
-
-class OptionMenuTest(AbstractTkTest, unittest.TestCase):
-
-    def setUp(self):
-        super().setUp()
-        self.textvar = tkinter.StringVar(self.root)
-
-    def tearDown(self):
-        del self.textvar
-        super().tearDown()
-
-
-    def test_widget_destroy(self):
-        var = tkinter.StringVar(self.root)
-        optmenu = ttk.OptionMenu(self.root, var)
-        name = var._name
-        optmenu.update_idletasks()
-        optmenu.destroy()
-        self.assertEqual(optmenu.tk.globalgetvar(name), var.get())
-        del var
-        gc_collect()  # For PyPy or other GCs.
-        self.assertRaises(tkinter.TclError, optmenu.tk.globalgetvar, name)
-
-
-    def test_initialization(self):
-        self.assertRaises(tkinter.TclError,
-            ttk.OptionMenu, self.root, self.textvar, invalid='thing')
-
-        optmenu = ttk.OptionMenu(self.root, self.textvar, 'b', 'a', 'b')
-        self.assertEqual(optmenu._variable.get(), 'b')
-
-        self.assertTrue(optmenu['menu'])
-        self.assertTrue(optmenu['textvariable'])
-
-        optmenu.destroy()
-
-
-    def test_menu(self):
-        items = ('a', 'b', 'c')
-        default = 'a'
-        optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
-        found_default = False
-        for i in range(len(items)):
-            value = optmenu['menu'].entrycget(i, 'value')
-            self.assertEqual(value, items[i])
-            if value == default:
-                found_default = True
-        self.assertTrue(found_default)
-        optmenu.destroy()
-
-        # default shouldn't be in menu if it is not part of values
-        default = 'd'
-        optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
-        curr = None
-        i = 0
-        while True:
-            last, curr = curr, optmenu['menu'].entryconfigure(i, 'value')
-            if last == curr:
-                # no more menu entries
-                break
-            self.assertNotEqual(curr, default)
-            i += 1
-        self.assertEqual(i, len(items))
-
-        # check that variable is updated correctly
-        optmenu.pack()
-        gc_collect()  # For PyPy or other GCs.
-        optmenu['menu'].invoke(0)
-        self.assertEqual(optmenu._variable.get(), items[0])
-
-        # changing to an invalid index shouldn't change the variable
-        self.assertRaises(tkinter.TclError, optmenu['menu'].invoke, -1)
-        self.assertEqual(optmenu._variable.get(), items[0])
-
-        optmenu.destroy()
-
-        # specifying a callback
-        success = []
-        def cb_test(item):
-            self.assertEqual(item, items[1])
-            success.append(True)
-        optmenu = ttk.OptionMenu(self.root, self.textvar, 'a', command=cb_test,
-            *items)
-        optmenu['menu'].invoke(1)
-        if not success:
-            self.fail("Menu callback not invoked")
-
-        optmenu.destroy()
-
-    def test_unique_radiobuttons(self):
-        # check that radiobuttons are unique across instances (bpo25684)
-        items = ('a', 'b', 'c')
-        default = 'a'
-        optmenu = ttk.OptionMenu(self.root, self.textvar, default, *items)
-        textvar2 = tkinter.StringVar(self.root)
-        optmenu2 = ttk.OptionMenu(self.root, textvar2, default, *items)
-        optmenu.pack()
-        optmenu2.pack()
-        optmenu['menu'].invoke(1)
-        optmenu2['menu'].invoke(2)
-        optmenu_stringvar_name = optmenu['menu'].entrycget(0, 'variable')
-        optmenu2_stringvar_name = optmenu2['menu'].entrycget(0, 'variable')
-        self.assertNotEqual(optmenu_stringvar_name,
-                            optmenu2_stringvar_name)
-        self.assertEqual(self.root.tk.globalgetvar(optmenu_stringvar_name),
-                         items[1])
-        self.assertEqual(self.root.tk.globalgetvar(optmenu2_stringvar_name),
-                         items[2])
-
-        optmenu.destroy()
-        optmenu2.destroy()
-
-    def test_trace_variable(self):
-        # prior to bpo45160, tracing a variable would cause the callback to be made twice
-        success = []
-        items = ('a', 'b', 'c')
-        textvar = tkinter.StringVar(self.root)
-        def cb_test(*args):
-            success.append(textvar.get())
-        optmenu = ttk.OptionMenu(self.root, textvar, "a", *items)
-        optmenu.pack()
-        cb_name = textvar.trace_add("write", cb_test)
-        optmenu['menu'].invoke(1)
-        self.assertEqual(success, ['b'])
-        self.assertEqual(textvar.get(), 'b')
-        textvar.trace_remove("write", cb_name)
-        optmenu.destroy()
-
-
-class DefaultRootTest(AbstractDefaultRootTest, unittest.TestCase):
-
-    def test_labeledscale(self):
-        self._test_widget(ttk.LabeledScale)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/test_ttk/test_style.py

@@ -1,181 +0,0 @@
-import unittest
-import sys
-import tkinter
-from tkinter import ttk
-from test import support
-from test.support import requires
-from tkinter.test.support import AbstractTkTest, get_tk_patchlevel
-
-requires('gui')
-
-CLASS_NAMES = [
-    '.', 'ComboboxPopdownFrame', 'Heading',
-    'Horizontal.TProgressbar', 'Horizontal.TScale', 'Item', 'Sash',
-    'TButton', 'TCheckbutton', 'TCombobox', 'TEntry',
-    'TLabelframe', 'TLabelframe.Label', 'TMenubutton',
-    'TNotebook', 'TNotebook.Tab', 'Toolbutton', 'TProgressbar',
-    'TRadiobutton', 'Treeview', 'TScale', 'TScrollbar', 'TSpinbox',
-    'Vertical.TProgressbar', 'Vertical.TScale'
-]
-
-class StyleTest(AbstractTkTest, unittest.TestCase):
-
-    def setUp(self):
-        super().setUp()
-        self.style = ttk.Style(self.root)
-
-
-    def test_configure(self):
-        style = self.style
-        style.configure('TButton', background='yellow')
-        self.assertEqual(style.configure('TButton', 'background'),
-            'yellow')
-        self.assertIsInstance(style.configure('TButton'), dict)
-
-
-    def test_map(self):
-        style = self.style
-
-        # Single state
-        for states in ['active'], [('active',)]:
-            with self.subTest(states=states):
-                style.map('TButton', background=[(*states, 'white')])
-                expected = [('active', 'white')]
-                self.assertEqual(style.map('TButton', 'background'), expected)
-                m = style.map('TButton')
-                self.assertIsInstance(m, dict)
-                self.assertEqual(m['background'], expected)
-
-        # Multiple states
-        for states in ['pressed', '!disabled'], ['pressed !disabled'], [('pressed', '!disabled')]:
-            with self.subTest(states=states):
-                style.map('TButton', background=[(*states, 'black')])
-                expected = [('pressed', '!disabled', 'black')]
-                self.assertEqual(style.map('TButton', 'background'), expected)
-                m = style.map('TButton')
-                self.assertIsInstance(m, dict)
-                self.assertEqual(m['background'], expected)
-
-        # Default state
-        for states in [], [''], [()]:
-            with self.subTest(states=states):
-                style.map('TButton', background=[(*states, 'grey')])
-                expected = [('grey',)]
-                self.assertEqual(style.map('TButton', 'background'), expected)
-                m = style.map('TButton')
-                self.assertIsInstance(m, dict)
-                self.assertEqual(m['background'], expected)
-
-
-    def test_lookup(self):
-        style = self.style
-        style.configure('TButton', background='yellow')
-        style.map('TButton', background=[('active', 'background', 'blue')])
-
-        self.assertEqual(style.lookup('TButton', 'background'), 'yellow')
-        self.assertEqual(style.lookup('TButton', 'background',
-            ['active', 'background']), 'blue')
-        self.assertEqual(style.lookup('TButton', 'optionnotdefined',
-            default='iknewit'), 'iknewit')
-
-
-    def test_layout(self):
-        style = self.style
-        self.assertRaises(tkinter.TclError, style.layout, 'NotALayout')
-        tv_style = style.layout('Treeview')
-
-        # "erase" Treeview layout
-        style.layout('Treeview', '')
-        self.assertEqual(style.layout('Treeview'),
-            [('null', {'sticky': 'nswe'})]
-        )
-
-        # restore layout
-        style.layout('Treeview', tv_style)
-        self.assertEqual(style.layout('Treeview'), tv_style)
-
-        # should return a list
-        self.assertIsInstance(style.layout('TButton'), list)
-
-        # correct layout, but "option" doesn't exist as option
-        self.assertRaises(tkinter.TclError, style.layout, 'Treeview',
-            [('name', {'option': 'inexistent'})])
-
-
-    def test_theme_use(self):
-        self.assertRaises(tkinter.TclError, self.style.theme_use,
-            'nonexistingname')
-
-        curr_theme = self.style.theme_use()
-        new_theme = None
-        for theme in self.style.theme_names():
-            if theme != curr_theme:
-                new_theme = theme
-                self.style.theme_use(theme)
-                break
-        else:
-            # just one theme available, can't go on with tests
-            return
-
-        self.assertFalse(curr_theme == new_theme)
-        self.assertFalse(new_theme != self.style.theme_use())
-
-        self.style.theme_use(curr_theme)
-
-
-    def test_configure_custom_copy(self):
-        style = self.style
-
-        curr_theme = self.style.theme_use()
-        self.addCleanup(self.style.theme_use, curr_theme)
-        for theme in self.style.theme_names():
-            self.style.theme_use(theme)
-            for name in CLASS_NAMES:
-                default = style.configure(name)
-                if not default:
-                    continue
-                with self.subTest(theme=theme, name=name):
-                    if support.verbose >= 2:
-                        print('configure', theme, name, default)
-                    if (theme in ('vista', 'xpnative')
-                            and sys.getwindowsversion()[:2] == (6, 1)):
-                        # Fails on the Windows 7 buildbot
-                        continue
-                    newname = f'C.{name}'
-                    self.assertEqual(style.configure(newname), None)
-                    style.configure(newname, **default)
-                    self.assertEqual(style.configure(newname), default)
-                    for key, value in default.items():
-                        self.assertEqual(style.configure(newname, key), value)
-
-
-    def test_map_custom_copy(self):
-        style = self.style
-
-        curr_theme = self.style.theme_use()
-        self.addCleanup(self.style.theme_use, curr_theme)
-        for theme in self.style.theme_names():
-            self.style.theme_use(theme)
-            for name in CLASS_NAMES:
-                default = style.map(name)
-                if not default:
-                    continue
-                with self.subTest(theme=theme, name=name):
-                    if support.verbose >= 2:
-                        print('map', theme, name, default)
-                    if (theme in ('vista', 'xpnative')
-                            and sys.getwindowsversion()[:2] == (6, 1)):
-                        # Fails on the Windows 7 buildbot
-                        continue
-                    newname = f'C.{name}'
-                    self.assertEqual(style.map(newname), {})
-                    style.map(newname, **default)
-                    if theme == 'alt' and name == '.' and get_tk_patchlevel() < (8, 6, 1):
-                        default['embossed'] = [('disabled', '1')]
-                    self.assertEqual(style.map(newname), default)
-                    for key, value in default.items():
-                        self.assertEqual(style.map(newname, key), value)
-
-
-if __name__ == "__main__":
-    unittest.main()

.CondaPkg/env/Lib/tkinter/test/widget_tests.py

@@ -1,520 +0,0 @@
-# Common tests for test_tkinter/test_widgets.py and test_ttk/test_widgets.py
-
-import unittest
-import tkinter
-from tkinter.test.support import (AbstractTkTest, tcl_version,
-                                  pixels_conv, tcl_obj_eq)
-import test.support
-
-
-_sentinel = object()
-
-class AbstractWidgetTest(AbstractTkTest):
-    _conv_pixels = round
-    _conv_pad_pixels = None
-    _stringify = False
-
-    @property
-    def scaling(self):
-        try:
-            return self._scaling
-        except AttributeError:
-            self._scaling = float(self.root.call('tk', 'scaling'))
-            return self._scaling
-
-    def _str(self, value):
-        if not self._stringify and self.wantobjects and tcl_version >= (8, 6):
-            return value
-        if isinstance(value, tuple):
-            return ' '.join(map(self._str, value))
-        return str(value)
-
-    def assertEqual2(self, actual, expected, msg=None, eq=object.__eq__):
-        if eq(actual, expected):
-            return
-        self.assertEqual(actual, expected, msg)
-
-    def checkParam(self, widget, name, value, *, expected=_sentinel,
-                   conv=False, eq=None):
-        widget[name] = value
-        if expected is _sentinel:
-            expected = value
-        if conv:
-            expected = conv(expected)
-        if self._stringify or not self.wantobjects:
-            if isinstance(expected, tuple):
-                expected = tkinter._join(expected)
-            else:
-                expected = str(expected)
-        if eq is None:
-            eq = tcl_obj_eq
-        self.assertEqual2(widget[name], expected, eq=eq)
-        self.assertEqual2(widget.cget(name), expected, eq=eq)
-        t = widget.configure(name)
-        self.assertEqual(len(t), 5)
-        self.assertEqual2(t[4], expected, eq=eq)
-
-    def checkInvalidParam(self, widget, name, value, errmsg=None):
-        orig = widget[name]
-        if errmsg is not None:
-            errmsg = errmsg.format(value)
-        with self.assertRaises(tkinter.TclError) as cm:
-            widget[name] = value
-        if errmsg is not None:
-            self.assertEqual(str(cm.exception), errmsg)
-        self.assertEqual(widget[name], orig)
-        with self.assertRaises(tkinter.TclError) as cm:
-            widget.configure({name: value})
-        if errmsg is not None:
-            self.assertEqual(str(cm.exception), errmsg)
-        self.assertEqual(widget[name], orig)
-
-    def checkParams(self, widget, name, *values, **kwargs):
-        for value in values:
-            self.checkParam(widget, name, value, **kwargs)
-
-    def checkIntegerParam(self, widget, name, *values, **kwargs):
-        self.checkParams(widget, name, *values, **kwargs)
-        self.checkInvalidParam(widget, name, '',
-                errmsg='expected integer but got ""')
-        self.checkInvalidParam(widget, name, '10p',
-                errmsg='expected integer but got "10p"')
-        self.checkInvalidParam(widget, name, 3.2,
-                errmsg='expected integer but got "3.2"')
-
-    def checkFloatParam(self, widget, name, *values, conv=float, **kwargs):
-        for value in values:
-            self.checkParam(widget, name, value, conv=conv, **kwargs)
-        self.checkInvalidParam(widget, name, '',
-                errmsg='expected floating-point number but got ""')
-        self.checkInvalidParam(widget, name, 'spam',
-                errmsg='expected floating-point number but got "spam"')
-
-    def checkBooleanParam(self, widget, name):
-        for value in (False, 0, 'false', 'no', 'off'):
-            self.checkParam(widget, name, value, expected=0)
-        for value in (True, 1, 'true', 'yes', 'on'):
-            self.checkParam(widget, name, value, expected=1)
-        self.checkInvalidParam(widget, name, '',
-                errmsg='expected boolean value but got ""')
-        self.checkInvalidParam(widget, name, 'spam',
-                errmsg='expected boolean value but got "spam"')
-
-    def checkColorParam(self, widget, name, *, allow_empty=None, **kwargs):
-        self.checkParams(widget, name,
-                         '#ff0000', '#00ff00', '#0000ff', '#123456',
-                         'red', 'green', 'blue', 'white', 'black', 'grey',
-                         **kwargs)
-        self.checkInvalidParam(widget, name, 'spam',
-                errmsg='unknown color name "spam"')
-
-    def checkCursorParam(self, widget, name, **kwargs):
-        self.checkParams(widget, name, 'arrow', 'watch', 'cross', '',**kwargs)
-        self.checkParam(widget, name, 'none')
-        self.checkInvalidParam(widget, name, 'spam',
-                errmsg='bad cursor spec "spam"')
-
-    def checkCommandParam(self, widget, name):
-        def command(*args):
-            pass
-        widget[name] = command
-        self.assertTrue(widget[name])
-        self.checkParams(widget, name, '')
-
-    def checkEnumParam(self, widget, name, *values, errmsg=None, **kwargs):
-        self.checkParams(widget, name, *values, **kwargs)
-        if errmsg is None:
-            errmsg2 = ' %s "{}": must be %s%s or %s' % (
-                    name,
-                    ', '.join(values[:-1]),
-                    ',' if len(values) > 2 else '',
-                    values[-1])
-            self.checkInvalidParam(widget, name, '',
-                                   errmsg='ambiguous' + errmsg2)
-            errmsg = 'bad' + errmsg2
-        self.checkInvalidParam(widget, name, 'spam', errmsg=errmsg)
-
-    def checkPixelsParam(self, widget, name, *values,
-                         conv=None, **kwargs):
-        if conv is None:
-            conv = self._conv_pixels
-        for value in values:
-            expected = _sentinel
-            conv1 = conv
-            if isinstance(value, str):
-                if conv1 and conv1 is not str:
-                    expected = pixels_conv(value) * self.scaling
-                    conv1 = round
-            self.checkParam(widget, name, value, expected=expected,
-                            conv=conv1, **kwargs)
-        self.checkInvalidParam(widget, name, '6x',
-                errmsg='bad screen distance "6x"')
-        self.checkInvalidParam(widget, name, 'spam',
-                errmsg='bad screen distance "spam"')
-
-    def checkReliefParam(self, widget, name):
-        self.checkParams(widget, name,
-                         'flat', 'groove', 'raised', 'ridge', 'solid', 'sunken')
-        errmsg='bad relief "spam": must be '\
-               'flat, groove, raised, ridge, solid, or sunken'
-        if tcl_version < (8, 6):
-            errmsg = None
-        self.checkInvalidParam(widget, name, 'spam',
-                errmsg=errmsg)
-
-    def checkImageParam(self, widget, name):
-        image = tkinter.PhotoImage(master=self.root, name='image1')
-        self.checkParam(widget, name, image, conv=str)
-        self.checkInvalidParam(widget, name, 'spam',
-                errmsg='image "spam" doesn\'t exist')
-        widget[name] = ''
-
-    def checkVariableParam(self, widget, name, var):
-        self.checkParam(widget, name, var, conv=str)
-
-    def assertIsBoundingBox(self, bbox):
-        self.assertIsNotNone(bbox)
-        self.assertIsInstance(bbox, tuple)
-        if len(bbox) != 4:
-            self.fail('Invalid bounding box: %r' % (bbox,))
-        for item in bbox:
-            if not isinstance(item, int):
-                self.fail('Invalid bounding box: %r' % (bbox,))
-                break
-
-
-    def test_keys(self):
-        widget = self.create()
-        keys = widget.keys()
-        self.assertEqual(sorted(keys), sorted(widget.configure()))
-        for k in keys:
-            widget[k]
-        # Test if OPTIONS contains all keys
-        if test.support.verbose:
-            aliases = {
-                'bd': 'borderwidth',
-                'bg': 'background',
-                'fg': 'foreground',
-                'invcmd': 'invalidcommand',
-                'vcmd': 'validatecommand',
-            }
-            keys = set(keys)
-            expected = set(self.OPTIONS)
-            for k in sorted(keys - expected):
-                if not (k in aliases and
-                        aliases[k] in keys and
-                        aliases[k] in expected):
-                    print('%s.OPTIONS doesn\'t contain "%s"' %
-                          (self.__class__.__name__, k))
-
-
-class StandardOptionsTests:
-    STANDARD_OPTIONS = (
-        'activebackground', 'activeborderwidth', 'activeforeground', 'anchor',
-        'background', 'bitmap', 'borderwidth', 'compound', 'cursor',
-        'disabledforeground', 'exportselection', 'font', 'foreground',
-        'highlightbackground', 'highlightcolor', 'highlightthickness',
-        'image', 'insertbackground', 'insertborderwidth',
-        'insertofftime', 'insertontime', 'insertwidth',
-        'jump', 'justify', 'orient', 'padx', 'pady', 'relief',
-        'repeatdelay', 'repeatinterval',
-        'selectbackground', 'selectborderwidth', 'selectforeground',
-        'setgrid', 'takefocus', 'text', 'textvariable', 'troughcolor',
-        'underline', 'wraplength', 'xscrollcommand', 'yscrollcommand',
-    )
-
-    def test_configure_activebackground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'activebackground')
-
-    def test_configure_activeborderwidth(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'activeborderwidth',
-                              0, 1.3, 2.9, 6, -2, '10p')
-
-    def test_configure_activeforeground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'activeforeground')
-
-    def test_configure_anchor(self):
-        widget = self.create()
-        self.checkEnumParam(widget, 'anchor',
-                'n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw', 'center')
-
-    def test_configure_background(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'background')
-        if 'bg' in self.OPTIONS:
-            self.checkColorParam(widget, 'bg')
-
-    def test_configure_bitmap(self):
-        widget = self.create()
-        self.checkParam(widget, 'bitmap', 'questhead')
-        self.checkParam(widget, 'bitmap', 'gray50')
-        filename = test.support.findfile('python.xbm', subdir='imghdrdata')
-        self.checkParam(widget, 'bitmap', '@' + filename)
-        # Cocoa Tk widgets don't detect invalid -bitmap values
-        # See https://core.tcl.tk/tk/info/31cd33dbf0
-        if not ('aqua' in self.root.tk.call('tk', 'windowingsystem') and
-                'AppKit' in self.root.winfo_server()):
-            self.checkInvalidParam(widget, 'bitmap', 'spam',
-                    errmsg='bitmap "spam" not defined')
-
-    def test_configure_borderwidth(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'borderwidth',
-                              0, 1.3, 2.6, 6, -2, '10p')
-        if 'bd' in self.OPTIONS:
-            self.checkPixelsParam(widget, 'bd', 0, 1.3, 2.6, 6, -2, '10p')
-
-    def test_configure_compound(self):
-        widget = self.create()
-        self.checkEnumParam(widget, 'compound',
-                'bottom', 'center', 'left', 'none', 'right', 'top')
-
-    def test_configure_cursor(self):
-        widget = self.create()
-        self.checkCursorParam(widget, 'cursor')
-
-    def test_configure_disabledforeground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'disabledforeground')
-
-    def test_configure_exportselection(self):
-        widget = self.create()
-        self.checkBooleanParam(widget, 'exportselection')
-
-    def test_configure_font(self):
-        widget = self.create()
-        self.checkParam(widget, 'font',
-                        '-Adobe-Helvetica-Medium-R-Normal--*-120-*-*-*-*-*-*')
-        self.checkInvalidParam(widget, 'font', '',
-                               errmsg='font "" doesn\'t exist')
-
-    def test_configure_foreground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'foreground')
-        if 'fg' in self.OPTIONS:
-            self.checkColorParam(widget, 'fg')
-
-    def test_configure_highlightbackground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'highlightbackground')
-
-    def test_configure_highlightcolor(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'highlightcolor')
-
-    def test_configure_highlightthickness(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'highlightthickness',
-                              0, 1.3, 2.6, 6, '10p')
-        self.checkParam(widget, 'highlightthickness', -2, expected=0,
-                        conv=self._conv_pixels)
-
-    def test_configure_image(self):
-        widget = self.create()
-        self.checkImageParam(widget, 'image')
-
-    def test_configure_insertbackground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'insertbackground')
-
-    def test_configure_insertborderwidth(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'insertborderwidth',
-                              0, 1.3, 2.6, 6, -2, '10p')
-
-    def test_configure_insertofftime(self):
-        widget = self.create()
-        self.checkIntegerParam(widget, 'insertofftime', 100)
-
-    def test_configure_insertontime(self):
-        widget = self.create()
-        self.checkIntegerParam(widget, 'insertontime', 100)
-
-    def test_configure_insertwidth(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'insertwidth', 1.3, 2.6, -2, '10p')
-
-    def test_configure_jump(self):
-        widget = self.create()
-        self.checkBooleanParam(widget, 'jump')
-
-    def test_configure_justify(self):
-        widget = self.create()
-        self.checkEnumParam(widget, 'justify', 'left', 'right', 'center',
-                errmsg='bad justification "{}": must be '
-                       'left, right, or center')
-        self.checkInvalidParam(widget, 'justify', '',
-                errmsg='ambiguous justification "": must be '
-                       'left, right, or center')
-
-    def test_configure_orient(self):
-        widget = self.create()
-        self.assertEqual(str(widget['orient']), self.default_orient)
-        self.checkEnumParam(widget, 'orient', 'horizontal', 'vertical')
-
-    def test_configure_padx(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'padx', 3, 4.4, 5.6, -2, '12m',
-                              conv=self._conv_pad_pixels)
-
-    def test_configure_pady(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'pady', 3, 4.4, 5.6, -2, '12m',
-                              conv=self._conv_pad_pixels)
-
-    def test_configure_relief(self):
-        widget = self.create()
-        self.checkReliefParam(widget, 'relief')
-
-    def test_configure_repeatdelay(self):
-        widget = self.create()
-        self.checkIntegerParam(widget, 'repeatdelay', -500, 500)
-
-    def test_configure_repeatinterval(self):
-        widget = self.create()
-        self.checkIntegerParam(widget, 'repeatinterval', -500, 500)
-
-    def test_configure_selectbackground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'selectbackground')
-
-    def test_configure_selectborderwidth(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'selectborderwidth', 1.3, 2.6, -2, '10p')
-
-    def test_configure_selectforeground(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'selectforeground')
-
-    def test_configure_setgrid(self):
-        widget = self.create()
-        self.checkBooleanParam(widget, 'setgrid')
-
-    def test_configure_state(self):
-        widget = self.create()
-        self.checkEnumParam(widget, 'state', 'active', 'disabled', 'normal')
-
-    def test_configure_takefocus(self):
-        widget = self.create()
-        self.checkParams(widget, 'takefocus', '0', '1', '')
-
-    def test_configure_text(self):
-        widget = self.create()
-        self.checkParams(widget, 'text', '', 'any string')
-
-    def test_configure_textvariable(self):
-        widget = self.create()
-        var = tkinter.StringVar(self.root)
-        self.checkVariableParam(widget, 'textvariable', var)
-
-    def test_configure_troughcolor(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'troughcolor')
-
-    def test_configure_underline(self):
-        widget = self.create()
-        self.checkIntegerParam(widget, 'underline', 0, 1, 10)
-
-    def test_configure_wraplength(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'wraplength', 100)
-
-    def test_configure_xscrollcommand(self):
-        widget = self.create()
-        self.checkCommandParam(widget, 'xscrollcommand')
-
-    def test_configure_yscrollcommand(self):
-        widget = self.create()
-        self.checkCommandParam(widget, 'yscrollcommand')
-
-    # non-standard but common options
-
-    def test_configure_command(self):
-        widget = self.create()
-        self.checkCommandParam(widget, 'command')
-
-    def test_configure_indicatoron(self):
-        widget = self.create()
-        self.checkBooleanParam(widget, 'indicatoron')
-
-    def test_configure_offrelief(self):
-        widget = self.create()
-        self.checkReliefParam(widget, 'offrelief')
-
-    def test_configure_overrelief(self):
-        widget = self.create()
-        self.checkReliefParam(widget, 'overrelief')
-
-    def test_configure_selectcolor(self):
-        widget = self.create()
-        self.checkColorParam(widget, 'selectcolor')
-
-    def test_configure_selectimage(self):
-        widget = self.create()
-        self.checkImageParam(widget, 'selectimage')
-
-    def test_configure_tristateimage(self):
-        widget = self.create()
-        self.checkImageParam(widget, 'tristateimage')
-
-    def test_configure_tristatevalue(self):
-        widget = self.create()
-        self.checkParam(widget, 'tristatevalue', 'unknowable')
-
-    def test_configure_variable(self):
-        widget = self.create()
-        var = tkinter.DoubleVar(self.root)
-        self.checkVariableParam(widget, 'variable', var)
-
-
-class IntegerSizeTests:
-    def test_configure_height(self):
-        widget = self.create()
-        self.checkIntegerParam(widget, 'height', 100, -100, 0)
-
-    def test_configure_width(self):
-        widget = self.create()
-        self.checkIntegerParam(widget, 'width', 402, -402, 0)
-
-
-class PixelSizeTests:
-    def test_configure_height(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'height', 100, 101.2, 102.6, -100, 0, '3c')
-
-    def test_configure_width(self):
-        widget = self.create()
-        self.checkPixelsParam(widget, 'width', 402, 403.4, 404.6, -402, 0, '5i')
-
-
-def add_standard_options(*source_classes):
-    # This decorator adds test_configure_xxx methods from source classes for
-    # every xxx option in the OPTIONS class attribute if they are not defined
-    # explicitly.
-    def decorator(cls):
-        for option in cls.OPTIONS:
-            methodname = 'test_configure_' + option
-            if not hasattr(cls, methodname):
-                for source_class in source_classes:
-                    if hasattr(source_class, methodname):
-                        setattr(cls, methodname,
-                                getattr(source_class, methodname))
-                        break
-                else:
-                    def test(self, option=option):
-                        widget = self.create()
-                        widget[option]
-                        raise AssertionError('Option "%s" is not tested in %s' %
-                                             (option, cls.__name__))
-                    test.__name__ = methodname
-                    setattr(cls, methodname, test)
-        return cls
-    return decorator
-
-def setUpModule():
-    if test.support.verbose:
-        tcl = tkinter.Tcl()
-        print('patchlevel =', tcl.call('info', 'patchlevel'), flush=True)