adopt traitlets 4.2 API

- `.tag(config=True)`
- `@default`
- `@observe`

IPython/core/alias.py

@@ -192,8 +192,8 class Alias(object):
 
 class AliasManager(Configurable):
 
-    default_aliases = List(default_aliases(), config=True)
-    user_aliases = List(default_value=[], config=True)
+    default_aliases = List(default_aliases()).tag(config=True)
+    user_aliases = List(default_value=[]).tag(config=True)
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
 
     def __init__(self, shell=None, **kwargs):

IPython/core/application.py

@@ -26,7 +26,10 from IPython.core.profiledir import ProfileDir, ProfileDirError
 from IPython.paths import get_ipython_dir, get_ipython_package_dir
 from IPython.utils.path import ensure_dir_exists
 from IPython.utils import py3compat
-from traitlets import List, Unicode, Type, Bool, Dict, Set, Instance, Undefined
+from traitlets import (
+    List, Unicode, Type, Bool, Dict, Set, Instance, Undefined,
+    default, observe,
+)
 
 if os.name == 'nt':
     programdata = os.environ.get('PROGRAMDATA', None)
@@ -96,11 +99,13 class BaseIPythonApplication(Application):
     config_file_specified = Set()
 
     config_file_name = Unicode()
+    @default('config_file_name')
     def _config_file_name_default(self):
         return self.name.replace('-','_') + u'_config.py'
-    def _config_file_name_changed(self, name, old, new):
-        if new != old:
-            self.config_file_specified.add(new)
+    @observe('config_file_name')
+    def _config_file_name_changed(self, change):
+        if change['new'] != change['old']:
+            self.config_file_specified.add(change['new'])
 
     # The directory that contains IPython's builtin profiles.
     builtin_profile_dir = Unicode(
@@ -108,15 +113,19 class BaseIPythonApplication(Application):
     )
     
     config_file_paths = List(Unicode())
+    @default('config_file_paths')
     def _config_file_paths_default(self):
         return [py3compat.getcwd()]
 
-    extra_config_file = Unicode(config=True,
+    extra_config_file = Unicode(
     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):
+    """).tag(config=True)
+    @observe('extra_config_file')
+    def _extra_config_file_changed(self, change):
+        old = change['old']
+        new = change['new']
         try:
             self.config_files.remove(old)
         except ValueError:
@@ -124,30 +133,37 class BaseIPythonApplication(Application):
         self.config_file_specified.add(new)
         self.config_files.append(new)
 
-    profile = Unicode(u'default', config=True,
+    profile = Unicode(u'default',
         help="""The IPython profile to use."""
-    )
-
-    def _profile_changed(self, name, old, new):
+    ).tag(config=True)
+    
+    @observe('profile')
+    def _profile_changed(self, change):
         self.builtin_profile_dir = os.path.join(
-                get_ipython_package_dir(), u'config', u'profile', new
+                get_ipython_package_dir(), u'config', u'profile', change['new']
         )
 
-    ipython_dir = Unicode(config=True,
+    ipython_dir = Unicode(
         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 option can also be specified through
         the environment variable IPYTHONDIR.
         """
-    )
+    ).tag(config=True)
+    @default('ipython_dir')
     def _ipython_dir_default(self):
         d = get_ipython_dir()
-        self._ipython_dir_changed('ipython_dir', d, d)
+        self._ipython_dir_changed({
+            'name': 'ipython_dir',
+            'old': d,
+            'new': d,
+        })
         return d
     
     _in_init_profile_dir = False
     profile_dir = Instance(ProfileDir, allow_none=True)
+    @default('profile_dir')
     def _profile_dir_default(self):
         # avoid recursion
         if self._in_init_profile_dir:
@@ -156,26 +172,29 class BaseIPythonApplication(Application):
         self.init_profile_dir()
         return self.profile_dir
 
-    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""")
+    overwrite = Bool(False,
+        help="""Whether to overwrite existing config files when copying"""
+    ).tag(config=True)
+    auto_create = Bool(False,
+        help="""Whether to create profile dir if it doesn't exist"""
+    ).tag(config=True)
 
     config_files = List(Unicode())
+    @default('config_files')
     def _config_files_default(self):
         return [self.config_file_name]
 
-    copy_config_files = Bool(False, config=True,
+    copy_config_files = Bool(False,
         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.
-        """)
+        """).tag(config=True)
     
-    verbose_crash = Bool(False, config=True,
+    verbose_crash = Bool(False,
         help="""Create a massive crash report when IPython encounters what may be an
         internal error.  The default is to append a short message to the
-        usual traceback""")
+        usual traceback""").tag(config=True)
 
     # The class to use as the crash handler.
     crash_handler_class = Type(crashhandler.CrashHandler)
@@ -199,7 +218,6 class BaseIPythonApplication(Application):
     
     def initialize_subcommand(self, subc, argv=None):
         if subc in self.deprecated_subcommands:
-            import time
             self.log.warning("Subcommand `ipython {sub}` is deprecated and will be removed "
                              "in future versions.".format(sub=subc))
             self.log.warning("You likely want to use `jupyter {sub}` in the "
@@ -225,8 +243,11 class BaseIPythonApplication(Application):
             return self.crash_handler(etype, evalue, tb)
         else:
             return crashhandler.crash_handler_lite(etype, evalue, tb)
-    
-    def _ipython_dir_changed(self, name, old, new):
+
+    @observe('ipython_dir')
+    def _ipython_dir_changed(self, change):
+        old = change['old']
+        new = change['new']
         if old is not Undefined:
             str_old = py3compat.cast_bytes_py2(os.path.abspath(old),
                 sys.getfilesystemencoding()

IPython/core/completer.py

@@ -66,7 +66,7 import sys
 import unicodedata
 import string
 
-from traitlets.config.configurable import Configurable 
+from traitlets.config.configurable import Configurable
 from IPython.core.error import TryNext
 from IPython.core.inputsplitter import ESC_MAGIC
 from IPython.core.latex_symbols import latex_symbols, reverse_latex_symbol
@@ -75,7 +75,7 from IPython.utils.decorators import undoc
 from IPython.utils.dir2 import dir2, get_real_method
 from IPython.utils.process import arg_split
 from IPython.utils.py3compat import builtin_mod, string_types, PY3, cast_unicode_py2
-from traitlets import CBool, Enum
+from traitlets import Bool, Enum, observe
 
 import jedi
 import jedi.api.helpers
@@ -174,7 +174,6 def compress_user(path, tilde_expand, tilde_val):
         return path
 
 
-
 def completions_sorting_key(word):
     """key for sorting completions
 
@@ -273,14 +272,14 class CompletionSplitter(object):
 
 class Completer(Configurable):
 
-    greedy = CBool(False, config=True,
+    greedy = Bool(False,
         help="""Activate greedy completion
         PENDING DEPRECTION. this is now mostly taken care of with Jedi.
 
         This will enable completion on elements of lists, results of function calls, etc.,
         but can be unsafe because the code is actually evaluated on TAB.
         """
-    )
+    ).tag(config=True)
     
 
     def __init__(self, namespace=None, global_namespace=None, **kwargs):
@@ -505,7 +504,7 def back_unicode_name_matches(text):
     try :
         unic = unicodedata.name(char)
         return '\\'+char,['\\'+unic]
-    except KeyError as e:
+    except KeyError:
         pass
     return u'', ()
 
@@ -532,17 +531,18 def back_latex_name_matches(text):
         latex = reverse_latex_symbol[char]
         # '\\' replace the \ as well
         return '\\'+char,[latex]
-    except KeyError as e:
+    except KeyError:
         pass
     return u'', ()
 
 
 class IPCompleter(Completer):
     """Extension of the completer class with IPython-specific features"""
-
-    def _greedy_changed(self, name, old, new):
+    
+    @observe('greedy')
+    def _greedy_changed(self, change):
         """update the splitter and readline delims when greedy is changed"""
-        if new:
+        if change['new']:
             self.splitter.delims = GREEDY_DELIMS
         else:
             self.splitter.delims = DELIMS
@@ -550,14 +550,14 class IPCompleter(Completer):
         if self.readline:
             self.readline.set_completer_delims(self.splitter.delims)
     
-    merge_completions = CBool(True, config=True,
+    merge_completions = Bool(True,
         help="""Whether to merge completion results into a single list
         
         If False, only the completion results from the first non-empty
         completer will be returned.
         """
-    )
-    omit__names = Enum((0,1,2), default_value=2, config=True,
+    ).tag(config=True)
+    omit__names = Enum((0,1,2), default_value=2,
         help="""Instruct the completer to omit private method names
         
         Specifically, when completing on ``object.<tab>``.
@@ -568,8 +568,8 class IPCompleter(Completer):
         
         When 0: nothing will be excluded.
         """
-    )
-    limit_to__all__ = CBool(default_value=False, config=True,
+    ).tag(config=True)
+    limit_to__all__ = Bool(False,
         help="""
         DEPRECATED as of version 5.0.
         
@@ -580,8 +580,8 class IPCompleter(Completer):
         When True: only those names in obj.__all__ will be included.
         
         When False [default]: the __all__ attribute is ignored 
-        """
-    )
+        """,
+    ).tag(config=True)
 
     def __init__(self, shell=None, namespace=None, global_namespace=None,
                  use_readline=True, config=None, **kwargs):
@@ -1101,7 +1101,7 class IPCompleter(Completer):
                 # allow combining chars
                 if ('a'+unic).isidentifier():
                     return '\\'+s,[unic]
-            except KeyError as e:
+            except KeyError:
                 pass
         return u'', []
 

IPython/core/formatters.py

@@ -26,6 +26,7 from IPython.lib import pretty
 from traitlets import (
     Bool, Dict, Integer, Unicode, CUnicode, ObjectName, List,
     ForwardDeclaredInstance,
+    default, observe,
 )
 from IPython.utils.py3compat import (
     with_metaclass, string_types, unicode_type,
@@ -49,29 +50,34 class DisplayFormatter(Configurable):
         else:
             self.active_types = self.format_types
     
-    active_types = List(Unicode()).tag(config=True,
+    active_types = List(Unicode(),
         help="""List of currently active mime-types to display.
         You can use this to set a white-list for formats to display.
         
         Most users will not need to change this value.
-        """)
+        """).tag(config=True)
+
+    @default('active_types')
     def _active_types_default(self):
         return self.format_types
-    
-    def _active_types_changed(self, name, old, new):
+
+    @observe('active_types')
+    def _active_types_changed(self, change):
         for key, formatter in self.formatters.items():
-            if key in new:
+            if key in change['new']:
                 formatter.enabled = True
             else:
                 formatter.enabled = False
     
     ipython_display_formatter = ForwardDeclaredInstance('FormatterABC')
-    def _ipython_display_formatter_default(self):
+    @default('ipython_display_formatter')
+    def _default_formatter(self):
         return IPythonDisplayFormatter(parent=self)
     
     # A dict of formatter whose keys are format types (MIME types) and whose
     # values are subclasses of BaseFormatter.
     formatters = Dict()
+    @default('formatters')
     def _formatters_default(self):
         """Activate the default formatters."""
         formatter_classes = [
@@ -570,12 +576,12 class PlainTextFormatter(BaseFormatter):
     # something.
     enabled = Bool(True).tag(config=False)
     
-    max_seq_length = Integer(pretty.MAX_SEQ_LENGTH).tag(config=True,
+    max_seq_length = Integer(pretty.MAX_SEQ_LENGTH,
         help="""Truncate large collections (lists, dicts, tuples, sets) to this size.
         
         Set to 0 to disable truncation.
         """
-    )
+    ).tag(config=True)
     
     # Look for a _repr_pretty_ methods to use for pretty printing.
     print_method = ObjectName('_repr_pretty_')
@@ -643,14 +649,17 class PlainTextFormatter(BaseFormatter):
         self.float_format = fmt
 
     # Use the default pretty printers from IPython.lib.pretty.
+    @default('singleton_printers')
     def _singleton_printers_default(self):
         return pretty._singleton_pprinters.copy()
 
+    @default('type_printers')
     def _type_printers_default(self):
         d = pretty._type_pprinters.copy()
         d[float] = lambda obj,p,cycle: p.text(self.float_format%obj)
         return d
 
+    @default('deferred_printers')
     def _deferred_printers_default(self):
         return pretty._deferred_type_pprinters.copy()
 

IPython/core/history.py

@@ -25,6 +25,7 from IPython.utils.path import locate_profile
 from IPython.utils import py3compat
 from traitlets import (
     Any, Bool, Dict, Instance, Integer, List, Unicode, TraitError,
+    default, observe,
 )
 from warnings import warn
 
@@ -148,7 +149,7 class HistoryAccessor(HistoryAccessorBase):
     _corrupt_db_limit = 2
 
     # String holding the path to the history file
-    hist_file = Unicode(config=True,
+    hist_file = Unicode(
         help="""Path to file to use for SQLite history database.
         
         By default, IPython will put the history database in the IPython
@@ -161,9 +162,9 class HistoryAccessor(HistoryAccessorBase):
         
             ipython --HistoryManager.hist_file=/tmp/ipython_hist.sqlite
         
-        """)
+        """).tag(config=True)
     
-    enabled = Bool(True, config=True,
+    enabled = Bool(True,
         help="""enable the SQLite history
         
         set enabled=False to disable the SQLite history,
@@ -171,20 +172,22 class HistoryAccessor(HistoryAccessorBase):
         and no background saving thread.  This may be necessary in some
         threaded environments where IPython is embedded.
         """
-    )
+    ).tag(config=True)
     
-    connection_options = Dict(config=True,
+    connection_options = Dict(
         help="""Options for configuring the SQLite connection
         
         These options are passed as keyword args to sqlite3.connect
         when establishing database conenctions.
         """
-    )
+    ).tag(config=True)
 
     # The SQLite database
     db = Any()
-    def _db_changed(self, name, old, new):
+    @observe('db')
+    def _db_changed(self, change):
         """validate the db, since it can be an Instance of two different types"""
+        new = change['new']
         connection_types = (DummyDB,)
         if sqlite3 is not None:
             connection_types = (DummyDB, sqlite3.Connection)
@@ -479,6 +482,7 class HistoryManager(HistoryAccessor):
     input_hist_raw = List([""])
     # A list of directories visited during session
     dir_hist = List()
+    @default('dir_hist')
     def _dir_hist_default(self):
         try:
             return [py3compat.getcwd()]
@@ -494,13 +498,13 class HistoryManager(HistoryAccessor):
     # The number of the current session in the history database
     session_number = Integer()
     
-    db_log_output = Bool(False, config=True,
+    db_log_output = Bool(False,
         help="Should the history database include output? (default: no)"
-    )
-    db_cache_size = Integer(0, config=True,
+    ).tag(config=True)
+    db_cache_size = Integer(0,
         help="Write to database every x commands (higher values save disk access & power).\n"
         "Values of 1 or less effectively disable caching."
-    )
+    ).tag(config=True)
     # The input and output caches
     db_input_cache = List()
     db_output_cache = List()

IPython/core/interactiveshell.py

@@ -49,7 +49,7 from IPython.core.error import InputRejected, UsageError
 from IPython.core.extensions import ExtensionManager
 from IPython.core.formatters import DisplayFormatter
 from IPython.core.history import HistoryManager
-from IPython.core.inputsplitter import IPythonInputSplitter, ESC_MAGIC, ESC_MAGIC2
+from IPython.core.inputsplitter import ESC_MAGIC, ESC_MAGIC2
 from IPython.core.logger import Logger
 from IPython.core.macro import Macro
 from IPython.core.payload import PayloadManager
@@ -75,8 +75,10 from IPython.utils.strdispatch import StrDispatch
 from IPython.utils.syspathcontext import prepended_to_syspath
 from IPython.utils.text import (format_screen, LSString, SList,
                                 DollarFormatter)
-from traitlets import (Integer, Bool, CBool, CaselessStrEnum, Enum,
-                                     List, Dict, Unicode, Instance, Type)
+from traitlets import (
+    Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
+    observe, default,
+)
 from warnings import warn
 from logging import error
 import IPython.core.hooks
@@ -114,9 +116,6 def no_op(*a, **kw): pass
 
 class SpaceInInput(Exception): pass
 
-@undoc
-class Bunch: pass
-
 
 def get_default_colors():
     if sys.platform=='darwin':
@@ -173,14 +172,14 class InteractiveShell(SingletonConfigurable):
 
     _instance = None
     
-    ast_transformers = List([], config=True, help=
+    ast_transformers = List([], help=
         """
         A list of ast.NodeTransformer subclass instances, which will be applied
         to user input before code is run.
         """
-    )
+    ).tag(config=True)
 
-    autocall = Enum((0,1,2), default_value=0, config=True, help=
+    autocall = Enum((0,1,2), default_value=0, help=
         """
         Make IPython automatically call any callable object even if you didn't
         type explicit parentheses. For example, 'str 43' becomes 'str(43)'
@@ -189,28 +188,28 class InteractiveShell(SingletonConfigurable):
         arguments on the line, and '2' for 'full' autocall, where all callable
         objects are automatically called (even if no arguments are present).
         """
-    )
+    ).tag(config=True)
     # TODO: remove all autoindent logic and put into frontends.
     # We can't do this yet because even runlines uses the autoindent.
-    autoindent = CBool(True, config=True, help=
+    autoindent = Bool(True, help=
         """
         Autoindent IPython code entered interactively.
         """
-    )
-    automagic = CBool(True, config=True, help=
+    ).tag(config=True)
+    automagic = Bool(True, help=
         """
         Enable magic commands to be called without the leading %.
         """
-    )
+    ).tag(config=True)
     
-    banner1 = Unicode(default_banner, config=True,
+    banner1 = Unicode(default_banner,
         help="""The part of the banner to be printed before the profile"""
-    )
-    banner2 = Unicode('', config=True,
+    ).tag(config=True)
+    banner2 = Unicode('',
         help="""The part of the banner to be printed after the profile"""
-    )
+    ).tag(config=True)
 
-    cache_size = Integer(1000, config=True, help=
+    cache_size = Integer(1000, help=
         """
         Set the size of the output cache.  The default is 1000, you can
         change it permanently in your config file.  Setting it to 0 completely
@@ -219,19 +218,19 class InteractiveShell(SingletonConfigurable):
         issued).  This limit is defined because otherwise you'll spend more
         time re-flushing a too small cache than working
         """
-    )
-    color_info = CBool(True, config=True, help=
+    ).tag(config=True)
+    color_info = Bool(True, help=
         """
         Use colors for displaying information about objects. Because this
         information is passed through a pager (like 'less'), and some pagers
         get confused with color codes, this capability can be turned off.
         """
-    )
+    ).tag(config=True)
     colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
-                             default_value=get_default_colors(), config=True,
+                             default_value=get_default_colors(),
         help="Set the color scheme (NoColor, Linux, or LightBG)."
-    )
-    colors_force = CBool(False, help=
+    ).tag(config=True)
+    colors_force = Bool(False, help=
         """
         Force use of ANSI color codes, regardless of OS and readline
         availability.
@@ -240,8 +239,8 class InteractiveShell(SingletonConfigurable):
         # without readline on Win32. When the ZMQ formatting system is
         # refactored, this should be removed.
     )
-    debug = CBool(False, config=True)
-    deep_reload = CBool(False, config=True, help=
+    debug = Bool(False).tag(config=True)
+    deep_reload = Bool(False, help=
         """
         **Deprecated**
 
@@ -255,23 +254,24 class InteractiveShell(SingletonConfigurable):
         deep_reload is off, IPython will use the normal reload(), but
         deep_reload will still be available as dreload().
         """
-    )
-    disable_failing_post_execute = CBool(False, config=True,
+    ).tag(config=True)
+    disable_failing_post_execute = Bool(False,
         help="Don't call post-execute functions that have failed in the past."
-    )
+    ).tag(config=True)
     display_formatter = Instance(DisplayFormatter, allow_none=True)
     displayhook_class = Type(DisplayHook)
     display_pub_class = Type(DisplayPublisher)
     data_pub_class = None
 
-    exit_now = CBool(False)
+    exit_now = Bool(False)
     exiter = Instance(ExitAutocall)
+    @default('exiter')
     def _exiter_default(self):
         return ExitAutocall(self)
     # Monotonically increasing execution counter
     execution_count = Integer(1)
     filename = Unicode("<ipython console>")
-    ipython_dir= Unicode('', config=True) # Set to get_ipython_dir() in __init__
+    ipython_dir= Unicode('').tag(config=True) # Set to get_ipython_dir() in __init__
 
     # Input splitter, to transform input line by line and detect when a block
     # is ready to be executed.
@@ -283,88 +283,91 class InteractiveShell(SingletonConfigurable):
     input_transformer_manager = Instance('IPython.core.inputsplitter.IPythonInputSplitter',
                                          (), {'line_input_checker': False})
     
-    logstart = CBool(False, config=True, help=
+    logstart = Bool(False, help=
         """
         Start logging to the default log file in overwrite mode.
         Use `logappend` to specify a log file to **append** logs to.
         """
-