def install_my_kernel_spec(user=True, prefix=None):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
# TODO: Copy resources once they're specified
print('Installing IPython kernel spec')
# TODO: remove line below once projects backend is updated w/ bash config
KernelSpecManager().install_kernel_spec(td,
'python3',
user=user,
replace=True,
prefix=prefix)
KernelSpecManager().install_kernel_spec(td,
'bash',
user=user,
replace=True,
prefix=prefix)
# Also install as shell for consistency, since it's the name DC images use
KernelSpecManager().install_kernel_spec(td,
'shell',
user=user,
replace=True,
prefix=prefix)
def main():
if KERNEL_NAME not in KernelSpecManager().find_kernel_specs():
install_kernel()
command = "jupyter-console --kernel %s" % KERNEL_NAME
for arg in argv[1:]:
command += " \"{}\"".format(arg)
exit(call(command, env=environ.copy(), shell=True))
def install_jupyter_hook(root=None):
"""Make xonsh available as a Jupyter kernel."""
if not HAVE_JUPYTER:
print('Could not install Jupyter kernel spec, please install '
'Jupyter/IPython.')
return
spec = {"argv": [sys.executable, "-m", "xonsh.jupyter_kernel",
"-f", "{connection_file}"],
"display_name": "Xonsh",
"language": "xonsh",
"codemirror_mode": "shell",
}
if CONDA:
d = os.path.join(sys.prefix + '/share/jupyter/kernels/xonsh/')
os.makedirs(d, exist_ok=True)
if sys.platform == 'win32':
# Ensure that conda-build detects the hard coded prefix
spec['argv'][0] = spec['argv'][0].replace(os.sep, os.altsep)
with open(os.path.join(d, 'kernel.json'), 'w') as f:
json.dump(spec, f, sort_keys=True)
else:
with TemporaryDirectory() as d:
os.chmod(d, 0o755) # Starts off as 700, not user readable
with open(os.path.join(d, 'kernel.json'), 'w') as f:
json.dump(spec, f, sort_keys=True)
print('Installing Jupyter kernel spec...')
KernelSpecManager().install_kernel_spec(
d, 'xonsh', user=('--user' in sys.argv), replace=True,
prefix=root)
def init_configurables(self):
'''
Initialize all configurable objects including a kernel manager, kernel
spec manager, session manager, and kernel pool. Optionally, load a
notebook and prespawn the requested number of kernels.
'''
self.kernel_spec_manager = KernelSpecManager(parent=self)
self.seed_notebook = None
if self.seed_uri is not None:
# Note: must be set before instantiating a SeedingMappingKernelManager
self.seed_notebook = self._load_notebook(self.seed_uri)
self.kernel_manager = SeedingMappingKernelManager(
parent=self,
log=self.log,
connection_dir=self.runtime_dir,
kernel_spec_manager=self.kernel_spec_manager)
self.session_manager = SessionManager(
log=self.log, kernel_manager=self.kernel_manager)
self.contents_manager = None
if self.prespawn_count:
if self.max_kernels and self.prespawn_count > self.max_kernels:
raise RuntimeError(
'cannot prespawn {}; more than max kernels {}'.format(
self.prespawn_count, self.max_kernels))
if self.api == 'notebook-http':
self.kernel_pool = ManagedKernelPool(self.prespawn_count,
self.kernel_manager)
else:
self.kernel_pool = KernelPool(self.prespawn_count,
self.kernel_manager)
def install_kernel(user=True, prefix=None):
""" Install the kernel for use by Jupyter.
"""
td = mkdtemp()
try:
chmod(td, 0o755) # Starts off as 700, not user readable
with open(path.join(td, "kernel.json"), "w") as f:
json_dump(
{
"argv": [
"python", "-m", "py2neo.cypher.kernel", "launch", "-f",
"{connection_file}"
],
"display_name":
"Cypher",
"language":
"cypher",
"pygments_lexer":
"py2neo.cypher",
},
f,
sort_keys=True)
return KernelSpecManager().install_kernel_spec(td,
KERNEL_NAME,
user=user,
prefix=prefix)
finally:
rmtree(td)
def install(_ctx) -> None:
kernel_json = {
"argv": [
sys.executable, "-m", "michelson_kernel", "run", "-f",
"{connection_file}"
],
"display_name":
"Michelson",
"language":
"michelson",
"codemirror_mode":
"michelson"
}
kernel_js_path = join(dirname(__file__), 'kernel.js')
kernel_spec = KernelSpecManager()
with TemporaryDirectory() as td:
# NOTE: Starts off as 700, not user readable
os.chmod(td, 0o755)
shutil.copy(kernel_js_path, join(td, 'kernel.js'))
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
kernel_spec.install_kernel_spec(td, 'michelson', prefix=sys.prefix)
def execute_notebook(source_notebook, destination_notebook, infra_args, papermill_args, notebooks_args):
"""Execute notebook with papermill.
:param source_notebook: Source notebook file name
:type source_notebook: str
:param destination_notebook: Source notebook file name
:type source_nodestination_notebooktebook: str
:param infra_args: Infrastructure arguments
:type infra_args: dict
:param papermill_args: Papermill arguments
:type papermill_args: dict
:param notebooks_args: Notebook arguments
:type notebooks_args: dict
"""
import papermill as pm
# if kernel name is specified
kernel_name = papermill_args.get("kernel_name")
# if not specified try to get it from the notebook
if not kernel_name:
with open(source_notebook) as nbfile:
notebook = json.loads(nbfile.read())
try:
kernel_name = notebook.get("metadata").get("kernelspec").get("name")
except:
pass
# create a kernel spec if not installed
try:
if kernel_name:
from jupyter_client.kernelspec import KernelSpecManager
if not KernelSpecManager().get_all_specs().get(kernel_name):
# TODO: replace jupyter_client.kernelspec.KernelSpecManager logic
from ipykernel.kernelspec import install
install(kernel_name=kernel_name)
papermill_args["kernel_name"] = kernel_name
except:
pass
# execute notebook
pm.execute_notebook(
source_notebook,
destination_notebook,
parameters=notebooks_args,
**papermill_args
)
# TODO scrapbook
if infra_args.get("history"):
batchsize = 50
from azureml.core import Run
results = pm.read_notebook(destination_notebook).dataframe.set_index("name")["value"]
run = Run.get_context()
for key, value in results.items():
if isinstance(value, list):
for index in range(0, len(value), batchsize):
run.log_list(key, value[index:index + batchsize])
else:
run.log(key, value)
def load_config(kernel_name) -> None:
"""Read the Home Assistant connection settings from the config file"""
kernels = KernelSpecManager().find_kernel_specs()
if kernel_name not in kernels:
print(
f"{PKG_NAME}: can't find kernel {kernel_name} in list of available kernels ({sorted(kernels.keys())})"
)
sys.exit(1)
config_path = Path(kernels[kernel_name], CONFIG_NAME)
parser_conf = configparser.ConfigParser(
defaults=CONFIG_DEFAULTS,
interpolation=configparser.ExtendedInterpolation(),
empty_lines_in_values=False,
converters={"unquoted": lambda x: x.strip("'\"") if x else None},
)
try:
parser_conf.read_file(config_path.open())
hass_conf = parser_conf["homeassistant"]
except KeyError:
print(f"{PKG_NAME}: missing section 'homeassistant' in config file")
sys.exit(1)
except Exception as err:
print(
f"{PKG_NAME}: unable to load config file {config_path}, err={err}")
sys.exit(1)
for opt in CONFIG_DEFAULTS:
CONFIG_SETTINGS[opt] = hass_conf.getunquoted(opt)
def __init__(self, path):
# type: (str) -> None
assert _interactive_integration_ready, (
'[interactive_test] dependency is not installed.')
assert os.path.exists(path), '{} does not exist.'.format(path)
self._paths = []
if os.path.isdir(path):
for root, _, files in os.walk(path):
for filename in files:
if filename.endswith('.ipynb'):
self._paths.append(os.path.join(root, filename))
elif path.endswith('.ipynb'):
self._paths.append(path)
assert len(self._paths) > 0, (
'No notebooks to be executed under{}'.format(path))
self._dir = os.path.dirname(self._paths[0])
self._output_html_dir = os.path.join(self._dir, 'output')
self.cleanup()
self._output_html_paths = {}
self._notebook_path_to_execution_id = {}
kernel_specs = KernelSpecManager().get_all_specs()
if 'test' not in kernel_specs:
# Install a test ipython kernel in current runtime environment. If this
# errors out, it means the test env is broken and should fail the test.
process = subprocess.run([
'python', '-m', 'ipykernel', 'install', '--user', '--name',
'test'
],
check=True)
process.check_returncode()
def install_h2o_kernel_spec(user=True, prefix=None):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
print('Installing H2O kernel Jupyter kernel spec')
KernelSpecManager().install_kernel_spec(td, 'h2o', user=user, replace=True, prefix=prefix)
def install_markdown_kernel_spec(args):
user = False
prefix = None
if args.sys_prefix:
prefix = sys.prefix
elif args.prefix:
prefix = args.prefix
elif args.user or not _is_root():
user = True
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
# Copy resources once they're specified
# shutil.copy(os.path.join(os.path.split(__file__)[
# 0], 'kernel.js'), os.path.join(td, 'kernel.js'))
# Copy resources once they're specified
shutil.copy(os.path.join(os.path.split(__file__)[0], 'logo-64x64.png'),
os.path.join(td, 'logo-64x64.png'))
KS = KernelSpecManager()
KS.log.setLevel(logging.ERROR)
KS.install_kernel_spec(td, 'markdown', user=user, prefix=prefix)
print('markdown jupyter kernel spec is installed')
def install_vim_kernel_spec(user=True, prefix=None):
curdir = os.path.dirname(os.path.abspath(__file__))
kernel_json = {"argv":[sys.executable,"-m","vim_kernel", "-f", "{connection_file}"], "display_name":"Vim"}
with open(os.path.join(curdir, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
print('Installing IPython kernel spec')
KernelSpecManager().install_kernel_spec(curdir, 'vim_kernel', user=user, prefix=prefix)
def install_kernel(cmd):
# Install the kernel spec when we install the package
from ipykernel import kernelspec
from jupyter_client.kernelspec import KernelSpecManager
kernel_name = 'geonotebook%i' % sys.version_info[0]
path = os.path.join(tempfile.mkdtemp(suffix='_kernels'), kernel_name)
try:
os.makedirs(path)
except OSError:
pass
kernel_dict = {
'argv': kernelspec.make_ipkernel_cmd(mod='geonotebook'),
'display_name': 'Geonotebook (Python %i)' % sys.version_info[0],
'language': 'python',
}
with open(os.path.join(path, 'kernel.json'), 'w') as fh:
json.dump(kernel_dict, fh, indent=1)
ksm = KernelSpecManager()
ksm.install_kernel_spec(path,
kernel_name=kernel_name,
user=False,
prefix=sys.prefix)
shutil.rmtree(path)
def install_my_kernel_spec(user=True, prefix=None):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
git_url = "https://raw.githubusercontent.com/ow2-proactive/proactive-jupyter-kernel/" \
"master/proactive-jupyter-kernel/"
urllib.request.urlretrieve(os.path.join(git_url, 'logo-32x32.png'),
os.path.join(td, 'logo-32x32.png'))
urllib.request.urlretrieve(os.path.join(git_url, 'logo-64x64.png'),
os.path.join(td, 'logo-64x64.png'))
urllib.request.urlretrieve(
os.path.join(git_url, 'logo-128x128.png'),
os.path.join(td, 'logo-128x128.png'))
# TODO: Copy resources once they're specified
print('Installing IPython kernel spec')
try:
KernelSpecManager().install_kernel_spec(td,
'ProActive',
user=user,
prefix=prefix)
print('Successfully installed ProActive kernel!')
except Exception as e:
print(str(e))
def install_kernelspec(self):
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
kernel_spec_manager = KernelSpecManager()
log.info('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
log.info('Installing kernel spec ' + kernel_spec_path)
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
else:
return
# retry with not self.user
log.info('Retry install kernel spec')
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=not self.user)
except Exception as e:
log.error(str(e.args))
log.error('Failed to install kernel spec')
def install_my_kernel_spec(user=True, prefix=None, powershell_command=None):
if sys.version_info >= (3, 0):
if powershell_command is None:
powershell_command = get_powershell()
kernel_json.update({'env': {'powershell_command': powershell_command}})
print('Using powershell_command=%r' % powershell_command)
else:
# python 2 cannot use env to pass values to the kernel
# https://github.com/vors/jupyter-powershell/issues/7
# TODO(python2): find a way to pass it
if powershell_command is not None:
print(
'Ignoring powershell_command on python2, jupyter will use default powershell_command=%r'
% powershell_command)
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
# TODO: Copy resources once they're specified
print('Installing IPython kernel spec')
KernelSpecManager().install_kernel_spec(td,
'powershell',
user=user,
prefix=prefix)
def get_kernel_location(kernel_name):
if kernel_exists(kernel_name):
manager = KernelSpecManager()
return manager.get_kernel_spec(kernel_name).resource_dir
else:
from jupyter_client.kernelspec import NoSuchKernel
raise NoSuchKernel(kernel_name)
def install(kernel_spec_manager=None, user=False, prefix=None):
"""Install the IPython kernelspec for Jupyter
Parameters
----------
kernel_spec_manager: KernelSpecManager [optional]
A KernelSpecManager to use for installation.
If none provided, a default instance will be created.
user: bool [default: False]
Whether to do a user-only install, or system-wide.
prefix: str, optional
Specify an install prefix for the kernelspec.
This is needed to install into a non-default location, such as a conda/virtual-env.
Returns
-------
The path where the kernelspec was installed.
"""
if kernel_spec_manager is None:
kernel_spec_manager = KernelSpecManager()
path = write_kernel_spec()
dest = kernel_spec_manager.install_kernel_spec(path, user=user, prefix=prefix)
# cleanup afterward
shutil.rmtree(path)
return dest
def install_jupyter_hook(prefix=None, root=None):
"""Make xonsh available as a Jupyter kernel."""
if not HAVE_JUPYTER:
print('Could not install Jupyter kernel spec, please install '
'Jupyter/IPython.')
return
spec = {"argv": [sys.executable, "-m", "xonsh.jupyter_kernel",
"-f", "{connection_file}"],
"display_name": "Xonsh",
"language": "xonsh",
"codemirror_mode": "shell",
}
with TemporaryDirectory() as d:
os.chmod(d, 0o755) # Starts off as 700, not user readable
if sys.platform == 'win32':
# Ensure that conda-build detects the hard coded prefix
spec['argv'][0] = spec['argv'][0].replace(os.sep, os.altsep)
with open(os.path.join(d, 'kernel.json'), 'w') as f:
json.dump(spec, f, sort_keys=True)
if 'CONDA_BUILD' in os.environ:
prefix = sys.prefix
if sys.platform == 'win32':
prefix = prefix.replace(os.sep, os.altsep)
user = ('--user' in sys.argv)
print('Installing Jupyter kernel spec:')
print(' root: {0!r}'.format(root))
print(' prefix: {0!r}'.format(prefix))
print(' as user: {0}'.format(user))
if root and prefix:
# os.path.join isn't used since prefix is probably absolute
prefix = root + prefix
print(' combined prefix {0!r}'.format(prefix))
KernelSpecManager().install_kernel_spec(
d, 'xonsh', user=user, replace=True, prefix=prefix)
def main():
args = parse_args()
kernel_env = make_kernel_env(args)
validate_kernel_env(kernel_env)
script_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
kernel_json = {
'argv': [
sys.executable,
'%s/parent_kernel.py' % script_dir,
'-f',
'{connection_file}',
],
'display_name': args.kernel_name,
'language': 'swift',
'env': kernel_env,
}
print('kernel.json:\n%s\n' % json.dumps(kernel_json, indent=2))
kernel_code_name = get_kernel_code_name(args.kernel_name)
with TemporaryDirectory() as td:
os.chmod(td, 0o755)
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, indent=2)
KernelSpecManager().install_kernel_spec(
td, kernel_code_name, user=args.user, prefix=args.prefix)
print('Registered kernel \'{}\' as \'{}\'!'.format(args.kernel_name, kernel_code_name))
def main():
args = parse_args()
kernel_env = make_kernel_env(args)
validate_kernel_env(kernel_env)
script_dir = os.path.dirname(os.path.realpath(sys.argv[0]))
kernel_json = {
'argv': [
sys.executable,
'%s/swift_kernel.py' % script_dir,
'-f',
'{connection_file}',
],
'display_name': args.kernel_name,
'language': 'swift',
'env': kernel_env,
}
print('kernel.json is\n%s' % json.dumps(kernel_json, indent=2))
kernel_code_name_allowed_chars = "-."
kernel_code_name = filter(lambda x: x.isalnum() or x in kernel_code_name_allowed_chars,
args.kernel_name.lower().replace(" ", kernel_code_name_allowed_chars[0]))
with TemporaryDirectory() as td:
os.chmod(td, 0o755)
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, indent=2)
KernelSpecManager().install_kernel_spec(
td, kernel_code_name, user=args.user, prefix=args.prefix, replace=True)
print('Registered kernel \'{}\' as \'{}\'!'.format(args.kernel_name, kernel_code_name))
def kernel_check():
try:
kernel = KernelSpecManager().get_kernel_spec("openvino_env")
except NoSuchKernel:
return False, ""
kernel_python = kernel.argv[0]
return True, kernel_python
def install_my_kernel_spec(user=True, prefix=None):
with TemporaryDirectory() as td:
os.chmod(td, 0o755) # Starts off as 700, not user readable
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
dir_path = os.path.dirname(os.path.realpath(__file__))
with open(os.path.join(td, 'kernel.js'), 'w', encoding='utf8') as f:
for m in [
'loadAdvancedMode.js', 'loadGlifHighlighting.js',
'kernel.js'
]:
f.write(f'// BEGIN FILE: {m}\n\n')
with open(os.path.join(dir_path, 'js', m),
'r',
encoding='utf8') as f2:
f.write(f2.read())
f.write(f'// END FILE: {m}\n\n')
with open(os.path.join(td, 'glif.css'), 'w', encoding='utf8') as f:
with open(os.path.join(dir_path, 'css', 'glif.css'),
'r',
encoding='utf8') as f2:
f.write(f2.read())
print(f'Installing Jupyter kernel spec to {prefix}')
KernelSpecManager().install_kernel_spec(td,
'GLIF',
user=user,
prefix=prefix)
def run(self):
# Regular install
install.run(self)
# Post install
print('Installing Ansible Kernel kernelspec')
from jupyter_client.kernelspec import KernelSpecManager
from IPython.utils.tempdir import TemporaryDirectory
kernel_json = {
"argv":
["python", "-m", "ansible_kernel", "-f", "{connection_file}"],
"codemirror_mode": "yaml",
"display_name": "Ansible",
"language": "ansible"
}
with TemporaryDirectory() as td:
os.chmod(td, 0o755)
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
ksm = KernelSpecManager()
ksm.install_kernel_spec(td,
'ansible',
user=self.user,
replace=True,
prefix=self.prefix)
def install_kernelspec(self):
from ipykernel.kernelspec import write_kernel_spec
from jupyter_client.kernelspec import KernelSpecManager
from wolfram_kernel.wolfram_kernel import WolframKernel
kernel_json = WolframKernel.kernel_json
kernel_js = WolframKernel.kernel_js
kernel_spec_manager = KernelSpecManager()
log.info('Writing kernel spec')
kernel_spec_path = write_kernel_spec(overrides=kernel_json)
with open(kernel_spec_path + "/kernel.js", "w") as jsfile:
jsfile.write(kernel_js)
log.info('Installing kernel spec')
try:
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=user)
except:
log.error('Failed to install kernel spec in ' +
kernel_spec_path)
kernel_spec_manager.install_kernel_spec(
kernel_spec_path,
kernel_name=kernel_json['name'],
user=not user)
def install(kernel_spec_manager=None,
user=False,
kernel_name=KERNEL_NAME,
display_name=None,
prefix=None,
profile=None):
"""Install the IPython kernelspec for Jupyter
Parameters
----------
kernel_spec_manager: KernelSpecManager [optional]
A KernelSpecManager to use for installation.
If none provided, a default instance will be created.
user: bool [default: False]
Whether to do a user-only install, or system-wide.
kernel_name: str, optional
Specify a name for the kernelspec.
This is needed for having multiple IPython kernels for different environments.
display_name: str, optional
Specify the display name for the kernelspec
profile: str, optional
Specify a custom profile to be loaded by the kernel.
prefix: str, optional
Specify an install prefix for the kernelspec.
This is needed to install into a non-default location, such as a conda/virtual-env.
Returns
-------
The path where the kernelspec was installed.
"""
if kernel_spec_manager is None:
kernel_spec_manager = KernelSpecManager()
if (kernel_name != KERNEL_NAME) and (display_name is None):
# kernel_name is specified and display_name is not
# default display_name to kernel_name
display_name = kernel_name
overrides = {}
if display_name:
overrides["display_name"] = display_name
if profile:
extra_arguments = ["--profile", profile]
if not display_name:
# add the profile to the default display name
overrides["display_name"] = 'Python %i [profile=%s]' % (
sys.version_info[0], profile)
else:
extra_arguments = None
path = write_kernel_spec(overrides=overrides,
extra_arguments=extra_arguments)
dest = kernel_spec_manager.install_kernel_spec(path,
kernel_name=kernel_name,
user=user,
prefix=prefix)
# cleanup afterward
shutil.rmtree(path)
return dest
def get_kernelspec(self, name):
"""Get a kernel specification dictionary given a kernel name
"""
ksm = KernelSpecManager()
kernelspec = ksm.get_kernel_spec(name).to_dict()
kernelspec['name'] = name
kernelspec.pop('argv')
return kernelspec
def install_my_kernel_spec(user=True, prefix=None):
with TemporaryDirectory() as td:
os.chmod(td, 0o755)
with open(os.path.join(td, 'kernel.json'), 'w') as f:
json.dump(kernel_json, f, sort_keys=True)
print('Installing IPython kernel spec')
KernelSpecManager().install_kernel_spec(td, 'mysql', user=user, replace=True, prefix=prefix)
def jupyter_manager(tmp_path):
jupyter_data_dir = tmp_path / "share" / "jupyter"
jupyter_data_dir.mkdir(parents=True, exist_ok=True)
manager = CondaKernelSpecManager(kernelspec_path=str(tmp_path))
# Install the kernel specs
manager.find_kernel_specs()
return KernelSpecManager(kernel_dirs=[str(jupyter_data_dir / "kernels")])
def install_my_kernel_spec(user=True, prefix=None):
"""Install the kernel spec for user in given prefix."""
print('Installing mlir-opt IPython kernel spec')
pkgroot = os.path.dirname(__file__)
KernelSpecManager().install_kernel_spec(os.path.join(pkgroot, 'assets'),
'mlir',
user=user,
prefix=prefix)
