upstream/ipython Commit - r22340:04d48146

adopt traitlets 4.2 API...

Min RK -

r22340:04d48146

parent child

IPython/core/alias.py

0 +2 -2

             class AliasManager(Configurable):
-                default_aliases = List(default_aliases(), config=True)
+                default_aliases = List(default_aliases()).tag(config=True)
-                user_aliases = List(default_value=[], 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

0 +47 -26

             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)
                 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):
+                @observe('config_file_name')
-                    if new != old:
+                def _config_file_name_changed(self, change):
-                        self.config_file_specified.add(new)
+                    if change['new'] != change['old']:
+                        self.config_file_specified.add(change['new'])
                 # The directory that contains IPython's builtin profiles.
                 builtin_profile_dir = Unicode(
                 )
                 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.
-                """)
+                """).tag(config=True)
-                def _extra_config_file_changed(self, name, old, new):
+                @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:
                     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."""
+                ).tag(config=True)
-                def _profile_changed(self, name, old, new):
+                @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:
                     self.init_profile_dir()
                     return self.profile_dir
-                overwrite = Bool(False, config=True,
+                overwrite = Bool(False,
-                    help="""Whether to overwrite existing config files when copying""")
+                    help="""Whether to overwrite existing config files when copying"""
-                auto_create = Bool(False, config=True,
+                ).tag(config=True)
-                    help="""Whether to create profile dir if it doesn't exist""")
+                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)
                 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 "
                         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

0 +18 -18

             import unicodedata
             import string
             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
             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
                     return path
             def completions_sorting_key(word):
                 """key for sorting completions
             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):
                 try :
                     unic = unicodedata.name(char)
                     return '\\'+char,['\\'+unic]
-                except KeyError as e:
+                except KeyError:
                     pass
                 return u'', ()
                     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
                     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.
                     """
+                ).tag(config=True)
-                omit__names = Enum((0,1,2), default_value=2, 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>``.
                     When 0: nothing will be excluded.
                     """
+                ).tag(config=True)
-                limit_to__all__ = CBool(default_value=False, config=True,
+                limit_to__all__ = Bool(False,
                     help="""
                     DEPRECATED as of version 5.0.
                     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):
                             # allow combining chars
                             if ('a'+unic).isidentifier():
                                 return '\\'+s,[unic]
-                        except KeyError as e:
+                        except KeyError:
                             pass
                     return u'', []

IPython/core/formatters.py

0 +17 -8

             from traitlets import (
                 Bool, Dict, Integer, Unicode, CUnicode, ObjectName, List,
                 ForwardDeclaredInstance,
+                default, observe,
             )
             from IPython.utils.py3compat import (
                 with_metaclass, string_types, unicode_type,
                     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 = [
                 # 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_')
                     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

0 +15 -11

             from IPython.utils import py3compat
             from traitlets import (
                 Any, Bool, Dict, Instance, Integer, List, Unicode, TraitError,
+                default, observe,
             )
             from warnings import warn
                 _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
                         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,
                     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)
                 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()]
                 # 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)"
+                ).tag(config=True)
-                db_cache_size = Integer(0, 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

0 +86 -81

             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
             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,
+            from traitlets import (
-                                                 List, Dict, Unicode, Instance, Type)
+                Integer, Bool, CaselessStrEnum, Enum, List, Dict, Unicode, Instance, Type,
+                observe, default,
+            )
             from warnings import warn
             from logging import error
             import IPython.core.hooks
             class SpaceInInput(Exception): pass
-            @undoc
-            class Bunch: pass
             def get_default_colors():
                 if sys.platform=='darwin':
                 _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)'
                     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.
                     """
+                ).tag(config=True)
-                automagic = CBool(True, config=True, help=
+                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"""
+                ).tag(config=True)
-                banner2 = Unicode('', 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
                     issued).  This limit is defined because otherwise you'll spend more
                     time re-flushing a too small cache than working
                     """
+                ).tag(config=True)
-                color_info = CBool(True, config=True, help=
+                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)."
+                ).tag(config=True)
-                colors_force = CBool(False, help=
+                colors_force = Bool(False, help=
                     """
                     Force use of ANSI color codes, regardless of OS and readline
                     availability.
                     # without readline on Win32. When the ZMQ formatting system is
                     # refactored, this should be removed.
                 )
-                debug = CBool(False, config=True)
+                debug = Bool(False).tag(config=True)
-                deep_reload = CBool(False, config=True, help=
+                deep_reload = Bool(False, help=
                     """
                     **Deprecated**
                     deep_reload is off, IPython will use the normal reload(), but
                     deep_reload will still be available as dreload().
                     """
+                ).tag(config=True)
-                disable_failing_post_execute = CBool(False, 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.
                 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.
                     """
+                ).tag(config=True)
-                logfile = Unicode('', config=True, help=
+                logfile = Unicode('', help=
                     """
                     The name of the logfile to use.
                     """
+                ).tag(config=True)
-                logappend = Unicode('', config=True, help=
+                logappend = Unicode('', help=
                     """
                     Start logging to the given file in append mode.
                     Use `logfile` to specify a log file to **overwrite** logs to.
                     """
+                ).tag(config=True)
                 object_info_string_level = Enum((0,1,2), default_value=0,
-                                                config=True)
+                ).tag(config=True)
-                pdb = CBool(False, config=True, help=
+                pdb = Bool(False, help=
                     """
                     Automatically call the pdb debugger after every exception.
                     """
+                ).tag(config=True)
-                multiline_history = CBool(sys.platform != 'win32', config=True,
+                multiline_history = Bool(sys.platform != 'win32',
                     help="Save multi-line entries as one entry in readline history"
+                ).tag(config=True)
-                display_page = Bool(False, config=True,
+                display_page = Bool(False,
                     help="""If True, anything that would be passed to the pager
                     will be displayed as regular output instead."""
+                ).tag(config=True)
                 # deprecated prompt traits:
-                prompt_in1 = Unicode('In [\\#]: ', config=True,
+                prompt_in1 = Unicode('In [\\#]: ',
-                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.in_template")
+                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.in_template"
-                prompt_in2 = Unicode('   .\\D.: ', config=True,
+                ).tag(config=True)
-                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.in2_template")
+                prompt_in2 = Unicode('   .\\D.: ',
-                prompt_out = Unicode('Out[\\#]: ', config=True,
+                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.in2_template"
-                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.out_template")
+                ).tag(config=True)
-                prompts_pad_left = CBool(True, config=True,
+                prompt_out = Unicode('Out[\\#]: ',
-                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.justify")
+                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.out_template"
+                ).tag(config=True)
+                prompts_pad_left = Bool(True,
+                    help="Deprecated, will be removed in IPython 5.0, use PromptManager.justify"
+                ).tag(config=True)
-                def _prompt_trait_changed(self, name, old, new):
+                @observe('prompt_in1', 'prompt_in2', 'prompt_out', 'prompt_pad_left')
+                def _prompt_trait_changed(self, change):
                     table = {
                         'prompt_in1' : 'in_template',
                         'prompt_in2' : 'in2_template',
                         'prompt_out' : 'out_template',
                         'prompts_pad_left' : 'justify',
                     }
+                    name = change['name']
                     warn("InteractiveShell.{name} is deprecated, use PromptManager.{newname}".format(
                             name=name, newname=table[name])
                     )
                     # protect against weird cases where self.config may not exist:
                     if self.config is not None:
                         # propagate to corresponding PromptManager trait
-                        setattr(self.config.PromptManager, table[name], new)
+                        setattr(self.config.PromptManager, table[name], change['new'])
-                _prompt_in1_changed = _prompt_trait_changed
-                _prompt_in2_changed = _prompt_trait_changed
-                _prompt_out_changed = _prompt_trait_changed
-                _prompt_pad_left_changed = _prompt_trait_changed
-                show_rewritten_input = CBool(True, config=True,
+                show_rewritten_input = Bool(True,
                     help="Show rewritten input, e.g. for autocall."
+                ).tag(config=True)
-                quiet = CBool(False, config=True)
+                quiet = Bool(False).tag(config=True)
-                history_length = Integer(10000, config=True)
+                history_length = Integer(10000,
+                    help='Total length of command history'
+                ).tag(config=True)
-                history_load_length = Integer(1000, config=True, help=
+                history_load_length = Integer(1000, help=
                     """
                     The number of saved history entries to be loaded
                     into the readline buffer at startup.
                     """
+                ).tag(config=True)
                 # The readline stuff will eventually be moved to the terminal subclass
                 # but for now, we can't do that as readline is welded in everywhere.
-                readline_use = CBool(True, config=True)
+                readline_use = Bool(True).tag(config=True)
-                readline_remove_delims = Unicode('-/~', config=True)
+                readline_remove_delims = Unicode('-/~').tag(config=True)
                 readline_delims = Unicode() # set by init_readline()
                 # don't use \M- bindings by default, because they
                 # conflict with 8-bit encodings. See gh-58,gh-88
                         '"\e[B": history-search-forward',
                         '"\C-k": kill-line',
                         '"\C-u": unix-line-discard',
-                    ], config=True)
+                    ]).tag(config=True)
                 _custom_readline_config = False
-                def _readline_parse_and_bind_changed(self, name, old, new):
+                @observe('readline_parse_and_bind')
+                def _readline_parse_and_bind_changed(self, change):
                     # notice that readline config is customized
                     # indicates that it should have higher priority than inputrc
                     self._custom_readline_config = True
                 ast_node_interactivity = Enum(['all', 'last', 'last_expr', 'none'],
-                                              default_value='last_expr', config=True,
+                                              default_value='last_expr',
                                               help="""
                     'all', 'last', 'last_expr' or 'none', specifying which nodes should be
-                    run interactively (displaying output from expressions).""")
+                    run interactively (displaying output from expressions)."""
+                ).tag(config=True)
                 # TODO: this part of prompt management should be moved to the frontends.
                 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
-                separate_in = SeparateUnicode('\n', config=True)
+                separate_in = SeparateUnicode('\n').tag(config=True)
-                separate_out = SeparateUnicode('', config=True)
+                separate_out = SeparateUnicode('').tag(config=True)
-                separate_out2 = SeparateUnicode('', config=True)
+                separate_out2 = SeparateUnicode('').tag(config=True)
-                wildcards_case_sensitive = CBool(True, config=True)
+                wildcards_case_sensitive = Bool(True).tag(config=True)
                 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
-                                        default_value='Context', config=True)
+                                        default_value='Context').tag(config=True)
                 # Subcomponents of InteractiveShell
                 alias_manager = Instance('IPython.core.alias.AliasManager', allow_none=True)
                 #-------------------------------------------------------------------------
                 # Trait changed handlers
                 #-------------------------------------------------------------------------
+                @observe('ipython_dir')
-                def _ipython_dir_changed(self, name, new):
+                def _ipython_dir_changed(self, change):
-                    ensure_dir_exists(new)
+                    ensure_dir_exists(change['new'])
                 def set_autoindent(self,value=None):
                     """Set the autoindent flag.
                 def show_banner(self, banner=None):
                     if banner is None:
                         banner = self.banner
-                    self.write(banner)
+                    sys.stdout.write(banner)
                 #-------------------------------------------------------------------------
                 # Things related to hooks

IPython/core/magic.py

0 +7 -11

             #  the file COPYING, distributed as part of this software.
             #-----------------------------------------------------------------------------
-            #-----------------------------------------------------------------------------
-            # Imports
-            #-----------------------------------------------------------------------------
-            # Stdlib
             import os
             import re
             import sys
             import types
             from getopt import getopt, GetoptError
-            # Our own
             from traitlets.config.configurable import Configurable
             from IPython.core import oinspect
             from IPython.core.error import UsageError
             from IPython.utils.process import arg_split
             from IPython.utils.py3compat import string_types, iteritems
             from IPython.utils.text import dedent
-            from traitlets import Bool, Dict, Instance
+            from traitlets import Bool, Dict, Instance, observe
             from logging import error
             #-----------------------------------------------------------------------------
                 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
-                auto_magic = Bool(True, config=True, help=
+                auto_magic = Bool(True, help=
-                    "Automatically call line magics without requiring explicit % prefix")
+                    "Automatically call line magics without requiring explicit % prefix"
+                ).tag(config=True)
-                def _auto_magic_changed(self, name, value):
+                @observe('auto_magic')
-                    self.shell.automagic = value
+                def _auto_magic_changed(self, change):
+                    self.shell.automagic = change['new']
                 _auto_status = [
                     'Automagic is OFF, % prefix IS needed for line magics.',

IPython/core/magics/script.py

0 +8 -18

             """Magic functions for running cells in various scripts."""
             from __future__ import print_function
-            #-----------------------------------------------------------------------------
-            #  Copyright (c) 2012 The IPython Development Team.
-            #  Distributed under the terms of the Modified BSD License.
-            #  The full license is in the file COPYING.txt, distributed with this software.
-            #-----------------------------------------------------------------------------
-            #-----------------------------------------------------------------------------
+            # Copyright (c) IPython Development Team.
-            # Imports
+            # Distributed under the terms of the Modified BSD License.
-            #-----------------------------------------------------------------------------
-            # Stdlib
             import errno
             import os
             import sys
             from subprocess import Popen, PIPE
             import atexit
-            # Our own packages
-            from traitlets.config.configurable import Configurable
             from IPython.core import magic_arguments
             from IPython.core.magic import  (
                 Magics, magics_class, line_magic, cell_magic
             from IPython.lib.backgroundjobs import BackgroundJobManager
             from IPython.utils import py3compat
             from IPython.utils.process import arg_split
-            from traitlets import List, Dict
+            from traitlets import List, Dict, default
             #-----------------------------------------------------------------------------
             # Magic implementation classes
                 with a program in a subprocess, and registers a few top-level
                 magics that call %%script with common interpreters.
                 """
-                script_magics = List(config=True,
+                script_magics = List(
                     help="""Extra script cell magics to define
                     This generates simple wrappers of `%%script foo` as `%%foo`.
                     If you want to add script magics that aren't on your path,
                     specify them in script_paths
                     """,
+                ).tag(config=True)
+                @default('script_magics')
                 def _script_magics_default(self):
                     """default to a common list of programs"""
                     return defaults
-                script_paths = Dict(config=True,
+                script_paths = Dict(
                     help="""Dict mapping short 'ruby' names to full paths, such as '/opt/secret/bin/ruby'
                     Only necessary for items in script_magics where the default path will not
                     find the right interpreter.
                     """
+                ).tag(config=True)
                 def __init__(self, shell=None):
                     super(ScriptMagics, self).__init__(shell=shell)

IPython/core/prefilter.py

0 +4 -19

             Prefilters transform user input before it is exec'd by Python.  These
             transforms are used to implement additional syntax such as !ls and %magic.
-            Authors:
-            * Brian Granger
-            * Fernando Perez
-            * Dan Milstein
-            * Ville Vainio
             """
-            #-----------------------------------------------------------------------------
+            # Copyright (c) IPython Development Team.
-            #  Copyright (C) 2008-2011  The IPython Development Team
+            # Distributed under the terms of the Modified BSD License.
-            #  Distributed under the terms of the BSD License.  The full license is in
-            #  the file COPYING, distributed as part of this software.
-            #-----------------------------------------------------------------------------
-            #-----------------------------------------------------------------------------
-            # Imports
-            #-----------------------------------------------------------------------------
             from keyword import iskeyword
             import re
             from IPython.core.splitinput import LineInfo
             from traitlets import (
-                List, Integer, Unicode, CBool, Bool, Instance, CRegExp
+                List, Integer, Unicode, Bool, Instance, CRegExp
             )
             #-----------------------------------------------------------------------------
                 or :meth:`sort_transformers` method after changing the priority.
                 """
-                multi_line_specials = CBool(True).tag(config=True)
+                multi_line_specials = Bool(True).tag(config=True)
                 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC', allow_none=True)
                 def __init__(self, shell=None, **kwargs):

IPython/core/profiledir.py

0 +17 -27

             from IPython.paths import get_ipython_package_dir
             from IPython.utils.path import expand_path, ensure_dir_exists
             from IPython.utils import py3compat
-            from traitlets import Unicode, Bool
+            from traitlets import Unicode, Bool, observe
             #-----------------------------------------------------------------------------
             # Module errors
                 pid_dir = Unicode(u'')
                 static_dir = Unicode(u'')
-                location = Unicode(u'', config=True,
+                location = Unicode(u'',
                     help="""Set the profile location directly. This overrides the logic used by the
                     `profile` option.""",
+                    ).tag(config=True)
                 _location_isset = Bool(False) # flag for detecting multiply set location
+                @observe('location')
-                def _location_changed(self, name, old, new):
+                def _location_changed(self, change):
                     if self._location_isset:
                         raise RuntimeError("Cannot set profile location more than once.")
                     self._location_isset = True
+                    new = change['new']
                     ensure_dir_exists(new)
                     # ensure config files exist:
                     self.pid_dir = os.path.join(new, self.pid_dir_name)
                     self.static_dir = os.path.join(new, self.static_dir_name)
                     self.check_dirs()
-                def _log_dir_changed(self, name, old, new):
-                    self.check_log_dir()
                 def _mkdir(self, path, mode=None):
                     """ensure a directory exists at a given path
                             raise
                     return True
-                def check_log_dir(self):
+                @observe('log_dir')
+                def check_log_dir(self, change=None):
                     self._mkdir(self.log_dir)
-                def _startup_dir_changed(self, name, old, new):
+                @observe('startup_dir')
-                    self.check_startup_dir()
+                def check_startup_dir(self, change=None):
-                def check_startup_dir(self):
                     self._mkdir(self.startup_dir)
                     readme = os.path.join(self.startup_dir, 'README')
                     if os.path.exists(src) and not os.path.exists(readme):
                         shutil.copy(src, readme)
-                def _security_dir_changed(self, name, old, new):
+                @observe('security_dir')
-                    self.check_security_dir()
+                def check_security_dir(self, change=None):
-                def check_security_dir(self):
                     self._mkdir(self.security_dir, 0o40700)
-                def _pid_dir_changed(self, name, old, new):
+                @observe('pid_dir')
-                    self.check_pid_dir()
+                def check_pid_dir(self, change=None):
-                def check_pid_dir(self):
                     self._mkdir(self.pid_dir, 0o40700)
-                def _static_dir_changed(self, name, old, new):
-                    self.check_startup_dir()
                 def check_dirs(self):
                     self.check_security_dir()
                     self.check_log_dir()

IPython/core/prompts.py

0 +12 -23

             # -*- coding: utf-8 -*-
-            """Classes for handling input/output prompts.
+            """Classes for handling input/output prompts."""
-            Authors:
+            # Copyright (c) 2001-2007 Fernando Perez <fperez@colorado.edu>
+            # Copyright (c) IPython Development Team.
-            * Fernando Perez
+            # Distributed under the terms of the Modified BSD License.
-            * Brian Granger
-            * Thomas Kluyver
-            """
-            #-----------------------------------------------------------------------------
-            #       Copyright (C) 2008-2011 The IPython Development Team
-            #       Copyright (C) 2001-2007 Fernando Perez <fperez@colorado.edu>
-            #  Distributed under the terms of the BSD License.  The full license is in
-            #  the file COPYING, distributed as part of this software.
-            #-----------------------------------------------------------------------------
-            #-----------------------------------------------------------------------------
-            # Imports
-            #-----------------------------------------------------------------------------
             import os
             import re
             from traitlets.config.configurable import Configurable
             from IPython.core import release
             from IPython.utils import coloransi, py3compat
-            from traitlets import Unicode, Instance, Dict, Bool, Int, observe
+            from traitlets import Unicode, Instance, Dict, Bool, Int, observe, default
             from IPython.utils.PyColorize import LightBGColors, LinuxColors, NoColor
                     things like the current time in the prompts. Functions are only called
                     if they are used in the prompt.
                     """)
-                def _lazy_evaluate_fields_default(self): return lazily_evaluate.copy()
                 in_template = Unicode('In [\\#]: ',
                     help="Input prompt.  '\\#' will be transformed to the prompt number"
                     help="Output prompt. '\\#' will be transformed to the prompt number"
                     ).tag(config=True)
+                @default('lazy_evaluate_fields')
+                def _lazy_evaluate_fields_default(self):
+                    return lazily_evaluate.copy()
                 justify = Bool(True, help="""
                     If True (default), each prompt will be right-aligned with the
                     preceding one.
                 # The number of characters in each prompt which don't contribute to width
                 invisible_chars = Dict()
+                @default('invisible_chars')
                 def _invisible_chars_default(self):
                     return {'in': 0, 'in2': 0, 'out': 0, 'rewrite':0}
                     self.update_prompt('in2', self.in2_template)
                     self.update_prompt('out', self.out_template)
                     self.update_prompt('rewrite')
-                    self.on_trait_change(self._update_prompt_trait, ['in_template',
+                    self.observe(self._update_prompt_trait,
-                                        'in2_template', 'out_template'])
+                        names=['in_template', 'in2_template', 'out_template'])
                 def update_prompt(self, name, new_template=None):
                     """This is called when a prompt template is updated. It processes

IPython/core/shellapp.py

0 +31 -34

             from IPython.utils.contexts import preserve_keys
             from IPython.utils.path import filefind
             from traitlets import (
-                Unicode, Instance, List, Bool, CaselessStrEnum
+                Unicode, Instance, List, Bool, CaselessStrEnum, default, observe,
             )
             from IPython.lib.inputhook import guis
                   - :meth:`init_extensions`
                   - :meth:`init_code`
                 """
-                extensions = List(Unicode(), config=True,
+                extensions = List(Unicode(),
                     help="A list of dotted module names of IPython extensions to load."
+                ).tag(config=True)
-                extra_extension = Unicode('', config=True,
+                extra_extension = Unicode('',
                     help="dotted module name of an IPython extension to load."
+                ).tag(config=True)
-                reraise_ipython_extension_failures = Bool(
+                reraise_ipython_extension_failures = Bool(False,
-                    False,
-                    config=True,
                     help="Reraise exceptions encountered loading IPython extensions?",
+                ).tag(config=True)
                 # Extensions that are always loaded (not configurable)
-                default_extensions = List(Unicode(), [u'storemagic'], config=False)
+                default_extensions = List(Unicode(), [u'storemagic']).tag(config=False)
-                hide_initial_ns = Bool(True, config=True,
+                hide_initial_ns = Bool(True,
                     help="""Should variables loaded at startup (by startup files, exec_lines, etc.)
                     be hidden from tools like %who?"""
+                ).tag(config=True)
-                exec_files = List(Unicode(), config=True,
+                exec_files = List(Unicode(),
                     help="""List of files to run at IPython startup."""
+                ).tag(config=True)
-                exec_PYTHONSTARTUP = Bool(True, config=True,
+                exec_PYTHONSTARTUP = Bool(True,
                     help="""Run the file referenced by the PYTHONSTARTUP environment
                     variable at IPython startup."""
+                ).tag(config=True)
-                file_to_run = Unicode('', config=True,
+                file_to_run = Unicode('',
-                    help="""A file to be run""")
+                    help="""A file to be run""").tag(config=True)
-                exec_lines = List(Unicode(), config=True,
+                exec_lines = List(Unicode(),
                     help="""lines of code to run at IPython startup."""
+                ).tag(config=True)
-                code_to_run = Unicode('', config=True,
+                code_to_run = Unicode('',
                     help="Execute the given command string."
+                ).tag(config=True)
-                module_to_run = Unicode('', config=True,
+                module_to_run = Unicode('',
                     help="Run the module as a script."
+                ).tag(config=True)
-                gui = CaselessStrEnum(gui_keys, config=True, allow_none=True,
+                gui = CaselessStrEnum(gui_keys, allow_none=True,
                     help="Enable GUI event loop integration with any of {0}.".format(gui_keys)
+                ).tag(config=True)
                 matplotlib = CaselessStrEnum(backend_keys, allow_none=True,
-                    config=True,
                     help="""Configure matplotlib for interactive use with
                     the default matplotlib backend."""
+                ).tag(config=True)
                 pylab = CaselessStrEnum(backend_keys, allow_none=True,
-                    config=True,
                     help="""Pre-load matplotlib and numpy for interactive use,
                     selecting a particular matplotlib backend and loop integration.
                     """
+                ).tag(config=True)
-                pylab_import_all = Bool(True, config=True,
+                pylab_import_all = Bool(True,
                     help="""If true, IPython will populate the user namespace with numpy, pylab, etc.
                     and an ``import *`` is done from numpy and pylab, when using pylab mode.
                     When False, pylab mode should not import any names into the user namespace.
                     """
+                ).tag(config=True)
                 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC',
                                  allow_none=True)
                 # whether interact-loop should start
                 interact = Bool(True)
                 user_ns = Instance(dict, args=None, allow_none=True)
-                def _user_ns_changed(self, name, old, new):
+                @observe('user_ns')
+                def _user_ns_changed(self, change):
                     if self.shell is not None:
-                        self.shell.user_ns = new
+                        self.shell.user_ns = change['new']
                         self.shell.init_user_ns()
                 def init_path(self):

IPython/extensions/storemagic.py

0 +6 -19

               c.StoreMagics.autorestore = True
             """
             from __future__ import print_function
-            #-----------------------------------------------------------------------------
-            #  Copyright (c) 2012, The IPython Development Team.
+            # Copyright (c) IPython Development Team.
+            # Distributed under the terms of the Modified BSD License.
-            #  Distributed under the terms of the Modified BSD License.
-            #  The full license is in the file COPYING.txt, distributed with this software.
-            #-----------------------------------------------------------------------------
-            #-----------------------------------------------------------------------------
-            # Imports
-            #-----------------------------------------------------------------------------
-            # Stdlib
             import inspect, os, sys, textwrap
-            # Our own
             from IPython.core.error import UsageError
             from IPython.core.magic import Magics, magics_class, line_magic
             from traitlets import Bool
             from IPython.utils.py3compat import string_types
-            #-----------------------------------------------------------------------------
-            # Functions and classes
-            #-----------------------------------------------------------------------------
             def restore_aliases(ip):
                 staliases = ip.db.get('stored_aliases', {})
                 Provides the %store magic."""
-                autorestore = Bool(False, config=True, help=
+                autorestore = Bool(False, help=
                     """If True, any %store-d variables will be automatically restored
                     when IPython starts.
                     """
+                ).tag(config=True)
                 def __init__(self, shell):
                     super(StoreMagics, self).__init__(shell=shell)

IPython/terminal/ipapp.py

0 +20 -17

             import logging
             import os
             import sys
+            import warnings
             from traitlets.config.loader import Config
             from traitlets.config.application import boolean_flag, catch_config_error, Application
             )
             from IPython.extensions.storemagic import StoreMagics
             from .ptshell import TerminalInteractiveShell
-            from IPython.utils import warn
             from IPython.paths import get_ipython_dir
             from traitlets import (
-                Bool, List, Dict,
+                Bool, List, Dict, default, observe,
             )
             #-----------------------------------------------------------------------------
                 flags = Dict(flags)
                 aliases = Dict(aliases)
                 classes = List()
+                @default('classes')
                 def _classes_default(self):
                     """This has to be in a method, for TerminalIPythonApp to be available."""
                     return [
                 # *do* autocreate requested profile, but don't create the config file.
                 auto_create=Bool(True)
                 # configurables
-                quick = Bool(False, config=True,
+                quick = Bool(False,
                     help="""Start IPython quickly by skipping the loading of config files."""
+                ).tag(config=True)
-                def _quick_changed(self, name, old, new):
+                @observe('quick')
-                    if new:
+                def _quick_changed(self, change):
+                    if change['new']:
                         self.load_config_file = lambda *a, **kw: None
-                display_banner = Bool(True, config=True,
+                display_banner = Bool(True,
                     help="Whether to display a banner upon starting IPython."
+                ).tag(config=True)
                 # if there is code of files to run from the cmd line, don't interact
                 # unless the --i flag (App.force_interact) is true.
-                force_interact = Bool(False, config=True,
+                force_interact = Bool(False,
                     help="""If a command or file is given via the command-line,
                     e.g. 'ipython foo.py', start an interactive shell after executing the
                     file or command."""
+                ).tag(config=True)
-                def _force_interact_changed(self, name, old, new):
+                @observe('force_interact')
-                    if new:
+                def _force_interact_changed(self, change):
+                    if change['new']:
                         self.interact = True
-                def _file_to_run_changed(self, name, old, new):
+                @observe('file_to_run', 'code_to_run', 'module_to_run')
+                def _file_to_run_changed(self, change):
+                    new = change['new']
                     if new:
                         self.something_to_run = True
                     if new and not self.force_interact:
                             self.interact = False
-                _code_to_run_changed = _file_to_run_changed
-                _module_to_run_changed = _file_to_run_changed
                 # internal, not-configurable
                 something_to_run=Bool(False)
                         # warn and transform into current syntax
                         argv = argv[:] # copy, don't clobber
                         idx = argv.index('-pylab')
-                        warn.warn("`-pylab` flag has been deprecated.\n"
+                        warnings.warn("`-pylab` flag has been deprecated.\n"
                         "    Use `--matplotlib <backend>` and import pylab manually.")
                         argv[idx] = '--pylab'
                 def _pylab_changed(self, name, old, new):
                     """Replace --pylab='inline' with --pylab='auto'"""
                     if new == 'inline':
-                        warn.warn("'inline' not available as pylab backend, "
+                        warnings.warn("'inline' not available as pylab backend, "
                                   "using 'auto' instead.")
                         self.pylab = 'auto'

IPython/terminal/ptshell.py

0 +13 -10

             from IPython.utils.py3compat import PY3, cast_unicode_py2, input
             from IPython.utils.terminal import toggle_set_term_title, set_term_title
             from IPython.utils.process import abbrev_cwd
-            from traitlets import Bool, CBool, Unicode, Dict, Integer, observe
+            from traitlets import Bool, Unicode, Dict, Integer, observe
             from prompt_toolkit.completion import Completer, Completion
             from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER, EditingMode
                 pt_cli = None
-                autoedit_syntax = CBool(False).tag(config=True,
+                autoedit_syntax = Bool(False,
-                                        help="auto editing of files with syntax errors.")
+                    help="auto editing of files with syntax errors.",
+                ).tag(config=True)
-                confirm_exit = CBool(True).tag(config=True,
+                confirm_exit = Bool(True,
                     help="""
                     Set to confirm when you try to exit IPython with an EOF (Control-D
                     in Unix, Control-Z/Enter in Windows). By typing 'exit' or 'quit',
                     you can force a direct exit without any confirmation.""",
+                ).tag(config=True)
                 editing_mode = Unicode('emacs',
                     help="Shortcut style to use at the prompt. 'vi' or 'emacs'.",
                 ).tag(config=True)
                         help="The name of a Pygments style to use for syntax highlighting: \n %s" % ', '.join(get_all_styles())
                 ).tag(config=True)
-                def _highlighting_style_changed(self, old, new):
+                @observe('highlighting_style')
+                def _highlighting_style_changed(self, change):
                     self._style = self._make_style_from_name(self.highlighting_style)
                 highlighting_style_overrides = Dict(
                     help="Display a multi column completion menu.",
                 ).tag(config=True)
-                @observe('term_title')
-                def _term_title_changed(self, change):
-                    self.init_term_title()
-                def init_term_title(self):
+                @observe('term_title')
+                def init_term_title(self, change=None):
                     # Enable or disable the terminal title.
                     if self.term_title:
                         toggle_set_term_title(True)

IPython/utils/colorable.py

0 +1 -1

                 """
                 A subclass of configurable for all the classes that have a `default_scheme`
                 """
-                default_style=Unicode('lightbg', config=True)
+                default_style=Unicode('lightbg').tag(config=True)

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages