def runTclFiles(tclFile, dump):
os.chdir(".\Testing")
r = tk.Tcl()
if dump:
r.eval('source ' + tclFile + '1')
else:
r.eval('source ' + tclFile)
def test_tkinter_lib():
try:
from PIL import Image
from svglib.svglib import svg2rlg
from reportlab.graphics import renderPM
import PySimpleGUI as sg
import re
except Exception:
print(
"\n!!!!! Looks like you are missing required python packages. Please look at requirements.txt !!!!"
)
exit(1)
try:
import tkinter
tkinter_version = tkinter.Tcl().eval('info patchlevel')
print("Installed tkinter_version: %s \n %s" %
(tkinter_version, "-" * 100))
print('Opening test window. Click on "Quit" to run further tests')
tkinter._test()
except Exception:
print(
"\n!!!!! Looks like you are missing required 'tkinter' python package !!!!"
)
print("Try installing looking at following resources:")
print("1. https://tkdocs.com/tutorial/install.html#install-win-python")
print(
"2. https://stackoverflow.com/questions/25905540/importerror-no-module-named-tkinter"
)
print()
exit(1)
def __init__(self,url, type, id, window, old_root, frame, path=None, exptype=None):
logger.setLevel(_logging.INFO)
stream_handler = _logging.StreamHandler()
formatter = _logging.Formatter("[%(filename)s] %(message)s")
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.info("CEF Python {ver}".format(ver=cef.__version__))
logger.info("Python {ver} {arch}".format(
ver=platform.python_version(), arch=platform.architecture()[0]))
logger.info("Tk {ver}".format(ver=tk.Tcl().eval('info patchlevel')))
assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this"
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
self.root = tk.Toplevel()
sw, sh = self.root.winfo_screenwidth(), self.root.winfo_screenheight()
app = MainFrame(self.root, url, type, id, window, old_root, frame)
rec = None
if exptype == "gsr":
rec = gsr.Record()
rec.on_rec(path)
# Tk must be initialized before CEF otherwise fatal error (Issue #306)
cef.Initialize()
t1 = threading.Thread(target=app.browser_frame.mainloop())
t1.start()
cef.Shutdown()
def __init__(self):
self.verbose = False
# when python is initialized inside slicer there is no argv
# so create a fake one if needed
try:
argv0 = sys.argv[0]
except AttributeError:
sys.argv = []
sys.argv.append("")
self.tcl = tkinter.Tcl()
self.tcl.createcommand("py_eval", self.py_eval)
self.tcl.createcommand("py_package", self.py_package)
self.tcl.createcommand("py_type", self.py_type)
self.tcl.createcommand("py_del", self.py_del)
self.tcl.createcommand("py_puts", self.py_puts)
self.tcl.createcommand("py_after", self.py_after)
self.tcl.createcommand("py_vtkInstanceName", self.py_vtkInstanceName)
self.timer = qt.QTimer()
self.timer.setSingleShot(True)
self.timer.setInterval(0)
self.timer.connect('timeout()', self.after_callback)
if sys.platform == 'win32':
# Update environment variables set by application - unlike other platforms,
# on windows this does not happen automatically so we do it here
# Note that subsequent env changes will not be reflected
for key in os.environ.keys():
self.tcl_putenv(key, os.environ[key])
# This path is Slicer-specific
self.tcl.eval('source "%s/bin/Python/tpycl/tpycl.tcl"' %
slicer.app.slicerHome)
def main():
logger.setLevel(_logging.INFO)
stream_handler = _logging.StreamHandler()
formatter = _logging.Formatter("[%(filename)s] %(message)s")
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.info("CEF Python {ver}".format(ver=cef.__version__))
logger.info("Python {ver} {arch}".format(ver=platform.python_version(),
arch=platform.architecture()[0]))
logger.info("Tk {ver}".format(ver=tk.Tcl().eval('info patchlevel')))
assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this"
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
root = tk.Tk()
app = MainFrame(root)
#app.get_browser().load_url(r"C:\Users\mani\AppData\Local\Temp\tmp9yiyyzeq.html")
#app.browser = cef.CreateBrowserSync(cef.WindowInfo(),
# url=self.html_text)
#print(type(app))
#app.set_url(r"C:\Users\mani\AppData\Local\Temp\tmp9yiyyzeq.html")
#app.LoadUrl()
# Tk must be initialized before CEF otherwise fatal error (Issue #306)
cef.Initialize()
#app.get_browser()LoadUrl(r"C:\Users\mani\AppData\Local\Temp\tmp9yiyyzeq.html")
app.mainloop()
cef.Shutdown()
def on_closing(self, event=0):
if sys.platform == "darwin": # macOS
if Version(tkinter.Tcl().call("info", "patchlevel")) >= Version("8.6.9"): # Tcl/Tk >= 8.6.9
os.system("defaults delete -g NSRequiresAquaSystemAppearance") # turn off dark mode for all apps
self.destroy()
self.running = False
exit()
def disable_macos_dark_title_bar():
if sys.platform == "darwin" and not Settings.deactivate_macos_window_header_manipulation: # macOS
if Version(platform.python_version()) < Version("3.10"):
if Version(tkinter.Tcl().call(
"info",
"patchlevel")) >= Version("8.6.9"): # Tcl/Tk >= 8.6.9
os.system(
"defaults delete -g NSRequiresAquaSystemAppearance")
def snack_raw_pitch_python(wav_fn, frame_shift, window_size, max_pitch, min_pitch):
"""Implement snack_raw_pitch() by calling Snack through Python's tkinter
library
Note this method can only be used if the user's machine is setup, so that
Tcl/Tk can be accessed through Python's tkinter library.
The vectors returned here are the raw Snack output, without padding.
For more info, see documentation for snack_raw_pitch().
"""
try:
import tkinter
except ImportError:
try:
import Tkinter as tkinter
except ImportError: # pragma: no cover
print("Need Python library tkinter. Is it installed?")
# HACK: Need to replace single backslash with two backslashes,
# so that the Tcl shell reads the file path correctly on Windows
if sys.platform == 'win32' or sys.platform == 'cygwin': # pragma: no cover
wav_fn = wav_fn.replace('\\', '\\\\')
# XXX I'm assuming Hz for pitch; the docs don't actually say that.
# http://www.speech.kth.se/snack/man/snack2.2/tcl-man.html#spitch
tcl = tkinter.Tcl()
try:
# XXX This will trigger a message 'cannot open /dev/mixer' on the
# console if you don't have a /dev/mixer. You don't *need* a mixer to
# snack the way we are using it, but there's no practical way to
# suppress the message without modifying the snack source. Fortunately
# most people running opensauce will in fact have a /dev/mixer.
tcl.eval('package require snack')
except tkinter.TclError as err: # pragma: no cover
log.critical('Cannot load snack (is it installed?): %s', err)
return
tcl.eval('snack::sound s')
tcl.eval('s read {}'.format(wav_fn))
cmd = ['s pitch -method esps']
cmd.extend(['-framelength {}'.format(frame_shift / 1000)])
cmd.extend(['-windowlength {}'.format(window_size / 1000)])
cmd.extend(['-maxpitch {}'.format(max_pitch)])
cmd.extend(['-minpitch {}'.format(min_pitch)])
# Run Snack pitch command
tcl.eval('set data [{}]'.format(' '.join(cmd)))
# XXX check for errors here and log and abort if there is one. Result
# string will start with ERROR:.
# Collect results and save in return variables
num_frames = int(tcl.eval('llength $data'))
F0_raw = np.empty(num_frames)
V_raw = np.empty(num_frames)
# snack returns four values per frame, we only care about the first two.
for i in range(num_frames):
values = tcl.eval('lindex $data ' + str(i)).split()
F0_raw[i] = np.float_(values[0])
V_raw[i] = np.float_(values[1])
return F0_raw, V_raw
def __init__(self, gtkw: str, hierarchy):
self.gtkw = gtkw
self.used_signals = set() # type: Set[str]
self.hierarchy = hierarchy
# set up TCL
tcl = tkinter.Tcl()
self.tcl = tcl
tcl.createcommand("add", self.tcl_add)
tcl.createcommand('quietly', self.tcl_quietly)
def __init__(self):
"""Initialize IXNET members
"""
super().__init__()
self._tclsh = tkinter.Tcl()
self._script = None
self._cfg = None
self._logger = logging.getLogger(__name__)
self._params = None
self._bidir = None
def __init__(self):
"""Initialize IXNET members
"""
super().__init__()
self._script = os.path.join(
settings.getValue('TRAFFICGEN_IXIA_3RD_PARTY'),
settings.getValue('TRAFFICGEN_IXNET_TCL_SCRIPT'))
self._tclsh = tkinter.Tcl()
self._cfg = None
self._logger = logging.getLogger(__name__)
self._params = None
self._bidir = None
def on_closing(self, event=0):
if sys.platform == "darwin": # macOS
if Version(tkinter.Tcl().call(
"info",
"patchlevel")) >= Version("8.6.9"): # Tcl/Tk >= 8.6.9
os.system("defaults delete -g NSRequiresAquaSystemAppearance"
) # Only for dark-mode testing!
# This command reverts the dark-mode setting for all programs.
self.audio_analyzer.running = False
self.play_sound_thread.running = False
self.destroy()
def __init__(self, config, opts):
"""Initializes connection to IxLoad.
Args:
config(dict): IxLoad related part of environment configuration
opts(OptionParser): py.test config.option object which contains all py.test cli options
"""
self.__opts = opts
self.__config = config
import tkinter
self.tcl_interpret = tkinter.Tcl()
def tcl_puts(*args):
if len(args) >= 2:
stream = args[0]
if stream == "stdout":
self.class_logger.debug(" ".join(args[1:]))
elif stream == "stderr":
self.class_logger.error(" ".join(args[1:]))
else:
self.class_logger.debug("stream <%s>: %s" %
(args[0], " ".join(args[1:])))
elif len(args) == 1:
self.class_logger.debug(args[0])
else:
self.class_logger.error("Called puts without arguments.")
return None
self.tcl_interpret.createcommand("tcl_puts", tcl_puts)
self.class_logger.debug("Insert tcl script to catch puts output.")
ixia_helpers.tcl_puts_replace(self.tcl_interpret)
self.id = config['id']
self.type = config['instance_type']
self.ixload_ip = config['ixload_ip']
self.ixload_user = config['ixload_user']
self.ports = config['ports']
self.ixload_tmppath = "C:\\Users\\{0}\\AppData\\Local\\Temp\\".format(
self.ixload_user)
self.ixload_respath = "C:\\IxLoadWD\\"
self.__log_name = "TAF-{0}-{1}-{2}".format(os.uname()[1], os.getuid(),
int(time.time()))
ixia_helpers.ixtclhal_import(self.tcl_interpret)
ixia_helpers.ixload_import(self.tcl_interpret)
self.qt = None
self.tst = None
self.repo_file = None
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = tkinter.Tcl()
patchlevel = []
for x in tcl.call('info', 'patchlevel').split('.'):
try:
x = int(x, 10)
except ValueError:
x = -1
patchlevel.append(x)
_tk_patchlevel = tuple(patchlevel)
return _tk_patchlevel
def get_tk_patchlevel():
global _tk_patchlevel
if _tk_patchlevel is None:
tcl = tkinter.Tcl()
patchlevel = tcl.call('info', 'patchlevel')
m = re.fullmatch('(\\d+)\\.(\\d+)([ab.])(\\d+)', patchlevel)
major, minor, releaselevel, serial = m.groups()
major, minor, serial = int(major), int(minor), int(serial)
releaselevel = {'a': 'alpha', 'b': 'beta', '.': 'final'}[releaselevel]
if releaselevel == 'final':
_tk_patchlevel = major, minor, serial, releaselevel, 0
else:
_tk_patchlevel = major, minor, 0, releaselevel, serial
return _tk_patchlevel
def __init__(self, *args, **kwargs):
super(BoardTests, self).__init__(*args, **kwargs)
# initialize tkinter
tk.Tcl()
# prevent __add_sprite from getting called as
# tkinter is not initialized
Board.DISABLE_SPRITE_MANAGER = True
# Make up board with no holes
self.__hole_board1 = Board.min_oft_and_holes(4, [(2, 3), (1, 2)])
self.__no_hole_board1 = Board.min_oft_and_holes(4, [])
self.__homogeneous_board1 = Board.homogeneous(2, 10, 5)
def exposed_new_tcl_interpreter(self, key, *args, **kwargs):
global tcl_archive
print(f"{PORT}> client adding tcl interpreter: {key}")
interpreter = tkinter.Tcl()
#if key in tcl_archive:
# try:
# del tcl_archive[key]
# except Exception as e:
# print(f"Exception: {e}")
tcl_archive[key] = interpreter
print(f"Tcl intrep: {interpreter} {type(interpreter)}")
x = interpreter.eval("puts \"===\"")
print(type(x))
return interpreter
def __init__(self, ipaddr, user):
"""Initializes connection to IxLoad.
Args:
ipaddr(str): IxLoad host IP address.
user(str): IxLoad windows user.
"""
import tkinter
self.tcl_interpret = tkinter.Tcl()
def tcl_puts(*args):
if len(args) >= 2:
stream = args[0]
if stream == "stdout":
self.class_logger.debug(" ".join(args[1:]))
elif stream == "stderr":
self.class_logger.error(" ".join(args[1:]))
else:
self.class_logger.debug("stream <%s>: %s" %
(args[0], " ".join(args[1:])))
elif len(args) == 1:
self.class_logger.debug(args[0])
else:
self.class_logger.error("Called puts without arguments.")
return None
self.tcl_interpret.createcommand("tcl_puts", tcl_puts)
self.class_logger.debug("Insert tcl script to catch puts output.")
ixia_helpers.tcl_puts_replace(self.tcl_interpret)
self.ixload_ip = ipaddr
self.ixload_user = user
# Temp path for sending rxf files to IxLoad
self.ixload_tmppath = "C:\\Users\\{0}\\AppData\\Local\\Temp\\".format(
self.ixload_user)
# Path for storing test csv reports. It could be override in child IxLoadHL class.
self.ixload_respath = self.ixload_tmppath
self.__log_name = "IxLoadTclAPI-{0}-{1}-{2}".format(
os.uname()[1], os.getuid(), int(time.time()))
self.ixload_logpath = None
ixia_helpers.ixtclhal_import(self.tcl_interpret)
ixia_helpers.ixload_import(self.tcl_interpret)
self.test_controller = None
self.tst = None
def main():
logger.setLevel(_logging.INFO)
stream_handler = _logging.StreamHandler()
formatter = _logging.Formatter("[%(filename)s] %(message)s")
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.info("CEF Python {ver}".format(ver=cef.__version__))
logger.info("Python {ver}".format(ver=sys.version[:6]))
logger.info("Tk {ver}".format(ver=tk.Tcl().eval('info patchlevel')))
assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this"
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
root = tk.Tk()
app = MainFrame(root)
# Tk must be initialized before CEF otherwise fatal error (Issue #306)
cef.Initialize()
app.mainloop()
cef.Shutdown()
def collect_tkinter(info_add):
try:
import _tkinter
except ImportError:
pass
else:
attributes = ('TK_VERSION', 'TCL_VERSION')
copy_attributes(info_add, _tkinter, 'tkinter.%s', attributes)
try:
import tkinter
except ImportError:
pass
else:
tcl = tkinter.Tcl()
patchlevel = tcl.call('info', 'patchlevel')
info_add('tkinter.info_patchlevel', patchlevel)
def _main(self):
""" Method: module loop waiting for module event """
MCS.append_log("Module Started")
try:
# Load TCL part
self.tcl_interpreter = tkinter.Tcl()
for script in self.load_list:
self.tcl_interpreter.eval("source {:.50s}/{:.50s}".format(
"modules/" + self.__class__.__name__, script))
except Exception as e:
MCS.append_log(
"{:.100s} Need to reboot... Exception: {:.100s}".format(
self.name, str(e)))
traceback.print_exc()
print("[" + self.name + "] Can't Load source !")
super(TclModule, self)._main()
return
def launch_browser(url, type):
logger.setLevel(_logging.INFO)
stream_handler = _logging.StreamHandler()
formatter = _logging.Formatter("[%(filename)s] %(message)s")
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.info("CEF Python {ver}".format(ver=cef.__version__))
logger.info("Python {ver} {arch}".format(ver=platform.python_version(),
arch=platform.architecture()[0]))
logger.info("Tk {ver}".format(ver=tk.Tcl().eval('info patchlevel')))
assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this"
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
root = tk.Toplevel()
root.state("zoomed")
app = MainFrame(root, url, type)
# Tk must be initialized before CEF otherwise fatal error (Issue #306)
cef.Initialize()
app.mainloop()
cef.Shutdown()
def main():
logger.setLevel(_logging.DEBUG)
stream_handler = _logging.StreamHandler()
formatter = _logging.Formatter("[%(filename)s] %(message)s")
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.info("CEF Python {ver}".format(ver=cef.__version__))
logger.info("Python {ver} {arch}".format(
ver=platform.python_version(), arch=platform.architecture()[0]))
logger.info("Tk {ver}".format(ver=tk.Tcl().eval('info patchlevel')))
assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this"
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
# Tk must be initialized before CEF otherwise fatal error (Issue #306)
root = tk.Tk()
app = MainFrame(root)
settings = {}
if MAC:
settings["external_message_pump"] = True
cef.Initialize(settings=settings)
app.mainloop()
logger.debug("Main loop exited")
cef.Shutdown()
def _add_info_box(self, frame):
self._text = richtext.RichText(frame, height=10, scroll="v")
self._text.grid(row=0, column=0, padx=1, pady=1, sticky=tk.NSEW)
self._text.add_text(_text["plat"].format(sys.platform))
self._text.add_text(_text["tcl"].format(
tk.Tcl().eval('info patchlevel')))
self._text.add_text(_text["pyplat"].format(sys.implementation))
self._text.add_text(_text["pyroot"].format(sys.base_prefix))
self._text.add_text(_text["np"].format(np.__version__))
self._text.add_text(_text["scipy"].format(scipy.__version__))
if gpd is not None:
self._text.add_text(_text["gpd"].format(gpd.__version__))
else:
self._text.add_text(_text["gpd_none"])
if pyproj is not None:
self._text.add_text(_text["pyproj"].format(pyproj.__version__))
else:
self._text.add_text(_text["pyproj_none"])
if tilemapbase is not None:
self._text.add_text(_text["tilemapbase"].format(
tilemapbase.__version__))
else:
self._text.add_text(_text["tilemapbase_none"])
def execute_hammer_command(hammername, commandpath, hammercommand):
count = 0
tcl = tkinter.Tcl()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(90.0)
#Bind socket to local host and port
try:
s.bind(("0.0.0.0", 8888))
except socket.error as msg:
print('Bind failed. Error Code : ' + str(msg[0]) + ' Message ' +
msg[1])
sys.exit()
print('Socket bind complete')
s.listen(4)
construct_request(commandpath + "\\" + hammercommand)
result = tcl.eval('source {' + commandpath + '\\hcmd.tcl}')
for key, value in channels.items():
commandline = "start script -mc " + hammername + " -h " + hammername + " -c " + key + " -n " + "C:\\Automation\\Test\\Trunk\\Regression\\" + value[
0] + " -i " + value[1]
#print("Sending command: " + commandline + "\n")
result = tcl.eval('hcmdmain {%s}' % commandline)
while count < len(channels):
c, addr = s.accept()
print_lock.acquire()
count += 1
print('Connection:' + str(count) + ' <<<<< ' + addr[0] + ':' +
str(addr[1]))
threading.Thread(target=get_result, args=(c, addr)).start()
s.close()
def gp_mp(x_pn): # (m)ake (p)ath
if not gf_id(x_pn): os.makedirs(x_pn)
def gp_ep(x_pn): # (e)mpty out (p)ath
if not gf_id(x_pn): return
pu_pn, pu_ons, pu_bns = next(os.walk(x_pn))
for bu2_on in pu_ons:
bu2_pn = gf_pj(pu_pn, bu2_on)
gp_rt(bu2_pn)
for bu2_bn in pu_bns:
bu2_fn = gf_pj(pu_pn, bu2_bn)
gp_ul(bu2_fn)
GC_TCL = tkinter.Tcl()
GC_TCL.eval("""
proc gf_tcl_ver {} {
return [info tclversion]
}
proc gf_run_xcmd {args} {
set fu_ec [ catch { set fu_result [ exec {*}$args ] } fu_error ]
if { $fu_ec } {
return [ list $fu_ec $fu_error ]
}
return [ list $fu_ec $fu_result ]
}
proc gf_il {x_it} { # (i)s (l)ink
return [ expr { [file type $x_it] eq "link" } ]
}
proc gp_ml { x_link x_target } { # (m)ake (l)ink
def capture_warnings(capture):
"Replace warning.showwarning with idle_showwarning_subproc, or reverse."
global _warnings_showwarning
if capture:
if _warnings_showwarning is None:
_warnings_showwarning = warnings.showwarning
warnings.showwarning = idle_showwarning_subproc
else:
if _warnings_showwarning is not None:
warnings.showwarning = _warnings_showwarning
_warnings_showwarning = None
capture_warnings(True)
tcl = tkinter.Tcl()
def handle_tk_events(tcl=tcl):
"""Process any tk events that are ready to be dispatched if tkinter
has been imported, a tcl interpreter has been created and tk has been
loaded."""
tcl.eval("update")
# Thread shared globals: Establish a queue between a subthread (which handles
# the socket) and the main thread (which runs user code), plus global
# completion, exit and interruptable (the main thread) flags:
exit_now = False
quitting = False
interruptable = False
import os
import sys
import platform
import json
import threading
from timeit import default_timer as timer
# print version, exit if minimum version requirements aren't met
if sys.hexversion < 0x03060000: # Trying to import tkinter in the new syntax after python 2 causes a crash
sys.exit("Python 3.6 or greater is required to run this program.")
print("Using Python {}.{}".format(sys.version_info[0], sys.version_info[1]))
version_string = f"Appstore Workbench {version}"
# This is called before the below module imports to ensure no exception is
# encountered trying to import tk
try:
import tkinter as tk
print("Using tkinter version {}".format(tk.Tcl().eval('info patchlevel')))
except:
sys.exit(
"Cannot start: Tkinter not installed, consult the readme for more information."
)
try:
TKVERSION = float(tk.Tcl().eval('info patchlevel')[0:3])
except Exception as e:
TKVERSION = 0
print("Failed to get tkinter version ~ {}".format(e))
print(TKVERSION)
# This is called before the below module imports to ensure no exception is
# encountered trying to import pil
try:
if browser.CanGoForward():
if self.forward_state != tk.NORMAL:
self.forward_button.config(state=tk.NORMAL)
self.forward_state = tk.NORMAL
else:
if self.forward_state != tk.DISABLED:
self.forward_button.config(state=tk.DISABLED)
self.forward_state = tk.DISABLED
self.after(100, self.update_state)
if __name__ == '__main__':
logger.setLevel(_logging.INFO)
stream_handler = _logging.StreamHandler()
formatter = _logging.Formatter("[%(filename)s] %(message)s")
stream_handler.setFormatter(formatter)
logger.addHandler(stream_handler)
logger.info("CEF Python {ver}".format(ver=cef.__version__))
logger.info("Python {ver} {arch}".format(ver=platform.python_version(),
arch=platform.architecture()[0]))
logger.info("Tk {ver}".format(ver=tk.Tcl().eval('info patchlevel')))
assert cef.__version__ >= "55.3", "CEF Python v55.3+ required to run this"
sys.excepthook = cef.ExceptHook # To shutdown all CEF processes on error
root = tk.Tk()
app = MainFrame(root)
# Tk must be initialized before CEF otherwise fatal error (Issue #306)
cef.Initialize()
app.mainloop()
cef.Shutdown()
def setUpModule():
if test.support.verbose:
tcl = tkinter.Tcl()
print('patchlevel =', tcl.call('info', 'patchlevel'))
