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")