application.py
390 lines
| 15.0 KiB
| text/x-python
|
PythonLexer
|
r2185 | # encoding: utf-8 | ||
""" | ||||
|
r2301 | An application for IPython. | ||
All top-level applications should use the classes in this module for | ||||
|
r12814 | handling configuration and creating configurables. | ||
|
r2301 | |||
|
r4872 | The job of an :class:`Application` is to create the master configuration | ||
|
r2731 | object and then create the configurable objects, passing the config to them. | ||
|
r2185 | |||
Authors: | ||||
* Brian Granger | ||||
* Fernando Perez | ||||
|
r4023 | * Min RK | ||
|
r2185 | |||
""" | ||||
#----------------------------------------------------------------------------- | ||||
|
r12814 | # Copyright (C) 2008 The IPython Development Team | ||
|
r2185 | # | ||
# Distributed under the terms of the BSD License. The full license is in | ||||
# the file COPYING, distributed as part of this software. | ||||
#----------------------------------------------------------------------------- | ||||
#----------------------------------------------------------------------------- | ||||
# Imports | ||||
#----------------------------------------------------------------------------- | ||||
|
r4994 | import atexit | ||
|
r12814 | import errno | ||
|
r4122 | import glob | ||
|
r2252 | import logging | ||
|
r2200 | import os | ||
|
r4023 | import shutil | ||
|
r2185 | import sys | ||
|
r2245 | |||
|
r5214 | from IPython.config.application import Application, catch_config_error | ||
|
r8885 | from IPython.config.loader import ConfigFileNotFound | ||
|
r2403 | from IPython.core import release, crashhandler | ||
|
r4024 | from IPython.core.profiledir import ProfileDir, ProfileDirError | ||
|
r16486 | from IPython.utils.path import get_ipython_dir, get_ipython_package_dir, ensure_dir_exists | ||
|
r13447 | from IPython.utils import py3compat | ||
|
r11836 | from IPython.utils.traitlets import List, Unicode, Type, Bool, Dict, Set, Instance | ||
|
r2185 | |||
#----------------------------------------------------------------------------- | ||||
# Classes and functions | ||||
#----------------------------------------------------------------------------- | ||||
|
r4023 | |||
#----------------------------------------------------------------------------- | ||||
# Base Application Class | ||||
#----------------------------------------------------------------------------- | ||||
# aliases and flags | ||||
|
r4214 | base_aliases = { | ||
|
r12282 | 'profile-dir' : 'ProfileDir.location', | ||
|
r4214 | 'profile' : 'BaseIPythonApplication.profile', | ||
'ipython-dir' : 'BaseIPythonApplication.ipython_dir', | ||||
'log-level' : 'Application.log_level', | ||||
|
r11277 | 'config' : 'BaseIPythonApplication.extra_config_file', | ||
|
r4214 | } | ||
|
r2294 | |||
|
r4023 | base_flags = dict( | ||
debug = ({'Application' : {'log_level' : logging.DEBUG}}, | ||||
"set log level to logging.DEBUG (maximize logging output)"), | ||||
quiet = ({'Application' : {'log_level' : logging.CRITICAL}}, | ||||
"set log level to logging.CRITICAL (minimize logging output)"), | ||||
init = ({'BaseIPythonApplication' : { | ||||
'copy_config_files' : True, | ||||
'auto_create' : True} | ||||
|
r4247 | }, """Initialize profile with default config files. This is equivalent | ||
to running `ipython profile create <profile>` prior to startup. | ||||
""") | ||||
|
r4023 | ) | ||
class BaseIPythonApplication(Application): | ||||
name = Unicode(u'ipython') | ||||
description = Unicode(u'IPython: an enhanced interactive Python shell.') | ||||
version = Unicode(release.version) | ||||
|
r4872 | |||
|
r4023 | aliases = Dict(base_aliases) | ||
flags = Dict(base_flags) | ||||
|
r4114 | classes = List([ProfileDir]) | ||
|
r4872 | |||
|
r4023 | # Track whether the config_file has changed, | ||
# because some logic happens only if we aren't using the default. | ||||
|
r11277 | config_file_specified = Set() | ||
|
r4872 | |||
|
r11364 | config_file_name = Unicode() | ||
|
r4025 | def _config_file_name_default(self): | ||
return self.name.replace('-','_') + u'_config.py' | ||||
|
r4023 | def _config_file_name_changed(self, name, old, new): | ||
if new != old: | ||||
|
r11277 | self.config_file_specified.add(new) | ||
|
r4023 | |||
# The directory that contains IPython's builtin profiles. | ||||
builtin_profile_dir = Unicode( | ||||
os.path.join(get_ipython_package_dir(), u'config', u'profile', u'default') | ||||
) | ||||
config_file_paths = List(Unicode) | ||||
def _config_file_paths_default(self): | ||||
|
r13447 | return [py3compat.getcwd()] | ||
|
r4023 | |||
|
r11277 | extra_config_file = Unicode(config=True, | ||
help="""Path to an extra config file to load. | ||||
If specified, load this config file in addition to any other IPython config. | ||||
""") | ||||
def _extra_config_file_changed(self, name, old, new): | ||||
try: | ||||
self.config_files.remove(old) | ||||
except ValueError: | ||||
pass | ||||
self.config_file_specified.add(new) | ||||
self.config_files.append(new) | ||||
|
r5259 | profile = Unicode(u'default', config=True, | ||
|
r4023 | help="""The IPython profile to use.""" | ||
) | ||||
|
r4872 | |||
|
r4023 | def _profile_changed(self, name, old, new): | ||
self.builtin_profile_dir = os.path.join( | ||||
get_ipython_package_dir(), u'config', u'profile', new | ||||
) | ||||
|
r4872 | |||
|
r12814 | ipython_dir = Unicode(config=True, | ||
|
r4023 | help=""" | ||
The name of the IPython directory. This directory is used for logging | ||||
configuration (through profiles), history storage, etc. The default | ||||
is usually $HOME/.ipython. This options can also be specified through | ||||
|
r6696 | the environment variable IPYTHONDIR. | ||
|
r2294 | """ | ||
|
r4023 | ) | ||
|
r12814 | def _ipython_dir_default(self): | ||
d = get_ipython_dir() | ||||
|
r12850 | self._ipython_dir_changed('ipython_dir', d, d) | ||
|
r12814 | return d | ||
|
r11836 | _in_init_profile_dir = False | ||
profile_dir = Instance(ProfileDir) | ||||
def _profile_dir_default(self): | ||||
# avoid recursion | ||||
if self._in_init_profile_dir: | ||||
return | ||||
# profile_dir requested early, force initialization | ||||
self.init_profile_dir() | ||||
return self.profile_dir | ||||
|
r4872 | |||
|
r4023 | overwrite = Bool(False, config=True, | ||
help="""Whether to overwrite existing config files when copying""") | ||||
auto_create = Bool(False, config=True, | ||||
help="""Whether to create profile dir if it doesn't exist""") | ||||
|
r4872 | |||
|
r4023 | config_files = List(Unicode) | ||
def _config_files_default(self): | ||||
|
r11364 | return [self.config_file_name] | ||
|
r4872 | |||
|
r4023 | copy_config_files = Bool(False, config=True, | ||
|
r4025 | help="""Whether to install the default config files into the profile dir. | ||
If a new profile is being created, and IPython contains config files for that | ||||
profile, then they will be staged into the new directory. Otherwise, | ||||
default config files will be automatically generated. | ||||
""") | ||||
|
r5317 | |||
verbose_crash = Bool(False, config=True, | ||||
|
r6872 | help="""Create a massive crash report when IPython encounters what may be an | ||
|
r5317 | internal error. The default is to append a short message to the | ||
usual traceback""") | ||||
|
r4023 | |||
# The class to use as the crash handler. | ||||
crash_handler_class = Type(crashhandler.CrashHandler) | ||||
|
r10381 | @catch_config_error | ||
|
r4023 | def __init__(self, **kwargs): | ||
super(BaseIPythonApplication, self).__init__(**kwargs) | ||||
|
r10154 | # ensure current working directory exists | ||
|
r10169 | try: | ||
|
r13447 | directory = py3compat.getcwd() | ||
|
r10169 | except: | ||
# raise exception | ||||
self.log.error("Current working directory doesn't exist.") | ||||
raise | ||||
|
r10154 | |||
|
r4023 | #------------------------------------------------------------------------- | ||
# Various stages of Application creation | ||||
#------------------------------------------------------------------------- | ||||
|
r2200 | |||
|
r4023 | def init_crash_handler(self): | ||
"""Create a crash handler, typically setting sys.excepthook to it.""" | ||||
self.crash_handler = self.crash_handler_class(self) | ||||
|
r5317 | sys.excepthook = self.excepthook | ||
|
r4994 | def unset_crashhandler(): | ||
sys.excepthook = sys.__excepthook__ | ||||
atexit.register(unset_crashhandler) | ||||
|
r5317 | |||
def excepthook(self, etype, evalue, tb): | ||||
"""this is sys.excepthook after init_crashhandler | ||||
set self.verbose_crash=True to use our full crashhandler, instead of | ||||
a regular traceback with a short message (crash_handler_lite) | ||||
""" | ||||
if self.verbose_crash: | ||||
return self.crash_handler(etype, evalue, tb) | ||||
else: | ||||
return crashhandler.crash_handler_lite(etype, evalue, tb) | ||||
|
r4023 | def _ipython_dir_changed(self, name, old, new): | ||
|
r14693 | str_old = py3compat.cast_bytes_py2(os.path.abspath(old), | ||
sys.getfilesystemencoding() | ||||
) | ||||
if str_old in sys.path: | ||||
sys.path.remove(str_old) | ||||
str_path = py3compat.cast_bytes_py2(os.path.abspath(new), | ||||
sys.getfilesystemencoding() | ||||
) | ||||
sys.path.append(str_path) | ||||
|
r16486 | ensure_dir_exists(new) | ||
|
r4023 | readme = os.path.join(new, 'README') | ||
|
r12814 | readme_src = os.path.join(get_ipython_package_dir(), u'config', u'profile', 'README') | ||
if not os.path.exists(readme) and os.path.exists(readme_src): | ||||
shutil.copy(readme_src, readme) | ||||
for d in ('extensions', 'nbextensions'): | ||||
path = os.path.join(new, d) | ||||
|
r16486 | try: | ||
ensure_dir_exists(path) | ||||
except OSError: | ||||
# this will not be EEXIST | ||||
self.log.error("couldn't create path %s: %s", path, e) | ||||
|
r6697 | self.log.debug("IPYTHONDIR set to: %s" % new) | ||
|
r4023 | |||
def load_config_file(self, suppress_errors=True): | ||||
|
r2200 | """Load the config file. | ||
|
r4023 | |||
|
r3458 | By default, errors in loading config are handled, and a warning | ||
printed on screen. For testing, the suppress_errors option is set | ||||
to False, so errors will make tests fail. | ||||
|
r2200 | """ | ||
|
r4564 | self.log.debug("Searching path %s for config files", self.config_file_paths) | ||
|
r4025 | base_config = 'ipython_config.py' | ||
self.log.debug("Attempting to load config file: %s" % | ||||
base_config) | ||||
try: | ||||
Application.load_config_file( | ||||
self, | ||||
|
r4872 | base_config, | ||
|
r4025 | path=self.config_file_paths | ||
) | ||||
|
r4909 | except ConfigFileNotFound: | ||
|
r4025 | # ignore errors loading parent | ||
|
r4564 | self.log.debug("Config file %s not found", base_config) | ||
|
r4025 | pass | ||
|
r11277 | |||
for config_file_name in self.config_files: | ||||
if not config_file_name or config_file_name == base_config: | ||||
continue | ||||
self.log.debug("Attempting to load config file: %s" % | ||||
self.config_file_name) | ||||
try: | ||||
Application.load_config_file( | ||||
self, | ||||
config_file_name, | ||||
path=self.config_file_paths | ||||
) | ||||
except ConfigFileNotFound: | ||||
# Only warn if the default config file was NOT being used. | ||||
if config_file_name in self.config_file_specified: | ||||
msg = self.log.warn | ||||
else: | ||||
msg = self.log.debug | ||||
msg("Config file not found, skipping: %s", config_file_name) | ||||
except: | ||||
# For testing purposes. | ||||
if not suppress_errors: | ||||
raise | ||||
self.log.warn("Error loading config file: %s" % | ||||
self.config_file_name, exc_info=True) | ||||
|
r2294 | |||
|
r4023 | def init_profile_dir(self): | ||
"""initialize the profile dir""" | ||||
|
r11836 | self._in_init_profile_dir = True | ||
|
r11870 | if self.profile_dir is not None: | ||
# already ran | ||||
return | ||||
|
r12796 | if 'ProfileDir.location' not in self.config: | ||
|
r4023 | # location not specified, find by profile name | ||
|
r2270 | try: | ||
|
r4023 | p = ProfileDir.find_profile_dir_by_name(self.ipython_dir, self.profile, self.config) | ||
except ProfileDirError: | ||||
# not found, maybe create it (always create default profile) | ||||
|
r8885 | if self.auto_create or self.profile == 'default': | ||
|
r4023 | try: | ||
p = ProfileDir.create_profile_dir_by_name(self.ipython_dir, self.profile, self.config) | ||||
except ProfileDirError: | ||||
self.log.fatal("Could not create profile: %r"%self.profile) | ||||
self.exit(1) | ||||
else: | ||||
self.log.info("Created profile dir: %r"%p.location) | ||||
else: | ||||
self.log.fatal("Profile %r not found."%self.profile) | ||||
self.exit(1) | ||||
else: | ||||
self.log.info("Using existing profile dir: %r"%p.location) | ||||
|
r2303 | else: | ||
|
r12796 | location = self.config.ProfileDir.location | ||
|
r4023 | # location is fully specified | ||
try: | ||||
p = ProfileDir.find_profile_dir(location, self.config) | ||||
except ProfileDirError: | ||||
# not found, maybe create it | ||||
if self.auto_create: | ||||
try: | ||||
p = ProfileDir.create_profile_dir(location, self.config) | ||||
except ProfileDirError: | ||||
self.log.fatal("Could not create profile directory: %r"%location) | ||||
self.exit(1) | ||||
else: | ||||
self.log.info("Creating new profile dir: %r"%location) | ||||
else: | ||||
self.log.fatal("Profile directory %r not found."%location) | ||||
self.exit(1) | ||||
else: | ||||
self.log.info("Using existing profile dir: %r"%location) | ||||
|
r14790 | # if profile_dir is specified explicitly, set profile name | ||
dir_name = os.path.basename(p.location) | ||||
if dir_name.startswith('profile_'): | ||||
self.profile = dir_name[8:] | ||||
|
r4872 | |||
|
r4023 | self.profile_dir = p | ||
self.config_file_paths.append(p.location) | ||||
|
r11836 | self._in_init_profile_dir = False | ||
|
r4872 | |||
|
r4023 | def init_config_files(self): | ||
"""[optionally] copy default config files into profile dir.""" | ||||
# copy config files | ||||
|
r4122 | path = self.builtin_profile_dir | ||
|
r4023 | if self.copy_config_files: | ||
src = self.profile | ||||
|
r4872 | |||
|
r4025 | cfg = self.config_file_name | ||
if path and os.path.exists(os.path.join(path, cfg)): | ||||
self.log.warn("Staging %r from %s into %r [overwrite=%s]"%( | ||||
cfg, src, self.profile_dir.location, self.overwrite) | ||||
) | ||||
|
r4023 | self.profile_dir.copy_config_file(cfg, path=path, overwrite=self.overwrite) | ||
|
r4025 | else: | ||
self.stage_default_config_file() | ||||
|
r4122 | else: | ||
# Still stage *bundled* config files, but not generated ones | ||||
# This is necessary for `ipython profile=sympy` to load the profile | ||||
# on the first go | ||||
files = glob.glob(os.path.join(path, '*.py')) | ||||
for fullpath in files: | ||||
cfg = os.path.basename(fullpath) | ||||
if self.profile_dir.copy_config_file(cfg, path=path, overwrite=False): | ||||
# file was copied | ||||
self.log.warn("Staging bundled %s from %s into %r"%( | ||||
cfg, self.profile, self.profile_dir.location) | ||||
) | ||||
|
r4872 | |||
|
r4025 | def stage_default_config_file(self): | ||
"""auto generate default config file, and stage it into the profile.""" | ||||
s = self.generate_config_file() | ||||
fname = os.path.join(self.profile_dir.location, self.config_file_name) | ||||
if self.overwrite or not os.path.exists(fname): | ||||
self.log.warn("Generating default config file: %r"%(fname)) | ||||
with open(fname, 'w') as f: | ||||
f.write(s) | ||||
|
r4872 | |||
|
r5214 | @catch_config_error | ||
|
r4023 | def initialize(self, argv=None): | ||
|
r4106 | # don't hook up crash handler before parsing command-line | ||
|
r4023 | self.parse_command_line(argv) | ||
|
r4106 | self.init_crash_handler() | ||
|
r4025 | if self.subapp is not None: | ||
# stop here if subapp is taking over | ||||
return | ||||
|
r4023 | cl_config = self.config | ||
self.init_profile_dir() | ||||
self.init_config_files() | ||||
self.load_config_file() | ||||
# enforce cl-opts override configfile opts: | ||||
self.update_config(cl_config) | ||||
|
r2296 | |||