upstream/ipython Commit - r4073:83ed9bae

Merge branch 'traitlets-str' into traitlets-str-merge...

Thomas Kluyver -

r4073:83ed9bae

parent child

IPython/config/tests/test_configurable.py

0 +4 -4

             )
             from IPython.utils.traitlets import (
-                Int, Float, Str
+                Int, Float, Unicode
             )
             from IPython.config.loader import Config
             class MyConfigurable(Configurable):
                 a = Int(1, config=True, help="The integer a.")
                 b = Float(1.0, config=True, help="The integer b.")
-                c = Str('no config')
+                c = Unicode('no config')
             mc_help=u"""MyConfigurable options
             class Foo(Configurable):
                 a = Int(0, config=True, help="The integer a.")
-                b = Str('nope', config=True)
+                b = Unicode('nope', config=True)
             class Bar(Foo):
-                b = Str('gotit', config=False, help="The string b.")
+                b = Unicode('gotit', config=False, help="The string b.")
                 c = Float(config=True, help="The string c.")

IPython/core/formatters.py

0 +20 -20

             # Our own imports
             from IPython.config.configurable import Configurable
             from IPython.lib import pretty
-            from IPython.utils.traitlets import Bool, Dict, Int, Str, CStr
+            from IPython.utils.traitlets import Bool, Dict, Int, Unicode, CUnicode, ObjectName
             #-----------------------------------------------------------------------------
                 returned and this format type is not used.
                 """
-                format_type = Str('text/plain')
+                format_type = Unicode('text/plain')
                 enabled = Bool(True, config=True)
-                print_method = Str('__repr__')
+                print_method = ObjectName('__repr__')
                 # The singleton printers.
                 # Maps the IDs of the builtin singleton objects to the format functions.
                 """
                 # The format type of data returned.
-                format_type = Str('text/plain')
+                format_type = Unicode('text/plain')
                 # This subclass ignores this attribute as it always need to return
                 # something.
                 enabled = Bool(True, config=False)
                 # Look for a _repr_pretty_ methods to use for pretty printing.
-                print_method = Str('_repr_pretty_')
+                print_method = ObjectName('_repr_pretty_')
                 # Whether to pretty-print or not.
                 pprint = Bool(True, config=True)
                 max_width = Int(79, config=True)
                 # The newline character.
-                newline = Str('\n', config=True)
+                newline = Unicode('\n', config=True)
                 # format-string for pprinting floats
-                float_format = Str('%r')
+                float_format = Unicode('%r')
                 # setter for float precision, either int or direct format-string
-                float_precision = CStr('', config=True)
+                float_precision = CUnicode('', config=True)
                 def _float_precision_changed(self, name, old, new):
                     """float_precision changed, set float_format accordingly.
                 could be injected into an existing DOM. It should *not* include the
                 ```<html>`` or ```<body>`` tags.
                 """
-                format_type = Str('text/html')
+                format_type = Unicode('text/html')
-                print_method = Str('_repr_html_')
+                print_method = ObjectName('_repr_html_')
             class SVGFormatter(BaseFormatter):
                 ```<svg>``` tags, that could be injected into an existing DOM. It should
                 *not* include the ```<html>`` or ```<body>`` tags.
                 """
-                format_type = Str('image/svg+xml')
+                format_type = Unicode('image/svg+xml')
-                print_method = Str('_repr_svg_')
+                print_method = ObjectName('_repr_svg_')
             class PNGFormatter(BaseFormatter):
                 The return value of this formatter should be raw PNG data, *not*
                 base64 encoded.
                 """
-                format_type = Str('image/png')
+                format_type = Unicode('image/png')
-                print_method = Str('_repr_png_')
+                print_method = ObjectName('_repr_png_')
             class LatexFormatter(BaseFormatter):
                 The return value of this formatter should be a valid LaTeX equation,
                 enclosed in either ```$``` or ```$$```.
                 """
-                format_type = Str('text/latex')
+                format_type = Unicode('text/latex')
-                print_method = Str('_repr_latex_')
+                print_method = ObjectName('_repr_latex_')
             class JSONFormatter(BaseFormatter):
                 The return value of this formatter should be a valid JSON string.
                 """
-                format_type = Str('application/json')
+                format_type = Unicode('application/json')
-                print_method = Str('_repr_json_')
+                print_method = ObjectName('_repr_json_')
             class JavascriptFormatter(BaseFormatter):
                 The return value of this formatter should be valid Javascript code and
                 should *not* be enclosed in ```<script>``` tags.
                 """
-                format_type = Str('application/javascript')
+                format_type = Unicode('application/javascript')
-                print_method = Str('_repr_javascript_')
+                print_method = ObjectName('_repr_javascript_')
             FormatterABC.register(BaseFormatter)
             FormatterABC.register(PlainTextFormatter)

IPython/core/interactiveshell.py

0 +14 -13

             from IPython.utils.strdispatch import StrDispatch
             from IPython.utils.syspathcontext import prepended_to_syspath
             from IPython.utils.text import num_ini_spaces, format_screen, LSString, SList
-            from IPython.utils.traitlets import (Int, Str, CBool, CaselessStrEnum, Enum,
+            from IPython.utils.traitlets import (Int, CBool, CaselessStrEnum, Enum,
                                                  List, Unicode, Instance, Type)
             from IPython.utils.warn import warn, error, fatal
             import IPython.core.hooks
                     return 'Linux'
-            class SeparateStr(Str):
+            class SeparateUnicode(Unicode):
-                """A Str subclass to validate separate_in, separate_out, etc.
+                """A Unicode subclass to validate separate_in, separate_out, etc.
-                This is a Str based trait that converts '0'->'' and '\\n'->'\n'.
+                This is a Unicode based trait that converts '0'->'' and '\\n'->'\n'.
                 """
                 def validate(self, obj, value):
                     if value == '0': value = ''
                     value = value.replace('\\n','\n')
-                    return super(SeparateStr, self).validate(obj, value)
+                    return super(SeparateUnicode, self).validate(obj, value)
             class ReadlineNoRecord(object):
                     """
                 )
-                prompt_in1 = Str('In [\\#]: ', config=True)
+                prompt_in1 = Unicode('In [\\#]: ', config=True)
-                prompt_in2 = Str('   .\\D.: ', config=True)
+                prompt_in2 = Unicode('   .\\D.: ', config=True)
-                prompt_out = Str('Out[\\#]: ', config=True)
+                prompt_out = Unicode('Out[\\#]: ', config=True)
                 prompts_pad_left = CBool(True, config=True)
                 quiet = CBool(False, config=True)
                 readline_use = CBool(True, config=True)
                 readline_merge_completions = CBool(True, config=True)
                 readline_omit__names = Enum((0,1,2), default_value=2, config=True)
-                readline_remove_delims = Str('-/~', config=True)
+                readline_remove_delims = Unicode('-/~', config=True)
                 # don't use \M- bindings by default, because they
                 # conflict with 8-bit encodings. See gh-58,gh-88
                 readline_parse_and_bind = List([
                 # TODO: this part of prompt management should be moved to the frontends.
                 # Use custom TraitTypes that convert '0'->'' and '\\n'->'\n'
-                separate_in = SeparateStr('\n', config=True)
+                separate_in = SeparateUnicode('\n', config=True)
-                separate_out = SeparateStr('', config=True)
+                separate_out = SeparateUnicode('', config=True)
-                separate_out2 = SeparateStr('', config=True)
+                separate_out2 = SeparateUnicode('', config=True)
                 wildcards_case_sensitive = CBool(True, config=True)
                 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
                                         default_value='Context', config=True)
                         # Remove some chars from the delimiters list.  If we encounter
                         # unicode chars, discard them.
                         delims = readline.get_completer_delims().encode("ascii", "ignore")
-                        delims = delims.translate(None, self.readline_remove_delims)
+                        for d in self.readline_remove_delims:
+                            delims = delims.replace(d, "")
                         delims = delims.replace(ESC_MAGIC, '')
                         readline.set_completer_delims(delims)
                         # otherwise we end up with a monster history after a while:

IPython/core/magic.py

0 +4 -4

                         In [1]: from math import pi
                         In [2]: %precision 3
-                        Out[2]: '%.3f'
+                        Out[2]: u'%.3f'
                         In [3]: pi
                         Out[3]: 3.142
                         In [4]: %precision %i
-                        Out[4]: '%i'
+                        Out[4]: u'%i'
                         In [5]: pi
                         Out[5]: 3
                         In [6]: %precision %e
-                        Out[6]: '%e'
+                        Out[6]: u'%e'
                         In [7]: pi**10
                         Out[7]: 9.364805e+04
                         In [8]: %precision
-                        Out[8]: '%r'
+                        Out[8]: u'%r'
                         In [9]: pi**10
                         Out[9]: 93648.047476082982

IPython/core/prefilter.py

0 +9 -9

             from IPython.core.splitinput import split_user_input
             from IPython.core import page
-            from IPython.utils.traitlets import List, Int, Any, Str, CBool, Bool, Instance
+            from IPython.utils.traitlets import List, Int, Any, Unicode, CBool, Bool, Instance
             from IPython.utils.text import make_quoted_expr
             from IPython.utils.autoattr import auto_attr
             class PrefilterHandler(Configurable):
-                handler_name = Str('normal')
+                handler_name = Unicode('normal')
                 esc_strings = List([])
                 shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
                 prefilter_manager = Instance('IPython.core.prefilter.PrefilterManager')
             class AliasHandler(PrefilterHandler):
-                handler_name = Str('alias')
+                handler_name = Unicode('alias')
                 def handle(self, line_info):
                     """Handle alias input lines. """
             class ShellEscapeHandler(PrefilterHandler):
-                handler_name = Str('shell')
+                handler_name = Unicode('shell')
                 esc_strings = List([ESC_SHELL, ESC_SH_CAP])
                 def handle(self, line_info):
             class MacroHandler(PrefilterHandler):
-                handler_name = Str("macro")
+                handler_name = Unicode("macro")
                 def handle(self, line_info):
                     obj = self.shell.user_ns.get(line_info.ifun)
             class MagicHandler(PrefilterHandler):
-                handler_name = Str('magic')
+                handler_name = Unicode('magic')
                 esc_strings = List([ESC_MAGIC])
                 def handle(self, line_info):
             class AutoHandler(PrefilterHandler):
-                handler_name = Str('auto')
+                handler_name = Unicode('auto')
                 esc_strings = List([ESC_PAREN, ESC_QUOTE, ESC_QUOTE2])
                 def handle(self, line_info):
             class HelpHandler(PrefilterHandler):
-                handler_name = Str('help')
+                handler_name = Unicode('help')
                 esc_strings = List([ESC_HELP])
                 def handle(self, line_info):
             class EmacsHandler(PrefilterHandler):
-                handler_name = Str('emacs')
+                handler_name = Unicode('emacs')
                 esc_strings = List([])
                 def handle(self, line_info):

IPython/core/tests/test_magic.py

0 +4 -4

                 In [1]: f = get_ipython().shell.display_formatter.formatters['text/plain']
                 In [2]: %precision 5
-                Out[2]: '%.5f'
+                Out[2]: u'%.5f'
                 In [3]: f.float_format
-                Out[3]: '%.5f'
+                Out[3]: u'%.5f'
                 In [4]: %precision %e
-                Out[4]: '%e'
+                Out[4]: u'%e'
                 In [5]: f(3.1415927)
-                Out[5]: '3.141593e+00'
+                Out[5]: u'3.141593e+00'
                 """

IPython/frontend/qt/console/ipython_widget.py

0 +7 -8

             from IPython.core.inputsplitter import IPythonInputSplitter, \
                 transform_ipy_prompt
             from IPython.core.usage import default_gui_banner
-            from IPython.utils.traitlets import Bool, Str, Unicode
+            from IPython.utils.traitlets import Bool, Unicode
             from frontend_widget import FrontendWidget
             import styles
 . IPython: .error, .in-prompt, .out-prompt, etc
                     """)
+                syntax_style = Unicode(config=True,
-                syntax_style = Str(config=True,
                     help="""
                     If not empty, use this Pygments style for syntax highlighting.
                     Otherwise, the style sheet is queried for Pygments style
                     """)
                 # Prompts.
-                in_prompt = Str(default_in_prompt, config=True)
+                in_prompt = Unicode(default_in_prompt, config=True)
-                out_prompt = Str(default_out_prompt, config=True)
+                out_prompt = Unicode(default_out_prompt, config=True)
-                input_sep = Str(default_input_sep, config=True)
+                input_sep = Unicode(default_input_sep, config=True)
-                output_sep = Str(default_output_sep, config=True)
+                output_sep = Unicode(default_output_sep, config=True)
-                output_sep2 = Str(default_output_sep2, config=True)
+                output_sep2 = Unicode(default_output_sep2, config=True)
                 # FrontendWidget protected class variables.
                 _input_splitter_class = IPythonInputSplitter

IPython/frontend/terminal/embed.py

0 +1 -1

             from IPython.frontend.terminal.interactiveshell import TerminalInteractiveShell
             from IPython.frontend.terminal.ipapp import load_default_config
-            from IPython.utils.traitlets import Bool, Str, CBool, Unicode
+            from IPython.utils.traitlets import Bool, CBool, Unicode
             from IPython.utils.io import ask_yes_no

IPython/frontend/terminal/interactiveshell.py

0 +1 -1

             from IPython.utils.process import abbrev_cwd
             from IPython.utils.warn import warn
             from IPython.utils.text import num_ini_spaces
-            from IPython.utils.traitlets import Int, Str, CBool, Unicode
+            from IPython.utils.traitlets import Int, CBool, Unicode
             #-----------------------------------------------------------------------------
             # Utilities

IPython/parallel/apps/ipclusterapp.py

0 +4 -3

             from IPython.core.profiledir import ProfileDir
             from IPython.utils.daemonize import daemonize
             from IPython.utils.importstring import import_item
-            from IPython.utils.traitlets import Int, Unicode, Bool, CFloat, Dict, List
+            from IPython.utils.traitlets import (Int, Unicode, Bool, CFloat, Dict, List,
+                                                    DottedObjectName)
             from IPython.parallel.apps.baseapp import (
                 BaseParallelApplication,
                 n = Int(2, config=True,
                     help="The number of engines to start.")
-                engine_launcher_class = Unicode('LocalEngineSetLauncher',
+                engine_launcher_class = DottedObjectName('LocalEngineSetLauncher',
                     config=True,
                     help="The class for launching a set of Engines."
                     )
                 delay = CFloat(1., config=True,
                     help="delay (in s) between starting the controller and the engines")
-                controller_launcher_class = Unicode('LocalControllerLauncher',
+                controller_launcher_class = DottedObjectName('LocalControllerLauncher',
                     config=True,
                     help="The class for launching a Controller."
                     )

IPython/parallel/client/client.py

0 +2 0

                         if os.path.isfile(exec_key):
                             extra_args['keyfile'] = exec_key
                         else:
+                            if isinstance(exec_key, unicode):
+                                exec_key = exec_key.encode('ascii')
                             extra_args['key'] = exec_key
                     self.session = Session(**extra_args)

IPython/parallel/controller/hub.py

0 +7 -7

             # internal:
             from IPython.utils.importstring import import_item
             from IPython.utils.traitlets import (
-                    HasTraits, Instance, Int, Unicode, Dict, Set, Tuple, CStr
+                    HasTraits, Instance, Int, Unicode, Dict, Set, Tuple, Bytes, DottedObjectName
                     )
             from IPython.parallel import error, util
                 heartbeat (str): identity of heartbeat XREQ socket
                 """
                 id=Int(0)
-                queue=CStr()
+                queue=Bytes()
-                control=CStr()
+                control=Bytes()
-                registration=CStr()
+                registration=Bytes()
-                heartbeat=CStr()
+                heartbeat=Bytes()
                 pending=Set()
             class HubFactory(RegistrationFactory):
                 monitor_url = Unicode('')
-                db_class = Unicode('IPython.parallel.controller.dictdb.DictDB', config=True,
+                db_class = DottedObjectName('IPython.parallel.controller.dictdb.DictDB',
-                    help="""The class to use for the DB backend""")
+                    config=True, help="""The class to use for the DB backend""")
                 # not configurable
                 db = Instance('IPython.parallel.controller.dictdb.BaseDB')

IPython/parallel/controller/scheduler.py

0 +1 -1

             # local imports
             from IPython.external.decorator import decorator
             from IPython.config.loader import Config
-            from IPython.utils.traitlets import Instance, Dict, List, Set, Int, Str, Enum
+            from IPython.utils.traitlets import Instance, Dict, List, Set, Int, Enum
             from IPython.parallel import error
             from IPython.parallel.factory import SessionFactory

IPython/utils/tests/test_traitlets.py

0 +44 -11

             # Imports
             #-----------------------------------------------------------------------------
+            import sys
             from unittest import TestCase
             from IPython.utils.traitlets import (
-                HasTraits, MetaHasTraits, TraitType, Any, CStr,
+                HasTraits, MetaHasTraits, TraitType, Any, CBytes,
-                Int, Long, Float, Complex, Str, Unicode, TraitError,
+                Int, Long, Float, Complex, Bytes, Unicode, TraitError,
-                Undefined, Type, This, Instance, TCPAddress, List, Tuple
+                Undefined, Type, This, Instance, TCPAddress, List, Tuple,
+                ObjectName, DottedObjectName
             )
                 _bad_values    = [10L, -10L, u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
-            class StringTrait(HasTraits):
+            class BytesTrait(HasTraits):
-                value = Str('string')
+                value = Bytes('string')
-            class TestString(TraitTestBase):
+            class TestBytes(TraitTestBase):
-                obj = StringTrait()
+                obj = BytesTrait()
                 _default_value = 'string'
                 _good_values   = ['10', '-10', '10L',
                 _default_value = u'unicode'
                 _good_values   = ['10', '-10', '10L', '-10L', '10.1',
-                                  '-10.1', '', u'', 'string', u'string', ]
+                                  '-10.1', '', u'', 'string', u'string', u"€"]
                 _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j,
                                   [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]
+            class ObjectNameTrait(HasTraits):
+                value = ObjectName("abc")
+            class TestObjectName(TraitTestBase):
+                obj = ObjectNameTrait()
+                _default_value = "abc"
+                _good_values = ["a", "gh", "g9", "g_", "_G", u"a345_"]
+                _bad_values = [1, "", u"€", "9g", "!", "#abc", "aj@", "a.b", "a()", "a[0]",
+                                                                        object(), object]
+                if sys.version_info[0] < 3:
+                    _bad_values.append(u"þ")
+                else:
+                    _good_values.append(u"þ")  # þ=1 is valid in Python 3 (PEP 3131).
+            class DottedObjectNameTrait(HasTraits):
+                value = DottedObjectName("a.b")
+            class TestDottedObjectName(TraitTestBase):
+                obj = DottedObjectNameTrait()
+                _default_value = "a.b"
+                _good_values = ["A", "y.t", "y765.__repr__", "os.path.join", u"os.path.join"]
+                _bad_values = [1, u"abc.€", "_.@", ".", ".abc", "abc.", ".abc."]
+                if sys.version_info[0] < 3:
+                    _bad_values.append(u"t.þ")
+                else:
+                    _good_values.append(u"t.þ")
             class TCPAddressTrait(HasTraits):
                 value = TCPAddress()
                 def test_invalid_args(self):
                     self.assertRaises(TypeError, Tuple, 5)
                     self.assertRaises(TypeError, Tuple, default_value='hello')
-                    t = Tuple(Int, CStr, default_value=(1,5))
+                    t = Tuple(Int, CBytes, default_value=(1,5))
             class LooseTupleTrait(HasTraits):
                 def test_invalid_args(self):
                     self.assertRaises(TypeError, Tuple, 5)
                     self.assertRaises(TypeError, Tuple, default_value='hello')
-                    t = Tuple(Int, CStr, default_value=(1,5))
+                    t = Tuple(Int, CBytes, default_value=(1,5))
             class MultiTupleTrait(HasTraits):
-                value = Tuple(Int, Str, default_value=[99,'bottles'])
+                value = Tuple(Int, Bytes, default_value=[99,'bottles'])
             class TestMultiTuple(TraitTestBase):

IPython/utils/traitlets.py

0 +54 -10

@@ -50,6 +50,7 b' Authors:'
50		50
51		51
52	import inspect	52	import inspect
		53	import re
53	import sys	54	import sys
54	import types	55	import types
55	from types import (	56	from types import (
@@ -951,30 +952,29 b' class CComplex(Complex):'
951	except:	952	except:
952	self.error(obj, value)	953	self.error(obj, value)
953		954
954		955	# We should always be explicit about whether we're using bytes or unicode, both
955	class Str(TraitType):	956	# for Python 3 conversion and for reliable unicode behaviour on Python 2. So
		957	# we don't have a Str type.
		958	class Bytes(TraitType):
956	"""A trait for strings."""	959	"""A trait for strings."""
957		960
958	default_value = ''	961	default_value = ''
959	info_text = 'a string'	962	info_text = 'a string'
960		963
961	def validate(self, obj, value):	964	def validate(self, obj, value):
962	if isinstance(value, ~~str~~):	965	if isinstance(value, bytes):
963	return value	966	return value
964	self.error(obj, value)	967	self.error(obj, value)
965		968
966		969
967	class C~~Str~~(~~Str~~):	970	class CBytes(Bytes):
968	"""A casting version of the string trait."""	971	"""A casting version of the string trait."""
969		972
970	def validate(self, obj, value):	973	def validate(self, obj, value):
971	try:	974	try:
972	return ~~str~~(value)	975	return bytes(value)
973	except:	976	except:
974	try:	977	self.error(obj, value)
975	return unicode(value)
976	except:
977	self.error(obj, value)
978		978
979		979
980	class Unicode(TraitType):	980	class Unicode(TraitType):
@@ -986,7 +986,7 b' class Unicode(TraitType):'
986	def validate(self, obj, value):	986	def validate(self, obj, value):
987	if isinstance(value, unicode):	987	if isinstance(value, unicode):
988	return value	988	return value
989	if isinstance(value, ~~str~~):	989	if isinstance(value, bytes):
990	return unicode(value)	990	return unicode(value)
991	self.error(obj, value)	991	self.error(obj, value)
992		992
@@ -999,6 +999,50 b' class CUnicode(Unicode):'
999	return unicode(value)	999	return unicode(value)
1000	except:	1000	except:
1001	self.error(obj, value)	1001	self.error(obj, value)
		1002
		1003
		1004	class ObjectName(TraitType):
		1005	"""A string holding a valid object name in this version of Python.
		1006
		1007	This does not check that the name exists in any scope."""
		1008	info_text = "a valid object identifier in Python"
		1009
		1010	if sys.version_info[0] < 3:
		1011	# Python 2:
		1012	_name_re = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*$")
		1013	def isidentifier(self, s):
		1014	return bool(self._name_re.match(s))
		1015
		1016	def coerce_str(self, obj, value):
		1017	"In Python 2, coerce ascii-only unicode to str"
		1018	if isinstance(value, unicode):
		1019	try:
		1020	return str(value)
		1021	except UnicodeEncodeError:
		1022	self.error(obj, value)
		1023	return value
		1024
		1025	else:
		1026	# Python 3:
		1027	isidentifier = staticmethod(lambda s: s.isidentifier())
		1028	coerce_str = staticmethod(lambda _,s: s)
		1029
		1030	def validate(self, obj, value):
		1031	value = self.coerce_str(obj, value)
		1032
		1033	if isinstance(value, str) and self.isidentifier(value):
		1034	return value
		1035	self.error(obj, value)
		1036
		1037	class DottedObjectName(ObjectName):
		1038	"""A string holding a valid dotted object name in Python, such as A.b3._c"""
		1039	def validate(self, obj, value):
		1040	value = self.coerce_str(obj, value)
		1041
		1042	if isinstance(value, str) and all(self.isidentifier(x) \
		1043	for x in value.split('.')):
		1044	return value
		1045	self.error(obj, value)
1002		1046
1003		1047
1004	class Bool(TraitType):	1048	class Bool(TraitType):

IPython/zmq/kernelapp.py

0 +7 -6

             )
             from IPython.utils import io
             from IPython.utils.localinterfaces import LOCALHOST
-            from IPython.utils.traitlets import Any, Instance, Dict, Unicode, Int, Bool
+            from IPython.utils.traitlets import (Any, Instance, Dict, Unicode, Int, Bool,
+                                                    DottedObjectName)
             from IPython.utils.importstring import import_item
             # local imports
             from IPython.zmq.heartbeat import Heartbeat
                 flags = Dict(kernel_flags)
                 classes = [Session]
                 # the kernel class, as an importstring
-                kernel_class = Unicode('IPython.zmq.pykernel.Kernel')
+                kernel_class = DottedObjectName('IPython.zmq.pykernel.Kernel')
                 kernel = Any()
                 poller = Any() # don't restrict this even though current pollers are all Threads
                 heartbeat = Instance(Heartbeat)
                 # streams, etc.
                 no_stdout = Bool(False, config=True, help="redirect stdout to the null device")
                 no_stderr = Bool(False, config=True, help="redirect stderr to the null device")
-                outstream_class = Unicode('IPython.zmq.iostream.OutStream', config=True,
+                outstream_class = DottedObjectName('IPython.zmq.iostream.OutStream',
-                    help="The importstring for the OutStream factory")
+                    config=True, help="The importstring for the OutStream factory")
-                displayhook_class = Unicode('IPython.zmq.displayhook.ZMQDisplayHook', config=True,
+                displayhook_class = DottedObjectName('IPython.zmq.displayhook.ZMQDisplayHook',
-                    help="The importstring for the DisplayHook factory")
+                    config=True, help="The importstring for the DisplayHook factory")
                 # polling
                 parent = Int(0, config=True,

IPython/zmq/session.py

0 +6 -5

             from IPython.config.configurable import Configurable, LoggingConfigurable
             from IPython.utils.importstring import import_item
             from IPython.utils.jsonutil import extract_dates, squash_dates, date_default
-            from IPython.utils.traitlets import CStr, Unicode, Bool, Any, Instance, Set
+            from IPython.utils.traitlets import (Bytes, Unicode, Bool, Any, Instance, Set,
+                                                    DottedObjectName)
             #-----------------------------------------------------------------------------
             # utility functions
                 debug=Bool(False, config=True, help="""Debug output in the Session""")
-                packer = Unicode('json',config=True,
+                packer = DottedObjectName('json',config=True,
                         help="""The name of the packer for serializing messages.
                         Should be one of 'json', 'pickle', or an import name
                         for a custom callable serializer.""")
                     else:
                         self.pack = import_item(str(new))
-                unpacker = Unicode('json', config=True,
+                unpacker = DottedObjectName('json', config=True,
                     help="""The name of the unpacker for unserializing messages.
                     Only used with custom functions for `packer`.""")
                 def _unpacker_changed(self, name, old, new):
                     else:
                         self.unpack = import_item(str(new))
-                session = CStr('', config=True,
+                session = Bytes(b'', config=True,
                     help="""The UUID identifying this session.""")
                 def _session_default(self):
                     return bytes(uuid.uuid4())
                     help="""Username for the Session. Default is your system username.""")
                 # message signature related traits:
-                key = CStr('', config=True,
+                key = Bytes(b'', config=True,
                     help="""execution key, for extra authentication.""")
                 def _key_changed(self, name, old, new):
                     if new:

docs/source/config/overview.txt

0 +8 -8

                 # Sample component that can be configured.
                 from IPython.config.configurable import Configurable
-                from IPython.utils.traitlets import Int, Float, Str, Bool
+                from IPython.utils.traitlets import Int, Float, Unicode, Bool
                 class MyClass(Configurable):
                     name = Unicode(u'defaultname', config=True)
             the class defaults anytime a :class:`MyClass` is created.  Furthermore,
             these attributes will be type checked and validated anytime they are set.
             This type checking is handled by the :mod:`IPython.utils.traitlets` module,
-            which provides the :class:`Str`, :class:`Int` and :class:`Float` types.  In
+            which provides the :class:`Unicode`, :class:`Int` and :class:`Float` types.
-            addition to these traitlets, the :mod:`IPython.utils.traitlets` provides
+            In addition to these traitlets, the :mod:`IPython.utils.traitlets` provides
             traitlets for a number of other types.
             .. note::
             to be reflected in the configuration system.  Here is a simple example::
                 from IPython.config.configurable import Configurable
-                from IPython.utils.traitlets import Int, Float, Str, Bool
+                from IPython.utils.traitlets import Int, Float, Unicode, Bool
                 class Foo(Configurable):
-                    name = Str('fooname', config=True)
+                    name = Unicode(u'fooname', config=True)
                     value = Float(100.0, config=True)
                 class Bar(Foo):
-                    name = Str('barname', config=True)
+                    name = Unicode(u'barname', config=True)
                     othervalue = Int(0, config=True)
             Now, we can create a configuration file to configure instances of :class:`Foo`
                 # config file
                 c = get_config()
-                c.Foo.name = 'bestname'
+                c.Foo.name = u'bestname'
                 c.Bar.othervalue = 10
             This class hierarchy and configuration file accomplishes the following:
               hierarchical data structures, namely regular attribute access
               (``Foo.Bar.Bam.name``). Third, using Python makes it easy for users to
               import configuration attributes from one configuration file to another.
-              Forth, even though Python is dynamically typed, it does have types that can
+              Fourth, even though Python is dynamically typed, it does have types that can
               be checked at runtime. Thus, a ``1`` in a config file is the integer '1',
               while a ``'1'`` is a string.

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