Depending on the final fix, I might want to put the Windows fix in a separate function.
I will regular and IDLE news items when the patch is acceptable.

I'm currently not in favor of this approach: It adds quite a bit of "fragile" code to work around an issue on just one platform, though the issue is not platform-specific.

Given our limited resources, I'd rather that we help fix the core issue at its ogirin rather than implement workarounds.

I'm currently not in favor of this approach: It adds quite a bit of "fragile" code to work around an issue on just one platform, though the issue is not platform-specific.

I agree, given that this is a Windows-only fix and the problem is not just on Windows (I can also reproduce the issue on my Linux machine), it may be better to use a different approach. I feel it may be worth pointing out, however, that pyperclip's "copy_wsl" method (for example) also pipes to "clip.exe" to get content onto the clipboard.

I feel it may be worth pointing out, however, that pyperclip's "copy_wsl" method (for example) also pipes to "clip.exe" to get content onto the clipboard.

That's true, thanks for pointing that out!

I'm not saying that such an approach is unreasonable in general: it obviously does work. However, while implementing such support for many different platforms is in the domain of projects such as tcl/tk and pyperclip, IMO it would not be appropriate to add such code to IDLE or tkinter, as it would be a significant ongoing maintenance burden.

Using pyperclip seems like a no-go, as that would require bringing pyperclip into the stdlib, which I don't think would be acceptable, for much the same reason as above. Therefore, we're left with working out the core issue in tkinter and/or tcl/tk.

I'm closing this PR for now, as it seems this isn't a direction we're going to pursue, but it can be re-opened later if we change our minds.

Do you know what Windows system call clip uses? Can we access it via ctypes (as done near the top of pyshell for resolution settings)? Or do you know any other alternative to the current patch?

For "clip.exe", set the process creation flag DETACHED_PROCESS in order to avoid allocating a console. For example:

import os
import subprocess

clip_path = os.path.join(os.environ['SystemRoot'], 'System32', 'clip.exe')
p = subprocess.run('clip', executable=clip_path,
    creationflags=subprocess.DETACHED_PROCESS,
    input='spam & eggs', encoding='utf-16le')

Alternatively, here's a function I just wrote that copies Unicode text to the clipboard using ctypes:

import time
import ctypes
from ctypes import wintypes

kernel32 = ctypes.WinDLL('kernel32', use_last_error=True)
user32 = ctypes.WinDLL('user32', use_last_error=True)

GMEM_MOVEABLE = 0x0002
CF_UNICODETEXT = 13

kernel32.GlobalAlloc.restype = wintypes.HGLOBAL
kernel32.GlobalFree.argtypes = (wintypes.HGLOBAL,)
kernel32.GlobalLock.restype = wintypes.LPVOID
kernel32.GlobalLock.argtypes = (wintypes.HGLOBAL,)
kernel32.GlobalUnlock.argtypes = (wintypes.HGLOBAL,)
user32.SetClipboardData.restype = wintypes.HANDLE
user32.SetClipboardData.argtypes = (wintypes.UINT, wintypes.HANDLE)

def text2clip(text):
    """Copy text to the clipboard."""
    # OpenClipboard fails with ERROR_ACCESS_DENIED if the clipboard
    # is owned by a window, so retry every 100 ms for a second.
    i = 0
    while not user32.OpenClipboard(None):
        i += 1
        if i > 9:
            raise ctypes.WinError(ctypes.get_last_error())
        time.sleep(0.1)
    try:
        if not user32.EmptyClipboard():
            raise ctypes.WinError(ctypes.get_last_error())
        text_array_t = ctypes.c_wchar * (len(text) + 1)
        hMem = kernel32.GlobalAlloc(GMEM_MOVEABLE, 
            ctypes.sizeof(text_array_t))
        if not hMem:
            raise ctypes.WinError(ctypes.get_last_error())
        pMem = kernel32.GlobalLock(hMem)
        text_array_t.from_address(pMem).value = text
        kernel32.GlobalUnlock(hMem)
        if not user32.SetClipboardData(CF_UNICODETEXT, hMem):
            kernel32.GlobalFree(hMem)
            raise ctypes.WinError(ctypes.get_last_error())
        # now the system owns hMem
    finally:
        user32.CloseClipboard()

@eryksun Thank you. It turns out that the problem also exists on Linux and macOS, so I will try harder with a cross-platform solution using tkinter.