def start_jupyter(self, args):
"""Start Jupyter with the Coconut kernel."""
install_func = partial(run_cmd, show_output=logger.verbose)
try:
install_func(["jupyter", "--version"])
except CalledProcessError:
jupyter = "ipython"
else:
jupyter = "jupyter"
# always install kernels if given no args, otherwise only if there's a kernel missing
do_install = not args
if not do_install:
kernel_list = run_cmd([jupyter, "kernelspec", "list"],
show_output=False,
raise_errs=False)
do_install = any(ker not in kernel_list
for ker in icoconut_kernel_names)
if do_install:
success = True
for icoconut_kernel_dir in icoconut_kernel_dirs:
install_args = [
jupyter, "kernelspec", "install", icoconut_kernel_dir,
"--replace"
]
try:
install_func(install_args)
except CalledProcessError:
user_install_args = install_args + ["--user"]
try:
install_func(user_install_args)
except CalledProcessError:
logger.warn("kernel install failed on command'",
" ".join(install_args))
self.register_error(errmsg="Jupyter error")
success = False
if success:
logger.show_sig(
"Successfully installed Coconut Jupyter kernel.")
if args:
if args[0] == "console":
ver = "2" if PY2 else "3"
try:
install_func(
["python" + ver, "-m", "coconut.main", "--version"])
except CalledProcessError:
kernel_name = "coconut"
else:
kernel_name = "coconut" + ver
run_args = [jupyter, "console", "--kernel", kernel_name
] + args[1:]
else:
run_args = [jupyter] + args
self.register_error(run_cmd(run_args, raise_errs=False),
errmsg="Jupyter error")
def site_uninstall(self):
"""Remove Coconut's pth file from site-packages."""
python_lib = self.get_python_lib()
pth_file = os.path.join(python_lib, os.path.basename(coconut_pth_file))
if os.path.isfile(pth_file):
os.remove(pth_file)
logger.show_sig("Removed %s from %s." % (os.path.basename(coconut_pth_file), python_lib))
else:
raise CoconutException("failed to find %s file to remove" % (os.path.basename(coconut_pth_file),))
def start_jupyter(self, args):
"""Start Jupyter with the Coconut kernel."""
install_func = partial(run_cmd, show_output=logger.verbose)
try:
install_func(["jupyter", "--version"])
except CalledProcessError:
jupyter = "ipython"
else:
jupyter = "jupyter"
# always install kernels if given no args, otherwise only if there's a kernel missing
do_install = not args
if not do_install:
kernel_list = run_cmd([jupyter, "kernelspec", "list"], show_output=False, raise_errs=False)
do_install = any(ker not in kernel_list for ker in icoconut_kernel_names)
if do_install:
success = True
for icoconut_kernel_dir in icoconut_kernel_dirs:
install_args = [jupyter, "kernelspec", "install", icoconut_kernel_dir, "--replace"]
try:
install_func(install_args)
except CalledProcessError:
user_install_args = install_args + ["--user"]
try:
install_func(user_install_args)
except CalledProcessError:
logger.warn("kernel install failed on command'", " ".join(install_args))
self.register_error(errmsg="Jupyter error")
success = False
if success:
logger.show_sig("Successfully installed Coconut Jupyter kernel.")
if args:
if args[0] == "console":
ver = "2" if PY2 else "3"
try:
install_func(["python" + ver, "-m", "coconut.main", "--version"])
except CalledProcessError:
kernel_name = "coconut"
else:
kernel_name = "coconut" + ver
run_args = [jupyter, "console", "--kernel", kernel_name] + args[1:]
else:
run_args = [jupyter] + args
self.register_error(run_cmd(run_args, raise_errs=False), errmsg="Jupyter error")
def input(self, more=False):
"""Prompt for code input."""
sys.stdout.flush()
if more:
msg = more_prompt
else:
msg = main_prompt
if self.style is not None:
internal_assert(prompt_toolkit is not None, "without prompt_toolkit cannot highlight style", self.style)
try:
return self.prompt(msg)
except EOFError:
raise # issubclass(EOFError, Exception), so we have to do this
except (Exception, AssertionError):
logger.display_exc()
logger.show_sig("Syntax highlighting failed; switching to --style none.")
self.style = None
return input(msg)
def install_default_jupyter_kernels(self, jupyter, kernel_list):
"""Install icoconut default kernels."""
logger.show_sig("Installing Jupyter kernels '" + "', '".join(icoconut_default_kernel_names) + "'...")
overall_success = True
for old_kernel_name in icoconut_old_kernel_names:
if old_kernel_name in kernel_list:
success = self.remove_jupyter_kernel(jupyter, old_kernel_name)
overall_success = overall_success and success
for kernel_dir in icoconut_default_kernel_dirs:
success = self.install_jupyter_kernel(jupyter, kernel_dir)
overall_success = overall_success and success
if overall_success:
return icoconut_default_kernel_names
else:
return []
def watch(self, source, write=True, package=None, run=False, force=False):
"""Watch a source and recompiles on change."""
from coconut.command.watch import Observer, RecompilationWatcher
source = fixpath(source)
logger.show()
logger.show_tabulated("Watching", showpath(source),
"(press Ctrl-C to end)...")
def recompile(path):
path = fixpath(path)
if os.path.isfile(path) and os.path.splitext(path)[1] in code_exts:
with self.handling_exceptions():
if write is True or write is None:
writedir = write
else:
# correct the compilation path based on the relative position of path to source
dirpath = os.path.dirname(path)
writedir = os.path.join(
write, os.path.relpath(dirpath, source))
filepaths = self.compile_path(path,
writedir,
package,
run,
force,
show_unchanged=False)
self.run_mypy(filepaths)
watcher = RecompilationWatcher(recompile)
observer = Observer()
observer.schedule(watcher, source, recursive=True)
with self.running_jobs():
observer.start()
try:
while True:
time.sleep(watch_interval)
watcher.keep_watching()
except KeyboardInterrupt:
logger.show_sig("Got KeyboardInterrupt; stopping watcher.")
finally:
observer.stop()
observer.join()
def watch(self, source, write=True, package=None, run=False, force=False):
"""Watch a source and recompiles on change."""
from coconut.command.watch import Observer, RecompilationWatcher
source = fixpath(source)
logger.show()
logger.show_tabulated("Watching", showpath(source), "(press Ctrl-C to end)...")
def recompile(path):
path = fixpath(path)
if os.path.isfile(path) and os.path.splitext(path)[1] in code_exts:
with self.handling_exceptions():
if write is True or write is None:
writedir = write
else:
# correct the compilation path based on the relative position of path to source
dirpath = os.path.dirname(path)
writedir = os.path.join(write, os.path.relpath(dirpath, source))
filepaths = self.compile_path(path, writedir, package, run, force, show_unchanged=False)
self.run_mypy(filepaths)
watcher = RecompilationWatcher(recompile)
observer = Observer()
observer.schedule(watcher, source, recursive=True)
with self.running_jobs():
observer.start()
try:
while True:
time.sleep(watch_interval)
watcher.keep_watching()
except KeyboardInterrupt:
logger.show_sig("Got KeyboardInterrupt; stopping watcher.")
finally:
observer.stop()
observer.join()
def set_mypy_args(self, mypy_args=None):
"""Set MyPy arguments."""
if mypy_args is None:
self.mypy_args = None
elif mypy_install_arg in mypy_args:
if mypy_args != [mypy_install_arg]:
raise CoconutException("'--mypy install' cannot be used alongside other --mypy arguments")
stub_dir = set_mypy_path()
logger.show_sig("Successfully installed MyPy stubs into " + repr(stub_dir))
self.mypy_args = None
else:
self.mypy_args = list(mypy_args)
if not any(arg.startswith("--python-version") for arg in self.mypy_args):
self.mypy_args += [
"--python-version",
ver_tuple_to_str(get_target_info_smart(self.comp.target, mode="mypy")),
]
if not any(arg.startswith("--python-executable") for arg in self.mypy_args):
self.mypy_args += [
"--python-executable",
sys.executable,
]
add_mypy_args = default_mypy_args + (verbose_mypy_args if logger.verbose else ())
for arg in add_mypy_args:
no_arg = invert_mypy_arg(arg)
arg_prefixes = (arg,) + ((no_arg,) if no_arg is not None else ())
if not any(arg.startswith(arg_prefixes) for arg in self.mypy_args):
self.mypy_args.append(arg)
logger.log("MyPy args:", self.mypy_args)
self.mypy_errs = []
def site_install(self):
"""Add Coconut's pth file to site-packages."""
python_lib = self.get_python_lib()
shutil.copy(coconut_pth_file, python_lib)
logger.show_sig("Added %s to %s." % (os.path.basename(coconut_pth_file), python_lib))
def start_jupyter(self, args):
"""Start Jupyter with the Coconut kernel."""
# get the correct jupyter command
for jupyter in (
[sys.executable, "-m", "jupyter"],
[sys.executable, "-m", "ipython"],
["jupyter"],
):
try:
self.run_silent_cmd(jupyter + ["--help"]) # --help is much faster than --version
except CalledProcessError:
logger.warn("failed to find Jupyter command at " + repr(" ".join(jupyter)))
else:
break
# get a list of installed kernels
kernel_list = self.get_jupyter_kernels(jupyter)
newly_installed_kernels = []
# always update the custom kernel, but only reinstall it if it isn't already there or given no args
custom_kernel_dir = install_custom_kernel(logger=logger)
if custom_kernel_dir is not None and (icoconut_custom_kernel_name not in kernel_list or not args):
logger.show_sig("Installing Jupyter kernel {name!r}...".format(name=icoconut_custom_kernel_name))
if self.install_jupyter_kernel(jupyter, custom_kernel_dir):
newly_installed_kernels.append(icoconut_custom_kernel_name)
if not args:
# install default kernels if given no args
newly_installed_kernels += self.install_default_jupyter_kernels(jupyter, kernel_list)
run_args = None
else:
# use the custom kernel if it exists
if icoconut_custom_kernel_name in kernel_list or icoconut_custom_kernel_name in newly_installed_kernels:
kernel = icoconut_custom_kernel_name
# otherwise determine which default kernel to use and install them if necessary
else:
ver = "2" if PY2 else "3"
try:
self.run_silent_cmd(["python" + ver, "-m", "coconut.main", "--version"])
except CalledProcessError:
kernel = "coconut_py"
else:
kernel = "coconut_py" + ver
if kernel not in kernel_list:
newly_installed_kernels += self.install_default_jupyter_kernels(jupyter, kernel_list)
logger.warn("could not find {name!r} kernel; using {kernel!r} kernel instead".format(name=icoconut_custom_kernel_name, kernel=kernel))
# pass the kernel to the console or otherwise just launch Jupyter now that we know our kernel is available
if args[0] == "console":
run_args = jupyter + ["console", "--kernel", kernel] + args[1:]
else:
run_args = jupyter + args
if newly_installed_kernels:
logger.show_sig("Successfully installed Jupyter kernels: '" + "', '".join(newly_installed_kernels) + "'")
# run the Jupyter command
if run_args is not None:
self.register_error(run_cmd(run_args, raise_errs=False), errmsg="Jupyter error")
