upstream/ipython Commit - r4872:34c10438

remove all trailling spaces

Bernardo B. Marques -

r4872:34c10438

parent child

Expand all files

The requested changes are too big and content was truncated. Show full diff

IPython/config/application.py

0 +39 -39

                         new = getattr(logging, new)
                         self.log_level = new
                     self.log.setLevel(new)
                 # the alias map for configurables
                 aliases = Dict({'log-level' : 'Application.log_level'})
                 # flags for loading Configurables or store_const style flags
                 # flags are loaded from this dict by '--key' flags
                 # this must be a dict of two-tuples, the first element being the Config/dict
                         assert len(value) == 2, "Bad flag: %r:%s"%(key,value)
                         assert isinstance(value[0], (dict, Config)), "Bad flag: %r:%s"%(key,value)
                         assert isinstance(value[1], basestring), "Bad flag: %r:%s"%(key,value)
                 # subcommands for launching other applications
                 # if this is not empty, this will be a parent Application
                 # this must be a dict of two-tuples,
                 # the first element being the application class/import string
                 # and the second being the help string for the subcommand
                 subcommands = Dict()
                 # parse_command_line will initialize a subapp, if requested
                 subapp = Instance('IPython.config.application.Application', allow_none=True)
                 # extra command-line arguments that don't set config values
                 extra_args = List(Unicode)
                 def __init__(self, **kwargs):
                     SingletonConfigurable.__init__(self, **kwargs)
                     # options and config files.
                     if self.__class__ not in self.classes:
                         self.classes.insert(0, self.__class__)
                     self.init_logging()
                 def _config_changed(self, name, old, new):
                     """Start logging for this application.
                     The default is to log to stdout using a StreaHandler. The log level
                     starts at loggin.WARN, but this can be adjusted by setting the
                     ``log_level`` attribute.
                     """
                     self.log = logging.getLogger(self.__class__.__name__)
                 def initialize(self, argv=None):
                     """Do the basic steps to configure me.
                     Override in subclasses.
                     """
                     self.parse_command_line(argv)
                 def start(self):
                     """Start the app mainloop.
                     Override in subclasses.
                     """
                     if self.subapp is not None:
                         return self.subapp.start()
                 def print_alias_help(self):
                     """Print the alias part of the help."""
                     if not self.aliases:
                         return
                     lines = []
                     classdict = {}
                     for cls in self.classes:
                         # include all parents (up to, but excluding Configurable) in available names
                         for c in cls.mro()[:-3]:
                             classdict[c.__name__] = c
                     for alias, longname in self.aliases.iteritems():
                         classname, traitname = longname.split('.',1)
                         cls = classdict[classname]
                         trait = cls.class_traits(config=True)[traitname]
                         help = cls.class_get_trait_help(trait).splitlines()
                         # reformat first line
                         lines.extend(help)
                     # lines.append('')
                     print os.linesep.join(lines)
                 def print_flag_help(self):
                     """Print the flag part of the help."""
                     if not self.flags:
                         return
                     lines = []
                     for m, (cfg,help) in self.flags.iteritems():
                         prefix = '--' if len(m) > 1 else '-'
                         lines.append(indent(dedent(help.strip())))
                     # lines.append('')
                     print os.linesep.join(lines)
                 def print_options(self):
                     if not self.flags and not self.aliases:
                         return
                     self.print_flag_help()
                     self.print_alias_help()
                     print
                 def print_subcommands(self):
                     """Print the subcommand part of the help."""
                     if not self.subcommands:
                         return
                     lines = ["Subcommands"]
                     lines.append('-'*len(lines[0]))
                     lines.append('')
                             lines.append(indent(dedent(help.strip())))
                     lines.append('')
                     print os.linesep.join(lines)
                 def print_help(self, classes=False):
                     """Print the help for each Configurable class in self.classes.
                     If classes=False (the default), only flags and aliases are printed.
                     """
                     self.print_subcommands()
                     self.print_options()
                     if classes:
                         if self.classes:
                             print "Class parameters"
                             for p in wrap_paragraphs(self.keyvalue_description):
                                 print p
                                 print
                         for cls in self.classes:
                             cls.class_print_help()
                             print
                     # Save the combined config as self.config, which triggers the traits
                     # events.
                     self.config = newconfig
                 def initialize_subcommand(self, subc, argv=None):
                     """Initialize a subcommand with argv."""
                     subapp,help = self.subcommands.get(subc)
                     if isinstance(subapp, basestring):
                         subapp = import_item(subapp)
                     # clear existing instances
                     self.__class__.clear_instance()
                     # instantiate
                     self.subapp = subapp.instance()
                     # and initialize subapp
                     self.subapp.initialize(argv)
                 def parse_command_line(self, argv=None):
                     """Parse the command line arguments."""
                     argv = sys.argv[1:] if argv is None else argv
                         if re.match(r'^\w(\-?\w)*$', subc) and subc in self.subcommands:
                             # it's a subcommand, and *not* a flag or class parameter
                             return self.initialize_subcommand(subc, subargv)
                     if '-h' in argv or '--help' in argv or '--help-all' in argv:
                         self.print_description()
                         self.print_help('--help-all' in argv)
                     if '--version' in argv:
                         self.print_version()
                         self.exit(0)
                     loader = KVArgParseConfigLoader(argv=argv, aliases=self.aliases,
                                                     flags=self.flags)
                     try:
                     else:
                         self.log.debug("Loaded config file: %s", loader.full_filename)
                         self.update_config(config)
                 def generate_config_file(self):
                     """generate default config file from Configurables"""
                     lines = ["# Configuration file for %s."%self.name]
             def boolean_flag(name, configurable, set_help='', unset_help=''):
                 """Helper for building basic --trait, --no-trait flags.
                 Parameters
                 ----------
                 name : str
                     The name of the flag.
                 configurable : str
                     help string for --name flag
                 unset_help : unicode
                     help string for --no-name flag
                 Returns
                 -------
                 cfg : dict
                     A dict with two keys: 'name', and 'no-name', for setting and unsetting
                     the trait, respectively.
                 # default helpstrings
                 set_help = set_help or "set %s=True"%configurable
                 unset_help = unset_help or "set %s=False"%configurable
                 cls,trait = configurable.split('.')
                 setter = {cls : {trait : True}}
                 unsetter = {cls : {trait : False}}
                 return {name : (setter, set_help), 'no-'+name : (unsetter, unset_help)}

IPython/config/configurable.py

0 +26 -26

                     Parameters
                     ----------
                     config : Config
                         If this is empty, default values are used. If config is a
                         :class:`Config` instance, it will be used to configure the
                         instance.
                     Notes
                     -----
                     Subclasses of Configurable must call the :meth:`__init__` method of
                     :class:`Configurable` *before* doing anything else and using
                     :func:`super`::
                         class MyConfigurable(Configurable):
                             def __init__(self, config=None):
                                 super(MyConfigurable, self).__init__(config)
                         # making that a class attribute.
                         # self.config = deepcopy(config)
                         self.config = config
                     # This should go second so individual keyword arguments override
                     # the values in config.
                     super(Configurable, self).__init__(**kwargs)
                     self.created = datetime.datetime.now()
                     # classes that are Configurable subclasses.  This starts with Configurable
                     # and works down the mro loading the config for each section.
                     section_names = [cls.__name__ for cls in \
                         reversed(self.__class__.__mro__) if
                         issubclass(cls, Configurable) and issubclass(self.__class__, cls)]
                     for sname in section_names:
                         # Don't do a blind getattr as that would cause the config to
                         # dynamically create the section with name self.__class__.__name__.
                         if new._has_section(sname):
                             my_config = new[sname]
                         help = cls.class_get_trait_help(v)
                         final_help.append(help)
                     return '\n'.join(final_help)
                 @classmethod
                 def class_get_trait_help(cls, trait):
                     """Get the help string for a single trait."""
                     if 'Enum' in trait.__class__.__name__:
                         # include Enum choices
                         lines.append(indent('Choices: %r'%(trait.values,)))
                     help = trait.get_metadata('help')
                     if help is not None:
                         help = '\n'.join(wrap_paragraphs(help, 76))
                     def c(s):
                         """return a commented, wrapped block."""
                         s = '\n\n'.join(wrap_paragraphs(s, 78))
                         return '# ' + s.replace('\n', '\n# ')
                     # section header
                     breaker = '#' + '-'*78
                     s = "# %s configuration"%cls.__name__
                     if desc:
                         lines.append(c(desc))
                         lines.append('')
                     parents = []
                     for parent in cls.mro():
                         # only include parents that are not base classes
                         if parent is not cls and issubclass(parent, Configurable) and \
                                 parent.class_traits(config=True):
                             parents.append(parent)
                     if parents:
                         pstr = ', '.join([ p.__name__ for p in parents ])
                         lines.append(c('%s will inherit config from: %s'%(cls.__name__, pstr)))
                         lines.append('')
                     for name,trait in cls.class_traits(config=True).iteritems():
                         help = trait.get_metadata('help') or ''
                         lines.append(c(help))
                         lines.append('# c.%s.%s = %r'%(cls.__name__, name, trait.get_default_value()))
                         lines.append('')
                     return '\n'.join(lines)
             class SingletonConfigurable(Configurable):
                 """A configurable that only allows one instance.
                 """
                 _instance = None
                 @classmethod
                 def _walk_mro(cls):
                     """Walk the cls.mro() for parent classes that are also singletons
                     For use in instance()
                     """
                     for subclass in cls.mro():
                         if issubclass(cls, subclass) and \
                                 issubclass(subclass, SingletonConfigurable) and \
                                 subclass != SingletonConfigurable:
                             yield subclass
                 @classmethod
                 def clear_instance(cls):
                     """unset _instance for this class and singleton parents.
                             # only clear instances that are instances
                             # of the calling class
                             subclass._instance = None
                 @classmethod
                 def instance(cls, *args, **kwargs):
                     """Returns a global instance of this class.
                         # parent classes' _instance attribute.
                         for subclass in cls._walk_mro():
                             subclass._instance = inst
                     if isinstance(cls._instance, cls):
                         return cls._instance
                     else:
             class LoggingConfigurable(Configurable):
                 """A parent class for Configurables that log.
                 Subclasses have a log trait, and the default behavior
                 is to get the logger from the currently running Application
                 via Application.instance().log.
                 """
                 log = Instance('logging.Logger')
                 def _log_default(self):
                     from IPython.config.application import Application
                     return Application.instance().log

IPython/config/loader.py

0 +40 -40

             class ArgumentParser(argparse.ArgumentParser):
                 """Simple argparse subclass that prints help to stdout by default."""
                 def print_help(self, file=None):
                     if file is None:
                         file = sys.stdout
                     return super(ArgumentParser, self).print_help(file)
                 print_help.__doc__ = argparse.ArgumentParser.print_help.__doc__
             #-----------------------------------------------------------------------------
             # Config class for holding config information
             #-----------------------------------------------------------------------------
                     # infinite recursion on top of PyPy. Instead, we manually fish the
                     # bound method.
                     is_section_key = self.__class__._is_section_key.__get__(self)
                     # Because we use this for an exec namespace, we need to delegate
                     # the lookup of names in __builtin__ to itself.  This means
                     # that you can't have section or attribute names that are
                     # builtins.
                     try:
                         return getattr(builtin_mod, key)
             class ConfigLoader(object):
                 """A object for loading configurations from just about anywhere.
                 The resulting configuration is packaged as a :class:`Struct`.
                 Notes
                 -----
                 A :class:`ConfigLoader` does one thing: load a config from a source
                 (file, command line arguments) and returns the data as a :class:`Struct`.
                 There are lots of things that :class:`ConfigLoader` does not do.  It does
                 not implement complex logic for finding config files.  It does not handle
                 default values or merge multiple configs.  These things need to be
                 handled elsewhere.
                 """
                 def __init__(self):
                     """A base class for config loaders.
                     Examples
                     --------
                     >>> cl = ConfigLoader()
                     >>> config = cl.load_config()
                     >>> config
                 def load_config(self):
                     """Load a config from somewhere, return a :class:`Config` instance.
                     Usually, this will cause self.config to be set and then returned.
                     However, in most cases, :meth:`ConfigLoader.clear` should be called
                     to erase any previous state.
             class PyFileConfigLoader(FileConfigLoader):
                 """A config loader for pure python files.
                 This calls execfile on a plain python file and looks for attributes
                 that are all caps.  These attribute are added to the config Struct.
                 """
                     # and self.config.  The sub-config is loaded with the same path
                     # as the parent, but it uses an empty config which is then merged
                     # with the parents.
                     # If a profile is specified, the config file will be loaded
                     # from that profile
                     def load_subconfig(fname, profile=None):
                         # import here to prevent circular imports
                         from IPython.core.profiledir import ProfileDir, ProfileDirError
                             pass
                         else:
                             self.config._merge(sub_config)
                     # Again, this needs to be a closure and should be used in config
                     # files to get the config being loaded.
                     def get_config():
                         # it succeeds. If it still fails, we let it raise.
                         exec_str = u'self.config.' + lhs + '=' + repr(rhs)
                         exec exec_str in locals(), globals()
                 def _load_flag(self, cfg):
                     """update self.config from a flag, which can be a dict or Config"""
                     if isinstance(cfg, (dict, Config)):
                 """A config loader that loads key value pairs from the command line.
                 This allows command line options to be gives in the following form::
                     ipython --profile="foo" --InteractiveShell.autocall=False
                 """
                     self.argv = argv
                     self.aliases = aliases or {}
                     self.flags = flags or {}
                 def clear(self):
                     super(KeyValueConfigLoader, self).clear()
                     self.extra_args = []
                 def _decode_argv(self, argv, enc=None):
                     """decode argv if bytes, using stin.encoding, falling back on default enc"""
                     uargv = []
                             arg = arg.decode(enc)
                         uargv.append(arg)
                     return uargv
                 def load_config(self, argv=None, aliases=None, flags=None):
                     """Parse the configuration and generate the Config object.
                     After loading, any arguments that are not key-value or
                     flags will be stored in self.extra_args - a list of
                     unparsed command-line arguments.  This is used for
                     arguments such as input files or subcommands.
                     Parameters
                     ----------
                     argv : list, optional
                         Of the form: `{'alias' : 'Configurable.trait'}`
                     flags : dict
                         A dict of flags, keyed by str name. Values can be Config objects
                         or dicts.  When the flag is triggered, The config is loaded as
                         `self.config.update(cfg)`.
                     """
                     from IPython.config.configurable import Configurable
                         aliases = self.aliases
                     if flags is None:
                         flags = self.flags
                     # ensure argv is a list of unicode strings:
                     uargv = self._decode_argv(argv)
                     for idx,raw in enumerate(uargv):
                         # strip leading '-'
                         item = raw.lstrip('-')
                         if raw == '--':
                             # don't parse arguments after '--'
                             # this is useful for relaying arguments to scripts, e.g.
                             # ipython -i foo.py --pylab=qt -- args after '--' go-to-foo.py
                             self.extra_args.extend(uargv[idx+1:])
                             break
                         if kv_pattern.match(raw):
                             lhs,rhs = item.split('=',1)
                             # Substitute longnames for aliases.
                                 # probably a mistyped alias, but not technically illegal
                                 warn.warn("Unrecognized alias: '%s', it will probably have no effect."%lhs)
                             self._exec_config_str(lhs, rhs)
                         elif flag_pattern.match(raw):
                             if item in flags:
                                 cfg,help = flags[item]
                             else:
                                 raise ArgumentError("Invalid argument: '%s'"%raw)
                         else:
                             # keep all args that aren't valid in a list,
                             # in case our parent knows what to do with them.
                             self.extra_args.append(item)
                     return self.config
                     self.argv = argv
                     self.aliases = aliases or {}
                     self.flags = flags or {}
                     self.parser_args = parser_args
                     self.version = parser_kw.pop("version", None)
                     kwargs = dict(argument_default=argparse.SUPPRESS)
             class KVArgParseConfigLoader(ArgParseConfigLoader):
                 """A config loader that loads aliases and flags with argparse,
                 but will use KVLoader for the rest.  This allows better parsing
                 of common args, such as `ipython -c 'print 5'`, but still gets
                 arbitrary config with `ipython --InteractiveShell.use_readline=False`"""
                 def _convert_to_config(self):
                     """self.parsed_data->self.config"""
                     for k, v in vars(self.parsed_data).iteritems():
                             paa('--'+key, type=unicode, dest=value, nargs=nargs)
                     for key, (value, help) in flags.iteritems():
                         if key in self.aliases:
+                            #
                             self.alias_flags[self.aliases[key]] = value
                             continue
                         if len(key) is 1:
                             paa('-'+key, '--'+key, action='append_const', dest='_flags', const=value)
                         else:
                             paa('--'+key, action='append_const', dest='_flags', const=value)
                 def _convert_to_config(self):
                     """self.parsed_data->self.config, parse unrecognized extra args via KVLoader."""
                     # remove subconfigs list from namespace before transforming the Namespace
                         del self.parsed_data._flags
                     else:
                         subcs = []
                     for k, v in vars(self.parsed_data).iteritems():
                         if v is None:
                             # it was a flag that shares the name of an alias
                         else:
                             # eval the KV assignment
                             self._exec_config_str(k, v)
                     for subc in subcs:
                         self._load_flag(subc)
                     if self.extra_args:
                         sub_parser = KeyValueConfigLoader()
                         sub_parser.load_config(self.extra_args)

IPython/core/alias.py

0 +13 -13

                 # their case.  For example, things like 'less' or 'clear' that manipulate
                 # the terminal should NOT be declared here, as they will only work if the
                 # kernel is running inside a true terminal, and not over the network.
                 if os.name == 'posix':
                     default_aliases = [('mkdir', 'mkdir'), ('rmdir', 'rmdir'),
                                        ('mv', 'mv -i'), ('rm', 'rm -i'), ('cp', 'cp -i'),
                                        ]
                 else:
                     default_aliases = []
                 return default_aliases
                     return cmd
                 def expand_alias(self, line):
                     """ Expand an alias in the command line
                     Returns the provided command line, possibly with the first word
                     (command) translated according to alias expansion rules.
                     [ipython]|16> _ip.expand_aliases("np myfile.txt")
                              <16> 'q:/opt/np/notepad++.exe myfile.txt'
                     """
                     pre,_,fn,rest = split_user_input(line)
                     res = pre + self.expand_aliases(fn, rest)
                     return res
                 def expand_aliases(self, fn, rest):
                     """Expand multiple levels of aliases:
                     if:
                     alias foo bar /tmp
                     alias baz foo
                     then:
                     baz huhhahhei -> bar /tmp huhhahhei
                     """
                     line = fn + " " + rest
                     done = set()
                     while 1:
                         pre,_,fn,rest = split_user_input(line, shell_line_split)
                             line=l2
                         else:
                             break
                     return line

IPython/core/application.py

0 +20 -20

             All top-level applications should use the classes in this module for
             handling configuration and creating componenets.
             The job of an :class:`Application` is to create the master configuration
             object and then create the configurable objects, passing the config to them.
             Authors:
                 name = Unicode(u'ipython')
                 description = Unicode(u'IPython: an enhanced interactive Python shell.')
                 version = Unicode(release.version)
                 aliases = Dict(base_aliases)
                 flags = Dict(base_flags)
                 classes = List([ProfileDir])
                 # Track whether the config_file has changed,
                 # because some logic happens only if we aren't using the default.
                 config_file_specified = Bool(False)
                 config_file_name = Unicode(u'ipython_config.py')
                 def _config_file_name_default(self):
                     return self.name.replace('-','_') + u'_config.py'
                 )
                 def _profile_default(self):
                     return "python3" if py3compat.PY3 else "default"
                 def _profile_changed(self, name, old, new):
                     self.builtin_profile_dir = os.path.join(
                             get_ipython_package_dir(), u'config', u'profile', new
                     )
                 ipython_dir = Unicode(get_ipython_dir(), config=True,
                     help="""
                     The name of the IPython directory. This directory is used for logging
                     configuration (through profiles), history storage, etc. The default
                     the environment variable IPYTHON_DIR.
                     """
                 )
                 overwrite = Bool(False, config=True,
                     help="""Whether to overwrite existing config files when copying""")
                 auto_create = Bool(False, config=True,
                     help="""Whether to create profile dir if it doesn't exist""")
                 config_files = List(Unicode)
                 def _config_files_default(self):
                     return [u'ipython_config.py']
                 copy_config_files = Bool(False, config=True,
                     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
                     # ensure even default IPYTHON_DIR exists
                     if not os.path.exists(self.ipython_dir):
                         self._ipython_dir_changed('ipython_dir', self.ipython_dir, self.ipython_dir)
                 #-------------------------------------------------------------------------
                 # Various stages of Application creation
                 #-------------------------------------------------------------------------
                     try:
                         Application.load_config_file(
                             self,
                             base_config,
                             path=self.config_file_paths
                         )
                     except IOError:
                     try:
                         Application.load_config_file(
                             self,
                             self.config_file_name,
                             path=self.config_file_paths
                         )
                     except IOError:
                                 self.exit(1)
                         else:
                             self.log.info("Using existing profile dir: %r"%location)
                     self.profile_dir = p
                     self.config_file_paths.append(p.location)
                 def init_config_files(self):
                     """[optionally] copy default config files into profile dir."""
                     # copy config files
                     path = self.builtin_profile_dir
                     if self.copy_config_files:
                         src = self.profile
                         cfg = self.config_file_name
                         if path and os.path.exists(os.path.join(path, cfg)):
                             self.log.warn("Staging %r from %s into %r [overwrite=%s]"%(
                                 self.log.warn("Staging bundled %s from %s into %r"%(
                                         cfg, self.profile, self.profile_dir.location)
                                 )
                 def stage_default_config_file(self):
                     """auto generate default config file, and stage it into the profile."""
                     s = self.generate_config_file()
                         self.log.warn("Generating default config file: %r"%(fname))
                         with open(fname, 'w') as f:
                             f.write(s)
                 def initialize(self, argv=None):
                     # don't hook up crash handler before parsing command-line
                     self.parse_command_line(argv)

IPython/core/completer.py

0 +33 -33

             def protect_filename(s):
                 """Escape a string to protect certain characters."""
                 return "".join([(ch in PROTECTABLES and '\\' + ch or ch)
                                 for ch in s])
                 path : str
                   String to be expanded.  If no ~ is present, the output is the same as the
                   input.
                 Returns
                 -------
                 newpath : str
                 tilde_expand = False
                 tilde_val = ''
                 newpath = path
                 if path.startswith('~'):
                     tilde_expand = True
                     rest = path[1:]
                 automatically builds the necessary """
                 # Private interface
                 # A string of delimiter characters.  The default value makes sense for
                 # IPython's most typical usage patterns.
                 _delims = DELIMS
             class Completer(Configurable):
                 greedy = CBool(False, config=True,
                     help="""Activate greedy completion
                     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.
                     """
                 )
                 def __init__(self, namespace=None, global_namespace=None, config=None):
                     """Create a new completer for the command line.
                         self.global_namespace = {}
                     else:
                         self.global_namespace = global_namespace
                     super(Completer, self).__init__(config=config)
                 def complete(self, text, state):
                     """
                     if self.use_main_ns:
                         self.namespace = __main__.__dict__
                     if state == 0:
                         if "." in text:
                             self.matches = self.attr_matches(text)
                     m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)
                     if m:
                         expr, attr = m.group(1, 3)
                     elif self.greedy:
                         m2 = re.match(r"(.+)\.(\w*)$", self.line_buffer)
                         if not m2:
                         expr, attr = m2.group(1,2)
                     else:
                         return []
                     try:
                         obj = eval(expr, self.namespace)
                     except:
                             return []
                     words = dir2(obj)
                     try:
                         words = generics.complete_object(obj, words)
                     except TryNext:
                         self.splitter.set_delims(GREEDY_DELIMS)
                     else:
                         self.splitter.set_delims(DELIMS)
                     if self.readline:
                         self.readline.set_completer_delims(self.splitter.get_delims())
                 def __init__(self, shell=None, namespace=None, global_namespace=None,
                              omit__names=True, alias_table=None, use_readline=True,
                              config=None):
                     # Readline configuration, only used by the rlcompleter method.
                     if use_readline:
                         # We store the right version of readline so that later code
                         import IPython.utils.rlineimpl as readline
                         self.readline = readline
                     else:
                     # buffers, to avoid completion problems.
                     term = os.environ.get('TERM','xterm')
                     self.dumb_terminal = term in ['dumb','emacs']
                     # Special handling of backslashes needed in win32 platforms
                     if sys.platform == "win32":
                         self.clean_glob = self._clean_glob_win32
                                      self.alias_matches,
                                      self.python_func_kw_matches,
                                      ]
                 def all_completions(self, text):
                     """
                     Wrapper around the complete method for the benefit of emacs
                 def _clean_glob_win32(self,text):
                     return [f.replace("\\","/")
                             for f in self.glob("%s*" % text)]
                 def file_matches(self, text):
                     """Match filenames, expanding ~USER type strings.
                         # beginning of filename so that we don't double-write the part
                         # of the filename we have so far
                         len_lsplit = len(lsplit)
                         matches = [text_prefix + text0 +
                                    protect_filename(f[len_lsplit:]) for f in m0]
                     else:
                         if open_quotes:
                             # would cause bugs when the filesystem call is made).
                             matches = m0
                         else:
                             matches = [text_prefix +
                                        protect_filename(f) for f in m0]
                     #io.rprint('mm', matches)  # dbg
                     return [ pre+m for m in magics if m.startswith(baretext)]
                 def alias_matches(self, text):
                     """Match internal system aliases"""
                     #print 'Completer->alias_matches:',text,'lb',self.text_until_cursor # dbg
                     # if we are not in the first 'item', alias matching
                 def dispatch_custom_completer(self, text):
                     #io.rprint("Custom! '%s' %s" % (text, self.custom_completers)) # dbg
                     line = self.line_buffer
                     if not line.strip():
                         return None
                     # Create a little structure to pass all the relevant information about
                     # the current completion to any custom completer.
                     event = Bunch()
                     cmd = line.split(None,1)[0]
                     event.command = cmd
                     event.text_until_cursor = self.text_until_cursor
                     #print "\ncustom:{%s]\n" % event # dbg
                     # for foo etc, try also to find completer for %foo
                     if not cmd.startswith(self.magic_escape):
                         try_magic = self.custom_completers.s_matches(
                             self.magic_escape + cmd)
                     else:
                         try_magic = []
                     for c in itertools.chain(self.custom_completers.s_matches(cmd),
                              try_magic,
                              self.custom_completers.flat_matches(self.text_until_cursor)):
                                 return [r for r in res if r.lower().startswith(text_low)]
                         except TryNext:
                             pass
                     return None
                 def complete(self, text=None, line_buffer=None, cursor_pos=None):
                     """Find completions for the given text and line context.
                     -------
                     text : str
                       Text that was actually used in the completion.
                     matches : list
                       A list of completion matches.
                     """
                     # If no line buffer is given, assume the input text is all there was
                     if line_buffer is None:
                         line_buffer = text
                     self.line_buffer = line_buffer
                     self.text_until_cursor = self.line_buffer[:cursor_pos]
                     #io.rprint('\nCOMP2 %r %r %r' % (text, line_buffer, cursor_pos))  # dbg
                                 import traceback; traceback.print_exc()
                         else:
                             # The normal production version is here
                             # This method computes the self.matches array
                             self.complete(text, line_buffer, cursor_pos)

IPython/core/completerlib.py

0 +16 -16

                         if len(endofline) >= 1:
                             comps.append(''.join(endofline))
                         return comps
                     except ValueError:
                         endofline = [x[-1:]]+endofline
                         x = x[:-1]
                 isfile = os.path.isfile
                 pjoin = os.path.join
                 basename = os.path.basename
                 # Now find actual path matches for packages or modules
                 folder_list = [p for p in folder_list
                                if isfile(pjoin(path, p,'__init__.py'))
                 if 'rootmodules' in ip.db:
                     return ip.db['rootmodules']
                 t = time()
                 store = False
                 modules = list(sys.builtin_module_names)
                 for path in sys.path:
                     modules += module_list(path)
                     if time() - t >= TIMEOUT_STORAGE and not store:
                         store = True
                         print("\nCaching the list of root modules, please wait!")
                         print("This is taking too long, we give up.\n")
                         ip.db['rootmodules'] = []
                         return []
                 modules = set(modules)
                 if '__init__' in modules:
                     modules.remove('__init__')
                 if (not hasattr(m, '__file__')) or (not only_modules) or m_is_init:
                     completions.extend( [attr for attr in dir(m) if
                                          is_importable(m, attr, only_modules)])
                 completions.extend(getattr(m, '__all__', []))
                 if m_is_init:
                     completions.extend(module_list(os.path.dirname(m.__file__)))
                 Takes either a list of completions, or all completions in string (that will
                 be split on whitespace).
                 Example::
                     [d:\ipython]|1> import ipy_completers
                     [d:\ipython]|2> ipy_completers.quick_completer('foo', ['bar','baz'])
                     [d:\ipython]|3> foo b<TAB>
                     bar baz
                     [d:\ipython]|3> foo ba
                 """
                 if isinstance(completions, basestring):
                     completions = completions.split()
                 def do_complete(self, event):
                     return completions
                 get_ipython().set_hook('complete_command',do_complete, str_key = cmd)
                 # from whatever <tab> -> 'import '
                 if nwords == 3 and words[0] == 'from':
                     return ['import ']
                 # 'from xy<tab>' or 'import xy<tab>'
                 if nwords < 3 and (words[0] in ['import','from']) :
                     if nwords == 1:
                         return get_root_modules()
                     completion_list = try_import('.'.join(mod[:-1]), True)
                     return ['.'.join(mod[:-1] + [el]) for el in completion_list]
                 # 'from xyz import abc<tab>'
                 if nwords >= 3 and words[0] == 'from':
                     mod = words[1]
                 lglob = glob.glob
                 isdir = os.path.isdir
                 relpath, tilde_expand, tilde_val = expand_user(relpath)
                 dirs = [f.replace('\\','/') + "/" for f in lglob(relpath+'*') if isdir(f)]
                 # Find if the user has already typed the first filename, after which we
                         return bkms.keys()
                     else:
                         return []
                 if event.symbol == '-':
                     width_dh = str(len(str(len(ip.user_ns['_dh']) + 1)))
                     # jump in directory history by number
                         # we don't want to deal with any of that, complex code
                         # for this is elsewhere
                         raise TryNext
                     found.append(d)
                 if not found:
                     bkmatches = [s for s in bks if s.startswith(event.symbol)]
                     if bkmatches:
                         return bkmatches
                     raise TryNext
                 return [compress_user(p, tilde_expand, tilde_val) for p in found]

IPython/core/crashhandler.py

0 +6 -6

                 message_template = _default_message_template
                 section_sep = '\n\n'+'*'*75+'\n\n'
                 def __init__(self, app, contact_name=None, contact_email=None,
                              bug_tracker=None, show_crash_traceback=True, call_pdb=False):
                     """Create a new crash handler
                     Parameters
                     ----------
                     app :  Application
                         A running :class:`Application` instance, which will be queried at
                         crash time for internal information.
                     contact_name : str
                                 contact_email = contact_email,
                                 bug_tracker = bug_tracker,
                                 crash_report_fname = self.crash_report_fname)
                 def __call__(self, etype, evalue, etb):
                     """Handle an exception, call for compatible with sys.excepthook"""
                 def make_report(self,traceback):
                     """Return a string containing a crash report."""
                     sec_sep = self.section_sep
                     report = ['*'*75+'\n\n'+'IPython post-mortem report\n\n']
                     rpt_add = report.append
                     rpt_add(sys_info())
                     try:
                         config = pformat(self.app.config)
                         rpt_add(sec_sep)

IPython/core/debugger.py

0 +21 -21

             prompt = 'ipdb> '
             #We have to check this directly from sys.argv, config struct not yet available
             if '-pydb' in sys.argv:
                 try:
                     import pydb
                     if hasattr(pydb.pydb, "runl") and pydb.version>'1.17':
                         # Version 1.17 is broken, and that's what ships with Ubuntu Edgy, so we
                     This is similar to the pdb.set_trace() function from the std lib, but
                     using IPython's enhanced debugger."""
                     self.debugger.set_trace(sys._getframe().f_back)
                         OldPdb.__init__(self,stdin=stdin,stdout=io.stdout)
                     else:
                         OldPdb.__init__(self,completekey,stdin,stdout)
                     self.prompt = prompt # The default prompt is '(Pdb)'
                     # IPython changes...
                     self.is_pydb = has_pydb
                     # module and add a few attributes needed for debugging
                     self.color_scheme_table = exception_colors()
                     # shorthands
                     C = coloransi.TermColors
                     cst = self.color_scheme_table
                     self.shell.set_completer_frame(self.curframe)
                 def new_do_quit(self, arg):
                     if hasattr(self, 'old_all_completions'):
                         self.shell.Completer.all_completions=self.old_all_completions
                     return OldPdb.do_quit(self, arg)
                 do_q = do_quit = decorate_fn_with_doc(new_do_quit, OldPdb.do_quit)
                 def format_stack_entry(self, frame_lineno, lprefix=': ', context = 3):
                     import linecache, repr
                     ret = []
                     Colors = self.color_scheme_table.active_colors
                     ColorsNormal = Colors.Normal
                     tpl_link = '%s%%s%s' % (Colors.filenameEm, ColorsNormal)
                     tpl_line = '%%s%s%%s %s%%s' % (Colors.lineno, ColorsNormal)
                     tpl_line_em = '%%s%s%%s %s%%s%s' % (Colors.linenoEm, Colors.line,
                                                         ColorsNormal)
                     frame, lineno = frame_lineno
                     return_value = ''
                     if '__return__' in frame.f_locals:
                         rv = frame.f_locals['__return__']
                     #s = filename + '(' + `lineno` + ')'
                     filename = self.canonic(frame.f_code.co_filename)
                     link = tpl_link % filename
                     if frame.f_code.co_name:
                         func = frame.f_code.co_name
                     else:
                         func = "<lambda>"
                     call = ''
                     if func != '?':
                         if '__args__' in frame.f_locals:
                             args = repr.repr(frame.f_locals['__args__'])
                         else:
                     else:
                         ret.append('  ')
                     ret.append('%s(%s)%s\n' % (link,lineno,call))
                     start = lineno - 1 - context//2
                     lines = linecache.getlines(filename)
                     start = max(start, 0)
                     start = min(start, len(lines) - context)
                     lines = lines[start : start + context]
                     for i,line in enumerate(lines):
                         show_arrow = (start + 1 + i == lineno)
                         linetpl = (frame is self.curframe or show_arrow) \
                     if lineno in self.get_file_breaks(filename):
                         bps = self.get_breaks(filename, lineno)
                         bp = bps[-1]
                     if bp:
                         Colors = self.color_scheme_table.active_colors
                         bp_mark = str(bp.number)
                     else:
                         num = '%*s' % (numbers_width - len(bp_mark), str(lineno))
                         line = tpl_line % (bp_mark_color + bp_mark, num, line)
                     return line
                 def list_command_pydb(self, arg):
                     filename, first, last = OldPdb.parse_list_cmd(self, arg)
                     if filename is not None:
                         self.print_list_lines(filename, first, last)
                 def print_list_lines(self, filename, first, last):
                     """The printing (as opposed to the parsing part of a 'list'
                     command."""
                     #
                     # End hack.  The rest of this method is copied verbatim from 2.6 pdb.py
                     #######################################################################
                     if not line:
                         print >>self.stdout, 'End of file'
                         return 0

IPython/core/display.py

0 +2 -2

                 """
                 include = kwargs.get('include')
                 exclude = kwargs.get('exclude')
                 from IPython.core.interactiveshell import InteractiveShell
                 inst = InteractiveShell.instance()
                 format = inst.display_formatter.format
                     in the frontend. The MIME type of the data should match the
                     subclasses used, so the Png subclass should be used for 'image/png'
                     data. If the data is a URL, the data will first be downloaded
                     and then displayed. If
                     Parameters
                     ----------

IPython/core/displayhook.py

0 +7 -7

                             return no_cache_def
                     else:
                         return p_str
                 def set_colors(self, colors):
                     """Set the active color scheme and configure colors for the three
                     prompt subsystems."""
                         prompts.prompt_specials = prompts.prompt_specials_nocolor
                     else:
                         prompts.prompt_specials = prompts.prompt_specials_color
                     self.color_table.set_active_scheme(colors)
                     self.prompt1.set_colors()
                     self.prompt2.set_colors()
                     format_dict : dict
                         The format dict for the object passed to `sys.displayhook`.
                     """
                     # We want to print because we want to always make sure we have a
                     # newline, even if all the prompt separators are ''. This is the
                     # standard IPython behavior.
                     result_repr = format_dict['text/plain']
                 def __call__(self, result=None):
                     """Printing with history cache management.
                     This is invoked everytime the interpreter needs to print, and is
                     activated by setting the variable sys.displayhook to it.
                     """
                         raise ValueError,"You shouldn't have reached the cache flush "\
                               "if full caching is not enabled!"
                     # delete auto-generated vars from global namespace
                     for n in range(1,self.prompt_count + 1):
                         key = '_'+`n`
                         try:
                             del self.shell.user_ns[key]
                         except: pass
                     self.shell.user_ns['_oh'].clear()
                     # Release our own references to objects:
                     self._, self.__, self.___ = '', '', ''
                     if '_' not in __builtin__.__dict__:
                         self.shell.user_ns.update({'_':None,'__':None, '___':None})
                     import gc

IPython/core/displaypub.py

0 +2 -2

                         A string that give the function or method that created the data,
                         such as 'IPython.core.page'.
                     data : dict
                         A dictionary having keys that are valid MIME types (like
                         'text/plain' or 'image/svg+xml') and values that are the data for
                         that MIME type. The data itself must be a JSON'able data
                         structure. Minimally all data should have the 'text/plain' data,
                     A string that give the function or method that created the data,
                     such as 'IPython.core.page'.
                 data : dict
                     A dictionary having keys that are valid MIME types (like
                     'text/plain' or 'image/svg+xml') and values that are the data for
                     that MIME type. The data itself must be a JSON'able data
                     structure. Minimally all data should have the 'text/plain' data,

IPython/core/error.py

0 +3 -3

             class TryNext(IPythonCoreError):
                 """Try next hook exception.
                 Raise this in your hook function to indicate that the next hook handler
                 should be used to handle the operation.  If you pass arguments to the
                 constructor those arguments will be used by the next hook instead of the
             class UsageError(IPythonCoreError):
                 """Error in magic function arguments, etc.
                 Something that probably won't warrant a full traceback, but should
                 nevertheless interrupt a macro / batch file.
                 """

IPython/core/excolors.py

0 +4 -4

                 >>> print ec.active_colors
                 None
                 Now we activate a color scheme:
                 >>> ec.set_active_scheme('NoColor')
                 >>> ec.active_scheme_name
                 'NoColor'
                 >>> ec.active_colors.keys()
                 ['em', 'filenameEm', 'excName', 'valEm', 'nameEm', 'line', 'topline',
                 'name', 'caret', 'val', 'vName', 'Normal', 'filename', 'linenoEm',
                 'lineno', 'normalEm']
                 """
                 ex_colors = ColorSchemeTable()
                 # Populate it with color schemes

IPython/core/extensions.py

0 +2 -2

                     def load_ipython_extension(ipython):
                         # Do things with ipython
                 This function is called after your extension is imported and the
                 currently active :class:`InteractiveShell` instance is passed as
                 the only argument.  You can do anything you want with IPython at
                 that point, including defining new magic and aliases, adding new
                 components, etc.
                 The :func:`load_ipython_extension` will be called again is you
                 load or reload the extension again.  It is up to the extension
                 author to add code to manage that.

IPython/core/formatters.py

0 +10 -10

                 # The newline character.
                 newline = Unicode('\n', config=True)
                 # format-string for pprinting floats
                 float_format = Unicode('%r')
                 # setter for float precision, either int or direct format-string
                 float_precision = CUnicode('', config=True)
                 def _float_precision_changed(self, name, old, new):
                     """float_precision changed, set float_format accordingly.
                     float_precision can be set by int or str.
                     This will set float_format, after interpreting input.
                     If numpy has been imported, numpy print precision will also be set.
                     integer `n` sets format to '%.nf', otherwise, format set directly.
                     An empty string returns to defaults (repr for float, 8 for numpy).
                     This parameter can be set via the '%precision' magic.
                     """
                     if '%' in new:
                         # got explicit format string
                         fmt = new
                             raise ValueError("Precision must be int or format string, not %r"%new)
                         except AssertionError:
                             raise ValueError("int precision must be non-negative, not %r"%i)
                         fmt = '%%.%if'%i
                         if 'numpy' in sys.modules:
                             # set numpy precision if it has been imported
                 this.
                 The return value of this formatter should be a valid HTML snippet that
                 could be injected into an existing DOM. It should *not* include the
                 ```<html>`` or ```<body>`` tags.
                 """
                 format_type = Unicode('text/html')
                 """A Javascript formatter.
                 To define the callables that compute the Javascript representation of
                 your objects, define a :meth:`_repr_javascript_` method or use the
                 :meth:`for_type` or :meth:`for_type_by_name` methods to register functions
                 that handle this.

IPython/core/history.py

0 +93 -93

                 # Should we log output to the database? (default no)
                 db_log_output = Bool(False, config=True)
                 # Write to database every x commands (higher values save disk access & power)
                 #  Values of 1 or less effectively disable caching.
                 db_cache_size = Int(0, config=True)
                 # The input and output caches
                 db_input_cache = List()
                 db_output_cache = List()
                 # History saving in separate thread
                 save_thread = Instance('IPython.core.history.HistorySavingThread')
                 try:               # Event is a function returning an instance of _Event...
                     save_flag = Instance(threading._Event)
                 except AttributeError:         # ...until Python 3.3, when it's a class.
                     save_flag = Instance(threading.Event)
                 # Private interface
                 # Variables used to store the three last inputs from the user.  On each new
                 # history update, we populate the user's namespace with these, shifted as
                         else:
                             # The hist_file is probably :memory: or something else.
                             raise
                     self.save_flag = threading.Event()
                     self.db_input_cache_lock = threading.Lock()
                     self.db_output_cache_lock = threading.Lock()
                     self.new_session()
                 def init_db(self):
                     """Connect to the database, and create tables if necessary."""
                     # use detect_types so that timestamps return datetime objects
                     self.db.execute("""CREATE TABLE IF NOT EXISTS sessions (session integer
                                     primary key autoincrement, start timestamp,
                                     end timestamp, num_cmds integer, remark text)""")
                     self.db.execute("""CREATE TABLE IF NOT EXISTS history
                             (session integer, line integer, source text, source_raw text,
                             PRIMARY KEY (session, line))""")
                     # Output history is optional, but ensure the table's there so it can be
                                     (session integer, line integer, output text,
                                     PRIMARY KEY (session, line))""")
                     self.db.commit()
                 def new_session(self, conn=None):
                     """Get a new session number."""
                     if conn is None:
                         conn = self.db
                     with conn:
                         cur = conn.execute("""INSERT INTO sessions VALUES (NULL, ?, NULL,
                                         NULL, "") """, (datetime.datetime.now(),))
                         self.session_number = cur.lastrowid
                 def end_session(self):
                     """Close the database session, filling in the end time and line count."""
                     self.writeout_cache()
                                         session==?""", (datetime.datetime.now(),
                                         len(self.input_hist_parsed)-1, self.session_number))
                     self.session_number = 0
                 def name_session(self, name):
                     """Give the current session a name in the history database."""
                     with self.db:
                         self.db.execute("UPDATE sessions SET remark=? WHERE session==?",
                                         (name, self.session_number))
                 def reset(self, new_session=True):
                     """Clear the session history, releasing all object references, and
                     optionally open a new session."""
                     self.output_hist.clear()
                     # The directory history can't be completely empty
                     self.dir_hist[:] = [os.getcwdu()]
                     if new_session:
                         if self.session_number:
                             self.end_session()
                         self.input_hist_parsed[:] = [""]
                         self.input_hist_raw[:] = [""]
                         self.new_session()
                 ## -------------------------------
                 ## Methods for retrieving history:
                 ## -------------------------------
                 def _run_sql(self, sql, params, raw=True, output=False):
                     """Prepares and runs an SQL query for the history database.
                     Parameters
                     ----------
                     sql : str
                       Parameters passed to the SQL query (to replace "?")
                     raw, output : bool
                       See :meth:`get_range`
                     Returns
                     -------
                     Tuples as :meth:`get_range`
                     if output:    # Regroup into 3-tuples, and parse JSON
                         return ((ses, lin, (inp, out)) for ses, lin, inp, out in cur)
                     return cur
                 def get_session_info(self, session=0):
                     """get info about a session
                     Parameters
                     ----------
                     session : int
                         Session number to retrieve. The current session is 0, and negative
                         numbers count back from current session, so -1 is previous session.
                     Returns
                     -------
                     (session_id [int], start [datetime], end [datetime], num_cmds [int], remark [unicode])
                     Sessions that are running or did not exit cleanly will have `end=None`
                     and `num_cmds=None`.
                     """
                     if session <= 0:
                         session += self.session_number
                     query = "SELECT * from sessions where session == ?"
                     return self.db.execute(query, (session,)).fetchone()
                 def get_tail(self, n=10, raw=True, output=False, include_latest=False):
                     """Get the last n lines from the history database.
                     Parameters
                     ----------
                     n : int
                       If False (default), n+1 lines are fetched, and the latest one
                       is discarded. This is intended to be used where the function
                       is called by a user command, which it should not return.
                     Returns
                     -------
                     Tuples as :meth:`get_range`
                     if not include_latest:
                         return reversed(list(cur)[1:])
                     return reversed(list(cur))
                 def search(self, pattern="*", raw=True, search_raw=True,
                                                                     output=False):
                     """Search the database using unix glob-style matching (wildcards
                     * and ?).
                     Parameters
                     ----------
                     pattern : str
                       If True, search the raw input, otherwise, the parsed input
                     raw, output : bool
                       See :meth:`get_range`
                     Returns
                     -------
                     Tuples as :meth:`get_range`
                     self.writeout_cache()
                     return self._run_sql("WHERE %s GLOB ?" % tosearch, (pattern,),
                                                 raw=raw, output=output)
                 def _get_range_session(self, start=1, stop=None, raw=True, output=False):
                     """Get input and output history from the current session. Called by
                     get_range, and takes similar parameters."""
                     input_hist = self.input_hist_raw if raw else self.input_hist_parsed
                     n = len(input_hist)
                     if start < 0:
                         start += n
                         stop = n
                     elif stop < 0:
                         stop += n
                     for i in range(start, stop):
                         if output:
                             line = (input_hist[i], self.output_hist_reprs.get(i))
                         else:
                             line = input_hist[i]
                         yield (0, i, line)
                 def get_range(self, session=0, start=1, stop=None, raw=True,output=False):
                     """Retrieve input by session.
                     Parameters
                     ----------
                     session : int
                         objects for the current session, or text reprs from previous
                         sessions if db_log_output was enabled at the time. Where no output
                         is found, None is used.
                     Returns
                     -------
                     An iterator over the desired lines. Each line is a 3-tuple, either
                         return self._get_range_session(start, stop, raw, output)
                     if session < 0:
                         session += self.session_number
                     if stop:
                         lineclause = "line >= ? AND line < ?"
                         params = (session, start, stop)
                     else:
                         lineclause = "line>=?"
                         params = (session, start)
                     return self._run_sql("WHERE session==? AND %s""" % lineclause,
                                                 params, raw=raw, output=output)
                 def get_range_by_str(self, rangestr, raw=True, output=False):
                     """Get lines of history from a string of ranges, as used by magic
                     commands %hist, %save, %macro, etc.
                     Parameters
                     ----------
                     rangestr : str
                       :func:`magic_history` for full details.
                     raw, output : bool
                       As :meth:`get_range`
                     Returns
                     -------
                     Tuples as :meth:`get_range`
                     for sess, s, e in extract_hist_ranges(rangestr):
                         for line in self.get_range(sess, s, e, raw=raw, output=output):
                             yield line
                 ## ----------------------------
                 ## Methods for storing history:
                 ## ----------------------------
                 def store_inputs(self, line_num, source, source_raw=None):
                     """Store source and raw input in history and create input cache
                     variables _i*.
                     Parameters
                     ----------
                     line_num : int
                       The prompt number of this input.
                     source : str
                       Python input.
                         source_raw = source
                     source = source.rstrip('\n')
                     source_raw = source_raw.rstrip('\n')
                     # do not store exit/quit commands
                     if self._exit_re.match(source_raw.strip()):
                         return
                     self.input_hist_parsed.append(source)
                     self.input_hist_raw.append(source_raw)
                     with self.db_input_cache_lock:
                         self.db_input_cache.append((line_num, source, source_raw))
                         # Trigger to flush cache and write to DB.
                                '_iii': self._iii,
                                new_i : self._i00 }
                     self.shell.user_ns.update(to_main)
                 def store_output(self, line_num):
                     """If database output logging is enabled, this saves all the
                     outputs from the indicated prompt number to the database. It's
                     called by run_cell after code has been executed.
                     Parameters
                     ----------
                     line_num : int
                     if (not self.db_log_output) or (line_num not in self.output_hist_reprs):
                         return
                     output = self.output_hist_reprs[line_num]
                     with self.db_output_cache_lock:
                         self.db_output_cache.append((line_num, output))
                     if self.db_cache_size <= 1:
                         self.save_flag.set()
                 def _writeout_input_cache(self, conn):
                     with conn:
                         for line in self.db_input_cache:
                             conn.execute("INSERT INTO history VALUES (?, ?, ?, ?)",
                                             (self.session_number,)+line)
                 def _writeout_output_cache(self, conn):
                     with conn:
                         for line in self.db_output_cache:
                             conn.execute("INSERT INTO output_history VALUES (?, ?, ?)",
                                             (self.session_number,)+line)
                 def writeout_cache(self, conn=None):
                     """Write any entries in the cache to the database."""
                     if conn is None:
                         conn = self.db
                     with self.db_input_cache_lock:
                         try:
                             self._writeout_input_cache(conn)
             class HistorySavingThread(threading.Thread):
                 """This thread takes care of writing history to the database, so that
                 the UI isn't held up while that happens.
                 It waits for the HistoryManager's save_flag to be set, then writes out
                 the history cache. The main thread is responsible for setting the flag when
                 the cache size reaches a defined threshold."""
                     super(HistorySavingThread, self).__init__()
                     self.history_manager = history_manager
                     atexit.register(self.stop)
                 def run(self):
                     # We need a separate db connection per thread:
                     try:
                     except Exception as e:
                         print(("The history saving thread hit an unexpected error (%s)."
                                "History will not be written to the database.") % repr(e))
                 def stop(self):
                     """This can be called from the main thread to safely stop this thread.
                     Note that it does not attempt to write out remaining history before
                     exiting. That should be done by calling the HistoryManager's
                     end_session method."""
                     self.history_manager.save_flag.set()
                     self.join()
             # To match, e.g. ~5/8-~2/3
             range_re = re.compile(r"""
             ((?P<startsess>~?\d+)/)?
             def extract_hist_ranges(ranges_str):
                 """Turn a string of history ranges into 3-tuples of (session, start, stop).
                 Examples
                 --------
                 list(extract_input_ranges("~8/5-~7/4 2"))
             @skip_doctest
             def magic_history(self, parameter_s = ''):
                 """Print input history (_i<n> variables), with most recent last.
                 %history       -> print at most 40 inputs (some may be multi-line)\\
                 %history n     -> print at most n inputs\\
                 %history n1 n2 -> print inputs between n1 and n2 (n2 not included)\\
                 ~8/1-~6/5 : From the first line of 8 sessions ago, to the fifth line
                             of 6 sessions ago.
                 Multiple ranges can be entered, separated by spaces
                 The same syntax is used by %macro, %save, %edit, %rerun
                 Options:
                    doctest-ready output.
                   -r: (default) print the 'raw' history, i.e. the actual commands you typed.
                   -t: print the 'translated' history, as IPython understands it.  IPython
                   filters your input and converts it all into valid Python source before
                   executing it (things like magics or aliases are turned into function
                   calls, for example). With this option, you'll see the native history
                   instead of the user-entered version: '%cd /' will be seen as
                   'get_ipython().magic("%cd /")' instead of '%cd /'.
                   -g: treat the arg as a pattern to grep for in (full) history.
                   This includes the saved history (almost all commands ever written).
                   Use '%hist -g' to show full saved history (may be very long).
                   -l: get the last n lines from all sessions. Specify n as a single arg, or
                   the default is the last 10 lines.
                   -f FILENAME: instead of printing the output to the screen, redirect it to
                    the given file.  The file is always overwritten, though IPython asks for
                    confirmation first if it already exists.
                 Examples
                 --------
                 ::
                   In [6]: %hist -n 4 6
 :a = 12
 :print a**2
                     print('This feature is only available if numbered prompts are in use.')
                     return
                 opts,args = self.parse_options(parameter_s,'noprtglf:',mode='string')
                 # For brevity
                 history_manager = self.shell.history_manager
                 def _format_lineno(session, line):
                     """Helper function to format line numbers properly."""
                     if session in (0, history_manager.session_number):
                     close_at_end = False
                 else:
                     if os.path.exists(outfname):
                         if not io.ask_yes_no("File %r exists. Overwrite?" % outfname):
                             print('Aborting.')
                             return
                     outfile = open(outfname,'w')
                     close_at_end = True
                 print_nums = 'n' in opts
                 get_output = 'o' in opts
                 pyprompts = 'p' in opts
                 # Raw history is the default
                 raw = not('t' in opts)
                 default_length = 40
                 pattern = None
                 if 'g' in opts:         # Glob search
                     pattern = "*" + args + "*" if args else "*"
                     hist = history_manager.search(pattern, raw=raw, output=get_output)
                         hist = history_manager.get_range_by_str(args, raw, get_output)
                     else:               # Just get history for the current session
                         hist = history_manager.get_range(raw=raw, output=get_output)
                 # We could be displaying the entire history, so let's not try to pull it
                 # into a list in memory. Anything that needs more space will just misalign.
                 width = 4
                 for session, lineno, inline in hist:
                     # Print user history with tabs expanded to 4 spaces.  The GUI clients
                     # use hard tabs for easier usability in auto-indented code, but we want
                     if get_output:
                         inline, output = inline
                     inline = inline.expandtabs(4).rstrip()
                     multiline = "\n" in inline
                     line_sep = '\n' if multiline else ' '
                     if print_nums:
                 %rep are equivalent.
                 - %recall (no arguments):
                 Place a string version of last computation result (stored in the special '_'
                 variable) to the next input prompt. Allows you to create elaborate command
                 lines without using copy-paste::
                      In[1]: l = ["hei", "vaan"]
                      In[2]: "".join(l)
                     Out[2]: heivaan
                      In[3]: %rep
                      In[4]: heivaan_ <== cursor blinking
                 %recall 45
                 Place history line 45 on the next input prompt. Use %hist to find
                 out the number.
                 %recall 1-4
                 Combine the specified lines into one cell, and place it on the next
                 input prompt. See %history for the slice syntax.
                 %recall foo+bar
                 If foo+bar can be evaluated in the user namespace, the result is
                 placed at the next input prompt. Otherwise, the history is searched
                 for lines which contain that substring, and the most recent one is
                 else:
                     self.set_next_input(cmd.rstrip())
                 print("Couldn't evaluate or find in history:", arg)
             def magic_rerun(self, parameter_s=''):
                 """Re-run previous input
                 By default, you can specify ranges of input history to be repeated
                 (as with %history). With no arguments, it will repeat the last line.
                 Options:
                   -l <n> : Repeat the last n lines of input, not including the
                   current command.
                   -g foo : Repeat the most recent line which contains foo
                 """
                 opts, args = self.parse_options(parameter_s, 'l:g:', mode='string')
             def init_ipython(ip):
                 ip.define_magic("rep", magic_rep)
                 ip.define_magic("recall", magic_rep)
                 ip.define_magic("rerun", magic_rerun)
                 ip.define_magic("hist",magic_history)    # Alternative name

IPython/core/hooks.py

0 +28 -28

                 # IPython configures a default editor at startup by reading $EDITOR from
                 # the environment, and falling back on vi (unix) or notepad (win32).
                 editor = self.editor
                 # marker for at which line to open the file (for existing objects)
                 if linenum is None or editor=='notepad':
                     linemark = ''
                 else:
                     linemark = '+%d' % int(linenum)
                 # Enclose in quotes if necessary and legal
                 if ' ' in editor and os.path.isfile(editor) and editor[0] != '"':
                     editor = '"%s"' % editor
                 # Call the actual editor
                 if os.system('%s %s %s' % (editor,linemark,filename)) != 0:
                     raise TryNext()
             import tempfile
             def fix_error_editor(self,filename,linenum,column,msg):
                 """Open the editor at the given filename, linenumber, column and
                 show an error message. This is used for correcting syntax errors.
                 The current implementation only has special support for the VIM editor,
                 and falls back on the 'editor' hook if VIM is not used.
             class CommandChainDispatcher:
                 """ Dispatch calls to a chain of commands until some func can handle it
                 Usage: instantiate, execute "add" to add commands (with optional
                 priority), execute normally via f() calling mechanism.
                 """
                 def __init__(self,commands=None):
                     if commands is None:
                         self.chain = []
                     else:
                         self.chain = commands
                 def __call__(self,*args, **kw):
                     """ Command chain is called just like normal func.
                     This will call all funcs in chain with the same args as were given to this
                     function, and return the result of first func that didn't raise
                     TryNext """
                     for prio,cmd in self.chain:
                         #print "prio",prio,"cmd",cmd #dbg
                         try:
                                 kw = exc.kwargs
                     # if no function will accept it, raise TryNext up to the caller
                     raise TryNext
                 def __str__(self):
                     return str(self.chain)
                 def add(self, func, priority=0):
                     """ Add a func to the cmd chain with given priority """
                     bisect.insort(self.chain,(priority,func))
                 def __iter__(self):
                     """ Return all objects in chain.
                     Handy if the objects are not callable.
                     """
                     return iter(self.chain)
             def input_prefilter(self,line):
                 """ Default input prefilter
                 This returns the line as unchanged, so that the interpreter
                 knows that nothing was done and proceeds with "classic" prefiltering
                 (%magics, !shell commands etc.).
                 Note that leading whitespace is not passed to this hook. Prefilter
                 can't alter indentation.
                 """
                 #print "attempt to rewrite",line #dbg
                 return line
             def shutdown_hook(self):
                 """ default shutdown hook
                 Typically, shotdown hooks should raise TryNext so all shutdown ops are done
                 """
                 #print "default shutdown hook ok" # dbg
                 return
             def late_startup_hook(self):
                 """ Executed after ipython has been constructed and configured
                 """
                 #print "default startup hook ok" # dbg
             def pre_prompt_hook(self):
                 """ Run before displaying the next prompt
                 Use this e.g. to display output from asynchronous operations (in order
                 to not mess up text entry)
                 """
                 return None
                 """ Get text from the clipboard.
                 """
                 from IPython.lib.clipboard import (
                     osx_clipboard_get, tkinter_clipboard_get,
                     win32_clipboard_get
                 )
                 if sys.platform == 'win32':

IPython/core/interactiveshell.py

0 +109 -109

                 def __init__(self, shell):
                     self.shell = shell
                     self._nested_level = 0
                 def __enter__(self):
                     if self._nested_level == 0:
                         try:
                         except (AttributeError, IndexError):   # Can fail with pyreadline
                             self.orig_length, self.readline_tail = 999999, []
                     self._nested_level += 1
                 def __exit__(self, type, value, traceback):
                     self._nested_level -= 1
                     if self._nested_level == 0:
                             if e > 0:
                                 for _ in range(e):
                                     self.shell.readline.remove_history_item(self.orig_length)
                             # If it still doesn't match, just reload readline history.
                             if self.current_length() != self.orig_length \
                                 or self.get_readline_tail() != self.readline_tail:
                             pass
                     # Returning False will cause exceptions to propagate
                     return False
                 def current_length(self):
                     return self.shell.readline.get_current_history_length()
                 def get_readline_tail(self, n=10):
                     """Get the last n items in readline history."""
                     end = self.shell.readline.get_current_history_length() + 1
                     get confused with color codes, this capability can be turned off.
                     """
                 )
                 colors = CaselessStrEnum(('NoColor','LightBG','Linux'),
                                          default_value=get_default_colors(), config=True,
                     help="Set the color scheme (NoColor, Linux, or LightBG)."
                 )
                 quiet = CBool(False, config=True)
                 history_length = Int(10000, 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)
                 separate_out = SeparateUnicode('', config=True)
                 separate_out2 = SeparateUnicode('', config=True)
                 wildcards_case_sensitive = CBool(True, config=True)
                 xmode = CaselessStrEnum(('Context','Plain', 'Verbose'),
                                         default_value='Context', config=True)
                 # Subcomponents of InteractiveShell
                     # is what we want to do.
                     self.save_sys_module_state()
                     self.init_sys_modules()
                     # While we're trying to have each part of the code directly access what
                     # it needs without keeping redundant references to objects, we have too
                     # much legacy code that expects ip.db to exist.
                 def init_io(self):
                     # This will just use sys.stdout and sys.stderr. If you want to
                     # override sys.stdout and sys.stderr themselves, you need to do that
                     # *before* instantiating this class, because io holds onto
                     # references to the underlying streams.
                     if sys.platform == 'win32' and self.has_readline:
                         io.stdout = io.stderr = io.IOStream(self.readline._outputfile)
                 def init_prompts(self):
                     # TODO: This is a pass for now because the prompts are managed inside
                     # the DisplayHook. Once there is a separate prompt manager, this
                     # will initialize that object and all prompt related information.
                     pass
                     """set_hook(name,hook) -> sets an internal IPython hook.
                     IPython exposes some of its internal API as user-modifiable hooks.  By
                     adding your function to one of these hooks, you can modify IPython's
                     behavior to call at runtime your own routines."""
                     # At some point in the future, this should validate the hook before it
                     # accepts it.  Probably at least check that the hook takes the number
                     # of args it's supposed to.
                     f = types.MethodType(hook,self)
                     # check if the hook is for strdispatcher first
                         sdp.add_re(re.compile(re_key), f, priority )
                         self.strdispatchers[name] = sdp
                         return
                     dp = getattr(self.hooks, name, None)
                     if name not in IPython.core.hooks.__all__:
                         print "Warning! Hook '%s' is not one of %s" % \
                               (name, IPython.core.hooks.__all__ )
                     if not dp:
                         dp = IPython.core.hooks.CommandChainDispatcher()
                     try:
                         dp.add(f,priority)
                     except AttributeError:
                     must therefore make a *copy* of the given namespace, to allow the
                     original module's __dict__ to be cleared and reused.
                     Parameters
                     ----------
                       ns : a namespace (a dict, typically)
                     else:
                         # fallback to our internal debugger
                         pm = lambda : self.InteractiveTB.debugger(force=True)
                     with self.readline_no_record:
                         pm()
                     # the script will fail, because the function's closure had references
                     # to the original objects, which are now all None.  So we must protect
                     # these modules from deletion by keeping a cache.
+                    #
                     # To avoid keeping stale modules around (we only need the one from the
                     # last run), we use a dict keyed with the full path to the script, so
                     # only the last version of the module is held in the cache.  Note,
                     # __dict__).  Because if we try to cache the actual modules, old ones
                     # (uncached) could be destroyed while still holding references (such as
                     # those held by GUI objects that tend to be long-lived)>
+                    #
                     # The %reset command will flush this cache.  See the cache_main_mod()
                     # and clear_main_mod_cache() methods for details on use.
                     # module, and can even mutate at runtime, depending on the context
                     # (Python makes no guarantees on it).  In contrast, __builtin__ is
                     # always a module object, though it must be explicitly imported.
                     # For more details:
                     # http://mail.python.org/pipermail/python-dev/2001-April/014068.html
                     ns = dict(__builtin__ = builtin_mod)
                     # Put 'help' in the user namespace
                     try:
                         from site import _Helper
                     # Store myself as the public api!!!
                     ns['get_ipython'] = self.get_ipython
                     ns['exit'] = self.exiter
                     ns['quit'] = self.exiter
                     # Anything put into ns now would show up in %who.  Think twice before
                     # putting anything here, as we really want %who to show the user their
                     # stuff, not our variables.
                     # Finally, update the real user's namespace
                     self.user_ns.update(ns)
                 def reset(self, new_session=True):
                     """Clear all internal namespaces, and attempt to release references to
                     user objects.
                     If new_session is True, a new history session will be opened.
                     """
                     # Clear histories
                     # Reset counter used to index all histories
                     if new_session:
                         self.execution_count = 1
                     # Flush cached output items
                     if self.displayhook.do_full_cache:
                         self.displayhook.flush()
                     # Restore the user namespaces to minimal usability
                     for ns in self.ns_refs_table:
                         ns.clear()
                         drop_keys.discard('__builtins__')
                         for k in drop_keys:
                             del ns[k]
                     # Restore the user namespaces to minimal usability
                     self.init_user_ns()
                     # Restore the default and user aliases
                     self.alias_manager.clear_aliases()
                     self.alias_manager.init_aliases()
                     # Flush the private list of module references kept for script
                     # execution protection
                     self.clear_main_mod_cache()
                     # Clear out the namespace from the last %run
                     self.new_main_mod()
                 def del_var(self, varname, by_name=False):
                     """Delete a variable from the various namespaces, so that, as
                     far as possible, we're not keeping any hidden references to it.
                     Parameters
                     ----------
                     varname : str
                     ns_refs = self.ns_refs_table + [self.user_ns,
                             self.user_global_ns, self._user_main_module.__dict__] +\
                             self._main_ns_cache.values()
                     if by_name:                    # Delete by name
                         for ns in ns_refs:
                             try:
                             to_delete = [n for n, o in ns.iteritems() if o is obj]
                             for name in to_delete:
                                 del ns[name]
                         # displayhook keeps extra references, but not in a dictionary
                         for name in ('_', '__', '___'):
                             if getattr(self.displayhook, name) is obj:
                                 setattr(self.displayhook, name, None)
                 def reset_selective(self, regex=None):
                     """Clear selective variables from internal namespaces based on a
                     specified regular expression.
                         for ns in self.ns_refs_table:
                             for var in ns:
                                 if m.search(var):
                                     del ns[var]
                 def push(self, variables, interactive=True):
                     """Inject a group of variables into the IPython user namespace.
                                        (name,cf.f_code.co_name))
                     else:
                         raise ValueError('variables must be a dict/str/list/tuple')
                     # Propagate variables to user namespace
                     self.user_ns.update(vdict)
                         root = '.'.join(path[:-1])
                         if info.parent is not None:
                             try:
                                 target = getattr(info.parent, '__class__')
                                 # The object belongs to a class instance.
                                 try:
                                     target = getattr(target, path[-1])
                                     # The class defines the object.
                                     if isinstance(target, property):
                                         oname = root + '.__class__.' + path[-1]
                                         info = Struct(self._ofind(oname))
                     """Find an object and return a struct with info about it."""
                     inf = Struct(self._ofind(oname, namespaces))
                     return Struct(self._ofind_property(oname, inf))
                 def _inspect(self, meth, oname, namespaces=None, **kw):
                     """Generic interface to the inspector system.
                 def init_traceback_handlers(self, custom_exceptions):
                     # Syntax error handler.
                     self.SyntaxTB = ultratb.SyntaxTB(color_scheme='NoColor')
                     # The interactive one is initialized with an offset, meaning we always
                     # want to remove the topmost item in the traceback, which is our own
                     # internal code. Valid modes: ['Plain','Context','Verbose']
                     care of calling it if needed, so unless you are explicitly catching a
                     SyntaxError exception, don't try to analyze the stack manually and
                     simply call this method."""
                     try:
                         if exc_tuple is None:
                             etype, value, tb = sys.exc_info()
                             else:
                                 self.write_err('No traceback available to show.\n')
                                 return
                         if etype is SyntaxError:
                             # Though this won't be called by syntax errors in the input
                             # line, there may be SyntaxError cases with imported code.
                                 else:
                                     stb = self.InteractiveTB.structured_traceback(etype,
                                                             value, tb, tb_offset=tb_offset)
                                     if self.call_pdb:
                                         # drop into debugger
                                         self.debugger(force=True)
                             # Actually show the traceback
                             self._showtraceback(etype, value, stb)
                     except KeyboardInterrupt:
                         self.write_err("\nKeyboardInterrupt\n")
                     sys.last_type = etype
                     sys.last_value = value
                     sys.last_traceback = last_traceback
                     if filename and etype is SyntaxError:
                         # Work hard to stuff the correct filename in the exception
                         try:
                                 value = msg, (filename, lineno, offset, line)
                     stb = self.SyntaxTB.structured_traceback(etype, value, [])
                     self._showtraceback(etype, value, stb)
                 # This is overridden in TerminalInteractiveShell to show a message about
                 # the %paste magic.
                 def showindentationerror(self):
                     """Called by run_cell when there's an IndentationError in code entered
                     at the prompt.
                     This is overridden in TerminalInteractiveShell to show a message about
                     the %paste magic."""
                     self.showsyntaxerror()
                         self.has_readline = True
                         self.readline = readline
                         sys.modules['readline'] = readline
                         # Platform-specific configuration
                         if os.name == 'nt':
                             # FIXME - check with Frederick to see if we can harmonize
                             except:
                                 warn('Problems reading readline initialization file <%s>'
                                      % inputrc_name)
                         # Configure readline according to user's prefs
                         # This is only done if GNU readline is being used.  If libedit
                         # is being used (as on Leopard) the readline config is
                         readline.set_completer_delims(delims)
                         # otherwise we end up with a monster history after a while:
                         readline.set_history_length(self.history_length)
                         self.refill_readline_hist()
                         self.readline_no_record = ReadlineNoRecord(self)
                     # Configure auto-indent for all platforms
                     self.set_autoindent(self.autoindent)
                 def refill_readline_hist(self):
                     # Load the last 1000 lines from history
                     self.readline.clear_history()
                 def set_next_input(self, s):
                     """ Sets the 'default' input string for the next command line.
                     Requires readline.
                     Example:
                     [D:\ipython]|1> _ip.set_next_input("Hello Word")
                     [D:\ipython]|2> Hello Word_  # cursor is here
                     """
                     if isinstance(s, unicode):
                         s = s.encode(self.stdin_encoding, 'replace')
                     from IPython.core.completer import IPCompleter
                     from IPython.core.completerlib import (module_completer,
                                                            magic_run_completer, cd_completer)
                     self.Completer = IPCompleter(shell=self,
                                                  namespace=self.user_ns,
                                                  global_namespace=self.user_global_ns,
                                                  use_readline=self.has_readline,
                                                  config=self.config,
                                                  )
                     # Add custom completers to the basic ones built into IPCompleter
                     sdisp = self.strdispatchers.get('complete_command', StrDispatch())
                     self.strdispatchers['complete_command'] = sdisp
                     The optional arguments allow the completion to take more context into
                     account, and are part of the low-level completion API.
                     This is a wrapper around the completion mechanism, similar to what
                     readline does at the command line when the TAB key is hit.  By
                     exposing it as a method, it can be used by other non-readline
                     # We do this first so that magic functions can override it.
                     if next_input:
                         self.set_next_input(next_input)
                     args = arg_s.split(' ',1)
                     magic_name = args[0]
                     magic_name = magic_name.lstrip(prefilter.ESC_MAGIC)
                     try:
                         magic_args = args[1]
                     except IndexError:
                         return result
                 def define_magic(self, magicname, func):
                     """Expose own function as magic function for ipython
                     def foo_impl(self,parameter_s=''):
                         'My very own magic!. (Use docstrings, IPython reads them).'
                         print 'Magic function. Passed parameter is between < >:'
                         print '<%s>' % parameter_s
                         print 'The self object is:',self
                     self.define_magic('foo',foo_impl)
                     """
                     im = types.MethodType(func,self)
                     name : str
                         The name of the macro.
                     themacro : str or Macro
                         The action to do upon invoking the macro.  If a string, a new
                         Macro object is created by passing the string to it.
                     """
                     from IPython.core import macro
                     if isinstance(themacro, basestring):
                         # os.system() or use ip.system=ip.system_raw
                         # if they really want a background process.
                         raise OSError("Background processes not supported.")
                     # we explicitly do NOT return the subprocess status code, because
                     # a non-None value would trigger :func:`sys.displayhook` calls.
                     # Instead, we store the exit_code in user_ns.
                     self.user_ns['_exit_code'] = system(self.var_expand(cmd, depth=2))
                 def system_raw(self, cmd):
                     """Call the given cmd in a subprocess using os.system
                     Parameters
                     ----------
                     cmd : str
                     # a non-None value would trigger :func:`sys.displayhook` calls.
                     # Instead, we store the exit_code in user_ns.
                     self.user_ns['_exit_code'] = os.system(self.var_expand(cmd, depth=2))
                 # use piped system by default, because it is better behaved
                 system = system_piped
                       Command to execute (can not end in '&', as background processes are
                       not supported.
                     split : bool, optional
                       If True, split the output into an IPython SList.  Otherwise, an
                       IPython LSString is returned.  These are objects similar to normal
                       lists and strings, with a few convenience attributes for easier
                     into::
                       ------> f(x)
                     after the user's input prompt.  This helps the user understand that the
                     input line was transformed automatically by IPython.
                     """
                         print >> io.stdout, rw
                     except UnicodeEncodeError:
                         print "------> " + cmd
                 #-------------------------------------------------------------------------
                 # Things related to extracting values/expressions from kernel and user_ns
                 #-------------------------------------------------------------------------
                             value = self._simple_error()
                         out[varname] = value
                     return out
                 def user_expressions(self, expressions):
                     """Evaluate a dict of expressions in the user's namespace.
                       A dict with string keys and string values.  The expression values
                       should be valid Python expressions, each of which will be evaluated
                       in the user namespace.
                     Returns
                     -------
                     A dict, keyed like the input expressions dict, with the repr() of each
                         except:
                             self.showtraceback()
                             warn('Unknown failure executing file: <%s>' % fname)
                 def run_cell(self, raw_cell, store_history=True):
                     """Run a complete IPython cell.
                     Parameters
                     ----------
                     raw_cell : str
                     """
                     if (not raw_cell) or raw_cell.isspace():
                         return
                     for line in raw_cell.splitlines():
                         self.input_splitter.push(line)
                     cell = self.input_splitter.source_reset()
                     with self.builtin_trap:
                         prefilter_failed = False
                         if len(cell.splitlines()) == 1:
                                 # don't allow prefilter errors to crash IPython
                                 self.showtraceback()
                                 prefilter_failed = True
                         # Store raw and processed history
                         if store_history:
                             self.history_manager.store_inputs(self.execution_count,
                                                               cell, raw_cell)
                         self.logger.log(cell, raw_cell)
                         if not prefilter_failed:
                             # don't run if prefilter failed
                             cell_name = self.compile.cache(cell, self.execution_count)
                             with self.display_trap:
                                 try:
                                     code_ast = self.compile.ast_parse(cell, filename=cell_name)
                                     self.showsyntaxerror()
                                     self.execution_count += 1
                                     return None
                                 self.run_ast_nodes(code_ast.body, cell_name,
                                                    interactivity="last_expr")
                                 # Execute any registered post-execution functions.
                                 for func, status in self._post_execute.iteritems():
                                     if not status:
                                         self.showtraceback()
                                         # Deactivate failing function
                                         self._post_execute[func] = False
                     if store_history:
                         # Write output to the database. Does nothing unless
                         # history output logging is enabled.
                         self.history_manager.store_output(self.execution_count)
                         # Each cell is a *single* input, regardless of how many lines it has
                         self.execution_count += 1
                 def run_ast_nodes(self, nodelist, cell_name, interactivity='last_expr'):
                     """Run a sequence of AST nodes. The execution mode depends on the
                     interactivity parameter.
                     Parameters
                     ----------
                     nodelist : list
                     """
                     if not nodelist:
                         return
                     if interactivity == 'last_expr':
                         if isinstance(nodelist[-1], ast.Expr):
                             interactivity = "last"
                         else:
                             interactivity = "none"
                     if interactivity == 'none':
                         to_run_exec, to_run_interactive = nodelist, []
                     elif interactivity == 'last':
                         to_run_exec, to_run_interactive = [], nodelist
                     else:
                         raise ValueError("Interactivity was %r" % interactivity)
                     exec_count = self.execution_count
                     try:
                         self.showtraceback()
                     return False
                 def run_code(self, code_obj):
                     """Execute a code object.
                             print
                     return outflag
                 # For backwards compatibility
                 runcode = run_code
                     filename = tempfile.mktemp('.py', prefix)
                     self.tempfiles.append(filename)
                     if data:
                         tmp_file = open(filename,'w')
                         tmp_file.write(data)
                     if self.quiet:
                         return True
                     return ask_yes_no(prompt,default)
                 def show_usage(self):
                     """Show a usage message"""
                     page.page(IPython.core.usage.interactive_usage)
                 def find_user_code(self, target, raw=True):
                     """Get a code string from history, file, or a string or macro.
                     This is mainly used by magic functions.
                     Parameters
                     ----------
                     target : str
                     raw : bool
                       If true (default), retrieve raw history. Has no effect on the other
                       retrieval mechanisms.
                     Returns
                     -------
                     A string of code.
                     ValueError is raised if nothing is found, and TypeError if it evaluates
                     to an object of another type. In each case, .args[0] is a printable
                     message.
                     """
                     code = self.extract_input_lines(target, raw=raw)  # Grab history
                     if code:
                         return code
                     if os.path.isfile(target):                        # Read file
                         return open(target, "r").read()
                     try:                                              # User namespace
                         codeobj = eval(target, self.user_ns)
                     except Exception:
                         return codeobj
                     elif isinstance(codeobj, Macro):
                         return codeobj.value
                     raise TypeError("%s is neither a string nor a macro." % target,
                                     codeobj)
                     For things that may depend on startup flags or platform specifics (such
                     as having readline or not), register a separate atexit function in the
                     code that has the appropriate information, rather than trying to
                     clutter
                     """
                     # Close the history session (this stores the end time and line count)
                     # this must be *before* the tempfile cleanup, in case of temporary
                     # history db
                     self.history_manager.end_session()
                     # Cleanup all tempfiles left around
                     for tfile in self.tempfiles:
                         try:
                             os.unlink(tfile)
                         except OSError:
                             pass
                     # Clear all user namespaces to release all references cleanly.
                     self.reset(new_session=False)

IPython/core/logger.py

0 +9 -9

                     return self._logmode
                 logmode = property(_get_mode,_set_mode)
                 def logstart(self,logfname=None,loghead=None,logmode=None,
                              log_output=False,timestamp=False,log_raw_input=False):
                     """Generate a new log-file with a default header.
                     if self.logfile is not None:
                         raise RuntimeError('Log file is already active: %s' %
                                            self.logfname)
                     # The parameters can override constructor defaults
                     if logfname is not None: self.logfname = logfname
                     if loghead is not None: self.loghead = loghead
                     self.timestamp = timestamp
                     self.log_output = log_output
                     self.log_raw_input = log_raw_input
                     # init depending on the log mode requested
                     isfile = os.path.isfile
                     logmode = self.logmode
                     elif logmode == 'over':
                         if isfile(self.logfname):
                             os.remove(self.logfname)
                         self.logfile = open(self.logfname,'w')
                     elif logmode == 'rotate':
                         if isfile(self.logfname):
                             if isfile(self.logfname+'.001~'):
                                 old = glob.glob(self.logfname+'.*~')
                                 old.sort()
                                 old.reverse()
                                     os.rename(f, root+'.'+`num`.zfill(3)+'~')
                             os.rename(self.logfname, self.logfname+'.001~')
                         self.logfile = open(self.logfname,'w')
                     if logmode != 'append':
                         self.logfile.write(self.loghead)
                     if val not in [False,True,0,1]:
                         raise ValueError, \
                               'Call switch_log ONLY with a boolean argument, not with:',val
                     label = {0:'OFF',1:'ON',False:'OFF',True:'ON'}
                     if self.logfile is None:
             %logon/%logoff are for temporarily starting and stopping logging for a logfile
             which already exists. But you must first start the logging process with
             %logstart (optionally giving a logfile name)."""
                     else:
                         if self.log_active == val:
                             print 'Logging is already',label[val]
                     In order to start logging again, a new logstart() call needs to be
                     made, possibly (though not necessarily) with a new filename, mode and
                     other options."""
                     if self.logfile is not None:
                         self.logfile.close()
                         self.logfile = None

IPython/core/magic.py

0 +214 -214

                     newhead.append(h)
                     done.add(h)
                 return newhead + tail
             def needs_local_scope(func):
                 """Decorator to mark magic functions which need to local scope to run."""
                 func.needs_local_scope = True
                 return func
             # Used for exception handling in magic_edit
             class MacroToEdit(ValueError): pass
             # on construction of the main InteractiveShell object.  Something odd is going
             # on with super() calls, Configurable and the MRO... For now leave it as-is, but
             # eventually this needs to be clarified.
             # BG: This is because InteractiveShell inherits from this, but is itself a
             # Configurable. This messes up the MRO in some way. The fix is that we need to
             # make Magic a configurable that InteractiveShell does not subclass.
                 # some utility functions
                 def __init__(self,shell):
                     self.options_table = {}
                     if profile is None:
                         self.magic_prun = self.profile_missing_notice
                     ['magic_ls','magic_cd',...]"""
                     # FIXME. This needs a cleanup, in the way the magics list is built.
                     # magics in class definition
                     class_magic = lambda fn: fn.startswith('magic_') and \
                                   callable(Magic.__dict__[fn])
                         out.append(fn.replace('magic_','',1))
                     out.sort()
                     return out
                 def extract_input_lines(self, range_str, raw=False):
                     """Return as a string a set of input history slices.
                     Inputs:
                       - range_str: the set of slices is given as a string, like
                       "~5/6-~4/2 4:8 9", since this function is for use by magic functions
                       which get their arguments as strings. The number before the / is the
                       session number: ~n goes n back from the current session.
                     lines = self.shell.history_manager.\
                                                 get_range_by_str(range_str, raw=raw)
                     return "\n".join(x for _, _, x in lines)
                 def arg_err(self,func):
                     """Print docstring if incorrect arguments were passed"""
                     print 'Error in arguments:'
                     # Magic command names as headers:
                     cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
                                              re.MULTILINE)
                     # Magic commands
                     cmd_re = re.compile(r'(?P<cmd>%s.+?\b)(?!\}\}:)' % ESC_MAGIC,
                                         re.MULTILINE)
                     # Paragraph continue
                       -posix (True): whether to split the input line in POSIX mode or not,
                       as per the conventions outlined in the shlex module from the
                       standard library."""
                     # inject default options at the beginning of the input line
                     caller = sys._getframe(1).f_code.co_name.replace('magic_','')
                     arg_str = '%s %s' % (self.options_table.get(caller,''),arg_str)
                     mode = kw.get('mode','string')
                     if mode not in ['string','list']:
                         raise ValueError,'incorrect mode given: %s' % mode
                         try:
                             opts,args = getopt(argv,opt_str,*long_opts)
                         except GetoptError,e:
                             raise UsageError('%s ( allowed: "%s" %s)' % (e.msg,opt_str,
                                                     " ".join(long_opts)))
                         for o,a in opts:
                             if o.startswith('--'):
                         args = ' '.join(args)
                     return opts,args
                 #......................................................................
                 # And now the actual magic functions
                           ('  '+mesc).join(self.lsmagic())
                     print '\n' + Magic.auto_status[self.shell.automagic]
                     return None
                 def magic_magic(self, parameter_s = ''):
                     """Print information about the magic function system.
                     Supported formats: -latex, -brief, -rest
                     """
                     mode = ''
                                 break
                         if mode == 'brief':
                             # only first line
                             if fn.__doc__:
                                 fndoc = fn.__doc__.split('\n',1)[0]
                             else:
                                 fndoc = 'No documentation'
                         else:
                             if fn.__doc__:
                                 fndoc = fn.__doc__.rstrip()
                             else:
                                 fndoc = 'No documentation'
                         if mode == 'rest':
                             rest_docs.append('**%s%s**::\n\n\t%s\n\n' %(ESC_MAGIC,
                                                                 fname,fndoc))
                         else:
                             magic_docs.append('%s%s:\n\t%s\n' %(ESC_MAGIC,
                                                                 fname,fndoc))
                     magic_docs = ''.join(magic_docs)
                     if mode == 'rest':
                         return "".join(rest_docs)
                     if mode == 'latex':
                         print self.format_latex(magic_docs)
                         return
                         magic_docs = format_screen(magic_docs)
                     if mode == 'brief':
                         return magic_docs
                     outmsg = """
             IPython's 'magic' functions
             ===========================
                 def magic_page(self, parameter_s=''):
                     """Pretty print the object and display it through a pager.
                     %page [options] OBJECT
                     If no object is given, use _ (last output).
                     Options:
                       -r: page str(object), don't pretty-print it."""
                 def magic_pinfo(self, parameter_s='', namespaces=None):
                     """Provide detailed information about an object.
                     '%pinfo object' is just a synonym for object? or ?object."""
                     #print 'pinfo par: <%s>' % parameter_s  # dbg
                     # detail_level: 0 -> obj? , 1 -> obj??
                     detail_level = 0
                     # We need to detect if we got called as 'pinfo pinfo foo', which can
                 def magic_pinfo2(self, parameter_s='', namespaces=None):
                     """Provide extra detailed information about an object.
                     '%pinfo2 object' is just a synonym for object?? or ??object."""
                     self.shell._inspect('pinfo', parameter_s, detail_level=1,
                                         namespaces=namespaces)
                     """Print the definition header for any callable object.
                     If the object is a class, print the constructor information.
                     Examples
                     --------
                     ::
                       In [3]: %pdef urllib.urlopen
                       urllib.urlopen(url, data=None, proxies=None)
                     """
                     ?-i a* function
                     Arguments:
                       PATTERN
                       where PATTERN is a string containing * as a wildcard similar to its
                       -i/-c: make the pattern case insensitive/sensitive.  If neither of
                       these options are given, the default is read from your configuration
                       file, with the option ``InteractiveShell.wildcards_case_sensitive``.
                       If this option is not specified in your configuration file, IPython's
                       internal default is to do a case sensitive search.
                       -e/-s NAMESPACE: exclude/search a given namespace.  The pattern you
                       and it contains module-level globals.  You can add namespaces to the
                       search with -s or exclude them with -e (these options can be given
                       more than once).
                     Examples:
                     %psearch a*            -> objects beginning with an a
                     %psearch -e builtin a* -> objects NOT in the builtin space starting in a
                     %psearch a* function   -> all functions beginning with an a
                     %psearch r*.* string   -> all strings in modules beginning with r
                     Case sensitve search:
                     %psearch -c a*         list all object beginning with lower case a
                     Show objects beginning with a single _:
                     %psearch -a _*         list objects beginning with a single underscore"""
                     try:
                         parameter_s.encode('ascii')
                     def_search.extend(opt('s',[]))
                     ns_exclude = ns_exclude=opt('e',[])
                     ns_search = [nm for nm in def_search if nm not in ns_exclude]
                     # Call the actual search
                     try:
                         psearch(args,shell.ns_table,ns_search,
                                 show_all=opt('a'),ignore_case=ignore_case)
                     except:
                         shell.showtraceback()
                 @skip_doctest
                 def magic_who_ls(self, parameter_s=''):
                     """Return a sorted list of all interactive variables.
                     out.sort()
                     return out
                 @skip_doctest
                 def magic_who(self, parameter_s=''):
                     """Print all interactive variables, with some minimal formatting.
                     The same type filtering of %who can be applied here.
                     For all variables, the type is printed. Additionally it prints:
                       - For {},[],(): their length.
                       - For numpy arrays, a summary with shape, number of
                       alpha      int         123
                       beta       str         test
                     """
                     varnames = self.magic_who_ls(parameter_s)
                     if not varnames:
                         if parameter_s:
                     # Find all variable names and types so we can figure out column sizes
                     def get_vars(i):
                         return self.shell.user_ns[i]
                     # some types are well known and can be shorter
                     abbrevs = {'IPython.core.macro.Macro' : 'Macro'}
                     def type_name(v):
                         tn = type(v).__name__
                         return abbrevs.get(tn,tn)
                     varlist = map(get_vars,varnames)
                     typelist = []
                                 vsize  = Numeric.size(var)
                                 vbytes = vsize*var.itemsize()
                                 vdtype = var.typecode()
                             if vbytes < 100000:
                                 print aformat % (vshape,vsize,vdtype,vbytes)
                             else:
                                 print vstr
                             else:
                                 print vstr[:25] + "<...>" + vstr[-25:]
                 def magic_reset(self, parameter_s=''):
                     """Resets the namespace by removing all names defined by the user.
                     Parameters
                     ----------
                       -f : force reset without asking for confirmation.
                       -s : 'Soft' reset: Only clears your namespace, leaving history intact.
                       References to objects may be kept. By default (without this option),
                       we do a 'hard' reset, giving you a new session and removing all
                       references to objects from the current session.
                     Examples
                     --------
                     In [6]: a = 1
                     if not ans:
                         print 'Nothing done.'
                         return
                     if 's' in opts:                     # Soft reset
                         user_ns = self.shell.user_ns
                         for i in self.magic_who_ls():
                             del(user_ns[i])
                     else:                     # Hard reset
                         self.shell.reset(new_session = False)
                 def magic_reset_selective(self, parameter_s=''):
                     """Resets the namespace by removing names defined by the user.
                     %reset_selective [-f] regex
                     No action is taken if regex is not included
                     Options
                       -f : force reset without asking for confirmation.
                     We first fully reset the namespace so your output looks identical to
                     this example for pedagogical reasons; in practice you do not need a
                     full reset.
                     In [1]: %reset -f
                     Now, with a clean namespace we can make a few variables and use
                     In [11]: who_ls
                     Out[11]: ['a']
                     """
                     opts, regex = self.parse_options(parameter_s,'f')
                     if opts.has_key('f'):
                         ans = True
                     else:
                         except TypeError:
                             raise TypeError('regex must be a string or compiled pattern')
                         for i in self.magic_who_ls():
                             if m.search(i):
                                 del(user_ns[i])
                 def magic_xdel(self, parameter_s=''):
                     """Delete a variable, trying to clear it from anywhere that
                     IPython's machinery has references to it. By default, this uses
                     the identity of the named object in the user namespace to remove
                     references held under other names. The object is also removed
                     from the output history.
                     Options
                       -n : Delete the specified name from all namespaces, without
                       checking their identity.
                         self.shell.del_var(varname, ('n' in opts))
                     except (NameError, ValueError) as e:
                         print type(e).__name__ +": "+ str(e)
                 def magic_logstart(self,parameter_s=''):
                     """Start logging anywhere in a session.
                       -t: put timestamps before each input line logged (these are put in
                       comments)."""
                     opts,par = self.parse_options(parameter_s,'ort')
                     log_output = 'o' in opts
                     log_raw_input = 'r' in opts
                             input_hist = self.shell.history_manager.input_hist_raw
                         else:
                             input_hist = self.shell.history_manager.input_hist_parsed
                         if log_output:
                             log_write = logger.log_write
                             output_hist = self.shell.history_manager.output_hist
                         if timestamp:
                             # re-enable timestamping
                             logger.timestamp = True
                         print ('Activating auto-logging. '
                                'Current session state plus future input saved.')
                         logger.logstate()
                     You must have previously started logging."""
                     self.shell.logger.switch_log(0)
                 def magic_logon(self,parameter_s=''):
                     """Restart logging.
                     stopped with %logoff. For starting logging for the first time, you
                     must use the %logstart function, which allows you to specify an
                     optional log filename."""
                     self.shell.logger.switch_log(1)
                 def magic_logstate(self,parameter_s=''):
                     """Print the status of the logging system."""
                     self.shell.logger.logstate()
                 def magic_pdb(self, parameter_s=''):
                     """Control the automatic calling of the pdb interactive debugger.
                     When more than one key is provided, additional keys are used as
                     secondary criteria when the there is equality in all keys selected
                     before them.
                     Abbreviations can be used for any key names, as long as the
                     abbreviation is unambiguous.  The following are the keys currently
                     defined:
                     If you want to run complete programs under the profiler's control, use
                     '%run -p [prof_opts] filename.py [args to program]' where prof_opts
                     contains profiler specific options as described here.
                     You can read the complete documentation for the profile module with::
                       In [1]: import profile; profile.help()
                     """
                     opts_def = Struct(D=[''],l=[],s=['time'],T=[''])
                     # protect user quote marks
                     parameter_s = parameter_s.replace('"',r'\"').replace("'",r"\'")
                     if user_mode:  # regular user call
                         opts,arg_str = self.parse_options(parameter_s,'D:l:rs:T:',
                                                           list_all=1)
                         namespace = locals()
                     opts.merge(opts_def)
                     prof = profile.Profile()
                     try:
                         prof = prof.runctx(arg_str,namespace,namespace)
                                     lims.append(float(lim))
                                 except ValueError:
                                     lims.append(lim)
                     # Trap output.
                     stdout_trap = StringIO()
                             stats.print_stats(*lims)
                         finally:
                             sys.stdout = sys_stdout
                     output = stdout_trap.getvalue()
                     output = output.rstrip()
                     Usage:\\
                       %run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
                     Parameters after the filename are passed as command-line arguments to
                     the program (put in sys.argv). Then, control returns to IPython's
                     prompt.
                     interactive work, while giving each program a 'clean sheet' to run in.
                     Options:
                     -n: __name__ is NOT set to '__main__', but to the running file's name
                     without extension (as python does under import).  This allows running
                     scripts and reloading the definitions in them without calling code
                     -d: run your program under the control of pdb, the Python debugger.
                     This allows you to execute your program step by step, watch variables,
                     etc.  Internally, what IPython does is similar to calling:
                       pdb.run('execfile("YOURFILENAME")')
                     with a breakpoint set on line 1 of your file.  You can change the line
                     if filename.lower().endswith('.ipy'):
                         self.shell.safe_execfile_ipy(filename)
                         return
                     # Control the response to exit() calls made by the script being run
                     exit_ignore = opts.has_key('e')
                     # Make sure that the running script gets a proper sys.argv as if it
                     # were run from a system shell.
                     save_argv = sys.argv # save it for later restoring
                     # This needs to be undone at the end to prevent holding references to
                     # every single object ever created.
                     sys.modules[main_mod_name] = main_mod
                     try:
                         stats = None
                         with self.readline_no_record:
                                     print "%s prompt to start your script." % deb.prompt
                                     try:
                                         deb.run('execfile("%s")' % filename,prog_ns)
                                     except:
                                         etype, value, tb = sys.exc_info()
                                         # Skip three frames in the traceback: the %run one,
                         # we can do is to at least restore __builtins__ for the user on
                         # exit.
                         self.shell.user_ns['__builtins__'] = builtin_mod
                         # Ensure key global structures are restored
                         sys.argv = save_argv
                         if restore_main:
                             # added.  Otherwise it will trap references to objects
                             # contained therein.
                             del sys.modules[main_mod_name]
                     return stats
                 @skip_doctest
                     Options:
                     -n<N>: execute the given statement <N> times in a loop. If this value
                     is not given, a fitting value is chosen.
                     -r<R>: repeat the loop iteration <R> times and take the best result.
                     Default: 3
                     -t: use time.time to measure the time, which is the default on Unix.
                     This function measures wall time.
                     -c: use time.clock to measure the time, which is the default on
                     Windows and measures wall time. On Unix, resource.getrusage is used
                     instead and returns the CPU user time.
                     -p<P>: use a precision of <P> digits to display the timing result.
                     Default: 3
                     Examples:
                       In [1]: %timeit pass
                       In [6]: %timeit -n1 time.sleep(2)
 loops, best of 3: 2 s per loop
                     The times reported by %timeit will be slightly higher than those
                     reported by the timeit.py script when variables are accessed. This is
                     # succeeds
                     #
                     # See bug: https://bugs.launchpad.net/ipython/+bug/348466
                     #units = [u"s", u"ms",u'\xb5',"ns"]
                     units = [u"s", u"ms",u'us',"ns"]
                     scaling = [1, 1e3, 1e6, 1e9]
                     opts, stmt = self.parse_options(parameter_s,'n:r:tcp:',
                     # Track compilation time so it can be reported if too long
                     # Minimum time above which compilation time will be reported
                     tc_min = 0.1
                     t0 = clock()
                     code = compile(src, "<magic-timeit>", "exec")
                     tc = clock()-t0
                     ns = {}
                     exec code in self.shell.user_ns, ns
                     timer.inner = ns["inner"]
                     if number == 0:
                         # determine number so that 0.2 <= total time < 2.0
                         number = 1
                             if timer.timeit(number) >= 0.2:
                                 break
                             number *= 10
                     best = min(timer.repeat(repeat, number)) / number
                     if best > 0.0 and best < 1000.0:
                     This function provides very basic timing functionality.  In Python
 .3, the timeit module offers more control and sophistication, so this
                     could be rewritten to use it (patches welcome).
                     Some examples:
                       In [1]: time 2**128
                       Wall time: 0.00 s
                       Compiler : 0.78 s
                       """
                     # fail immediately if the given expression can't be compiled
                     expr = self.shell.prefilter(parameter_s,False)
                     # Minimum time above which compilation time will be reported
                     tc_min = 0.1
                     try:
                         mode = 'eval'
                         t0 = clock()
                       %macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
                     Options:
                       -r: use 'raw' input.  By default, the 'processed' history is used,
                       so that magics are loaded in their transformed version to valid
                       Python.  If this option is given, the raw input as typed as the
                     notation, where N:M means numbers N through M-1.
                     For example, if your history contains (%hist prints it):
 : x=1
 : y=3
 : z=x+y
                     code instead of printing them when you type their name.
                     You can view a macro's contents by explicitly printing it with:
                       'print macro_name'.
                     """
                     opts,args = self.parse_options(parameter_s,'r',mode='list')
                     if not args:   # List existing macros
                         raise UsageError(
                             "%macro insufficient args; usage '%macro name n1-n2 n3-4...")
                     name, codefrom = args[0], " ".join(args[1:])
                     #print 'rng',ranges  # dbg
                     try:
                         lines = self.shell.find_user_code(codefrom, 'r' in opts)
                       %save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
                     Options:
                       -r: use 'raw' input.  By default, the 'processed' history is used,
                       so that magics are loaded in their transformed version to valid
                       Python.  If this option is given, the raw input as typed as the
                       command line is used instead.
                     This function uses the same syntax as %history for input ranges,
                     then saves the lines to the filename you specify.
                     It adds a '.py' extension to the file if you don't do so yourself, and
                         f.write(py3compat.cast_unicode(cmds))
                     print 'The following commands were written to file `%s`:' % fname
                     print cmds
                 def magic_pastebin(self, parameter_s = ''):
                     """Upload code to the 'Lodge it' paste bin, returning the URL."""
                     try:
                     pbserver = ServerProxy('http://paste.pocoo.org/xmlrpc/')
                     id = pbserver.pastes.newPaste("python", code)
                     return "http://paste.pocoo.org/show/" + id
                 def magic_loadpy(self, arg_s):
                     """Load a .py python script into the GUI console.
                         with open(arg_s) as f:
                             content = f.read()
                     self.set_next_input(content)
                 def _find_edit_target(self, args, opts, last_call):
                     """Utility method used by magic_edit to find what to edit."""
                     def make_filename(arg):
                         "Make a filename from the given args"
                         arg = unquote_filename(arg)
                             filename = get_py_filename(arg)
                         except IOError:
                             # If it ends with .py but doesn't already exist, assume we want
                             # a new file.
                             if arg.endswith('.py'):
                                 filename = arg
                             else:
                                 filename = None
                         return filename
                     # Set a few locals from the options for convenience:
                     opts_prev = 'p' in opts
                     opts_raw = 'r' in opts
                     # custom exceptions
                     class DataIsObject(Exception): pass
                     # Default line number value
                     lineno = opts.get('n',None)
                         args = '_%s' % last_call[0]
                         if not self.shell.user_ns.has_key(args):
                             args = last_call[1]
                     # use last_call to remember the state of the previous call, but don't
                     # let it be clobbered by successive '-p' calls.
                     try:
                     use_temp = True
                     data = ''
                     # First, see if the arguments should be a filename.
                     filename = make_filename(args)
                     if filename:
                                          "or as a filename." % args)
                                     return
                                 use_temp = False
                             except DataIsObject:
                                 # macros have a special edit function
                                 if isinstance(data, Macro):
                                     raise MacroToEdit(data)
                                 # For objects, try to edit the file where they are defined
                                 try:
                                     filename = inspect.getabsfile(data)
                                     if 'fakemodule' in filename.lower() and inspect.isclass(data):
                                         # class created by %edit? Try to find source
                                         # by looking for method definitions instead, the
                                         # __module__ in those classes is FakeModule.
                                             filename = inspect.getabsfile(attr)
                                             if filename and 'fakemodule' not in filename.lower():
                                                 # change the attribute to be the edit target instead
                                                 data = attr
                                                 break
                                     datafile = 1
                                 except TypeError:
                                     filename = make_filename(args)
                     if use_temp:
                         filename = self.shell.mktempfile(data)
                         print 'IPython will make a temporary file named:',filename
                     return filename, lineno, use_temp
                 def _edit_macro(self,mname,macro):
                 def magic_ed(self,parameter_s=''):
                     """Alias to %edit."""
                     return self.magic_edit(parameter_s)
                 @skip_doctest
                 def magic_edit(self,parameter_s='',last_call=['','']):
                     """Bring up an editor and execute the resulting code.
                     notepad under Windows. See the end of this docstring for how to change
                     the editor hook.
                     You can also set the value of this editor via the
                     ``TerminalInteractiveShell.editor`` option in your configuration file.
                     This is useful if you wish to use a different editor from your typical
                     default with IPython (and for Windows users who typically don't set
                     environment variables).
                     This command allows you to conveniently edit multi-line code right in
                     your IPython session.
                     If called without arguments, %edit opens up an empty editor with a
                     temporary file and will execute the contents of this file when you
                     close it (don't forget to save it!).
                     you can configure this by providing your own modified hook if your
                     favorite editor supports line-number specifications with a different
                     syntax.
                     -p: this will call the editor with the same data as the previous time
                     it was used, regardless of how long ago (in your current session) it
                     was.
                     this option is given, the raw input as typed as the command line is
                     used instead.  When you exit the editor, it will be executed by
                     IPython's own processor.
                     -x: do not execute the edited code immediately upon exit. This is
                     mainly useful if you are editing programs which need to be called with
                     command line arguments, which you can then do using %run.
                     Arguments:
                     If arguments are given, the following possibilites exist:
                     - If the argument is a filename, IPython will load that into the
                       editor. It will execute its contents with execfile() when you exit,
                       loading any code in the file into your interactive namespace.
                     Out[1]: 'def foo():n    print "foo() was defined in an editing session"n'
                     We can then call the function foo():
                     In [2]: foo()
                     foo() was defined in an editing session
                     Now we edit foo.  IPython automatically loads the editor with the
                     (temporary) file where foo() was previously defined:
                     In [3]: ed foo
                     Editing... done. Executing edited code...
                     And if we call foo() again we get the modified version:
                     In [4]: foo()
                     foo() has now been changed!
                     general instructions on how to set a new hook for use once you've
                     defined it."""
                     opts,args = self.parse_options(parameter_s,'prxn:')
                     try:
                         filename, lineno, is_temp = self._find_edit_target(args, opts, last_call)
                     except MacroToEdit as e:
                     except TryNext:
                         warn('Could not open editor')
                         return
                     # XXX TODO: should this be generalized for all string vars?
                     # For now, this is special-cased to blocks created by cpaste
                     if args.strip() == 'pasted_block':
                         self.shell.user_ns['pasted_block'] = file_read(filename)
                     if 'x' in opts:  # -x prevents actual execution
                         print
                     else:
                         else:
                             self.shell.safe_execfile(filename,self.shell.user_ns,
                                                      self.shell.user_ns)
                     if is_temp:
                         try:
                             return open(filename).read()
                     Currently implemented schemes: NoColor, Linux, LightBG.
                     Color scheme names are not case-sensitive.
                     Examples
                     --------
                     To get a plain black and white terminal::
                       %colors nocolor
                     """
                     def color_switch_err(name):
                         warn('Error changing %s color schemes.\n%s' %
                              (name,sys.exc_info()[1]))
                     new_scheme = parameter_s.strip()
                     if not new_scheme:
                         raise UsageError(
             Defaulting color scheme to 'NoColor'"""
                         new_scheme = 'NoColor'
                         warn(msg)
                     # readline option is 0
                     if not shell.colors_force and not shell.has_readline:
                         new_scheme = 'NoColor'
                     # Set prompt colors
                     try:
                         shell.displayhook.set_colors(new_scheme)
                             color_switch_err('object inspector')
                     else:
                         shell.inspector.set_active_scheme('NoColor')
                 def magic_pprint(self, parameter_s=''):
                     """Toggle pretty printing on/off."""
                     ptformatter = self.shell.display_formatter.formatters['text/plain']
                     You can also define aliases with parameters using %s specifiers (one
                     per parameter):
                       In [1]: alias parts echo first %s second %s
                       In [2]: %parts A B
                       first A second B
                     Note that %l and %s are mutually exclusive.  You can only use one or
                     the other in your aliases.
                     Aliases expand Python variables just like system calls using ! or !!
                     do: all expressions prefixed with '$' get expanded.  For details of
                     the semantic rules, see PEP-215:
                     http://www.python.org/peps/pep-0215.html.  This is the library used by
                         print "Total number of aliases:", len(aliases)
                         sys.stdout.flush()
                         return aliases
                     # Now try to define a new one
                     try:
                         alias,cmd = par.split(None, 1)
                     Under Windows, it checks executability as a match agains a
                     '|'-separated string of extensions, stored in the IPython config
                     variable win_exec_ext.  This defaults to 'exe|com|bat'.
                     This function also resets the root module cache of module completer,
                     used on slow filesystems.
                     """
                     # for the benefit of module completer in ipy_completers.py
                     del self.db['rootmodules']
                     path = [os.path.abspath(os.path.expanduser(p)) for p in
                         os.environ.get('PATH','').split(os.pathsep)]
                     path = filter(os.path.isdir,path)
                         db['syscmdlist'] = syscmdlist
                     finally:
                         os.chdir(savedir)
                 @skip_doctest
                 def magic_pwd(self, parameter_s = ''):
                     """Return the current working directory path.
                     Examples
                     --------
                     ::
                       In [9]: pwd
                       Out[9]: '/home/tsuser/sprint/ipython'
                     """
                     return os.getcwdu()
                 @skip_doctest
                 def magic_cd(self, parameter_s=''):
                     """Change the current working directory.
                       cd -<n>: changes to the n-th directory in the directory history.
                       cd --foo: change to directory that matches 'foo' in history
                       cd -b <bookmark_name>: jump to a bookmark set by %bookmark
                          (note: cd <bookmark_name> is enough if there is no
                           directory <bookmark_name>, but a bookmark with the name exists.)
                           'cd -b <tab>' allows you to tab-complete bookmark names.
                     Options:
                     -q: quiet.  Do not print the working directory after the cd command is
                     executed.  By default IPython's cd command does print this directory,
                     since the default prompts do not display path information.
                     Note that !cd doesn't work for this purpose because the shell where
                     !command runs is immediately discarded after executing 'command'.
                     Examples
                     --------
                     ::
                       In [10]: cd parent/child
                       /home/tsuser/parent/child
                     """
                             if pat in os.path.basename(ent) and os.path.isdir(ent):
                                 ps = ent
                                 break
                             if fallback is None and pat in ent and os.path.isdir(ent):
                                 fallback = ent
                         # if we have no last part match, pick the first full path match
                         if ps is None:
                             ps = fallback
                         if ps is None:
                             print "No matching entry in directory history"
                             return
                         else:
                             opts = {}
                     else:
                         #turn all non-space-escaping backslashes to slashes,
                         # for c:\windows\directory\names\
                         parameter_s = re.sub(r'\\(?! )','/', parameter_s)
                         opts,ps = self.parse_options(parameter_s,'qb',mode='string')
                     # jump to previous
                     if ps == '-':
                     else:
                         if not os.path.isdir(ps) or opts.has_key('b'):
                             bkms = self.db.get('bookmarks', {})
                             if bkms.has_key(ps):
                                 target = bkms[ps]
                                 print '(bookmark:%s) -> %s' % (ps,target)
                             if oldcwd != cwd:
                                 dhist.append(cwd)
                                 self.db['dhist'] = compress_dhist(dhist)[-100:]
                     else:
                         os.chdir(self.shell.home_dir)
                         if hasattr(self.shell, 'term_title') and self.shell.term_title:
                             set_term_title('IPython: ' + '~')
                         cwd = os.getcwdu()
                         dhist = self.shell.user_ns['_dh']
                         if oldcwd != cwd:
                             dhist.append(cwd)
                             self.db['dhist'] = compress_dhist(dhist)[-100:]
                 def magic_env(self, parameter_s=''):
                     """List environment variables."""
                     return os.environ.data
                 def magic_pushd(self, parameter_s=''):
                     """Place the current dir on stack and change directory.
                     Usage:\\
                       %pushd ['dirname']
                     """
                     dir_s = self.shell.dir_stack
                     tgt = os.path.expanduser(unquote_filename(parameter_s))
                     cwd = os.getcwdu().replace(self.home_dir,'~')
                     This history is automatically maintained by the %cd command, and
                     always available as the global list variable _dh. You can use %cd -<n>
                     to go to directory number <n>.
                     Note that most of time, you should view directory history by entering
                     cd -<TAB>.
                     """
                     dh = self.shell.user_ns['_dh']
                     """Shell capture - execute a shell command and capture its output.
                     DEPRECATED. Suboptimal, retained for backwards compatibility.
                     You should use the form 'var = !command' instead. Example:
                      "%sc -l myfiles = ls ~" should now be written as
                      "myfiles = !ls ~"
                     myfiles.s, myfiles.l and myfiles.n still apply as documented
                     below.
                     The '=' sign in the syntax is mandatory, and the variable name you
                     supply must follow Python's standard conventions for valid names.
                     (A special format without variable name exists for internal use)
                     Options:
                     For example:
                     # all-random
                         # Capture into variable a
                         In [1]: sc a=ls *py
                       !!ls
                     is a shorthand equivalent to:
                       %sx ls
 ) %sx differs from %sc in that %sx automatically splits into a list,
                     like '%sc -l'.  The reason for this is to make it as easy as possible
                     to process line-oriented shell output via further python commands.
                     if parameter_s:
                         return self.shell.getoutput(parameter_s)
                 def magic_bookmark(self, parameter_s=''):
                     """Manage IPython's bookmark system.
                         raise UsageError("%bookmark: too many arguments")
                     bkms = self.db.get('bookmarks',{})
                     if opts.has_key('d'):
                         try:
                             todel = args[0]
                     This magic is similar to the cat utility, but it will assume the file
                     to be Python source and will show it with syntax highlighting. """
                     try:
                         filename = get_py_filename(parameter_s)
                         cont = file_read(filename)
                                  ]
                     strip_from_start = map(re.compile,strip_re)
                     lines = []
                     for l in raw_lines:
                         for pat in strip_from_start:
                             l = pat.sub('',l)
                         lines.append(l)
                     block = "\n".join(lines) + '\n'
                     #print "block:\n",block
                     return block
                     """ Show a quick reference sheet """
                     import IPython.core.usage
                     qr = IPython.core.usage.quick_reference + self.magic_magic('-brief')
                     page.page(qr)
                 def magic_doctest_mode(self,parameter_s=''):
                         ptformatter.pprint = False
                         disp_formatter.plain_text_only = True
                         shell.magic_xmode('Plain')
                     else:
                         # turn off
                             name = src.replace('profile_', '')
                             print "    %s"%name
                             pd = ProfileDir.create_profile_dir_by_name(ipython_dir, name)
                             pd.copy_config_file('ipython_config.py', path=src,
                                             overwrite=overwrite)
                 @skip_doctest
                     Backend in use: Qt4Agg
                     For more information, type 'help(pylab)'.
                     """
                     if Application.initialized():
                         app = Application.instance()
                         try:
                             import_all_status = app.pylab_import_all
                         except AttributeError:
                             import_all_status = True
                     else:
                         import_all_status = True
                     self.shell.enable_pylab(s,import_all=import_all_status)
                 def magic_tb(self, s):
                     See %xmode for changing exception reporting modes."""
                     self.shell.showtraceback()
                 @skip_doctest
                 def magic_precision(self, s=''):
                     """Set floating point precision for pretty printing.
                     Can set either integer precision or a format string.
                     If numpy has been imported and precision is an int,
                     numpy display precision will also be set, via ``numpy.set_printoptions``.
                     If no argument is given, defaults will be restored.
                     Examples
                     --------
                     ::
                         In [1]: from math import pi
                         In [2]: %precision 3
                         Out[2]: u'%.3f'
                         In [3]: pi
                         Out[3]: 3.142
                         In [4]: %precision %i
                         Out[4]: u'%i'
                         In [5]: pi
                         Out[5]: 3
                         In [6]: %precision %e
                         Out[6]: u'%e'
                         In [7]: pi**10
                         Out[7]: 9.364805e+04
                         In [8]: %precision
                         Out[8]: u'%r'
                         In [9]: pi**10
                         Out[9]: 93648.047476082982
                     """
                     ptformatter = self.shell.display_formatter.formatters['text/plain']
                     ptformatter.float_precision = s
                     return ptformatter.float_format
                                 nb = current.reads(s, u'xml')
                         with open(new_fname, 'w') as f:
                             current.write(nb, f, new_format)
             # end Magic

IPython/core/oinspect.py

0 +33 -33

                   When format_call is True, the whole call information is formattted as a
                   single string.  Otherwise, the object's name and its argspec dict are
                   returned.  If no call information is available, None is returned.
                 docstring : str or None
                   The most relevant docstring for calling purposes is returned, if
                   available.  The priority is: call docstring for callable instances, then
                     else:
                         if has_self:
                             argspec['args'] = argspec['args'][1:]
                     call_line = oinfo['name']+format_argspec(argspec)
                 # Now get docstring.
                     If any exception is generated, None is returned instead and the
                     exception is suppressed."""
                     try:
                         # We need a plain string here, NOT unicode!
                         hdef = oname + inspect.formatargspec(*getargspec(obj))
                         return py3compat.unicode_to_str(hdef, 'ascii')
                     except:
                         return None
                 def __head(self,h):
                     """Return a header string with proper colors."""
                     return '%s%s%s' % (self.color_table.active_colors.header,h,
                 def set_active_scheme(self,scheme):
                     self.color_table.set_active_scheme(scheme)
                     self.parser.color_table.set_active_scheme(scheme)
                 def noinfo(self,msg,oname):
                     """Generic message when no information is found."""
                     print 'No %s found' % msg,
                         print 'for %s' % oname
                     else:
                         print
                 def pdef(self,obj,oname=''):
                     """Print the definition header for any callable object.
                     Optional:
                     -formatter: a function to run the docstring through for specially
                     formatted docstrings.
                     Examples
                     --------
                     In [1]: class NoInit:
                        ...:     pass
                     In [2]: class NoDoc:
                        ...:     def __init__(self):
                        ...:         pass
                     In [3]: %pdoc NoDoc
                     No documentation found for NoDoc
                     In [4]: %pdoc NoInit
                     No documentation found for NoInit
                     In [5]: obj = NoInit()
                     In [6]: %pdoc obj
                     No documentation found for obj
                     In [5]: obj2 = NoDoc()
                     In [6]: %pdoc obj2
                     No documentation found for obj2
                     """
                         self.noinfo('documentation',oname)
                     else:
                         page.page('\n'.join(lines))
                 def psource(self,obj,oname=''):
                     """Print the source code for an object."""
                     # Flush the source cache because inspect can return out-of-date source
                     linecache.checkcache()
                     try:
                         src = getsource(obj)
                     except:
                         self.noinfo('source',oname)
                     else:
                         return
                     # We only reach this point if object was successfully queried
                     # run contents of file through pager starting at line
                     # where the object is defined
                     ofile = inspect.getabsfile(obj)
                         # getsourcelines returns lineno with 1-offset and page() uses
                         # 0-offset, so we must adjust.
                         page.page(self.format(open(ofile).read()),lineno-1)
                 def _format_fields(self, fields, title_width=12):
                     """Formats a list of fields for display.
                     Parameters
                     ----------
                     fields : list
                                 ("Length", "length"),
                                 ("File", "file"),
                                 ("Definition", "definition")]
                 pinfo_fields_obj = [("Class Docstring", "class_docstring"),
                                     ("Constructor Docstring","init_docstring"),
                                     ("Call def", "call_def"),
                                     ("Call docstring", "call_docstring")]
                 def pinfo(self,obj,oname='',formatter=None,info=None,detail_level=0):
                     """Show detailed information about an object.
                     Optional arguments:
                     - oname: name of the variable pointing to the object.
                     - formatter: special formatter for docstrings (see pdoc)
                         field = info[key]
                         if field is not None:
                             displayfields.append((title, field.rstrip()))
                     # Source or docstring, depending on detail level and whether
                     # source found.
                     if detail_level > 0 and info['source'] is not None:
                         displayfields.append(("Source", self.format(py3compat.unicode_to_str(info['source']))))
                     elif info['docstring'] is not None:
                         displayfields.append(("Docstring", info["docstring"]))
                     # Constructor info for classes
                     if info['isclass']:
                         if info['init_definition'] or info['init_docstring']:
                             if info['init_docstring'] is not None:
                                 displayfields.append((" Docstring",
                                                     indent(info['init_docstring'])))
                     # Info for objects:
                     else:
                         for title, key in self.pinfo_fields_obj:
                             field = info[key]
                             if field is not None:
                                 displayfields.append((title, field.rstrip()))
                     # Finally send to printer/pager:
                     if displayfields:
                         page.page(self._format_fields(displayfields))
                     """Compute a dict with detailed information about an object.
                     Optional arguments:
                     - oname: name of the variable pointing to the object.
                     - formatter: special formatter for docstrings (see pdoc)
                     # store output in a dict, we initialize it here and fill it as we go
                     out = dict(name=oname, found=True, isalias=isalias, ismagic=ismagic)
                     string_max = 200 # max size of strings to show (snipped if longer)
                     shalf = int((string_max -5)/2)
                     # avoid repetitions).  If source fails, we add them back, see below.
                     if ds and detail_level == 0:
                             out['docstring'] = ds
                     # Original source code for any callable
                     if detail_level:
                         # Flush the source cache because inspect can return out-of-date
                                 out['source'] = source.rstrip()
                         except Exception:
                             pass
                         if ds and source is None:
                             out['docstring'] = ds
                     # Constructor docstring for classes
                     if inspect.isclass(obj):
                     # Compute the object's argspec as a callable.  The key is to decide
                     # whether to pull it from the object itself, from its __init__ or
                     # from its __call__ method.
                     if inspect.isclass(obj):
                         # Old-style classes need not have an __init__
                         callable_obj = getattr(obj, "__init__", None)
                     - ns_table: dict of name->namespaces for search.
                     Optional arguments:
                       - ns_search: list of namespace names to include in search.
                       - ignore_case(False): make the search case-insensitive.
                       underscores.
                     """
                     #print 'ps pattern:<%r>' % pattern # dbg
                     # defaults
                     type_pattern = 'all'
                     filter = ''

IPython/core/prefilter.py

0 +14 -14

                 """Main prefilter component.
                 The IPython prefilter is run on all user input before it is run.  The
                 prefilter consumes lines of input and produces transformed lines of
                 input.
                 The iplementation consists of two phases:
                 After all the transformers have been run, the line is fed to the checkers,
                 which are instances of :class:`PrefilterChecker`.  The line is passed to
                 the :meth:`check` method, which either returns `None` or a
                 :class:`PrefilterHandler` instance.  If `None` is returned, the other
                 checkers are tried.  If an :class:`PrefilterHandler` instance is returned,
                 the line is passed to the :meth:`handle` method of the returned
                 handler and no further checkers are tried.
                 Both transformers and checkers have a `priority` attribute, that determines
                 the order in which they are called.  Smaller priorities are tried first.
                     # Now we compute line_info for the checkers and handlers
                     line_info = LineInfo(line, continue_prompt)
                     # the input history needs to track even empty lines
                     stripped = line.strip()
                                          for lnum, line in enumerate(llines) ])
                     else:
                         out = self.prefilter_line(llines[0], continue_prompt)
                     return out
             #-----------------------------------------------------------------------------
             class MacroChecker(PrefilterChecker):
                 priority = Int(250, config=True)
                 def check(self, line_info):
                     obj = self.shell.user_ns.get(line_info.ifun)
                     if isinstance(obj, Macro):
                     "Allow ! and !! in multi-line statements if multi_line_specials is on"
                     # Note that this one of the only places we check the first character of
                     # ifun and *not* the pre_char.  Also note that the below test matches
                     # both ! and !!.
                     if line_info.continue_prompt \
                         and self.prefilter_manager.multi_line_specials:
                             if line_info.esc == ESC_MAGIC:
                 def check(self, line_info):
                     """Check to see if user is assigning to a var for the first time, in
                     which case we want to avoid any sort of automagic / autocall games.
                     This allows users to assign to either alias or magic names true python
                     variables (the magic/alias systems always take second seat to true
                     python code).  E.g. ls='hi', or ls,that=1,2"""
                     oinfo = line_info.ofind(self.shell) # This can mutate state via getattr
                     if not oinfo['found']:
                         return None
                     if callable(oinfo['obj']) \
                            and (not re_exclude_auto.match(line_info.the_rest)) \
                            and re_fun_name.match(line_info.ifun):
                     # aliases won't work in indented sections.
                     line_out = '%sget_ipython().system(%s)' % (line_info.pre_whitespace,
                                                      make_quoted_expr(transformed))
                     return line_out
             class MacroHandler(PrefilterHandler):
                 handler_name = Unicode("macro")
                 def handle(self, line_info):
                     obj = self.shell.user_ns.get(line_info.ifun)
                     pre_space = line_info.pre_whitespace
                     force_auto = isinstance(obj, IPyAutocall)
                     auto_rewrite = getattr(obj, 'rewrite', True)
                     if esc == ESC_QUOTE:
                         # Auto-quote splitting on whitespace
                         newcmd = '%s("%s")' % (ifun,'", "'.join(the_rest.split()) )
                     if auto_rewrite:
                         self.shell.auto_rewrite_input(newcmd)
                     return newcmd

IPython/core/profileapp.py

0 +13 -13

                     )
                 ))
                 ipython_dir = Unicode(get_ipython_dir(), config=True,
                     help="""
                     The name of the IPython directory. This directory is used for logging
                     configuration (through profiles), history storage, etc. The default
                     the environment variable IPYTHON_DIR.
                     """
                 )
                 def list_profile_dirs(self):
                     # Find the search paths
                     paths = [os.getcwdu(), self.ipython_dir]
                                 profile = f.split('_',1)[-1]
                                 start_cmd = 'ipython profile=%s' % profile
                                 print start_cmd + " ==> " + full_path
                 def start(self):
                     self.list_profile_dirs()
                 description = create_help
                 examples = _create_examples
                 auto_create = Bool(True, config=False)
                 def _copy_config_files_default(self):
                     return True
                 parallel = Bool(False, config=True,
                     help="whether to include parallel computing config files")
                 def _parallel_changed(self, name, old, new):
                     parallel_files = [   'ipcontroller_config.py',
                                         'ipengine_config.py',
                                         'ipcluster_config.py'
                                     ]
                     if new:
                         for cf in parallel_files:
                             if cf in self.config_files:
                                 self.config_files.remove(cf)
                 def parse_command_line(self, argv):
                     super(ProfileCreate, self).parse_command_line(argv)
                     # accept positional arg as profile name
                     if self.extra_args:
                         self.profile = self.extra_args[0]
                 flags = Dict(create_flags)
                 classes = [ProfileDir]
                 def init_config_files(self):
                     super(ProfileCreate, self).init_config_files()
                     # use local imports, since these classes may import from here
                         app.profile = self.profile
                         app.init_profile_dir()
                         app.init_config_files()
                 def stage_default_config_file(self):
                     pass
                     create = (ProfileCreate, "Create a new profile dir with default config files"),
                     list = (ProfileList, "List existing profiles")
                 ))
                 def start(self):
                     if self.subapp is None:
                         print "No subcommand specified. Must specify one of: %s"%(self.subcommands.keys())

IPython/core/prompts.py

0 +6 -6

                 in_number  = InputColors.NoColor,  # Input prompt number
                 in_prompt2 = InputColors.NoColor, # Continuation prompt
                 in_normal  = InputColors.NoColor,  # color off (usu. Colors.Normal)
                 out_prompt = Colors.NoColor, # Output prompt
                 out_number = Colors.NoColor, # Output prompt number
                     # by all prompt classes through the cache.  Nice OO spaghetti code!
                     self.cache = cache
                     self.sep = sep
                     # regexp to count the number of spaces at the end of a prompt
                     # expression, useful for prompt auto-rewriting
                     self.rspace = re.compile(r'(\s*)$')
                                             ('${self.sep}${self.col_p}',
                                              multiple_replace(prompt_specials, self.p_template),
                                              '${self.col_norm}'),self.cache.shell.user_ns,loc)
                         self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
                                                                      self.p_template),
                                                     self.cache.shell.user_ns,loc)
                     self.col_norm = Colors.in_normal
                     # We need a non-input version of these escapes for the '--->'
                     # auto-call prompts used in the auto_rewrite() method.
                     self.col_p_ni = self.col_p.replace('\001','').replace('\002','')
                     self.col_norm_ni = Colors.normal
                 def __str__(self):
                     self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
             class Prompt2(BasePrompt):
                 """Interactive continuation prompt."""
                 def __init__(self, cache, prompt='   .\\D.: ', pad_left=True):
                     self.cache = cache
                     self.p_template = prompt

IPython/core/release.py

0 +3 -3

             * Easily embeddable in other Python programs and wxPython GUIs.
             * Integrated access to the pdb debugger and the Python profiler.
             The parallel computing architecture has the following main features:
             * Quickly parallelize Python code from an interactive Python/IPython session.
             * A flexible and dynamic process model that be deployed on anything from
               multicore workstations to supercomputers.
             * An architecture that supports many different styles of parallelism, from
             * High level APIs that enable many things to be parallelized in a few lines
               of code.
             * Share live parallel jobs with other users securely.
             * Dynamically load balanced task farming system.

IPython/core/splitinput.py

0 +11 -11

             # Although it's not solely driven by the regex, note that:
             # ,;/% only trigger if they are the first character on the line
             # ! and !! trigger if they are first char(s) *or* follow an indent
             # ? triggers as first or last char.
             line_split = re.compile("""
                 """
                 # We need to ensure that the rest of this routine deals only with unicode
                 line = py3compat.cast_unicode(line, sys.stdin.encoding or 'utf-8')
                 if pattern is None:
                     pattern = line_split
                 match = pattern.match(line)
             class LineInfo(object):
                 """A single line of input and associated info.
                 Includes the following as properties:
                 line
                   The original, raw line
                 continue_prompt
                   Is this line a continuation in a sequence of multiline input?
                 pre
                   Any leading whitespace.
                 esc
                   The escape character(s) in pre or the empty string if there isn't one.
                   Note that '!!' and '??' are possible values for esc. Otherwise it will
                   always be a single character.
                 ifun
                   The 'function part', which is basically the maximal initial sequence
                   of valid python identifiers and the '.' character. This is what is
                   checked for alias and magic transformations, used for auto-calling,
                   etc. In contrast to Python identifiers, it may start with "%" and contain
                   "*".
                 the_rest
                   Everything else on the line.
                 """
                     self.pre_char       = self.pre.strip()
                     if self.pre_char:
                         self.pre_whitespace = '' # No whitespace allowd before esc chars
                     else:
                         self.pre_whitespace = self.pre
                     self._oinfo = None
                         self._oinfo = ip.shell._ofind(self.ifun)
                     return self._oinfo
                 def __str__(self):
                     return "LineInfo [%s|%s|%s|%s]" %(self.pre, self.esc, self.ifun, self.the_rest)

IPython/core/tests/test_handlers.py

0 +10 -10

                      #("a = b # PYTHON-MODE", '_i'),          # emacs -- avoids _in cache
                      # post-esc-char whitespace goes inside
                      ("! true",   'get_ipython().system(u" true")'),
                      # handle_help
                      ('if 1:\n    !!true',   'if 1:\n    get_ipython().magic(u"sx true")'),
                      # Even with m_l_s on, autocall is off even with special chars
                      ('if 1:\n    /fun 1 2', 'if 1:\n    /fun 1 2'),
                      ('if 1:\n    ;fun 1 2', 'if 1:\n    ;fun 1 2'),
                      ('if 1:\n    ,fun 1 2', 'if 1:\n    ,fun 1 2'),
                      ('if 1:\n    ?fun 1 2', 'if 1:\n    ?fun 1 2'),
                      # What about !!
                      ])
                 # Objects which are instances of IPyAutocall are *always* autocalled
                 autocallable = Autocallable()
                 ip.user_ns['autocallable'] = autocallable
                 # auto
                 ip.magic('autocall 0')
                 # Only explicit escapes or instances of IPyAutocallable should get
                 # expanded
                 run([
                     ('len "abc"',       'len "abc"'),
                     ('autocallable',    'autocallable()'),
                     (",list 1 2 3",     'list("1", "2", "3")'),
                     (";list 1 2 3",     'list("1 2 3")'),
                     ("/len range(1,4)", 'len(range(1,4))'),
                     ])
                 ip.magic('autocall 1')
                 run([
                     (",list 1 2 3", 'list("1", "2", "3")'),
                     (";list 1 2 3", 'list("1 2 3")'),
                     ("/len range(1,4)", 'len(range(1,4))'),
                     ('len "abc"', 'len("abc")'),
                     ('len "abc";', 'len("abc");'),  # ; is special -- moves out of parens
                 ip.magic('autocall 2')
                 run([
                     (",list 1 2 3", 'list("1", "2", "3")'),
                     (";list 1 2 3", 'list("1 2 3")'),
                     ("/len range(1,4)", 'len(range(1,4))'),
                     ('len "abc"', 'len("abc")'),
                     ('len "abc";', 'len("abc");'),
                     ('len [1,2]', 'len([1,2])'),
                     ('call_idx [1]', 'call_idx [1]'),
                     ('call_idx 1', 'call_idx(1)'),
                     # This is what's different:

IPython/core/tests/test_history.py

0 +11 -11

                         hist = ['a=1', 'def f():\n    test = 1\n    return test', u"b='€Æ¾÷ß'"]
                         for i, h in enumerate(hist, start=1):
                             ip.history_manager.store_inputs(i, h)
                         ip.history_manager.db_log_output = True
                         # Doesn't match the input, but we'll just check it's stored.
                         ip.history_manager.output_hist_reprs[3] = "spam"
                         ip.history_manager.store_output(3)
                         nt.assert_equal(ip.history_manager.input_hist_raw, [''] + hist)
                         # Check whether specifying a range beyond the end of the current
                         # session results in an error (gh-804)
                         ip.magic('%hist 2-500')
                         # New session
                         ip.history_manager.reset()
                         newcmds = ["z=5","class X(object):\n    pass", "k='p'"]
                         # Previous session:
                         gothist = ip.history_manager.get_range(-1, 1, 4)
                         nt.assert_equal(list(gothist), zip([1,1,1],[1,2,3], hist))
                         # Check get_hist_tail
                         gothist = ip.history_manager.get_tail(4, output=True,
                                                                 include_latest=True)
                                     (2, 2, (newcmds[1], None)),
                                     (2, 3, (newcmds[2], None)),]
                         nt.assert_equal(list(gothist), expected)
                         gothist = ip.history_manager.get_tail(2)
                         expected = [(2, 1, newcmds[0]),
                                     (2, 2, newcmds[1])]
                         nt.assert_equal(list(gothist), expected)
                         # Check get_hist_search
                         gothist = ip.history_manager.search("*test*")
                         nt.assert_equal(list(gothist), [(1,2,hist[1])] )
                         gothist = ip.history_manager.search("b*", output=True)
                         nt.assert_equal(list(gothist), [(1,3,(hist[2],"spam"))] )
                         # Cross testing: check that magic %save can get previous session.
                         testfilename = os.path.realpath(os.path.join(tmpdir, "test.py"))
                         ip.magic_save(testfilename + " ~1/1-3")
                         testfile = open(testfilename, "r")
                         nt.assert_equal(testfile.read().decode("utf-8"),
                                 "# coding: utf-8\n" + "\n".join(hist))
                         # Duplicate line numbers - check that it doesn't crash, and
                         # gets a new session
                         ip.history_manager.store_inputs(1, "rogue")
                             (-7, 1, 6)]
                 actual = list(extract_hist_ranges(instr))
                 nt.assert_equal(actual, expected)
             def test_magic_rerun():
                 """Simple test for %rerun (no args -> rerun last line)"""
                 ip = get_ipython()

IPython/core/tests/test_inputsplitter.py

0 +27 -27

                 raw_input that simulates interactive input."""
                 from IPython.core.inputsplitter import InputSplitter
                 isp = InputSplitter()
                 # In practice, this input loop would be wrapped in an outside loop to read
                 # input indefinitely, until some exit/quit command was issued.  Here we
                           'line \nline\nline\nline \n\n'),
                          ]
                 tt.check_pairs(isp.remove_comments, tests)
             def test_has_comment():
                 tests = [('text', False),
                          ('text #comment', True),
                     class X: pass
                     fake_stdin = X()
                     sys.stdin = fake_stdin
                 def test(self):
                     # Verify that if sys.stdin has no 'encoding' attribute we do the right
                     # thing
                     enc = isp.get_input_encoding()
                     self.assertEqual(enc, 'ascii')
                 def tearDown(self):
                     sys.stdin = self.old_stdin
                     self.assertEqual(self.isp.source_reset(), '1\n2\n')
                     self.assertEqual(self.isp._buffer, [])
                     self.assertEqual(self.isp.source, '')
                 def test_indent(self):
                     isp = self.isp # shorthand
                     isp.push('x=1')
                     isp.push("if 1:")
                     isp.push("    x = (1+\n    2)")
                     self.assertEqual(isp.indent_spaces, 4)
                 def test_indent4(self):
                     # In cell mode, inputs must be fed in whole blocks, so skip this test
                     if self.isp.input_mode == 'cell': return
                     self.assertFalse(isp.push('if 1:'))
                     for line in ['  x=1', '# a comment', '  y=2']:
                         self.assertTrue(isp.push(line))
                 def test_push3(self):
                     isp = self.isp
                     isp.push('if True:')
                     isp.push('  a = 1')
                     self.assertFalse(isp.push('b = [1,'))
                 def test_replace_mode(self):
                     isp = self.isp
                     isp.input_mode = 'cell'
                     self.assertTrue(isp.push_accepts_more())
                     isp.push('')
                     self.assertFalse(isp.push_accepts_more())
                 def test_push_accepts_more3(self):
                     isp = self.isp
                     isp.push("x = (2+\n3)")
                     self.assertTrue(isp.push_accepts_more())
                     isp.push('')
                     self.assertFalse(isp.push_accepts_more())
                 def test_push_accepts_more5(self):
                     # In cell mode, inputs must be fed in whole blocks, so skip this test
                     if self.isp.input_mode == 'cell': return
                     # we can check that the given dict is *contained* in test_ns
                     for k,v in ns.iteritems():
                         self.assertEqual(test_ns[k], v)
                 def test_simple(self):
                     self.check_ns(['x=1'], dict(x=1))
                 def test_abc(self):
                     self.check_ns(['if 1:','a=1','b=2','c=3'], dict(a=1, b=2, c=3))
                 def test_multi(self):
                     self.check_ns(['x =(1+','1+','2)'], dict(x=4))
             def test_LineInfo():
                 """Simple test for LineInfo construction and str()"""
                      ('?%hist', 'get_ipython().magic(u"pinfo %hist")'),
                      ('?abc = qwe', 'get_ipython().magic(u"pinfo abc")'),
                      ],
                   end_help =
                   [ ('x3?', 'get_ipython().magic(u"pinfo x3")'),
                     ('x4??', 'get_ipython().magic(u"pinfo2 x4")'),
                      ('%cd /home', 'get_ipython().magic(u"cd /home")'),
                      ('    %magic', '    get_ipython().magic(u"magic")'),
                      ],
                    # Quoting with separate arguments
                    escaped_quote =
                    [ (',f', 'f("")'),
                      ('  ,f y', '  f("y")'),
                      (',f a b', 'f("a", "b")'),
                      ],
                    # Quoting with single argument
                    escaped_quote2 =
                    [ (';f', 'f("")'),
                      (';f x', 'f("x")'),
                      ('  ;f y', '  f("y")'),
                      (';f a b', 'f("a b")'),
                      ],
                    # Simply apply parens
                    escaped_paren =
                    [ ('/f', 'f()'),
                      ('/f x', 'f(x)'),
                      ('  /f y', '  f(y)'),
                      ('/f a b', 'f(a, b)'),
                      ],
                    # Check that we transform prompts before other transforms
                    mixed =
                    [ ('In [1]: %lsmagic', 'get_ipython().magic(u"lsmagic")'),
             def test_assign_system():
                 tt.check_pairs(isp.transform_assign_system, syntax['assign_system'])
             def test_assign_magic():
                 tt.check_pairs(isp.transform_assign_magic, syntax['assign_magic'])
                 transform_checker(syntax['classic_prompt'], isp.transform_classic_prompt)
                 for example in syntax_ml['classic_prompt']:
                     transform_checker(example, isp.transform_classic_prompt)
             def test_ipy_prompt():
                 transform_checker(syntax['ipy_prompt'], isp.transform_ipy_prompt)
                         for raw, out_t in example:
                             if raw.startswith(' '):
                                 continue
                             isp.push(raw)
                             out, out_raw = isp.source_raw_reset()
                             self.assertEqual(out.rstrip(), out_t,
                             raw = '\n'.join(raw_parts).rstrip()
                             self.assertEqual(out.rstrip(), out_t)
                             self.assertEqual(out_raw.rstrip(), raw)
             class BlockIPythonInputTestCase(IPythonInputTestCase):
                 # Deactivate tests that don't make sense for the block mode
                 test_push3 = test_split = lambda s: None
                 def setUp(self):
                     self.isp = isp.IPythonInputSplitter(input_mode='cell')
                             # Match ignoring trailing whitespace
                             self.assertEqual(out.rstrip(), out_t.rstrip())
                             self.assertEqual(out_raw.rstrip(), raw.rstrip())
             #-----------------------------------------------------------------------------
             # Main - use as a script, mostly for developer experiments
                 autoindent = True
                 #autoindent = False
                 try:
                     while True:
                         prompt = start_prompt

IPython/core/tests/test_oinspect.py

0 +7 -7

                 def method(self, x, z=2):
                     """Some method's docstring"""
             class OldStyle:
                 """An old-style class for testing."""
                 pass
                 info = inspector.info(obj, name)
                 call_line, ds = oinspect.call_tip(info)
                 nt.assert_equal(call_line, call)
                 nt.assert_equal(ds, docstring)
             #-----------------------------------------------------------------------------
             # Tests
             def test_calltip_builtin():
                 check_calltip(sum, 'sum', None, sum.__doc__)
             def test_info():
                 "Check that Inspector.info fills out various fields as expected."
                 i = inspector.info(Call, oname='Call')
                 nt.assert_true(i['isclass'])
                 nt.assert_equal(i['init_definition'], "Call(self, x, y=1)\n")
                 nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
                 i = inspector.info(Call, detail_level=1)
                 nt.assert_not_equal(i['source'], None)
                 nt.assert_equal(i['docstring'], None)
                 c = Call(1)
                 c.__doc__ = "Modified instance docstring"
                 i = inspector.info(c)
                 nt.assert_equal(i['class_docstring'], Call.__doc__)
                 nt.assert_equal(i['init_docstring'], Call.__init__.__doc__)
                 nt.assert_equal(i['call_docstring'], c.__call__.__doc__)
                 # Test old-style classes, which for example may not have an __init__ method.
                 if not py3compat.PY3:
                     i = inspector.info(OldStyle)
                     nt.assert_equal(i['type_name'], 'classobj')
                     i = inspector.info(OldStyle())
                     nt.assert_equal(i['type_name'], 'instance')
                     nt.assert_equal(i['docstring'], OldStyle.__doc__)

IPython/core/tests/test_run.py

0 +6 -6

                 In [1]: _ip.clear_main_mod_cache()
                 # random
                 In [2]: %run refbug
                 In [3]: call_f()
                    ....:     os.unlink(fname)
                    ....: except:
                    ....:     pass
                    ....:
                 """
             def doctest_reset_del():
                 In [2]: class A(object):
                    ...:     def __del__(self):
                    ...:         print str("Hi")
                    ...:
                 In [3]: a = A()
                 def test_builtins_type(self):
                     """Check that the type of __builtins__ doesn't change with %run.
                     However, the above could pass if __builtins__ was already modified to
                     be a dict (it should be a module) by a previous use of %run.  So we
                     also check explicitly that it really is a module:
                            "a = A()\n")
                     self.mktmp(src)
                     tt.ipexec_validate(self.fname, 'object A deleted')
                 @dec.skip_known_failure
                 def test_aggressive_namespace_cleanup(self):
                     """Test that namespace cleanup is not too aggressive GH-238

IPython/core/ultratb.py

0 +41 -41

                 import sys,ultratb
                 sys.excepthook = ultratb.ColorTB()
             * VerboseTB
             I've also included a port of Ka-Ping Yee's "cgitb.py" that produces all kinds
             of useful info when a traceback occurs.  Ping originally had it spit out HTML
             and intended it for CGI programmers, but why should they have all the fun?  I
               Verbose_novars mode instead of the regular Verbose, which avoids formatting
               variables (but otherwise includes the information and context given by
               Verbose).
             Installation instructions for ColorTB:
                 import sys,ultratb
                 """Print a message about internal inspect errors.
                 These are unfortunately quite common."""
                 error('Internal Python error in the inspect module.\n'
                       'Below is the traceback from this internal error.\n')
                     while lnum > 0:
                         if pmatch(lines[lnum]): break
                         lnum -= 1
                     return lines, lnum
                 raise IOError('could not find code object')
             # (SyntaxErrors have to be treated specially because they have no traceback)
             _parser = PyColorize.Parser()
             def _format_traceback_lines(lnum, index, lines, Colors, lvals=None,scheme=None):
                 numbers_width = INDENT_SIZE - 1
                 res = []
                     # is unicode-safe.  So for now this is rather an ugly hack, but
                     # necessary to at least have readable tracebacks. Improvements welcome!
                     line = py3compat.cast_bytes_py2(line, 'utf-8')
                     new_line, err = _line_format(line, 'str', scheme)
                     if not err: line = new_line
                     if i == lnum:
                         # This is the line with the error
                         pad = numbers_width - len(str(i))
                         else:
                             marker = ''
                         num = marker + str(i)
                         line = '%s%s%s %s%s' %(Colors.linenoEm, num,
                                                Colors.line, line, Colors.Normal)
                     else:
                         num = '%*s' % (numbers_width,i)
                         line = '%s%s%s %s' %(Colors.lineno, num,
                                              Colors.Normal, line)
                     res.append(line)
                     """Output stream that exceptions are written to.
                     Valid values are:
                     - None: the default, which means that IPython will dynamically resolve
                     to io.stdout.  This ensures compatibility with most tools, including
                     Windows (where plain stdout doesn't recognize ANSI escapes).
                 def _set_ostream(self, val):
                     assert val is None or (hasattr(val, 'write') and hasattr(val, 'flush'))
                     self._ostream = val
                 ostream = property(_get_ostream, _set_ostream)
                 def set_colors(self,*args,**kw):
                 def color_toggle(self):
                     """Toggle between the currently active color scheme and NoColor."""
                     if self.color_scheme_table.active_scheme_name == 'NoColor':
                         self.color_scheme_table.set_active_scheme(self.old_scheme)
                         self.Colors = self.color_scheme_table.active_colors
             #---------------------------------------------------------------------------
             class ListTB(TBTools):
                 """Print traceback information from a traceback list, with optional color.
                 Calling: requires 3 arguments:
                   (etype, evalue, elist)
                 as would be obtained by:
                 def __init__(self,color_scheme = 'NoColor', call_pdb=False, ostream=None):
                     TBTools.__init__(self, color_scheme=color_scheme, call_pdb=call_pdb,
                                      ostream=ostream)
                 def __call__(self, etype, value, elist):
                     self.ostream.flush()
                     self.ostream.write(self.text(etype, value, elist))
                     tb_offset : int, optional
                       Number of frames in the traceback to skip.  If not given, the
                       instance value is used (set in constructor).
                     context : int, optional
                       Number of lines of context information to print.
                         if tb_offset and len(elist) > tb_offset:
                             elist = elist[tb_offset:]
                         out_list.append('Traceback %s(most recent call last)%s:' %
                                             (Colors.normalEm, Colors.Normal) + '\n')
                         out_list.extend(self._format_list(elist))
                     out_list.append(lines)
                     # Note: this code originally read:
                     ## for line in lines[:-1]:
                     ##     out_list.append(" "+line)
                     ## out_list.append(lines[-1])
                     # This means it was indenting everything but the last line by a little
                     # bit.  I've disabled this for now, but if we see ugliness somewhre we
                     # can restore it.
                     return out_list
                 def _format_list(self, extracted_list):
                     same index in the argument list.  Each string ends in a newline;
                     the strings may contain internal newlines as well, for those items
                     whose source text line is not None.
                     Lifted almost verbatim from traceback.py
                     """
                     list = []
                     for filename, lineno, name, line in extracted_list[:-1]:
                         item = '  File %s"%s"%s, line %s%d%s, in %s%s%s\n' % \
                                 (Colors.filename, filename, Colors.Normal,
                                  Colors.lineno, lineno, Colors.Normal,
                                  Colors.name, name, Colors.Normal)
                         if line:
                     list.append(item)
                     #from pprint import pformat; print 'LISTTB', pformat(list) # dbg
                     return list
                 def _format_exception_only(self, etype, value):
                     """Format the exception part of a traceback.
                     printed) display detailed information about where the syntax error
                     occurred.  The message indicating which exception occurred is the
                     always last string in the list.
                     Also lifted nearly verbatim from traceback.py
                     """
                                     while i < len(line) and line[i].isspace():
                                         i = i+1
                                     list.append('%s    %s%s\n' % (Colors.line,
                                                                   line.strip(),
                                                                   Colors.Normal))
                                     if offset is not None:
                                         s = '    '
                 def get_exception_only(self, etype, value):
                     """Only print the exception type and message, without a traceback.
                     Parameters
                     ----------
                     etype : exception type
                 def show_exception_only(self, etype, evalue):
                     """Only print the exception type and message, without a traceback.
                     Parameters
                     ----------
                     etype : exception type
                         # Header with the exception type, python version, and date
                         pyver = 'Python ' + sys.version.split()[0] + ': ' + sys.executable
                         date = time.ctime(time.time())
                         head = '%s%s%s\n%s%s%s\n%s' % (Colors.topline, '-'*75, ColorsNormal,
                                                        exc, ' '*(75-len(str(etype))-len(pyver)),
                                                        pyver, date.rjust(75) )
                             inspect_error()
                             traceback.print_exc(file=self.ostream)
                             info("\nIPython's exception reporting continues...\n")
                         if func == '?':
                             call = ''
                         else:
                             there is no way to disambguate partial dotted structures until
                             the full list is known.  The caller is responsible for pruning
                             the final list of duplicates before using it."""
                             # build composite names
                             if token == '.':
                                 try:
                                   "The following traceback may be corrupted or invalid\n"
                                   "The error message is: %s\n" % msg)
                             error(_m)
                         # prune names list of duplicates, but keep the right order
                         unique_names = uniq_stable(names)
                          if ipinst is not None:
                              ipinst.hooks.synchronize_with_editor(filepath, lnum, 0)
                     # vds: <<
                     # return all our info assembled as a single string
                     # return '%s\n\n%s\n%s' % (head,'\n'.join(frames),''.join(exception[0]) )
                     return [head] + frames + [''.join(exception[0])]
                 def debugger(self,force=False):
                     """Call up the pdb debugger if desired, always clean up the tb
                     reference.
                 one needs to remove a number of topmost frames from the traceback (such as
                 occurs with python programs that themselves execute other python code,
                 like Python shells).  """
                 def __init__(self, mode='Plain', color_scheme='Linux', call_pdb=False,
                              ostream=None,
                              tb_offset=0, long_header=False, include_vars=False,
                              check_cache=None):
                     self._join_chars = dict(Plain='', Context='\n', Verbose='\n')
                     # set_mode also sets the tb_join_char attribute
                     self.set_mode(mode)
                 def _extract_tb(self,tb):
                     if tb:
                         return traceback.extract_tb(tb)
                 def stb2text(self, stb):
                     """Convert a structured traceback (a list) to a string."""
                     return self.tb_join_char.join(stb)
                 def set_mode(self,mode=None):
                     """Switch to the desired mode.
                 It will find out about exceptions by itself.
                 A brief example:
                 AutoTB = AutoFormattedTB(mode = 'Verbose',color_scheme='Linux')
                 try:
                   ...
                 except:
                   AutoTB()  # or AutoTB(out=logfile) where logfile is an open file object
                 """
                 def __call__(self,etype=None,evalue=None,etb=None,
                              out=None,tb_offset=None):
                     """Print out a formatted exception traceback.
                       per-call basis (this overrides temporarily the instance's tb_offset
                       given at initialization time.  """
                     if out is None:
                         out = self.ostream
                     out.flush()
                 except:
                     traceback.print_exc()
                 print ''
                 handler = ColorTB()
                 print '*** ColorTB ***'
                 try:
                 except:
                     apply(handler, sys.exc_info() )
                 print ''
                 handler = VerboseTB()
                 print '*** VerboseTB ***'
                 try:
                 except:
                     apply(handler, sys.exc_info() )
                 print ''

IPython/core/usage.py

0 +14 -14

                 Almost all configuration in IPython is available via the command-line. Do
                 `ipython --help-all` to see all available options.  For persistent
                 configuration, look into your `ipython_config.py` configuration file for
                 details.
                 This file is typically installed in the `IPYTHON_DIR` directory, and there
                 IPYTHON_DIR defaults to `$HOME/.config/ipython`, and for other Unix systems
                 to `$HOME/.ipython`.  For Windows users, $HOME resolves to C:\\Documents
                 and Settings\\YourUserName in most instances.
                 To initialize a profile with the default configuration file, do::
                   $> ipython profile create
                 and start editing `IPYTHON_DIR/profile_default/ipython_config.py`
                 In IPython's documentation, we will refer to this directory as
             * Persistent command history across sessions.
             * Logging of input with the ability to save and restore a working session.
             * System escape with !. Typing !ls will run 'ls' in the current directory.
             * The reload command does a 'deep' reload of a module: changes made to the
                     Note that the '/' MUST be the first character on the line!  This
                     won't work:
                         >>> print /globals    # syntax error
                     In most cases the automatic algorithm should work, so you should
                     rarely need to explicitly invoke /. One notable exception is if you
                     are trying to call a function with a list of tuples as arguments (the
                     but this will work:
                         In [2]: /zip (1,2,3),(4,5,6)
                         ------> zip ((1,2,3),(4,5,6))
                         Out[2]= [(1, 4), (2, 5), (3, 6)]
                     IPython tells you that it has altered your command line by
                     displaying the new command line preceded by -->.  e.g.:
                         In [18]: callable list
                         -------> callable (list)
 . Auto-Quoting
                     You can force auto-quoting of a function's arguments by using ',' as
             Magic functions are prefixed by %, and typically take their arguments without
             parentheses, quotes or even commas for convenience.
             Example magic function calls:
             %alias d ls -F   : 'd' is now an alias for 'ls -F'
             %cd??            : See help AND source for magic %cd
             System commands:
             !cp a.txt b/     : System command escape, calls os.system()
             cp a.txt b/      : after %rehashx, most system commands work without !
             cp ${f}.txt $bar : Variable expansion in magics and system commands
             _i, _ii, _iii    : Previous, next previous, next next previous input
             _i4, _ih[2:5]    : Input history line 4, lines 2-4
             exec _i81        : Execute input history line #81 again
             %rep 81          : Edit input history line #81
             _, __, ___       : previous, next previous, next next previous output
             _dh              : Directory history
             _oh              : Output history
                 In [1]: print "Hello IPython!"  # Enter was pressed at the end of the line
                 Hello IPython!
                 In [2]: for i in range(10):
                    ...: 	print i,
                    ...:
 1 2 3 4 5 6 7 8 9
             If you want to enter more than one expression in a single input block
                    ...: z=3
                    ...: x**2  # This does *not* produce an Out[] value
                    ...: x+y+z  # Only the last expression does
                    ...:
                 Out[3]: 6
             The behavior where an extra blank line forces execution is only active if you

IPython/deathrow/Gnuplot2.py

0 +22 -22

                 with their index. Leave other plot items alone."""
                 class StandaloneItem(Exception): pass
                 def get_titles(titles):
                     """Return the next title and the input titles array.
                     The input array may be changed to None when no titles are left to
                     prevent extra unnecessary calls to this function."""
                     try:
                         title = titles[tit_ct[0]]  # tit_ct[0] is in zip_items'scope
                     except IndexError:
                     explicit '' argument must be given as the limit to be kept.
                     Similar functions exist for [y{2}z{2}rtuv]range."""
                     self('set xrange [%s:%s]' % (min,max))
                 def yrange(self,min='*',max='*'):
                     self('set yrange [%s:%s]' % (min,max))
                 def zrange(self,min='*',max='*'):
                     self('set zrange [%s:%s]' % (min,max))
                 def x2range(self,min='*',max='*'):
                     self('set xrange [%s:%s]' % (min,max))
                 def y2range(self,min='*',max='*'):
                     self('set yrange [%s:%s]' % (min,max))
                 def z2range(self,min='*',max='*'):
                     self('set zrange [%s:%s]' % (min,max))
                 def rrange(self,min='*',max='*'):
                     self('set rrange [%s:%s]' % (min,max))
                 def trange(self,min='*',max='*'):
                     self('set trange [%s:%s]' % (min,max))
                 def urange(self,min='*',max='*'):
                     self('set urange [%s:%s]' % (min,max))
                 def vrange(self,min='*',max='*'):
                     self('set vrange [%s:%s]' % (min,max))
                     # Filter out other options the original plot doesn't know
                     hardcopy = popkey(keyw,'hardcopy',psargs['filename'] is not None)
                     titles = popkey(keyw,'titles',0)
                     # the filename keyword should control hardcopy generation, this is an
                     # override switch only which needs to be explicitly set to zero
                     if hardcopy:
                     - filename: a string, typically ending in .eps. If given, the plot is
                     sent to this file in PostScript format.
                     - hardcopy: this can be set to 0 to override 'filename'. It does not
                     need to be given to produce PostScript, its purpose is to allow
                     switching PostScript output off globally in scripts without having to
                     PostScript.
                     For example:
                     In [1]: x=frange(0,2*pi,npts=100)
                     Generate a plot in file 'sin.eps':
                     PostScript generation through plot() is useful mainly for scripting
                     uses where you are not interested in interactive plotting. For
                     interactive use, the hardcopy() function is typically more convenient:
                     In [5]: plot(x,sin(x))
                     In [6]: hardcopy('sin.eps')  """
                     self.__plot_ps(Gnuplot_ori.Gnuplot.plot,*items,**keyw)
                 def plot2(self,arg,**kw):
                     """Plot the entries of a dictionary or a list/tuple of arrays.
                     This simple utility calls plot() with a list of Gnuplot.Data objects
                     constructed either from the values of the input dictionary, or the entries
                     in it if it is a tuple or list.  Each item gets labeled with the key/index
                     Gnuplot.py, this version has several enhancements, listed in the
                     plot() documentation.
                     """
                     self.__plot_ps(Gnuplot_ori.Gnuplot.splot,*items,**keyw)
                 def replot(self, *items, **keyw):
                     'filename' keyword argument in each call to replot. The Gnuplot python
                     interface has no way of knowing that your previous call to
                     Gnuplot.plot() was meant for PostScript output."""
                     self.__plot_ps(Gnuplot_ori.Gnuplot.replot,*items,**keyw)
                 # The original hardcopy has a bug. See fix at the end. The rest of the code

IPython/deathrow/gui/wx/ipshell_nonblocking.py

0 +34 -34

                 def __repr__(self):
                     return "Type help() for interactive help, " \
                            "or help(object) for help about object."
                 def __call__(self, *args, **kwds):
                     class DummyWriter(object):
                         '''Dumy class to handle help output'''
                         def __init__(self, pager):
                             self._pager = pager
                         def write(self, data):
                             '''hook to fill self._pager'''
                             self._pager(data)
                     import pydoc
                     pydoc.help.output = DummyWriter(self._pager)
                     pydoc.help.interact = lambda :1
                     return pydoc.help(*args, **kwds)
             ##############################################################################
             class _CodeExecutor(ThreadEx):
                 ''' Thread that execute ipython code '''
                 def __init__(self, instance):
                     ThreadEx.__init__(self)
                     self.instance = instance
                 def run(self):
                     '''Thread main loop'''
                     try:
                         self.instance._help_text = None
                         self.instance._execute()
                         # used for uper class to generate event after execution
                         self.instance._after_execute()
                     except KeyboardInterrupt:
                         pass
             ##############################################################################
             class NonBlockingIPShell(object):
                 '''
                 Create an IPython instance, running the commands in a separate,
                 non-blocking thread.
                 This allows embedding in any GUI without blockage.
                 Note: The ThreadEx class supports asynchroneous function call
                     self.init_ipython0(user_ns, user_global_ns,
                                        cin, cout, cerr,
                                        ask_exit_handler)
                     #vars used by _execute
                     self._iter_more = 0
                     self._history_level = 0
                     #thread working vars
                     self._line_to_execute = ''
                     self._threading = True
                     #vars that will be checked by GUI loop to handle thread states...
                     #will be replaced later by PostEvent GUI funtions...
                     self._doc_text = None
                                  cin=None, cout=None, cerr=None,
                                  ask_exit_handler=None):
                     ''' Initialize an ipython0 instance '''
                     #first we redefine in/out/error functions of IPython
                     #BUG: we've got a limitation form ipython0 there
                     #only one instance can be instanciated else tehre will be
                         Term.cout = cout
                     if cerr:
                         Term.cerr = cerr
                     excepthook = sys.excepthook
                     #Hack to save sys.displayhook, because ipython seems to overwrite it...
                         self._IP.stdin_encoding = loc
                     #we replace the ipython default pager by our pager
                     self._IP.set_hook('show_in_pager', self._pager)
                     #we replace the ipython default shell command caller
                     #by our shell handler
                     self._IP.set_hook('shell_hook', self._shell)
                     #we replace the ipython default input command caller by our method
                     iplib.raw_input_original = self._raw_input_original
                     #we replace the ipython default exit command by our method
                     import __builtin__
                     __builtin__.raw_input = self._raw_input
                     sys.excepthook = excepthook
                 #----------------------- Thread management section ----------------------
                 def do_execute(self, line):
                     """
                     Tell the thread to process the 'line' command
                     self._line_to_execute = line
                     if self._threading:
                         #we launch the ipython line execution in a thread to make it
                         #interruptible with include it in self namespace to be able
                         #to call  ce.raise_exc(KeyboardInterrupt)
                         self.ce = _CodeExecutor(self)
                         self.ce.start()
                             self._help_text = None
                             self._execute()
                             # used for uper class to generate event after execution
                             self._after_execute()
                         except KeyboardInterrupt:
                             pass
                     @rtype: bool
                     """
                     return self._threading
                 def set_threading(self, state):
                     """
                     Sets threading state, if set to True, then each command sent to
                     @rtype: string
                     """
                     return self._doc_text
                 def get_help_text(self):
                     """
                     Returns the output of the processing that need to be paged via help pager(if any)
                     @rtype: string
                     """
                     return self._IP.banner
                 def get_prompt_count(self):
                     """
                     Returns the prompt number.
                     @rtype: int
                     """
                     return self._IP.indent_current_nsp
                 def update_namespace(self, ns_dict):
                     '''
                     Add the current dictionary to the shell namespace.
                     while((history == '' or history == '\n') and self._history_level >0):
                         if self._history_level >= 1:
                             self._history_level -= 1
                         history = self._get_history()
                     return history
                 def history_forward(self):
                     @rtype: int
                     '''
                     return len(self._IP.input_hist_raw)-1
                 def _get_history(self):
                     '''
                     Get's the command string of the current history level.
                         self._help_text = text
                     else:
                         self._help_text += text
                 def _pager(self, IP, text):
                     '''
                     This function is used as a callback replacment to IPython pager function
                     get_doc_text function.
                     '''
                     self._doc_text = text
                 def _raw_input_original(self, prompt=''):
                     '''
                     Custom raw_input() replacement. Get's current line from console buffer.
                     """ A replacement from python's raw_input.
                     """
                     raise NotImplementedError
                 def _execute(self):
                     '''
                     Executes the current line provided by the shell object.
                     sys.stdout = Term.cout
                     #self.sys_displayhook_ori = sys.displayhook
                     #sys.displayhook = self.displayhook
                     try:
                         line = self._IP.raw_input(None, self._iter_more)
                         if self._IP.autoindent:
                     sys.stdout = orig_stdout
                     #sys.displayhook = self.sys_displayhook_ori
                 def _shell(self, ip, cmd):
                     '''
                     Replacement method to allow shell commands without them blocking.

IPython/deathrow/gui/wx/ipython_history.py

0 +22 -22

                 def __init__(self, parent,flt_empty=True,
                              flt_doc=True,flt_cmd=True,flt_magic=True):
                     wx.Panel.__init__(self,parent,-1)
                     #text_ctrl = wx.TextCtrl(self, -1, style=wx.TE_MULTILINE)
                     text_ctrl = PythonSTC(self, -1)
                     st_filt = wx.StaticText(self, -1, " Filter:")
                     self.filter_empty = wx.CheckBox(self, -1, "Empty commands")
                     self.filter_doc.Bind(wx.EVT_CHECKBOX, self.evtCheckDocFilter)
                     self.filter_cmd.Bind(wx.EVT_CHECKBOX, self.evtCheckCmdFilter)
                     self.filter_magic.Bind(wx.EVT_CHECKBOX, self.evtCheckMagicFilter)
                     #self.filter_empty.SetValue(flt_empty)
                     #self.filter_doc.SetValue(flt_doc)
                     #self.filter_cmd.SetValue(flt_cmd)
                     #self.filter_magic.SetValue(flt_magic)
                     sizer = wx.BoxSizer(wx.VERTICAL)
                     sizer.Add(text_ctrl, 1, wx.EXPAND)
                     text_ctrl.SetMarginType(1, stc.STC_MARGIN_NUMBER)
                     text_ctrl.SetMarginWidth(1, 15)
                 def write(self,history_line):
                     add = True
                     if self.filter_empty.GetValue() == True and history_line == '':
                         self.options[name]['value']='False'
                     self.updateOptionTracker(name,
                                              self.options[name]['value'])
                 def evtCheckEmptyFilter(self, event):
                     self.processOptionCheckedEvt(event, 'filter_empty')
                 def evtCheckDocFilter(self, event):
                     self.processOptionCheckedEvt(event, 'filter_doc')
                 def evtCheckMagicFilter(self, event):
                     self.processOptionCheckedEvt(event, 'filter_magic')
                 def getOptions(self):
                     return self.options
                 def reloadOptions(self,options):
                     self.options = options
                     for key in self.options.keys():
                     Default history tracker (does nothing)
                     '''
                     pass
                 def setOptionTrackerHook(self,func):
                     '''
                     Define a new history tracker
                     '''
                     self.updateOptionTracker = func
             #----------------------------------------------------------------------
             # Font definition for Styled Text Control
             class PythonSTC(stc.StyledTextCtrl):
                 fold_symbols = 3
                 def __init__(self, parent, ID,
                              pos=wx.DefaultPosition, size=wx.DefaultSize,
                              style=0):
                     #self.SetViewEOL(True)
                     self.SetEOLMode(stc.STC_EOL_CRLF)
                     #self.SetUseAntiAliasing(True)
                     self.SetEdgeMode(stc.STC_EDGE_LINE)
                     self.SetEdgeColumn(80)
                     self.SetEdgeColour(wx.LIGHT_GREY)
                     self.SetLayoutCache(stc.STC_CACHE_PAGE)
                     # Setup a margin to hold fold markers
                     #self.SetFoldFlags(16)
                     ###  WHAT IS THIS VALUE?  WHAT ARE THE OTHER FLAGS?  DOES IT MATTER?
                     self.SetMarginType(2, stc.STC_MARGIN_SYMBOL)
                     self.SetMarginMask(2, stc.STC_MASK_FOLDERS)
                     self.SetMarginWidth(2, 12)
                     if self.fold_symbols == 0:
                         # Arrow pointing right for contracted folders,
                         # arrow pointing down for expanded
                         self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
                                                     stc.STC_MARK_ARROWDOWN, "black", "black")
                                                     stc.STC_MARK_EMPTY,     "white", "black")
                         self.MarkerDefine(stc.STC_MARKNUM_FOLDERMIDTAIL, \
                                                     stc.STC_MARK_EMPTY,     "white", "black")
                     elif self.fold_symbols == 1:
                         # Plus for contracted folders, minus for expanded
                         self.MarkerDefine(stc.STC_MARKNUM_FOLDEROPEN, \
                     self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,    "fore:#000000,back:#FF0000,bold")
                     # Python styles
                     # Default
                     self.StyleSetSpec(stc.STC_P_DEFAULT, "fore:#000000,face:%(helv)s,size:%(size)d" % faces)
                     # Comments
                     self.StyleSetSpec(stc.STC_P_COMMENTLINE, "fore:#007F00,face:%(other)s,size:%(size)d" % faces)
                     # register some images for use in the AutoComplete box.
                     #self.RegisterImage(1, images.getSmilesBitmap())
                     #self.RegisterImage(2,
                     #    wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))
                     #self.RegisterImage(3,
                     #    wx.ArtProvider.GetBitmap(wx.ART_COPY, size=(16,16)))
                             #self.AutoCompShow(0, st)
                             kw = keyword.kwlist[:]
                             kw.sort()  # Python sorts are case sensitive
                             self.AutoCompSetIgnoreCase(False)  # so this needs to match
                     if braceAtCaret < 0:
                         charAfter = self.GetCharAt(caretPos)
                         styleAfter = self.GetStyleAt(caretPos)
                         if charAfter and chr(charAfter) in "[]{}()" and styleAfter == stc.STC_P_OPERATOR:
                             braceAtCaret = caretPos

IPython/deathrow/gui/wx/ipython_view.py

0 +76 -76

                 '''
                 An NonBlockingIPShell Thread that is WX dependent.
                 '''
                 def __init__(self, parent,
                              argv=[],user_ns={},user_global_ns=None,
                              cin=None, cout=None, cerr=None,
                              ask_exit_handler=None):
                     NonBlockingIPShell.__init__(self, argv, user_ns, user_global_ns,
                                                 cin, cout, cerr,
                                                 ask_exit_handler)
                     self._IP.exit = self._ask_exit
                 def addGUIShortcut(self, text, func):
                     wx.CallAfter(self.parent.add_button_handler,
                             button_info={   'text':text,
                                             'func':self.parent.doExecuteLine(func)})
                 def _raw_input(self, prompt=''):
                     """ A replacement from python's raw_input.
                     """
                     self.answer = None
                     if(self._threading == True):
                                     wx.CallAfter(self._yesNoBox,  prompt)
                                     while self.answer is None:
                                             time.sleep(.1)
                     else:
                                     self._yesNoBox(prompt)
                     return self.answer
                 def _yesNoBox(self, prompt):
                     """ yes/no box managed with wx.CallAfter jsut in case caler is executed in a thread"""
                     dlg = wx.TextEntryDialog(
                     answer = ''
                     if dlg.ShowModal() == wx.ID_OK:
                         answer = dlg.GetValue()
                     dlg.Destroy()
                     self.answer = answer
                 def _ask_exit(self):
                     wx.CallAfter(self.ask_exit_callback, ())
                 def _after_execute(self):
                     wx.CallAfter(self.parent.evtStateExecuteDone, ())
             class WxConsoleView(stc.StyledTextCtrl):
                 '''
                 Specialized styled text control view for console-like workflow.
                 We use here a scintilla frontend thus it can be reused in any GUI that
                 supports scintilla with less work.
                 @cvar ANSI_COLORS_BLACK: Mapping of terminal colors to X11 names.
                                      '0;36': [6, 'CYAN'],             '0;37': [7, 'LIGHT GREY'],
                                      '1;30': [8, 'DARK GREY'],        '1;31': [9, 'RED'],
                                      '1;32': [10, 'SEA GREEN'],       '1;33': [11, 'YELLOW'],
                                      '1;34': [12, 'LIGHT BLUE'],      '1;35':
                                                                       [13, 'MEDIUM VIOLET RED'],
                                      '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
                     stc.StyledTextCtrl.__init__(self, parent, ID, pos, size, style)
                     ####### Scintilla configuration ###################################
                     # Ctrl + B or Ctrl + N can be used to zoomin/zoomout the text inside
                     # the widget
                     self.CmdKeyAssign(ord('B'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
                     self.CmdKeyAssign(ord('N'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
                     self.SetTabWidth(4)
                     self.EnsureCaretVisible()
                     self.SetMargins(3, 3) #text is moved away from border with 3px
                     # Suppressing Scintilla margins
                     self.SetMarginWidth(0, 0)
                     self.background_color = background_color
                     self.buildStyles()
                     self.indent = 0
                     self.prompt_count = 0
                     self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
                     self.write(intro)
                     self.setPrompt(prompt)
                     self.showPrompt()
                     self.autocomplete_mode = autocomplete_mode
                     self.Bind(wx.EVT_KEY_DOWN, self._onKeypress)
                 def buildStyles(self):
                     #we define platform specific fonts
                     if wx.Platform == '__WXMSW__':
                         self.SetCaretForeground("WHITE")
                         self.ANSI_STYLES = self.ANSI_STYLES_BLACK
                     self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
                                       "fore:%s,back:%s,size:%d,face:%s"
                                                 % (self.ANSI_STYLES['0;30'][1],
                                       self.background_color,
                                       faces['size'], faces['mono']))
                     self.StyleClearAll()
                     self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,
                                       "fore:#FF0000,back:#0000FF,bold")
                     self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
                                       "fore:#000000,back:#FF0000,bold")
                     for style in self.ANSI_STYLES.values():
                         self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
                     #######################################################################
                 def setBackgroundColor(self, color):
                     self.background_color = color
                     self.buildStyles()
                 def getBackgroundColor(self, color):
                     return self.background_color
                 def asyncWrite(self, text):
                     '''
                     Write given text to buffer in an asynchroneous way.
                     '''
                     try:
                         wx.MutexGuiEnter()
                         #be sure not to be interrutpted before the MutexGuiLeave!
                         self.write(text)
                     except KeyboardInterrupt:
                         wx.MutexGuiLeave()
                         raise KeyboardInterrupt
                     wx.MutexGuiLeave()
                 def write(self, text):
                     '''
                     Write given text to buffer.
                     segment = segments.pop(0)
                     self.StartStyling(self.getCurrentLineEnd(), 0xFF)
                     self.AppendText(segment)
                     if segments:
                         ansi_tags = self.color_pat.findall(text)
                                 self.SetStyling(len(segments[i+1]), self.ANSI_STYLES[tag][0])
                             segments.pop(i)
                     self.moveCursor(self.getCurrentLineEnd())
                 def getPromptLen(self):
                     '''
                     Return the length of current prompt
                 def setIndentation(self, indentation):
                     self.indent = indentation
                 def setPromptCount(self, count):
                     self.prompt_count = count
                 def showPrompt(self):
                     '''
                     Prints prompt at start of line.
                     self.write(self.prompt)
                     #now we update the position of end of prompt
                     self.current_start = self.getCurrentLineEnd()
                     autoindent = self.indent*' '
                     autoindent = autoindent.replace('    ','\t')
                     self.write(autoindent)
                 def changeLine(self, text):
                     '''
                     Replace currently entered command line with given text.
                     #If cursor is at wrong position put it at last line...
                     if self.GetCurrentPos() < self.getCurrentPromptStart():
                         self.GotoPos(self.getCurrentPromptStart())
                 def removeFromTo(self, from_pos, to_pos):
                     if from_pos < to_pos:
                         self.SetSelection(from_pos, to_pos)
                         self.DeleteBack()
                 def removeCurrentLine(self):
                     self.LineDelete()
                 def moveCursor(self, position):
                     self.GotoPos(position)
                 def selectFromTo(self, from_pos, to_pos):
                     self.SetSelectionStart(from_pos)
                     self.SetSelectionEnd(to_pos)
                 def writeHistory(self, history):
                     self.removeFromTo(self.getCurrentPromptStart(), self.getCurrentLineEnd())
                     self.changeLine(history)
                 def getCompletionMethod(self, completion):
                     return self.autocomplete_mode
                 def writeCompletion(self, possibilities):
                     if self.autocomplete_mode == 'IPYTHON':
                         max_len = len(max(possibilities, key=len))
                         max_symbol = ' '*max_len
                         #now we check how much symbol we can put on a line...
                         test_buffer = max_symbol + ' '*4
                         allowed_symbols = 80/len(test_buffer)
                         if allowed_symbols == 0:
                             allowed_symbols = 1
                         pos = 1
                         buf = ''
                         for symbol in possibilities:
                         for breaker in splitter:
                             last_word = last_word.split(breaker)[-1]
                         self.AutoCompShow(len(last_word), " ".join(possibilities))
                 def _onKeypress(self, event, skip=True):
                     '''
                     Key press callback used for correcting behavior for console-like
                         elif event.GetKeyCode() == wx.WXK_LEFT:
                             if event.Modifiers == wx.MOD_NONE:
                                 self.moveCursorOnNewValidKey()
                                 self.moveCursor(self.getCursorPos()-1)
                                 if self.getCursorPos() < self.getCurrentPromptStart():
                                     self.moveCursor(self.getCurrentPromptStart())
                             if self.getCursorPos() > self.getCurrentPromptStart():
                                 event.Skip()
                             return True
                         if skip:
                             if event.GetKeyCode() not in [wx.WXK_PAGEUP, wx.WXK_PAGEDOWN]\
                             and event.Modifiers == wx.MOD_NONE:
                                 self.moveCursorOnNewValidKey()
                             event.Skip()
                             return True
                         return False
                     else:
                         event.Skip()
                 def OnUpdateUI(self, evt):
                     # check for matching braces
                     braceAtCaret = -1
                         #self.Refresh(True, wxRect(pt.x, pt.y, 5,5))
                         #print pt
                         #self.Refresh(False)
             class IPShellWidget(wx.Panel):
                 '''
                 This is wx.Panel that embbed the IPython Thread and the wx.StyledTextControl
                 If you want to port this to any other GUI toolkit, just replace the
                 WxConsoleView by YOURGUIConsoleView and make YOURGUIIPythonView derivate
                 from whatever container you want. I've choosed to derivate from a wx.Panel
                 because it seems to be more useful
                 Any idea to make it more 'generic' welcomed.
                 '''
                 def __init__(self, parent, intro=None,
                              background_color="BLACK", add_button_handler=None,
                              wx_ip_shell=None, user_ns={},user_global_ns=None,
                              ):
                     '''
                     ### IPython wx console view instanciation ###
                     #If user didn't defined an intro text, we create one for him
                     #If you really wnat an empty intro just call wxIPythonViewPanel
                     #with intro=''
                     if intro is None:
                         welcome_text = "Welcome to WxIPython Shell.\n\n"
                     self.threading_option.SetToolTip(wx.ToolTip(
                         "Use threading: infinite loop don't freeze the GUI and commands can be breaked\nNo  threading: maximum compatibility"))
                     #self.threading_option.SetValue(False)
                     self.options={'completion':{'value':'IPYTHON',
                                                 'checkbox':self.completion_option,'STC':True,'IPYTHON':False,
                                                 'setfunc':self.text_ctrl.setCompletionMethod},
                     self.cout.write = self.text_ctrl.asyncWrite
                     #we reloard options
                     self.reloadOptions(self.options)
                     self.text_ctrl.Bind(wx.EVT_KEY_DOWN, self.keyPress)
                     self.completion_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionCompletion)
                     self.background_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionBackgroundColor)
                     self.threading_option.Bind(wx.EVT_CHECKBOX, self.evtCheckOptionThreading)
                     ### making the layout of the panel ###
                     sizer = wx.BoxSizer(wx.VERTICAL)
                     sizer.Add(self.text_ctrl, 1, wx.EXPAND)
                 def askExitCallback(self, event):
                     self.askExitHandler(event)
                 #---------------------- IPython Thread Management ------------------------
                 def stateDoExecuteLine(self):
                     lines=self.text_ctrl.getCurrentLine()
                     if(self.text_ctrl.getCursorPos()!=0):
                         self.text_ctrl.removeCurrentLine()
                     self.setCurrentState('WAIT_END_OF_EXECUTION')
                 def evtStateExecuteDone(self,evt):
                     self.doc = self.IP.get_doc_text()
                     self.help = self.IP.get_help_text()
                         self.pager_lines = self.help.split('\n')
                         self.pager_state = 'INIT'
                         self.setCurrentState('SHOW_DOC')
                         self.pager(self.help)
                     else:
                         if(self.text_ctrl.getCursorPos()!=0):
                             self.text_ctrl.removeCurrentLine()
                                 self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
                             else:
                                 self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
                             for line in self.pager_lines[self.pager_index+1:self.pager_index+9]:
                                 self.text_ctrl.write("\x01\x1b[1;36m\x02 "+line+'\n')
                             self.pager_index += 10
                                     self.text_ctrl.write(">\x01\x1b[1;36m\x02"+self.pager_lines[self.pager_index]+'\n')
                                 else:
                                     self.text_ctrl.write("\x01\x1b[1;36m\x02 "+self.pager_lines[self.pager_index]+'\n')
                                 self.pager_index += 1
                                 self.pager_nb_lines -= 1
                             if self.pager_nb_lines > 0:
                                     self.pager_nb_lines = 0
                             self.pager_state = 'DONE'
                             self.stateShowPrompt()
                 #------------------------ Key Handler ------------------------------------
                 def keyPress(self, event):
                     '''
                                 #we raise an exception inside the IPython thread container
                                 self.IP.ce.raise_exc(KeyboardInterrupt)
                                 return
                     #let this before 'wx.WXK_RETURN' because we have to put 'IDLE'
                     #mode if AutoComp has been set as inactive
                     if self.cur_state == 'COMPLETING':
                             self.pager_state = 'PROCESS_LINES'
                             self.pager(self.doc)
                             return
                         if self.cur_state == 'WAITING_USER_INPUT':
                             line=self.text_ctrl.getCurrentLine()
                             self.text_ctrl.write('\n')
                             self.setCurrentState('WAIT_END_OF_EXECUTION')
                             return
                     if event.GetKeyCode() in [ord('q'),ord('Q')]:
                         if self.pager_state == 'WAITING':
                             self.pager_state = 'DONE'
                             return
                     if self.cur_state == 'WAITING_USER_INPUT':
                         event.Skip()
                     if self.cur_state == 'IDLE':
                         if event.KeyCode == wx.WXK_UP:
                             history = self.IP.history_back()
                                 return
                             completed, possibilities = self.IP.complete(self.text_ctrl.getCurrentLine())
                             if len(possibilities) > 1:
                                 if self.text_ctrl.autocomplete_mode == 'IPYTHON':
                                     cur_slice = self.text_ctrl.getCurrentLine()
                                     self.text_ctrl.write('\n')
                                     self.text_ctrl.writeCompletion(possibilities)
                     self.updateOptionTracker('threading',
                                              self.options['threading']['value'])
                     self.text_ctrl.SetFocus()
                 def getOptions(self):
                     return self.options
                 def reloadOptions(self,options):
                     self.options = options
                     for key in self.options.keys():
                         value = self.options[key]['value']
                         self.options[key]['checkbox'].SetValue(self.options[key][value])
                         self.options[key]['setfunc'](value)
                     if self.options['threading']['value']=='True':
                         self.IP.set_threading(True)
                         self.cout.write = self.text_ctrl.asyncWrite
                     else:
                         self.IP.set_threading(False)
                         self.cout.write = self.text_ctrl.write
                 #------------------------ Hook Section -----------------------------------
                 def updateOptionTracker(self,name,value):
                     '''
                     Default history tracker (does nothing)
                     '''
                     pass
                 def setOptionTrackerHook(self,func):
                     '''
                     Define a new history tracker
                     Default history tracker (does nothing)
                     '''
                     pass
                 def setHistoryTrackerHook(self,func):
                     '''
                     Define a new history tracker
                     Default status tracker (does nothing)
                     '''
                     pass
                 def setStatusTrackerHook(self,func):
                     '''
                     Define a new status tracker

IPython/deathrow/gui/wx/thread_ex.py

0 +11 -11

             import threading
             import inspect
             import ctypes
             def _async_raise(tid, exctype):
                 """raises the exception, performs cleanup if needed"""
                 if not inspect.isclass(exctype):
                 if res == 0:
                     raise ValueError("invalid thread id")
                 elif res != 1:
                     # """if it returns a number greater than one, you're in trouble,
                     # and you should call it again with exc=NULL to revert the effect"""
                     ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, 0)
                     raise SystemError("PyThreadState_SetAsyncExc failed")
             class ThreadEx(threading.Thread):
                 def _get_my_tid(self):
                     """determines this (self's) thread id"""
                     if not self.isAlive():
                         raise threading.ThreadError("the thread is not active")
                     # do we have it cached?
                     if hasattr(self, "_thread_id"):
                         return self._thread_id
                     # no, look for it in the _active dict
                     for tid, tobj in threading._active.items():
                         if tobj is self:
                             self._thread_id = tid
                             return tid
                     raise AssertionError("could not determine the thread's id")
                 def raise_exc(self, exctype):
                     """raises the given exception type in the context of this thread"""
                     _async_raise(self._get_my_tid(), exctype)
                 def kill(self):
                     """raises SystemExit in the context of the given thread, which should
                     cause the thread to exit silently (unless caught)"""
                     self.raise_exc(SystemExit)

IPython/deathrow/gui/wx/wxIPython.py

0 +40 -40

             __license__ = "BSD"
             #-----------------------------------------
             # Creating one main frame for our
             # application with movables windows
             #-----------------------------------------
             class MyFrame(wx.Frame):
                 """Creating one main frame for our
                 application with movables windows"""
                 def __init__(self, parent=None, id=-1, title="WxIPython",
                             pos=wx.DefaultPosition,
                             size=(800, 600), style=wx.DEFAULT_FRAME_STYLE, sync_ok=False):
                     wx.Frame.__init__(self, parent, id, title, pos, size, style)
                     self._mgr = wx.aui.AuiManager()
                     # notify PyAUI which frame to use
                     self._mgr.SetManagedWindow(self)
                     #create differents panels and make them persistant
                     self.history_panel    = IPythonHistoryPanel(self)
                     self.history_panel.setOptionTrackerHook(self.optionSave)
                     self.ipython_panel    = IPShellWidget(self,background_color = "BLACK")
                     #self.ipython_panel    = IPShellWidget(self,background_color = "WHITE")
                     if(sync_ok):
                     #Create a notebook to display different IPython shell implementations
                     self.nb = wx.aui.AuiNotebook(self)
                     self.optionLoad()
                     self.statusbar = self.createStatus()
                     self.createMenu()
                     ########################################################################
                     ### add the panes to the manager
                     # main panels
                         self.nb.AddPage(self.ipython_panel2, "IPython1 Synchroneous Shell")
                     self._mgr.AddPane(self.history_panel , wx.RIGHT,  "IPython history")
                     # now we specify some panel characteristics
                     self._mgr.GetPane(self.ipython_panel).CaptionVisible(True);
                     self._mgr.GetPane(self.history_panel).CaptionVisible(True);
                     self._mgr.GetPane(self.history_panel).MinSize((200,400));
                     # tell the manager to "commit" all the changes just made
                     self._mgr.Update()
                     self.Bind(wx.EVT_MENU,  self.OnShowHistoryPanel,id=wx.ID_HIGHEST+2)
                     self.Bind(wx.EVT_MENU,  self.OnShowAbout, id=wx.ID_HIGHEST+3)
                     self.Bind(wx.EVT_MENU,  self.OnShowAllPanel,id=wx.ID_HIGHEST+6)
                     warn_text = 'Hello from IPython and wxPython.\n'
                     warn_text +='Please Note that this work is still EXPERIMENTAL\n'
                     warn_text +='It does NOT emulate currently all the IPython functions.\n'
                     warn_text +="\nIf you use MATPLOTLIB with show() you'll need to deactivate the THREADING option.\n"
                     if(not sync_ok):
                         warn_text +="\n->No twisted package detected, IPython1 example deactivated."
                     dlg = wx.MessageDialog(self,
                                            warn_text,
                                            'Warning Box',
                             opt.write(key + '=' + options_ipython_panel[key]['value']+'\n')
                         for key in options_history_panel.keys():
                             opt.write(key + '=' + options_history_panel[key]['value']+'\n')
                     finally:
                         opt.close()
                 def optionLoad(self):
                     try:
                         ip = get()
                         opt = open(path + '/options.conf','r')
                         lines = opt.readlines()
                         opt.close()
                         options_ipython_panel = self.ipython_panel.getOptions()
                         options_history_panel = self.history_panel.getOptions()
                         for line in lines:
                             key = line.split('=')[0]
                             value = line.split('=')[1].replace('\n','').replace('\r','')
                                 print >>sys.__stdout__,"Warning: key ",key,"not found in widget options. Check Options.conf"
                         self.ipython_panel.reloadOptions(options_ipython_panel)
                         self.history_panel.reloadOptions(options_history_panel)
                     except IOError:
                         print >>sys.__stdout__,"Could not open Options.conf, defaulting to default values."
                 def createMenu(self):
                     """local method used to create one menu bar"""
                     mb = wx.MenuBar()
                     file_menu = wx.Menu()
                     file_menu.Append(wx.ID_EXIT, "Exit")
                     view_menu = wx.Menu()
                     view_menu.Append(wx.ID_HIGHEST+1, "Show IPython Panel")
                     view_menu.Append(wx.ID_HIGHEST+2, "Show History Panel")
                     view_menu.AppendSeparator()
                     view_menu.Append(wx.ID_HIGHEST+6, "Show All")
                     about_menu = wx.Menu()
                     about_menu.Append(wx.ID_HIGHEST+3, "About")
                     mb.Append(view_menu, "View")
                     mb.Append(about_menu, "About")
                     #mb.Append(options_menu, "Options")
                     self.SetMenuBar(mb)
                 def createStatus(self):
                               'SHOW_DOC':'Showing doc',
                               'SHOW_PROMPT':'Showing prompt'}
                     self.statusbar.SetStatusText(states[text], 0)
                 def OnClose(self, event):
                     """#event used to close program  """
                     # deinitialize the frame manager
                     self._mgr.UnInit()
                     self.Destroy()
                     event.Skip()
                 def OnExitDlg(self, event):
                     dlg = wx.MessageDialog(self, 'Are you sure you want to quit WxIPython',
                                             'WxIPython exit',
                         self._mgr.UnInit()
                         self.Destroy()
                     dlg.Destroy()
                 #event to display IPython pannel
                 def OnShowIPythonPanel(self,event):
                     """ #event to display Boxpannel """
                     self._mgr.GetPane(self.ipython_panel).Show(True)
                     self._mgr.Update()
                 #event to display History pannel
                 def OnShowHistoryPanel(self,event):
                     self._mgr.GetPane(self.history_panel).Show(True)
                     self._mgr.Update()
                 def OnShowAllPanel(self,event):
                     """#event to display all Pannels"""
                     self._mgr.GetPane(self.ipython_panel).Show(True)
                     info.License = wordwrap(licenseText, 500, wx.ClientDC(self))
                     # Then we call wx.AboutBox giving it that info object
                     wx.AboutBox(info)
             #-----------------------------------------
             #Creating our application
             #-----------------------------------------
             class MyApp(wx.PySimpleApp):
                 """Creating our application"""
                 def __init__(self, sync_ok=False):
                     wx.PySimpleApp.__init__(self)
                     self.frame = MyFrame(sync_ok=sync_ok)
                     self.frame.Show()
             #-----------------------------------------
             #Main loop
             #-----------------------------------------
             def main():
                 app = MyApp(is_sync_frontend_ok)
                 app.SetTopWindow(app.frame)

IPython/deathrow/ipy_constants.py

0 +63 -63

             Definition of Fundamental Physical Constants, CODATA Recommended Values
             Source, Peter J. Mohr and Barry N. Taylor,
             CODATA Recommended Values of the Fundamental
             Physical Constants, 1998
             Website: physics.nist.gov/constants
             """
             # License: BSD-like
             # Copyright: Gael Varoquaux (gael.varoquaux@normalesup.org)
             # inspired by maxima's physconst.mac by Cliff Yapp
             #from math import * # math MUST be imported BEFORE PhysicalQInteractive
             from IPython.extensions.PhysicalQInteractive import PhysicalQuantityInteractive
             # Math constants:
             # Atomic and Nuclear Constants
             # General
             #-------------------------------------------------------------------------
             # fine-structure constant
             alpha = 7.297352533E-3
             # electron-muon mass ratio
             memu = 4.83633210E-3
             # electron-tau mass ratio
             metau = 2.87555E-4
             # electron-proton mass ratio
             memp = 5.446170232E-4
             # electron-neutron mass ratio
             memn = 5.438673462E-4
             # electron-deuteron mass ratio
             memd = 2.7244371170E-4
             # electron to alpha particle mass ratio
             memalpha = 1.3709335611E-4
             u_e = PhysicalQuantityInteractive(-928.476362E-26 , 'J/T')
             u_e.__doc__ = """electron magnetic moment    """
             # electron magnetic moment to Bohr magneton ratio
             ueuB = -1.0011596521869
             # electron magnetic moment to nuclear magneton ratio
             ueuN = -1838.2819660
             # electron magnetic moment anomaly |ue|/uB - 1
             a_e = 1.1596521869E-3
             # electron g-factor
             g_e = -2.0023193043737
             # electron-muon magnetic moment ratio
             ueuu = 206.7669720
             # electron-proton magnetic moment ratio
             ueup = -658.2106875
             # electron to shielded proton magnetic moment ratio  (H2O, sphere, 25  C)
             ueusp = -658.2275954
             # electron-neutron magnetic moment ratio
             ueun = 960.92050
             # electron-deuteron magnetic moment ratio
             ueud = -2143.923498
             # electron to shielded helione magnetic moment ratio  (gas, sphere, 25  C)
             muc2_MeV = PhysicalQuantityInteractive(105.6583568 , 'MeV')
             muc2_MeV.__doc__ = """energy equivalent in MeV """
             # muon-electron mass ratio
             mume = 206.7682657
             # muon-tau mass ratio
             # muon-proton mass ratio
             mump = 0.1126095173
             # muon-neutron mass ratio
             mumn = 0.1124545079
             uu = PhysicalQuantityInteractive(-4.49044813E-26 , 'J/T')
             uu.__doc__ = """muon magnetic moment    """
             # ratio of muon magnetic moment to Bohr magneton ratio
             uuuB = -4.84197085E-3
             # ratio of muon magnetic moment to nuclear magneton ratio
             uuuN = -8.89059770
             # muon magnetic moment anomaly |uu|/(e /2mu) - 1
             a_u = 1.16591602E-3
             # muon g-factor -2(1 + au)
             g_u = -2.0023318320
             # muon-proton magnetic moment ratio
             uuup = -3.18334539
             # Tau, tau-
             mtauc2_MeV = PhysicalQuantityInteractive(1777.05 , 'MeV')
             mtauc2_MeV.__doc__ = """tau mass energy equivalent in MeV """
             # tau-electron mass ratio
             mtaume = 3477.60
             # tau-muon mass ratio
             mtaumu = 16.8188
             # tau-proton mass ratio
             mtaump = 1.89396
             # tau-neutron mass ratio
             mtaumn = 1.89135
             mpc2_MeV = PhysicalQuantityInteractive(938.271998 , 'MeV')
             mpc2_MeV.__doc__ = """energy equivalent in MeV  """
             # proton-electron mass ratio
             mpme = 1836.1526675
             # proton-muon mass ratio
             mpmu = 8.88024408
             # proton-tau mass ratio
             mpmtau = 0.527994
             # proton-neutron mass ratio
             mpmn = 0.99862347855
             up = PhysicalQuantityInteractive(1.410606633E-26 , 'J/T')
             up.__doc__ = """proton magnetic moment   """
             # proton magnetic moment to Bohr magneton ratio
             upuB = 1.521032203E-3
             # proton magnetic moment to nuclear magneton ratio
             upuN = 2.792847337
             # proton g-factor 2up/uN
             g_p = 5.585694675
             # proton-neutron magnetic moment ratio
             upun = -1.45989805
             usp = PhysicalQuantityInteractive(1.410570399E-26 , 'J/T')
             usp.__doc__ = """shielded proton magnetic moment  (H2O, sphere, 25  C)"""
             # shielded proton magnetic moment to Bohr magneton ratio
             uspuB = 1.520993132E-3
             # shielded proton magnetic moment to nuclear magneton ratio
             uspuN = 2.792775597
             # proton magnetic shielding correction 1 - u p/up  (H2O, sphere, 25  C)
             mnc2_MeV = PhysicalQuantityInteractive(939.565330 , 'MeV')
             mnc2_MeV.__doc__ = """neutron mass energy equivalent  in MeV  """
             # neutron-electron mass ratio
             mnme = 1838.6836550
             # neutron-muon mass ratio
             mnmu = 8.89248478
             # neutron-tau mass ratio
             mnm = 0.528722
             # neutron-proton mass ratio
             mnmp = 1.00137841887
             un = PhysicalQuantityInteractive(-0.96623640E-26 , 'J/T')
             un.__doc__ = """neutron magnetic moment """
             # neutron magnetic moment to Bohr magneton ratio
             unuB = -1.04187563E-3
             # neutron magnetic moment to nuclear magneton ratio
             unuN = -1.91304272
             # neutron g-factor
             g_n = -3.82608545
             # neutron-electron magnetic moment ratio
             unue = 1.04066882E-3
             # neutron-proton magnetic moment ratio
             unup = -0.68497934
             # neutron to shielded proton magnetic moment ratio (H2O, sphere, 25  C)
             mdc2_eV = PhysicalQuantityInteractive(1875.612762 , 'MeV')
             mdc2_eV.__doc__ = """deuteron mass energy equivalent in MeV  """
             # deuteron-electron mass ratio
             mdme = 3670.4829550
             # deuteron-proton mass ratio
             mdmp = 1.99900750083
             ud = PhysicalQuantityInteractive(0.433073457E-26 , 'J/T')
             ud.__doc__ = """deuteron magnetic moment  """
             # deuteron magnetic moment to Bohr magneton ratio
             uduB = 0.4669754556E-3
             # deuteron magnetic moment to nuclear magneton ratio
             uduN = 0.8574382284
             # deuteron-electron magnetic moment ratio
             udue = -4.664345537E-4
             # deuteron-proton magnetic moment ratio
             udup = 0.3070122083
             # deuteron-neutron magnetic moment ratio
             udun = -0.44820652
             # Helion, h
             mhc2_MeV = PhysicalQuantityInteractive(2808.39132 , 'MeV')
             mhc2_MeV.__doc__ = """helion mass energy equivalent in MeV """
             # helion-electron mass ratio
             mhme = 5495.885238
             # helion-proton mass ratio
             mhmp = 2.99315265850
             ush = PhysicalQuantityInteractive(-1.074552967E-26 , 'J/T')
             ush.__doc__ = """shielded helion magnetic moment (gas, sphere, 25  C)"""
             # shielded helion magnetic moment to Bohr magneton ratio
             ushuB = -1.158671474E-3
             # shielded helion magnetic moment to nuclear magneton ratio
             ushuN = -2.127497718
             # shielded helion to proton magnetic moment ratio  (gas, sphere, 25  C)
             gamma_h = PhysicalQuantityInteractive(2.037894764E8 , '1/(s*T)')
             gamma_h.__doc__ = """shielded helion gyromagnetic  (gas, sphere, 25  C) """
             # Alpha particle,
             #-------------------------------------------------------------------------
             m_alpha = PhysicalQuantityInteractive(6.64465598E-27 , 'kg')
             malphac2_MeV = PhysicalQuantityInteractive(3727.37904 , 'MeV')
             malphac2_MeV.__doc__ = """alpha particle mass energy equivalent in MeV  """
             # alpha particle to electron mass ratio
             malphame = 7294.299508
             # alpha particle to proton mass ratio
             malphamp = 3.9725996846
             Vm_2.__doc__ = """molar volume of ideal gas RT/p   T = 273.15 K, p = 100 kPa  """
             # Sackur-Tetrode constant (absolute entropy constant) 52 + ln_(2 mukT1/h2)3/2kT1/p0
             # T1 = 1 K, p0 = 100 kPa
             S_0R_1 = -1.1517048
             # T1 = 1 K, p0 = 101.325 kPa
             S_0R_2 = -1.1648678

IPython/deathrow/ipy_defaults.py

0 +5 -5

             """ Set default options for IPython.
             Just import this module to get reasonable defaults for everything.
             These configurations used to be performed in ipythonrc (or ipythonrc.ini).
             Therefore importing this in your config files makes ipython basically
             ignore your ipythonrc. This is *not* imported by default, you need to import
             this manually in one of your config files.
             You can further override these defaults in e.g. your ipy_user_config.py,
             if readline.have_readline:
                 for cmd in rlopts.split('\n'):
                     readline.parse_and_bind(cmd)

IPython/deathrow/ipy_profile_sh.py

0 +34 -34

             Start ipython in shell mode by invoking "ipython -p sh"
             (the old version, "ipython -p pysh" still works but this is the more "modern"
             shell mode and is recommended for users who don't care about pysh-mode
             compatibility)
             """
             import ipy_defaults
             def main():
                 ip = ipapi.get()
                 o = ip.options
                 # autocall to "full" mode (smart mode is default, I like full mode)
                 o.autocall = 2
                 # Jason Orendorff's path class is handy to have in user namespace
                 # if you are doing shell-like stuff
                 try:
                     ip.ex("from IPython.external.path import path" )
                 except ImportError:
                     pass
                 # beefed up %env is handy in shell mode
                 import envpersist
                 # To see where mycmd resides (in path/aliases), do %which mycmd
                 import ipy_which
                 # tab completers for hg, svn, ...
                 import ipy_app_completers
                 # To make executables foo and bar in mybin usable without PATH change, do:
                 # %rehashdir c:/mybin
                 # %store foo
                 # does not work without subprocess module!
                 #import ipy_signals
                 ip.ex('import os')
                 ip.ex("def up(): os.chdir('..')")
                 ip.user_ns['LA'] = LastArgFinder()
                 # You can assign to _prompt_title variable
                 # to provide some extra information for prompt
                 # (e.g. the current mode, host/username...)
                 ip.user_ns['_prompt_title'] = ''
                 # Nice prompt
                 o.prompt_in1= r'\C_Green${_prompt_title}\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#> '
                 o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green> '
                 o.prompt_out= '<\#> '
                 from IPython.core import release
                 import sys
                 # Non-chatty banner
                 o.banner = "IPython %s   [on Py %s]\n" % (release.version,sys.version.split(None,1)[0])
                 ip.default_option('cd','-q')
                 ip.default_option('macro', '-r')
                 # If you only rarely want to execute the things you %edit...
                 #ip.default_option('edit','-x')
                 o.prompts_pad_left="1"
                 # Remove all blank lines in between prompts, like a normal shell.
                 o.separate_in="0"
                 o.separate_out="0"
                 o.separate_out2="0"
                 # now alias all syscommands
                 db = ip.db
                 syscmds = db.get("syscmdlist",[] )
                 if not syscmds:
                     print textwrap.dedent("""
                     """)
                     ip.magic('rehashx')
                     syscmds = db.get("syscmdlist")
                 # lowcase aliases on win32 only
                 if os.name == 'posix':
                     mapper = lambda s:s
                 else:
                     def mapper(s): return s.lower()
                 for cmd in syscmds:
                     # print "sys",cmd #dbg
                     noext, ext = os.path.splitext(cmd)
                     if ext.lower() == '.exe':
                         cmd = noext
                     key = mapper(cmd)
                     if key not in ip.alias_manager.alias_table:
                         # Dots will be removed from alias names, since ipython
                         # assumes names with dots to be python code
                         ip.define_alias(key.replace('.',''), cmd)
                 # mglob combines 'find', recursion, exclusion... '%mglob?' to learn more
                 ip.load("IPython.external.mglob")
                 # win32 is crippled w/o cygwin, try to help it a little bit
                 if sys.platform == 'win32':
                     if 'cygwin' in os.environ['PATH'].lower():
                         # use the colors of cygwin ls (recommended)
                         ip.define_alias('d', 'ls -F --color=auto')
                     else:
                         # get icp, imv, imkdir, igrep, irm,...
                         ip.load('ipy_fsops')
                         # and the next best thing to real 'ls -F'
                         ip.define_alias('d','dir /w /og /on')
                 ip.set_hook('input_prefilter', slash_prefilter_f)
                 extend_shell_behavior(ip)
             class LastArgFinder:
                 """ Allow $LA to work as "last argument of previous command", like $! in bash
                 To call this in normal IPython code, do LA()
                 """
                 def __call__(self, hist_idx = None):
                         return str(self)
                     return ip.input_hist_raw[hist_idx].strip().split()[-1]
                 def __str__(self):
                     ip = ipapi.get()
                     for cmd in reversed(ip.input_hist_raw):
                         parts = cmd.strip().split()
                         if len(parts) < 2 or parts[-1] in ['$LA', 'LA()']:
             def slash_prefilter_f(self,line):
                 """ ./foo, ~/foo and /bin/foo now run foo as system command
                 Removes the need for doing !./foo, !~/foo or !/bin/foo
                 """
                 from IPython.utils import genutils
                             if command or more:
                                 # push to raw history, so hist line numbers stay in sync
                                 ip.input_hist_raw.append("# " + command + "\n")
                                 more = ip.push_line(ip.prefilter(command,more))
                                 command = ''
                                 # IPython's runsource returns None if there was an error

IPython/deathrow/ipy_profile_zope.py

0 +3 -3

                         query = {}
                         if indexes.get('path'):
                             from string import join
                             path = join(obj.getPhysicalPath(), '/')
                             query.update({'path': path})
                         if indexes.get('getID'):
                             query.update({'getID': obj.id, })
                 ip = ipapi.get()
                 o = ip.options
                 # autocall to "full" mode (smart mode is default, I like full mode)
                 SOFTWARE_HOME = os.environ.get( "SOFTWARE_HOME" )
                 sys.path.append( SOFTWARE_HOME )
                 print "SOFTWARE_HOME=%s\n" % SOFTWARE_HOME
                        app
                        portal
                        utils.{ %s }
                     Uses the $SOFTWARE_HOME and $CONFIG_FILE environment
                     variables.
                     """ % ( ",".join([ x for x in dir(zope_debug.utils) if not x.startswith("_") ] ) ) )

IPython/deathrow/ipy_vimserver.py

0 +4 -4

             """ Integration with gvim, by Erich Heine
             Provides a %vim magic command, and reuses the same vim session. Uses
             unix domain sockets for communication between vim and IPython. ipy.vim is
             available in doc/examples of the IPython distribution.
             Slightly touched up email announcement (and description how to use it) by
             Erich Heine is here:
             Ive recently been playing with ipython, and like it quite a bit. I did
             both to this email (hoping of course that the mailing list allows such
             things).
             There are 2 files:
             ipy_vimserver.py -- this file contains the ipython stuff
             ipy.vim -- this file contains the gvim stuff

IPython/deathrow/numutils.py

0 +10 -10

             inf = infty = Infinity = (array([1])/0.0)[0]
             #****************************************************************************
             # function definitions
             exp_safe_MIN = math.log(2.2250738585072014e-308)
             exp_safe_MAX = 1.7976931348623157e+308
                 Ref: http://mathworld.wolfram.com/VectorNorm.html
                      http://mathworld.wolfram.com/L-Infinity-Norm.html"""
                 if p in ('inf','Infinity'):
                     return max(absolute(a).flat)
                 else:
                     return (sum_flat(absolute(a)**p))**(1.0/p)
             def frange(xini,xfin=None,delta=None,**kw):
                 """frange([start,] stop[, step, keywords]) -> array of floats
                 #defaults
                 kw.setdefault('closed',1)
                 endpoint = kw['closed'] != 0
                 # funny logic to allow the *first* argument to be optional (like range())
                 # This was modified with a simpler version from a similar frange() found
                 # at http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66472
                 if xfin == None:
                     xfin = xini + 0.0
                     xini = 0.0
                 if delta == None:
                     delta = 1.0
                 Since rank defaults to 2, this function behaves in the default case (when
                 only n is given) like the Numeric identity function."""
                 iden = zeros((n,)*rank,typecode=typecode)
                 for i in range(n):
                     idx = (i,)*rank
                 Increase the value of max_length for very large numbers. Note that on
 -bit machines, 2**1023 is the largest integer power of 2 which can be
                 converted to a Python float."""
                 assert number < 2L << max_length
                 shifts = map (operator.rshift, max_length * [number], \
                               range (max_length - 1, -1, -1))
             def log2(x,ln2 = math.log(2.0)):
                 """Return the log(x) in base 2.
                 This is a _slow_ function but which is guaranteed to return the correct
                 integer value if the input is an ineger exact power of 2."""
             def fromfunction_kw(function, dimensions, **kwargs):
                 """Drop-in replacement for fromfunction() from Numerical Python.
                 Allows passing keyword arguments to the desired function.
                 Call it as (keywords are optional):

IPython/deathrow/oldfrontend/asyncfrontendbase.py

0 +12 -12

                 Overrides FrontEndBase to wrap execute in a deferred result.
                 All callbacks are made as callbacks on the deferred result.
                 """
                 implements(IFrontEnd)
                 classProvides(IFrontEndFactory)
                 def __init__(self, engine=None, history=None):
                     assert(engine==None or IEngineCore.providedBy(engine))
                     self.engine = IEngineCore(engine)
                             self.history = FrontEndHistory(input_cache=[''])
                     else:
                         self.history = history
                 def execute(self, block, blockID=None):
                     """Execute the block and return the deferred result.
                     Parameters:
                         block : {str, AST}
                         blockID : any
                             Caller may provide an ID to identify this block.
                             result['blockID'] := blockID
                     Result:
                         Deferred result of self.interpreter.execute
                     """
                     if(not self.is_complete(block)):
                         return Failure(Exception("Block is not compilable"))
                     if(blockID == None):
                         blockID = guid.generate()
                     d = self.engine.execute(block)
                     d.addCallback(self._add_history, block=block)
                     d.addCallbacks(self._add_block_id_for_result,
                             callbackArgs=(blockID,),
                             errbackArgs=(blockID,))
                     d.addBoth(self.update_cell_prompt, blockID=blockID)
                     d.addCallbacks(self.render_result,
                         errback=self.render_error)
                     return d

IPython/deathrow/oldfrontend/cocoa/cocoa_frontend.py

0 +137 -137

             # encoding: utf-8
             # -*- test-case-name: IPython.frontend.cocoa.tests.test_cocoa_frontend -*-
             """PyObjC classes to provide a Cocoa frontend to the
             IPython.kernel.engineservice.IEngineBase.
             To add an IPython interpreter to a cocoa app, instantiate an
             IPythonCocoaController in a XIB and connect its textView outlet to an
             NSTextView instance in your UI. That's it.
                                     NSLog, NSNotificationCenter, NSMakeRange,\
                                     NSLocalizedString, NSIntersectionRange,\
                                     NSString, NSAutoreleasePool
             from AppKit import NSApplicationWillTerminateNotification, NSBeep,\
                                 NSTextView, NSRulerView, NSVerticalRuler
             # Classes to implement the Cocoa frontend
             #-----------------------------------------------------------------------------
             # TODO:
             #   1. use MultiEngineClient and out-of-process engine rather than
             #       ThreadedEngineService?
             #   2. integrate Xgrid launching of engines
             class AutoreleasePoolWrappedThreadedEngineService(ThreadedEngineService):
                 """Wrap all blocks in an NSAutoreleasePool"""
                 def wrapped_execute(self, msg, lines):
                     """wrapped_execute"""
                     try:
                                         self).wrapped_execute(msg, lines)
                     finally:
                         p.drain()
                     return result
             class Cell(NSObject):
                 Representation of the prompts, input and output of a cell in the
                 frontend
                 """
                 blockNumber = objc.ivar().unsigned_long()
                 blockID = objc.ivar()
                 inputBlock = objc.ivar()
                 output = objc.ivar()
             class CellBlock(object):
                 """
                 Storage for information about text ranges relating to a single cell
                 """
                 def __init__(self, inputPromptRange, inputRange=None, outputPromptRange=None,
                             outputRange=None):
                     super(CellBlock, self).__init__()
                     self.inputRange = inputRange
                     self.outputPromptRange = outputPromptRange
                     self.outputRange = outputRange
                 def update_ranges_for_insertion(self, text, textRange):
                     """Update ranges for text insertion at textRange"""
                     for r in [self.inputPromptRange,self.inputRange,
                                 self.outputPromptRange, self.outputRange]:
                         if(r == None):
                                 r.length += len(text) - intersection.length
                             else:
                                 r.length -= intersection.length
                 def update_ranges_for_deletion(self, textRange):
                     """Update ranges for text deletion at textRange"""
                     for r in [self.inputPromptRange,self.inputRange,
                                 self.outputPromptRange, self.outputRange]:
                         if(r==None):
                                 r.length += intersection.length
                             else:
                                 r.length -= intersection.length
                 def __repr__(self):
                     return 'CellBlock('+ str((self.inputPromptRange,
                                             self.inputRange,
                                             self.outputPromptRange,
                                             self.outputRange)) + ')'
             class IPythonCocoaController(NSObject, AsyncFrontEndBase):
                 userNS = objc.ivar() #mirror of engine.user_ns (key=>str(value))
                 waitingForEngine = objc.ivar().bool()
                 textView = objc.IBOutlet()
                 def init(self):
                     self = super(IPythonCocoaController, self).init()
                     AsyncFrontEndBase.__init__(self,
                                 engine=AutoreleasePoolWrappedThreadedEngineService())
                     if(self != None):
                         self._common_init()
                     return self
                 def _common_init(self):
                     """_common_init"""
                     self.userNS = NSMutableDictionary.dictionary()
                     self.waitingForEngine = False
                     self.lines = {}
                     self.tabSpaces = 4
                     self.tabUsesSpaces = True
                     self.currentBlockID = self.next_block_ID()
                     self.blockRanges = {} # blockID=>CellBlock
                 def awakeFromNib(self):
                     """awakeFromNib"""
                     self._common_init()
                     # Start the IPython engine
                     self.engine.startService()
                     NSLog('IPython engine started')
                     # Register for app termination
                     nc = NSNotificationCenter.defaultCenter()
                     nc.addObserver_selector_name_object_(
                                                 'appWillTerminate:',
                                                 NSApplicationWillTerminateNotification,
                                                 None)
                     self.textView.setDelegate_(self)
                     self.textView.enclosingScrollView().setHasVerticalRuler_(True)
                     r = NSRulerView.alloc().initWithScrollView_orientation_(
                     self.verticalRulerView.setClientView_(self.textView)
                     self._start_cli_banner()
                     self.start_new_block()
                 def appWillTerminate_(self, notification):
                     """appWillTerminate"""
                     self.engine.stopService()
                 def complete(self, token):
                     """Complete token in engine's user_ns
                     Parameters
                     ----------
                     token : string
                     Result
                     ------
                     Deferred result of
                     IPython.kernel.engineservice.IEngineBase.complete
                     """
                     return self.engine.complete(token)
                 def execute(self, block, blockID=None):
                     self.waitingForEngine = True
                     self.willChangeValueForKey_('commandHistory')
                                                                     blockID)
                     d.addBoth(self._engine_done)
                     d.addCallback(self._update_user_ns)
                     return d
                 def push_(self, namespace):
                     """Push dictionary of key=>values to python namespace"""
                     self.waitingForEngine = True
                     self.willChangeValueForKey_('commandHistory')
                     d = self.engine.push(namespace)
                     d.addBoth(self._engine_done)
                     d.addCallback(self._update_user_ns)
                 def pull_(self, keys):
                     """Pull keys from python namespace"""
                     self.waitingForEngine = True
                     result = blockingCallFromThread(self.engine.pull, keys)
                     self.waitingForEngine = False
                 @objc.signature('v@:@I')
                 def executeFileAtPath_encoding_(self, path, encoding):
                     """Execute file at path in an empty namespace. Update the engine
                     user_ns with the resulting locals."""
                     lines,err = NSString.stringWithContentsOfFile_encoding_error_(
                         path,
                         encoding,
                         None)
                     self.engine.execute(lines)
                 def _engine_done(self, x):
                     self.waitingForEngine = False
                     self.didChangeValueForKey_('commandHistory')
                     return x
                 def _update_user_ns(self, result):
                     """Update self.userNS from self.engine's namespace"""
                     d = self.engine.keys()
                     d.addCallback(self._get_engine_namespace_values_for_keys)
                     return result
                 def _get_engine_namespace_values_for_keys(self, keys):
                     d = self.engine.pull(keys)
                     d.addCallback(self._store_engine_namespace_values, keys=keys)
                 def _store_engine_namespace_values(self, values, keys=[]):
                     assert(len(values) == len(keys))
                     self.willChangeValueForKey_('userNS')
                     for (k,v) in zip(keys,values):
                         self.userNS[k] = saferepr(v)
                     self.didChangeValueForKey_('userNS')
                 def update_cell_prompt(self, result, blockID=None):
                     print self.blockRanges
                     if(isinstance(result, Failure)):
                         prompt = self.input_prompt()
                     else:
                         prompt = self.input_prompt(number=result['number'])
                     r = self.blockRanges[blockID].inputPromptRange
                     self.insert_text(prompt,
                             textRange=r,
                             scrollToVisible=False
                             )
                     return result
                 def render_result(self, result):
                     blockID = result['blockID']
                     inputRange = self.blockRanges[blockID].inputRange
                     del self.blockRanges[blockID]
                     #print inputRange,self.current_block_range()
                     self.insert_text('\n' +
                             self.output_prompt(number=result['number']) +
                             textRange=NSMakeRange(inputRange.location+inputRange.length,
 ))
                     return result
                 def render_error(self, failure):
                     print failure
                     blockID = failure.blockID
 ))
                     self.start_new_block()
                     return failure
                 def _start_cli_banner(self):
                     """Print banner"""
                     banner = """IPython1 %s -- An enhanced Interactive Python.""" % \
                                 IPython.__version__
                     self.insert_text(banner + '\n\n')
                 def start_new_block(self):
                     """"""
                     self.currentBlockID = self.next_block_ID()
                     self.blockRanges[self.currentBlockID] = self.new_cell_block()
                     self.insert_text(self.input_prompt(),
                         textRange=self.current_block_range().inputPromptRange)
                 def next_block_ID(self):
                     return guid.generate()
                 def new_cell_block(self):
                     """A new CellBlock at the end of self.textView.textStorage()"""
                     return CellBlock(NSMakeRange(self.textView.textStorage().length(),
 ), #len(self.input_prompt())),
                                     NSMakeRange(self.textView.textStorage().length(),# + len(self.input_prompt()),
 ))
                 def current_block_range(self):
                     return self.blockRanges.get(self.currentBlockID,
                                     self.new_cell_block())
                 def current_block(self):
                     """The current block's text"""
                     return self.text_for_range(self.current_block_range().inputRange)
                 def text_for_range(self, textRange):
                     """text_for_range"""
                     ts = self.textView.textStorage()
                     return ts.string().substringWithRange_(textRange)
                 def current_line(self):
                     block = self.text_for_range(self.current_block_range().inputRange)
                     block = block.split('\n')
                     return block[-1]
                 def insert_text(self, string=None, textRange=None, scrollToVisible=True):
                     """Insert text into textView at textRange, updating blockRanges
                     as necessary
                     """
                     if(textRange == None):
                         #range for end of text
                         textRange = NSMakeRange(self.textView.textStorage().length(), 0)
                     self.textView.replaceCharactersInRange_withString_(
                         textRange, string)
                     for r in self.blockRanges.itervalues():
                         r.update_ranges_for_insertion(string, textRange)
                     self.textView.setSelectedRange_(textRange)
                     if(scrollToVisible):
                         self.textView.scrollRangeToVisible_(textRange)
                 def replace_current_block_with_string(self, textView, string):
                     textView.replaceCharactersInRange_withString_(
                                                 self.current_block_range().inputRange,
                     r = NSMakeRange(textView.textStorage().length(), 0)
                     textView.scrollRangeToVisible_(r)
                     textView.setSelectedRange_(r)
                 def current_indent_string(self):
                     """returns string for indent or None if no indent"""
                     return self._indent_for_block(self.current_block())
                 def _indent_for_block(self, block):
                     lines = block.split('\n')
                     if(len(lines) > 1):
                         currentIndent = len(lines[-1]) - len(lines[-1].lstrip())
                         if(currentIndent == 0):
                             currentIndent = self.tabSpaces
                         if(self.tabUsesSpaces):
                             result = ' ' * currentIndent
                         else:
                             result = '\t' * (currentIndent/self.tabSpaces)
                     else:
                         result = None
                     return result
                 # NSTextView delegate methods...
                 def textView_doCommandBySelector_(self, textView, selector):
                     assert(textView == self.textView)
                     NSLog("textView_doCommandBySelector_: "+selector)
                     if(selector == 'insertNewline:'):
                         indent = self.current_indent_string()
                         if(indent):
                             line = indent + self.current_line()
                         else:
                             line = self.current_line()
                         if(self.is_complete(self.current_block())):
                             self.execute(self.current_block(),
                                             blockID=self.currentBlockID)
                             self.start_new_block()
                             return True
                         return False
                     elif(selector == 'moveUp:'):
                         prevBlock = self.get_history_previous(self.current_block())
                         if(prevBlock != None):
                         else:
                             NSBeep()
                         return True
                     elif(selector == 'moveDown:'):
                         nextBlock = self.get_history_next()
                         if(nextBlock != None):
                         else:
                             NSBeep()
                         return True
                     elif(selector == 'moveToBeginningOfParagraph:'):
                         textView.setSelectedRange_(NSMakeRange(
                                         self.current_block_range().inputRange.location,
 ))
                         return True
                     elif(selector == 'moveToEndOfParagraph:'):
                         if(textView.selectedRange().location <= \
                             self.current_block_range().location):
                             raise NotImplemented()
                         return False # don't actually handle the delete
                     elif(selector == 'insertTab:'):
                         if(len(self.current_line().strip()) == 0): #only white space
                             return False
                         else:
                             self.textView.complete_(self)
                             return True
                     elif(selector == 'deleteBackward:'):
                         #if we're at the beginning of the current block, ignore
                         if(textView.selectedRange().location == \
                                 r.update_ranges_for_deletion(deleteRange)
                             return False
                     return False
                 def textView_shouldChangeTextInRanges_replacementStrings_(self,
                     textView, ranges, replacementStrings):
                     """
                     Delegate method for NSTextView.
                     Refuse change text in ranges not at end, but make those changes at
                     end.
                     """
                     assert(len(ranges) == len(replacementStrings))
                     allow = True
                     for r,s in zip(ranges, replacementStrings):
                             r.location < self.current_block_range().inputRange.location):
                             self.insert_text(s)
                             allow = False
                     return allow
                 def textView_completions_forPartialWordRange_indexOfSelectedItem_(self,
                     textView, words, charRange, index):
                     try:
                         ts = textView.textStorage()
                     except:
                         completions = objc.nil
                         NSBeep()
                     return (completions,0)

IPython/deathrow/oldfrontend/cocoa/plugin/setup.py

0 +1 -1

             """
             setup.py
             Setuptools installer script for generating a Cocoa plugin for the
             IPython cocoa frontend
             Author: Barry Wark

IPython/deathrow/oldfrontend/cocoa/tests/test_cocoa_frontend.py

0 +10 -10

             # encoding: utf-8
             """This file contains unittests for the
             IPython.frontend.cocoa.cocoa_frontend module.
             """
             __docformat__ = "restructuredtext en"
             #---------------------------------------------------------------------------
             #       Copyright (C) 2005  The IPython Development Team
+            #
             #  Distributed under the terms of the BSD License.  The full license is in
             #  the file COPYING, distributed as part of this software.
             #---------------------------------------------------------------------------
             #---------------------------------------------------------------------------
             # Imports
             #---------------------------------------------------------------------------
             # Tell nose to skip this module
                     """test that current_indent_string returns current indent or None.
                     Uses _indent_for_block for direct unit testing.
                     """
                     self.controller.tabUsesSpaces = True
                     self.assert_(self.controller._indent_for_block("""a=3""") == None)
                     self.assert_(self.controller._indent_for_block("") == None)
                     block = """def test():\n    a=3"""
                     self.assert_(self.controller._indent_for_block(block) == \
                                 ' ' * self.controller.tabSpaces)
                     block = """if(True):\n%sif(False):\n%spass""" % \
                                 (' '*self.controller.tabSpaces,
 *' '*self.controller.tabSpaces)

IPython/deathrow/oldfrontend/frontendbase.py

0 +99 -99

             # encoding: utf-8
             # -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
             """
             frontendbase provides an interface and base class for GUI frontends for
             IPython.kernel/IPython.kernel.core.
             Frontend implementations will likely want to subclass FrontEndBase.
             Author: Barry Wark
             """
             from IPython.frontend.zopeinterface import (
                 Interface,
                 Attribute,
             )
             from IPython.kernel.core.history import FrontEndHistory
             from IPython.kernel.core.util import Bunch
             class IFrontEndFactory(Interface):
                 """Factory interface for frontends."""
                 def __call__(engine=None, history=None):
                     """
                     Parameters:
                     interpreter : IPython.kernel.engineservice.IEngineCore
                     """
                     pass
             class IFrontEnd(Interface):
                 """Interface for frontends. All methods return t.i.d.Deferred"""
                 Attribute("input_prompt_template", "string.Template instance\
                             substituteable with execute result.")
                 Attribute("output_prompt_template", "string.Template instance\
                             substituteable with execute result.")
                 Attribute("continuation_prompt_template", "string.Template instance\
                             substituteable with execute result.")
                 def update_cell_prompt(result, blockID=None):
                     """Subclass may override to update the input prompt for a block.
                     In asynchronous frontends, this method will be called as a
                     twisted.internet.defer.Deferred's callback/errback.
                     Implementations should thus return result when finished.
                     Result is a result dict in case of success, and a
                     twisted.python.util.failure.Failure in case of an error
                     """
                     pass
                 def render_result(result):
                     """Render the result of an execute call. Implementors may choose the
                      method of rendering.
                     For example, a notebook-style frontend might render a Chaco plot
                     inline.
                     Parameters:
                         result : dict (result of IEngineBase.execute )
                             blockID = result['blockID']
                     Result:
                         Output of frontend rendering
                     """
                     pass
                 def render_error(failure):
                     """Subclasses must override to render the failure.
                     In asynchronous frontend, since this method will be called as a
                     twisted.internet.defer.Deferred's callback. Implementations
                     should thus return result when finished.
                     blockID = failure.blockID
                     """
                     pass
                 def input_prompt(number=''):
                     """Returns the input prompt by subsituting into
                     self.input_prompt_template
                     """
                     pass
                 def output_prompt(number=''):
                     """Returns the output prompt by subsituting into
                     self.output_prompt_template
                     """
                     pass
                 def continuation_prompt():
                     """Returns the continuation prompt by subsituting into
                     self.continuation_prompt_template
                     """
                     pass
                 def is_complete(block):
                     """Returns True if block is complete, False otherwise."""
                     pass
                 def get_history_previous(current_block):
                     """Returns the block previous in  the history. Saves currentBlock if
                     the history_cursor is currently at the end of the input history"""
                     pass
                 def get_history_next():
                     """Returns the next block in the history."""
                     pass
                 def complete(self, line):
                     """Returns the list of possible completions, and the completed
                         line.
             ##############################################################################
             # Base class for all the frontends.
             ##############################################################################
             class FrontEndBase(object):
                 FrontEndBase manages the state tasks for a CLI frontend:
                     - Input and output history management
                     - Input/continuation and output prompt generation
                 Some issues (due to possibly unavailable engine):
                     - How do we get the current cell number for the engine?
                     - How do we handle completions?
                 """
                 history_cursor = 0
                 input_prompt_template = string.Template(rc.prompt_in1)
                 output_prompt_template = string.Template(rc.prompt_out)
                 continuation_prompt_template = string.Template(rc.prompt_in2)
                 def __init__(self, shell=None, history=None):
                     self.shell = shell
                     if history is None:
                             self.history = FrontEndHistory(input_cache=[''])
                     else:
                         self.history = history
                 def input_prompt(self, number=''):
                     """Returns the current input prompt
                     It would be great to use ipython1.core.prompts.Prompt1 here
                     """
                     return self.input_prompt_template.safe_substitute({'number':number})
                 def continuation_prompt(self):
                     """Returns the current continuation prompt"""
                     return self.continuation_prompt_template.safe_substitute()
                 def output_prompt(self, number=''):
                     """Returns the output prompt for result"""
                     return self.output_prompt_template.safe_substitute({'number':number})
                 def is_complete(self, block):
                     """Determine if block is complete.
                     Parameters
                     block : string
                     Result
                     True if block can be sent to the engine without compile errors.
                     False otherwise.
                     """
                     try:
                         is_complete = codeop.compile_command(block.rstrip() + '\n\n',
                                         "<string>", "exec")
                     except:
                         return False
                     lines = block.split('\n')
                     return ((is_complete is not None)
                                 and (len(lines)==1 or str(lines[-1])==''))
                 def execute(self, block, blockID=None):
                     """Execute the block and return the result.
                     Parameters:
                         block : {str, AST}
                         blockID : any
                             Caller may provide an ID to identify this block.
                             result['blockID'] := blockID
                     Result:
                         Deferred result of self.interpreter.execute
                     """
                     if(not self.is_complete(block)):
                         raise Exception("Block is not compilable")
                     if(blockID == None):
                         blockID = guid.generate()
                     try:
                         result = self.shell.execute(block)
                     except Exception,e:
                         result = self._add_block_id_for_result(result, blockID=blockID)
                         result = self.update_cell_prompt(result, blockID=blockID)
                         result = self.render_result(result)
                     return result
                 def _add_block_id_for_result(self, result, blockID):
                     """Add the blockID to result or failure. Unfortunatley, we have to
                     treat failures differently than result dicts.
                     """
                     result['blockID'] = blockID
                     return result
                 def _add_block_id_for_failure(self, failure, blockID):
                     """_add_block_id_for_failure"""
                     failure.blockID = blockID
                     return failure
                 def _add_history(self, result, block=None):
                     """Add block to the history"""
                     assert(block != None)
                     self.history.add_items([block])
                     self.history_cursor += 1
                     return result
                 def get_history_previous(self, current_block):
                     """ Returns previous history string and decrement history cursor.
                     """
                     command = self.history.get_history_item(self.history_cursor - 1)
                     if command is not None:
                         if(self.history_cursor+1 == len(self.history.input_cache)):
                             self.history.input_cache[self.history_cursor] = current_block
                         self.history_cursor -= 1
                     return command
                 def get_history_next(self):
                     """ Returns next history string and increment history cursor.
                     """
                     command = self.history.get_history_item(self.history_cursor+1)
                     if command is not None:
                         self.history_cursor += 1
                     return command
                 ###
                 # Subclasses probably want to override these methods...
                 ###
                 def update_cell_prompt(self, result, blockID=None):
                     """Subclass may override to update the input prompt for a block.
                     This method only really makes sens in asyncrhonous frontend.
                     Since this method will be called as a
                     twisted.internet.defer.Deferred's callback, implementations should
                     return result when finished.
                     """
                     raise NotImplementedError
                 def render_result(self, result):
                     """Subclasses must override to render result.
                     In asynchronous frontends, this method will be called as a
                     twisted.internet.defer.Deferred's callback. Implementations
                     should thus return result when finished.
                     """
                     raise NotImplementedError
                 def render_error(self, failure):
                     """Subclasses must override to render the failure.
                     In asynchronous frontends, this method will be called as a
                     twisted.internet.defer.Deferred's callback. Implementations
                     should thus return result when finished.
                     """
                     raise NotImplementedError

IPython/deathrow/oldfrontend/linefrontendbase.py

0 +24 -24

                 to be the base class behind all the frontend that are line-oriented,
                 rather than block-oriented.
                 """
                 # We need to keep the prompt number, to be able to increment
                 # it when there is an exception.
                 prompt_number = 1
                 # We keep a reference to the last result: it helps testing and
                 # programatic control of the frontend.
                 last_result = dict(number=0)
                 # The last prompt displayed. Useful for continuation prompts.
                 def complete(self, line):
                     """Complete line in engine's user_ns
                     Parameters
                     ----------
                     line : string
                     Returns
                     -------
                     The replacement for the line and the list of possible completions.
                     completions = self.shell.complete(line)
                     complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
                     if completions:
                         prefix = common_prefix(completions)
                         residual = complete_sep.split(line)[:-1]
                         line = line[:-len(residual)] + prefix
                     return line, completions
                 def render_result(self, result):
                     """ Frontend-specific rendering of the result of a calculation
                     if 'stdout' in result and result['stdout']:
                         self.write('\n' + result['stdout'])
                     if 'display' in result and result['display']:
                         self.write("%s%s\n" % (
                                         self.output_prompt_template.substitute(
                                                 number=result['number']),
                                         result['display']['pprint']
                                         ) )
                 def render_error(self, failure):
                     """ Frontend-specific rendering of error.
                     """
                     self.write('\n\n'+str(failure)+'\n\n')
                     return failure
                         # thus want to consider an empty string as a complete
                         # statement.
                         return True
                     elif ( len(self.input_buffer.split('\n'))>2
                                     and not re.findall(r"\n[\t ]*\n[\t ]*$", string)):
                         return False
                     else:
                             # This should probably be done in a different place (like
                             # maybe 'prefilter_input' method? For now, this works.
                             clean_string = string.rstrip('\n')
                             if not clean_string.endswith('\\'): clean_string +='\n\n'
                             is_complete = codeop.compile_command(clean_string,
                                         "<string>", "exec")
                             self.release_output()
                 def complete_current_input(self):
                     """ Do code completion on current line.
                     """
                     if self.debug:
                         print >>sys.__stdout__, "complete_current_input",
                     line = self.input_buffer
                     new_line, completions = self.complete(line)
                     if len(completions)>1:
                     if self.debug:
                         print >>sys.__stdout__, 'line', line
                         print >>sys.__stdout__, 'new_line', new_line
                         print >>sys.__stdout__, completions
                 def get_line_width(self):
                     """
                     if new_line is None:
                         new_line = self.input_buffer
                     self.write('\n')
                     max_len = len(max(possibilities, key=len)) + 1
                     # Now we check how much symbol we can put on a line...
                     chars_per_line = self.get_line_width()
                     symbols_per_line = max(1, chars_per_line/max_len)
                 def new_prompt(self, prompt):
                     """ Prints a prompt and starts a new editing buffer.
                         Subclasses should use this method to make sure that the
                         terminal is put in a state favorable for a new line
                     """Returns the current continuation prompt.
                     """
                     return ("."*(len(self.last_prompt)-2) + ': ')
                 def execute_command(self, command, hidden=False):
                     """ Execute a command, not only in the model, but also in the
                 #--------------------------------------------------------------------------
                 # Private API
                 #--------------------------------------------------------------------------
                 def _on_enter(self, new_line_pos=0):
                     """ Called when the return key is pressed in a line editing
                         buffer.
                         new_line_pos = -new_line_pos
                         lines = current_buffer.split('\n')[:-1]
                         prompt_less_lines = prompt_less_buffer.split('\n')
                         # Create the new line, with the continuation prompt, and the
                         # same amount of indent than the line above it.
                         new_line = self.continuation_prompt() + \
                               self._get_indent_string('\n'.join(
                         else:
                             lines.insert(new_line_pos, new_line)
                         self.input_buffer = '\n'.join(lines)
                 def _get_indent_string(self, string):
                     """ Return the string of whitespace that prefixes a line. Used to
                                         ' '*(indent_chars % 4)
                     return indent_string

IPython/deathrow/oldfrontend/prefilterfrontend.py

0 +16 -16

                 return my_system_call
             #-----------------------------------------------------------------------------
             # Frontend class using ipython0 to do the prefiltering.
             #-----------------------------------------------------------------------------
             class PrefilterFrontEnd(LineFrontEndBase):
                 """
                 debug = False
                 def __init__(self, ipython0=None, *args, **kwargs):
                     """ Parameters
                         ----------
                         __builtin__.raw_input = old_rawinput
                     self.ipython0 = ipython0
                     # Set the pager:
                     self.ipython0.set_hook('show_in_pager',
                                 lambda s, string: self.write("\n" + string))
                     self.ipython0.write = self.write
                     self._ip = _ip = self.ipython0
                     # XXX: Muck around with magics so that they work better
                     # in our environment
                     if not sys.platform.startswith('win'):
                         self.ipython0.magic_ls = mk_system_call(self.system_call,
                                                                             'ls -CF')
                     # And now clean up the mess created by ipython0
                     self.release_output()
                     self.start()
                 #--------------------------------------------------------------------------
                 # FrontEndBase interface
                 #--------------------------------------------------------------------------
                 def show_traceback(self):
                 def save_output_hooks(self):
                     """ Store all the output hooks we can think of, to be able to
                     restore them.
                     We need to do this early, as starting the ipython0 instance will
                     screw ouput hooks.
                     """
                     Term.cerr.write = self.__old_cerr_write
                     sys.stdout = self.__old_stdout
                     sys.stderr = self.__old_stderr
                     pydoc.help.output = self.__old_help_output
                     sys.displayhook = self.__old_display_hook
                 def complete(self, line):
                     key = lambda x: x.replace('_', '')
                     completions.sort(key=key)
                     if completions:
                         prefix = common_prefix(completions)
                         line = line[:-len(word)] + prefix
                     return line, completions
                 #--------------------------------------------------------------------------
                 # LineFrontEndBase interface
                 #--------------------------------------------------------------------------
                 def prefilter_input(self, input_string):
                     # capture it.
                     self.capture_output()
                     self.last_result = dict(number=self.prompt_number)
                     try:
                         try:
                             for line in input_string.split('\n'):
                     return filtered_string
                 #--------------------------------------------------------------------------
                 # PrefilterFrontEnd interface
                 #--------------------------------------------------------------------------
                 def system_call(self, command_string):
                     """ Allows for frontend to define their own system call, to be
                         able capture output and redirect input.
                     # that in the 'pyreadline' module (modes/basemode.py) where we break at
                     # each delimiter and try to complete the residual line, until we get a
                     # successful list of completions.
                     expression = '\s|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})'
                     complete_sep = re.compile(expression)
                     text = complete_sep.split(line)[-1]
                     return text

IPython/deathrow/oldfrontend/process/killableprocess.py

0 +6 -6

             # Addapted from killableprocess.py.
             #______________________________________________________________________________
             #
             # killableprocess - subprocesses which can be reliably killed
                         if startupinfo is None:
                             startupinfo = winprocess.STARTUPINFO()
                         if None not in (p2cread, c2pwrite, errwrite):
                             startupinfo.dwFlags |= winprocess.STARTF_USESTDHANDLES
                             startupinfo.hStdInput = int(p2cread)
                             startupinfo.hStdOutput = int(c2pwrite)
                             startupinfo.hStdError = int(errwrite)
                             args = comspec + " /c " + args
                         # We create a new job for this process, so that we can kill
                         # the process and any sub-processes
                         self._job = winprocess.CreateJobObject()
                         creationflags |= winprocess.CREATE_SUSPENDED
                             creationflags,
                             winprocess.EnvironmentBlock(env),
                             cwd, startupinfo)
                         self._child_created = True
                         self._handle = hp
                         self._thread = ht
                             winprocess.TerminateJobObject(self._job, 127)
                         else:
                             winprocess.TerminateProcess(self._handle, 127)
                         self.returncode = 127
                     else:
                         if group:
                             os.killpg(self.pid, signal.SIGKILL)

IPython/deathrow/oldfrontend/process/pipedprocess.py

0 +5 -5

             # encoding: utf-8
             """
             Object for encapsulating process execution by using callbacks for stdout,
             stderr and stdin.
             """
             __docformat__ = "restructuredtext en"
                     killing it.
                 """
                 def __init__(self, command_string, out_callback,
                                     end_callback=None,):
                     """ command_string: the command line executed to start the
                     process.
                     out_callback: the python callable called on stdout/stderr.
                     self.out_callback = out_callback
                     self.end_callback = end_callback
                     Thread.__init__(self)
                 def run(self):
                     """ Start the process and hook up the callbacks.
                     if self.end_callback is not None:
                         self.end_callback()

IPython/deathrow/oldfrontend/tests/test_asyncfrontendbase.py

0 +24 -24

             """This file contains unittests for the asyncfrontendbase module."""
             #---------------------------------------------------------------------------
             #  Copyright (C) 2008-2009  The IPython Development Team
+            #
             #  Distributed under the terms of the BSD License.  The full license is in
             #  the file COPYING, distributed as part of this software.
             #---------------------------------------------------------------------------
             #---------------------------------------------------------------------------
             # Imports
             #---------------------------------------------------------------------------
             from twisted.trial import unittest
             from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
             from IPython.frontend import frontendbase
             from IPython.kernel.engineservice import EngineService
             from IPython.testing.parametric import Parametric, parametric
             class FrontEndCallbackChecker(AsyncFrontEndBase):
                 """FrontEndBase subclass for checking callbacks"""
                 def __init__(self, engine=None, history=None):
                     super(FrontEndCallbackChecker, self).__init__(engine=engine,
                                                                 history=history)
                     self.updateCalled = False
                     self.renderResultCalled = False
                     self.renderErrorCalled = False
                 def update_cell_prompt(self, result, blockID=None):
                     self.updateCalled = True
                     return result
                 def render_result(self, result):
                     self.renderResultCalled = True
                     return result
                 def render_error(self, failure):
                     self.renderErrorCalled = True
                     return failure
             class TestAsyncFrontendBase(unittest.TestCase):
                 def setUp(self):
                     """Setup the EngineService and FrontEndBase"""
                     self.fb = FrontEndCallbackChecker(engine=EngineService())
                 def test_implements_IFrontEnd(self):
                     self.assert_(frontendbase.IFrontEnd.implementedBy(
                                                 AsyncFrontEndBase))
                 def test_is_complete_returns_False_for_incomplete_block(self):
                     block = """def test(a):"""
                     self.assert_(self.fb.is_complete(block) == False)
                 def test_is_complete_returns_True_for_complete_block(self):
                     block = """def test(a): pass"""
                     self.assert_(self.fb.is_complete(block))
                     block = """a=3"""
                     self.assert_(self.fb.is_complete(block))
                 def test_blockID_added_to_result(self):
                     block = """3+3"""
                     d = self.fb.execute(block, blockID='TEST_ID')
                     d.addCallback(lambda r: self.assert_(r['blockID']=='TEST_ID'))
                     return d
                 def test_blockID_added_to_failure(self):
                     block = "raise Exception()"
                     d = self.fb.execute(block,blockID='TEST_ID')
                     d.addErrback(lambda f: self.assert_(f.blockID=='TEST_ID'))
                     return d
                 def test_callbacks_added_to_execute(self):
                     d = self.fb.execute("10+10")
                     d.addCallback(lambda r: self.assert_(self.fb.updateCalled and self.fb.renderResultCalled))
                     return d
                 def test_error_callback_added_to_execute(self):
                     """Test that render_error called on execution error."""
                     d = self.fb.execute("raise Exception()")
                     d.addErrback(lambda f: self.assert_(self.fb.renderErrorCalled))
                     return d
                 def test_history_returns_expected_block(self):
                     """Make sure history browsing doesn't fail."""
                     blocks = ["a=1","a=2","a=3"]
                     d = self.fb.execute(blocks[0])
                     d.addCallback(lambda _: self.fb.execute(blocks[1]))
                     d.addCallback(lambda _: self.assert_(self.fb.get_history_previous("")==blocks[-3]))
                     d.addCallback(lambda _: self.assert_(self.fb.get_history_next()==blocks[-2]))
                     return d
                 def test_history_returns_none_at_startup(self):
                     self.assert_(self.fb.get_history_previous("")==None)
                     self.assert_(self.fb.get_history_next()==None)

IPython/deathrow/oldfrontend/tests/test_frontendbase.py

0 +2 -2

             # encoding: utf-8
             """
             Test the basic functionality of frontendbase.
             """
             __docformat__ = "restructuredtext en"
             from IPython.frontend.frontendbase import FrontEndBase
             def test_iscomplete():
                 """ Check that is_complete works.
                 """
                 f = FrontEndBase()
                 assert f.is_complete('(a + a)')

IPython/deathrow/oldfrontend/tests/test_linefrontend.py

0 +1 -1

             # encoding: utf-8
             """
             Test the LineFrontEnd
             """
             __docformat__ = "restructuredtext en"

IPython/deathrow/oldfrontend/tests/test_prefilterfrontend.py

0 +5 -5

             #-----------------------------------------------------------------------------
             class TestPrefilterFrontEnd(PrefilterFrontEnd):
                 input_prompt_template = string.Template('')
                 output_prompt_template = string.Template('')
                 banner = ''
                     self.out.truncate()
                 def write(self, string, *args, **kwargs):
                    self.out.write(string)
                 def _on_enter(self):
                     self.input_buffer += '\n'
                 out_value = f.out.getvalue()
                 yield assert_equal, out_value, '1'
             @isolate_ipython0
             def test_magic():
                 """ Test the magic expansion and history.
                     This test is fairly fragile and will break when magics change.
                 """
                 f = TestPrefilterFrontEnd()
                 assert 'traceback' not in f.last_result
                 ## XXX: ipython doctest magic breaks this. I have no clue why
                 #out_value = f.out.getvalue()
                 #assert out_value.split()[-1] == 'foobar'
             @isolate_ipython0

IPython/deathrow/oldfrontend/tests/test_process.py

0 +3 -3

                 """ Checks that we can send characters on stdin to the process.
                 """
                 s = StringIO()
                 p = PipedProcess(sys.executable + ' -c "a = raw_input(); print a"',
                                         out_callback=s.write, )
                 p.start()
                 test_string = '12345\n'
                 """ Check that we can kill a process, and its subprocess.
                 """
                 s = StringIO()
                 p = PipedProcess(sys.executable + ' -c "a = raw_input();"',
                                         out_callback=s.write, )
                 p.start()
                 while not hasattr(p, 'process'):
                     sleep(0.1)
                 p.process.kill()
                 assert p.process.poll() is not None

IPython/deathrow/oldfrontend/wx/console_widget.py

0 +47 -47

             # FIXME: Need to provide an API for non user-generated display on the
             # screen: this should not be editable by the user.
             #-------------------------------------------------------------------------------
             # Constants
             #-------------------------------------------------------------------------------
             _COMPLETE_BUFFER_MARKER = 31
             _ERROR_MARKER = 30
                 # Default scintilla settings
                 'antialiasing'  : True,
                 'carret_color'  : 'BLACK',
                 'background_color' :'WHITE',
                 #prompt definition
                 'prompt_in1'    : \
             # system colors
             #SYS_COLOUR_BACKGROUND = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BACKGROUND)
             # Translation table from ANSI escape sequences to color.
             ANSI_STYLES = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
                            '0;32': [2, 'GREEN'],           '0;33': [3, 'BROWN'],
                            '0;34': [4, 'BLUE'],            '0;35': [5, 'PURPLE'],
                            '0;36': [6, 'CYAN'],            '0;37': [7, 'LIGHT GREY'],
                            '1;30': [8, 'DARK GREY'],       '1;31': [9, 'RED'],
                            '1;32': [10, 'SEA GREEN'],      '1;33': [11, 'YELLOW'],
                            '1;34': [12, 'LIGHT BLUE'],     '1;35':
                                                              [13, 'MEDIUM VIOLET RED'],
                            '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
                             'size' : 10,
                             'size2': 8,
                             }
             #-----------------------------------------------------------------------------
             # The console widget class
                 # Translation table from ANSI escape sequences to color. Override
                 # this to specify your colors.
                 ANSI_STYLES = ANSI_STYLES.copy()
                 # Font faces
                 faces = FACES.copy()
                 # Store the last time a refresh was done
                 _last_refresh_time = 0
                 #--------------------------------------------------------------------------
                 # Public API
                 #--------------------------------------------------------------------------
                 def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
                                     size=wx.DefaultSize, style=wx.WANTS_CHARS, ):
                     editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
                     self.configure_scintilla()
                     # Track if 'enter' key as ever been processed
                     # This variable will only be reallowed until key goes up
                     self.enter_catched = False
                     self.current_prompt_pos = 0
                     self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
                     self.Bind(wx.EVT_KEY_UP, self._on_key_up)
                 def write(self, text, refresh=True):
                     """ Write given text to buffer, while translating the ansi escape
                         sequences.
                     """
                     # XXX: do not put print statements to sys.stdout/sys.stderr in
                     # this method, the print statements will call this method, as
                     # you will end up with an infinit loop
                     title = self.title_pat.split(text)
                     if len(title)>1:
                     except UnicodeDecodeError:
                         # XXX: Do I really want to skip the exception?
                         pass
                     if segments:
                         for ansi_tag, text in zip(segments[::2], segments[1::2]):
                             self.StartStyling(self.GetLength(), 0xFF)
                             else:
                                 style = self.ANSI_STYLES[ansi_tag][0]
                             self.SetStyling(len(text), style)
                     self.GotoPos(self.GetLength())
                     if refresh:
                         current_time = time.time()
                             else:
                                 wx.Yield()
                             #    self.ProcessEvent(wx.PaintEvent())
                             self._last_refresh_time = current_time
                 def new_prompt(self, prompt):
                     """ Prints a prompt at start of line, and move the start of the
                         current block there.
                     # ASCII-less prompt
                     ascii_less = ''.join(self.color_pat.split(self.last_prompt)[2::2])
                     return "."*(len(ascii_less)-2) + ': '
                 def scroll_to_bottom(self):
                     maxrange = self.GetScrollRange(wx.VERTICAL)
                         widget.
                     """
                     p = self.style.copy()
                     # Marker for complete buffer.
                     self.MarkerDefine(_COMPLETE_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
                                             background=p['trace'])
                     self.SetEOLMode(stc.STC_EOL_LF)
                     # Ctrl"+" or Ctrl "-" can be used to zoomin/zoomout the text inside
                     # the widget
                     self.CmdKeyAssign(ord('+'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
                     self.CmdKeyAssign(ord('-'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
                     # Also allow Ctrl Shift "=" for poor non US keyboard users.
                     self.CmdKeyAssign(ord('='), stc.STC_SCMOD_CTRL|stc.STC_SCMOD_SHIFT,
                                                         stc.STC_CMD_ZOOMIN)
                     # Keys: we need to clear some of the keys the that don't play
                     # well with a console.
                     self.CmdKeyClear(ord('D'), stc.STC_SCMOD_CTRL)
                     self.SetIndent(4)
                     self.SetTabWidth(4)
                     # we don't want scintilla's autocompletion to choose
                     # automaticaly out of a single choice list, as we pop it up
                     # automaticaly
                     self.AutoCompSetChooseSingle(False)
                     self.title_pat = re.compile('\x1b]0;(.*?)\x07')
                     # styles
                     self.SetCaretForeground(p['carret_color'])
                     background_color = p['background_color']
                     if 'default' in p:
                         if 'back' not in p['default']:
                             p['default'] += ',back:%s' % background_color
                             p['default'] += ',size:%s' % self.faces['size']
                         if 'face' not in p['default']:
                             p['default'] += ',face:%s' % self.faces['mono']
                         self.StyleSetSpec(stc.STC_STYLE_DEFAULT, p['default'])
                     else:
                         self.StyleSetSpec(stc.STC_STYLE_DEFAULT,
                                         "fore:%s,back:%s,size:%d,face:%s"
                                         % (self.ANSI_STYLES['0;30'][1],
                                            background_color,
                                            self.faces['size'], self.faces['mono']))
                     self.StyleClearAll()
                     # XXX: two lines below are usefull if not using the lexer
                     #for style in self.ANSI_STYLES.values():
                     #    self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
                     # prompt definition
                     self.prompt_in1 = p['prompt_in1']
                         #we add a vertical line to console widget
                         self.SetEdgeMode(stc.STC_EDGE_LINE)
                         self.SetEdgeColumn(edge_column)
                 #--------------------------------------------------------------------------
                 # EditWindow API
                 #--------------------------------------------------------------------------
                 def OnUpdateUI(self, event):
                     """ Override the OnUpdateUI of the EditWindow class, to prevent
                         syntax highlighting both for faster redraw, and for more
                         consistent look and feel.
                     """
                 #--------------------------------------------------------------------------
                 # Private API
                 #--------------------------------------------------------------------------
                 def _on_key_down(self, event, skip=True):
                     """ Key press callback used for correcting behavior for
                         console-like interfaces: the cursor is constraint to be after
                         the last prompt.
                                 if event.ShiftDown():
                                     # Try to force execution
                                     self.GotoPos(self.GetLength())
                                     self.write('\n' + self.continuation_prompt(),
                                                     refresh=False)
                                     self._on_enter()
                                 else:
                             else:
                                 # FIXME: This behavior is not ideal: if the selection
                                 # is already started, it will jump.
                                 self.SetSelectionStart(self.current_prompt_pos)
                                 self.SetSelectionEnd(self.GetCurrentPos())
                                 catched = True
                             # Jump back up
                             self.GotoPos(self.GetLineEndPosition(line_num-1))
                         return True
                     elif ( current_pos > self.GetLineEndPosition(line_num)
                                     and not current_pos == self.GetLength()):
                         # Jump to next line
                         self.GotoPos(current_pos + 1 +
                                                 len(continuation_prompt))
                         return True
                     # We re-allow enter event processing
                     self.enter_catched = False
                     return False

IPython/deathrow/oldfrontend/wx/ipythonx.py

0 +5 -5

                             self._input_state == 'readline':
                         wx.CallAfter(self.ask_exit)
                     else:
                         WxController._on_key_down(self, event, skip=skip)
                 def ask_exit(self):
                     else:
                         wx.CallAfter(wx.GetApp().Exit)
                     self.write('Exiting ...', refresh=False)
                 def do_exit(self):
                     """ Exits the interpreter, kills the windows.
                     self.Show(True)
                     wx.EVT_CLOSE(self, self.on_close)
                 def on_close(self, event):
                     """ Called on closing the windows.
                         Stops the event loop, to close all the child windows.
                     """
                     wx.CallAfter(wx.Exit)

IPython/deathrow/oldfrontend/wx/wx_frontend.py

0 +34 -34

                 This class inherits from ConsoleWidget, that provides a console-like
                 widget to provide a text-rendering widget suitable for a terminal.
                 """
                 # Print debug info on what is happening to the console.
                 debug = False
                 # A flag governing the behavior of the input. Can be:
                 #
                 #       'readline' for readline-like behavior with a prompt
                 #            and an edit buffer.
                 #       'raw_input' similar to readline, but triggered by a raw-input
                 #           call. Can be used by subclasses to act differently.
                 #--------------------------------------------------------------------------
                 # Public API
                 #--------------------------------------------------------------------------
                 def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
                              size=wx.DefaultSize,
                              style=wx.CLIP_CHILDREN|wx.WANTS_CHARS,
                         self.style = styledef
                     ConsoleWidget.__init__(self, parent, id, pos, size, style)
                     PrefilterFrontEnd.__init__(self, **kwds)
                     # Stick in our own raw_input:
                     self.ipython0.raw_input = self.raw_input
                         self.shell.user_ns['self'] = self
                     # Inject our own raw_input in namespace
                     self.shell.user_ns['raw_input'] = self.raw_input
                 def raw_input(self, prompt=''):
                     """ A replacement from python's raw_input.
                     """
                     self.new_prompt(prompt)
                     self._input_state = 'raw_input'
                     if hasattr(self, '_cursor'):
                         del self._cursor
                     self.SetCursor(wx.StockCursor(wx.CURSOR_CROSS))
                     self.__old_on_enter = self._on_enter
                     event_loop = wx.EventLoop()
                         event_loop.Exit()
                     self._on_enter = my_on_enter
                     # XXX: Running a separate event_loop. Ugly.
                     event_loop.Run()
                     self._on_enter = self.__old_on_enter
                     self._input_state = 'buffering'
                     self._cursor = wx.BusyCursor()
                         self._running_process = False
                         event_loop.Exit()
                     self._running_process = PipedProcess(command_string,
                                 out_callback=self.buffered_write,
                                 end_callback = _end_system_call)
                     self._running_process.start()
                     # XXX: Running a separate event_loop. Ugly.
                     event_loop.Run()
                     # Be sure to flush the buffer.
                     self._buffer_flush(event=None)
                     """ Analyse current and displays useful calltip for it.
                     """
                     if self.debug:
                         print >>sys.__stdout__, "do_calltip"
                     separators =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
                     symbol = self.input_buffer
                     symbol_string = separators.split(symbol)[-1]
                 def _popup_completion(self, create=False):
                     """ Updates the popup completion menu if it exists. If create is
                         true, open the menu.
                     """
                     if self.debug:
                         print >>sys.__stdout__, "_popup_completion"
                     line = self.input_buffer
                     if (self.AutoCompActive() and line and not line[-1] == '.') \
                                 or create==True:
                             offset = len(self._get_completion_text(line))
                             self.pop_completion(completions, offset=offset)
                             if self.debug:
                                 print >>sys.__stdout__, completions
                 def buffered_write(self, text):
                     self._out_buffer.append(text)
                     self._out_buffer_lock.release()
                     if not self._buffer_flush_timer.IsRunning():
                         wx.CallAfter(self._buffer_flush_timer.Start,
                                                     milliseconds=100, oneShot=True)
                 #--------------------------------------------------------------------------
                 # LineFrontEnd interface
                 #--------------------------------------------------------------------------
                 def execute(self, python_string, raw_string=None):
                     self._input_state = 'buffering'
                     self.CallTipCancel()
                     # Use a callafter to update the display robustly under windows
                     def callback():
                         self.GotoPos(self.GetLength())
                         PrefilterFrontEnd.execute(self, python_string,
                                                         raw_string=raw_string)
                     wx.CallAfter(callback)
                         return True
                 def save_output_hooks(self):
                     self.__old_raw_input = __builtin__.raw_input
                     PrefilterFrontEnd.save_output_hooks(self)
                     self.SetLexer(stc.STC_LEX_NULL)
                     PrefilterFrontEnd.capture_output(self)
                     __builtin__.raw_input = self.raw_input
                 def release_output(self):
                     __builtin__.raw_input = self.__old_raw_input
                     PrefilterFrontEnd.release_output(self)
                     for i in range(start_line, self.GetCurrentLine()):
                         self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
                 #--------------------------------------------------------------------------
                 # FrontEndBase interface
                 #--------------------------------------------------------------------------
                 def render_error(self, e):
                     start_line = self.GetCurrentLine()
                     self.write('\n' + e + '\n')
                 #--------------------------------------------------------------------------
                 # ConsoleWidget interface
                 #--------------------------------------------------------------------------
                 def new_prompt(self, prompt):
                             # get back to a prompt.
                     elif self._input_state == 'subprocess' and (
                             ( key_code <256 and not event.ControlDown() )
                                 or
                             ( key_code in (ord('d'), ord('D')) and
                               event.ControlDown())):
                         #  We are running a process, we redirect keys.
                         self.do_calltip()
                     elif self.AutoCompActive() and not key_code == ord('\t'):
                         event.Skip()
                         if key_code in (wx.WXK_BACK, wx.WXK_DELETE):
                             wx.CallAfter(self._popup_completion, create=True)
                         elif not key_code in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
                                         wx.WXK_RIGHT, wx.WXK_ESCAPE):
                         # Tab-completion
                         elif key_code == ord('\t'):
                             current_line, current_line_num = self.CurLine
                             if not re.match(r'^%s\s*$' % self.continuation_prompt(),
                                                                         current_line):
                                 self.complete_current_input()
                                 if self.AutoCompActive():
                                 ConsoleWidget._on_key_down(self, event, skip=skip)
                         else:
                             ConsoleWidget._on_key_down(self, event, skip=skip)
                 def _on_key_up(self, event, skip=True):
                         wx.CallAfter(self._popup_completion, create=True)
                     else:
                         ConsoleWidget._on_key_up(self, event, skip=skip)
                     # Make sure the continuation_prompts are always followed by a
                     # whitespace
                     new_lines = []
                     if self._input_state == 'readline':
                     if sys.platform == 'win32':
                         self.input_buffer = self.input_buffer
                     old_prompt_num = self.current_prompt_pos
                     has_executed = PrefilterFrontEnd._on_enter(self,
                                                         new_line_pos=new_line_pos)
                     if old_prompt_num == self.current_prompt_pos:
                         # No execution has happened
                         self.GotoPos(self.GetLineEndPosition(current_line_num + 1))
                     return has_executed
                 #--------------------------------------------------------------------------
                 def OnUpdateUI(self, event):
                     """ Override the OnUpdateUI of the EditWindow class, to prevent
                         syntax highlighting both for faster redraw, and for more
                         consistent look and feel.
                     """
                 #--------------------------------------------------------------------------
                 # Private API
                 #--------------------------------------------------------------------------
                 def _buffer_flush(self, event):
                     """ Called by the timer to flush the write buffer.
                         This is always called in the mainloop, by the wx timer.
                     """
                     self._out_buffer_lock.acquire()

IPython/deathrow/oldfrontend/zopeinterface.py

0 +1 -1

             zope.interface mock. If zope is installed, this module provides a zope
             interface classes, if not it provides mocks for them.
             Classes provided:
             Interface, Attribute, implements, classProvides
             """
             __docformat__ = "restructuredtext en"

IPython/deathrow/tests/test_prefilter.py

0 +25 -25

                 if sys.argv[1] == '-v':
                     sys.argv = sys.argv[:-1]  # IPython is confused by -v, apparently
                     verbose = True
             IPython.Shell.start()
             ip = IPython.ipapi.get()
                 handler func always returns '', which causes ipython to cease handling
                 the string immediately.  That way, that it doesn't echo output, raise
                 exceptions, etc.  But do note that testing multiline strings thus gets
                 a bit hard."""
                 def mock_handler(self, line, continue_prompt=None,
                                  pre=None,iFun=None,theRest=None,
                                  obj=None):
                                   s.ESC_SH_CAP : s.handle_shell_escape,
                                   }
             reset_esc_handlers()
             # This is so I don't have to quote over and over.  Gotta be a better way.
             handle_normal       = 'handle_normal'
             handle_auto         = 'handle_auto'
                 if assertion:
                     if verbose:
                         sys.stdout.write('.')
                         sys.stdout.flush()
                 else:
                     if verbose:
                         sys.stdout.write('F')
                         sys.stdout.flush()
                     failures.append(failure_msg)
             def check_handler(expected_handler, line):
                 """Verify that the expected hander was called (for the given line,
                 passed in for failure reporting).
                 Pulled out to its own function so that tests which don't use
                 run_handler_tests can still take advantage of it."""
                 check(handler_called == expected_handler,
                       "instead %s called" % (expected_handler,
                                              repr(line),
                                              handler_called))
             def run_handler_tests(h_tests):
                 """Loop through a series of (input_line, handler_name) pairs, verifying
                 that, for each ip calls the given handler for the given line.
                 The verbose complaint includes the line passed in, so if that line can
                 include enough info to find the error, the tests are modestly
                 self-documenting.
                 """
                 for ln, expected_handler in h_tests:
                     global handler_called
                     handler_called = None
             def run_one_test(ln, expected_handler):
                 run_handler_tests([(ln, expected_handler)])
             # =========================================
             # Tests
                 ( '%magic',    handle_magic),
                 # XXX Possibly, add test for /,; once those are unhooked from %autocall
                 ( 'emacs_mode # PYTHON-MODE', handle_emacs ),
                 ( ' ',         handle_normal),
                 # Trailing qmark combos.  Odd special cases abound
                 # ! always takes priority!
                 ( '!thing?',      handle_shell_escape),
                 ( '!thing arg?',  handle_shell_escape),
                 ( '!!thing?',     handle_shell_escape),
                 ( '!!thing arg?', handle_shell_escape),
             old_mls = ip.options.multi_line_specials
             for ln in [ '    !ls $f multi_line_specials %s',
                         '    !!ls $f multi_line_specials %s',  # !! escapes work on mls
                         # Trailing ? doesn't trigger help:
                         '    !ls $f multi_line_specials %s ?',
                         '    !!ls $f multi_line_specials %s ?',
                         ]:
                 ip.options.multi_line_specials = 1
             attr_mutator = AttributeMutator()
             ip.to_user_ns('attr_mutator')
             ip.options.autocall = 1
             run_one_test('attr_mutator.foo should mutate', handle_normal)
             check(attr_mutator.called, 'ofind should be called in absence of assign characters')
             for c in list('!=()<>+*/%^&|'):
                 attr_mutator.called = False
                 run_one_test('attr_mutator.foo %s should *not* mutate' % c, handle_normal)
                 run_one_test('attr_mutator.foo%s should *not* mutate' % c, handle_normal)
                 check(not attr_mutator.called,
                       'ofind should not be called near character %s' % c)
                 run_handler_tests([
                     ("alias_cmd",           handle_alias),
                     # XXX See note above
                     #("alias_head.with_dot unshadowed, autocall=%s" % ac_state, handle_alias),
                     ("alias_cmd.something aliases must match whole expr", handle_normal),
                     ("alias_cmd /", handle_alias),
                     ])
             class Autocallable(IPython.ipapi.IPyAutocall):
                 def __call__(self):
                     return "called"
             autocallable = Autocallable()
             ip.to_user_ns('autocallable')
                 ( 'len autocall_0',     handle_normal),
                 ( 'thing autocall_0',   handle_normal),
                 ( 'autocallable',       handle_auto),
                 # With explicit escapes, callable and non-callables both get expanded,
                 # regardless of the %autocall setting:
                 ( '/len autocall_0',    handle_auto),
                 ( ',len autocall_0 b0', handle_auto),
                 ( ';len autocall_0 b0', handle_auto),
                 ( '/thing autocall_0',    handle_auto),
                 ( ',thing autocall_0 b0', handle_auto),
                 ( ';thing autocall_0 b0', handle_auto),
             # Now, with autocall in default, 'smart' mode
             ip.options.autocall = 1
             run_handler_tests( [
                 # Autocalls without escapes -- only expand if it's callable
                 ( 'len a1',       handle_auto),
                 bin_tests.append((';len %s binop_autocall' % b, handle_auto))
                 bin_tests.append((',len %s binop_autocall' % b, handle_auto))
                 bin_tests.append(('/len %s binop_autocall' % b, handle_auto))
             # Who loves auto-generating tests?
             run_handler_tests(bin_tests)
             # ============
             num_f = len(failures)
             if verbose:
                 print
             print "%s tests run, %s failure%s" % (num_tests,
                                                   num_f,
                                                   num_f != 1 and "s" or "")

IPython/deathrow/twshell.py

0 +26 -26

             from twisted.internet import reactor, threads
             from IPython.core.ipmaker import make_IPython
             from IPython.core.iplib import InteractiveShell
             from IPython.utils.ipstruct import Struct
             import Queue,thread,threading,signal
             from signal import signal, SIGINT
                         return getattr(orig_reactor, name)
                     def __setattr__(self, name, value):
                         return setattr(orig_reactor, name, value)
                 internet.reactor = DummyReactor()
                 return orig_reactor
                 def __init__(self,name,usage=None,rc=Struct(opts=None,args=None),
                              user_ns=None,user_global_ns=None,banner2='',**kw):
                     """Similar to the normal InteractiveShell, but with threading control"""
                     InteractiveShell.__init__(self,name,usage,rc,user_ns,
                                               user_global_ns,banner2)
                     # A queue to hold the code to be executed.
                     self.code_queue = Queue.Queue()
                     # Stuff to do at closing time
                     self.worker_ident = None
                     self.reactor_started = False
                     self.first_run = True
                 def runsource(self, source, filename="<input>", symbol="single"):
                     """Compile and run some source in the interpreter.
                     Modified version of code.py's runsource(), to handle threading issues.
                     See the original for full docstring details."""
                     # If Ctrl-C was typed, we reset the flag and return right away
                     if shellglobals.KBINT:
                         shellglobals.KBINT = False
                     if self._kill:
                         # can't queue new code if we are being killed
                         return True
                     try:
                         code = self.compile(source, filename, symbol)
                     except (OverflowError, SyntaxError, ValueError):
                         # Case 2
                         return True
                     # shortcut - if we are in worker thread, or the worker thread is not running,
                     # execute directly (to allow recursion and prevent deadlock if code is run early
                     # in IPython construction)
                     if (not self.reactor_started or (self.worker_ident is None and not self.first_run)
                         or self.worker_ident == thread.get_ident() or shellglobals.run_in_frontend(source)):
                         InteractiveShell.runcode(self,code)
                         return
                     # Case 3
                     # Store code in queue, so the execution thread can handle it.
                     self.first_run = False
                     completed_ev, received_ev = threading.Event(), threading.Event()
                     self.code_queue.put((code,completed_ev, received_ev))
                     reactor.callLater(0.0,self.runcode)
                         print "Warning: Timeout for mainloop thread exceeded"
                         print "switching to nonthreaded mode (until mainloop wakes up again)"
                         self.worker_ident = None
                     else:
                         completed_ev.wait()
                     return False
                 def runcode(self):
                     """Execute a code object.
                     Multithreaded wrapper around IPython's runcode()."""
                     # we are in worker thread, stash out the id for runsource()
                     self.worker_ident = thread.get_ident()
                     if self._kill:
                     code_to_run = None
                     while 1:
                         try:
                             code_to_run, completed_ev, received_ev = self.code_queue.get_nowait()
                         except Queue.Empty:
                             break
                         received_ev.set()
                         # Exceptions need to be raised differently depending on which
                         # thread is active.  This convoluted try/except is only there to
                         # protect against asynchronous exceptions, to ensure that a shellglobals.KBINT
                         finally:
                             shellglobals.CODE_RUN = False
                             # allow runsource() return from wait
                             completed_ev.set()
                     # This MUST return true for gtk threading to work
                     return True
                         while True and not self.quitting:
                             reactorrun_orig()
                     self.reactor.run = reactorrun
                     self.IP = make_IPython(argv, user_ns=user_ns, debug=debug,
                                            shell_class=shell_class,
                                            on_kill=[mainquit])
                     reactor.callWhenRunning(spawnMainloopThread)
                     self.IP.reactor_started = True
                     self.reactor.run()
                     print "mainloop ending...."
             exists = True

IPython/extensions/parallelmagic.py

0 +20 -20

                 def magic_result(self, ipself, parameter_s=''):
                     """Print the result of command i on all engines..
                     To use this a :class:`DirectView` instance must be created
                     and then activated by calling its :meth:`activate` method.
                     Then you can do the following::
                         In [23]: %result
                         Out[23]:
                         <Results List>
                         [0] In [6]: a = 10
                         [1] In [6]: a = 10
                         In [22]: %result 6
                         Out[22]:
                         <Results List>
                         [0] In [6]: a = 10
                         [1] In [6]: a = 10
                 def magic_px(self, ipself, parameter_s=''):
                     """Executes the given python command in parallel.
                     To use this a :class:`DirectView` instance must be created
                     and then activated by calling its :meth:`activate` method.
                     Then you can do the following::
                         In [24]: %px a = 5
                         Parallel execution on engine(s): all
                         Out[24]:
                         <Results List>
                         [0] In [7]: a = 5
                         [1] In [7]: a = 5
                 def magic_autopx(self, ipself, parameter_s=''):
                     """Toggles auto parallel mode.
                     To use this a :class:`DirectView` instance must be created
                     and then activated by calling its :meth:`activate` method. Once this
                     is called, all commands typed at the command line are send to
                     the engines to be executed in parallel. To control which engine
                         self._enable_autopx()
                 def _enable_autopx(self):
                     """Enable %autopx mode by saving the original run_cell and installing
                     pxrun_cell.
                     """
                     if self.active_view is None:
                     self.autopx = True
                     print "%autopx enabled"
                 def _disable_autopx(self):
                     """Disable %autopx by restoring the original InteractiveShell.run_cell.
                     """
                         stdouts = [result.stdout.rstrip()]
                     else:
                         stdouts = [s.rstrip() for s in result.stdout]
                     targets = self.active_view.targets
                     if isinstance(targets, int):
                         targets = [targets]
                 def pxrun_cell(self, raw_cell, store_history=True):
                     """drop-in replacement for InteractiveShell.run_cell.
                     This executes code remotely, instead of in the local namespace.
                     See InteractiveShell.run_cell for details.
                     """
                     if (not raw_cell) or raw_cell.isspace():
                         return
                     ipself = self.shell
                     with ipself.builtin_trap:
                         cell = ipself.prefilter_manager.prefilter_lines(raw_cell)
                         # Store raw and processed history
                         if store_history:
                             ipself.history_manager.store_inputs(ipself.execution_count,
                                                               cell, raw_cell)
                         # ipself.logger.log(cell, raw_cell)
                         cell_name = ipself.compile.cache(cell, ipself.execution_count)
                         try:
                             code_ast = ast.parse(cell, filename=cell_name)
                         except (OverflowError, SyntaxError, ValueError, TypeError, MemoryError):
                         ipself.history_manager.store_output(ipself.execution_count)
                         # Each cell is a *single* input, regardless of how many lines it has
                         ipself.execution_count += 1
                     if re.search(r'get_ipython\(\)\.magic\(u?"%?autopx', cell):
                         self._disable_autopx()
                         return False

IPython/external/Itpl/_Itpl.py

0 +11 -11

             class Itpl:
                 """Class representing a string with interpolation abilities.
                 Upon creation, an instance works out what parts of the format
                 string are literal and what parts need to be evaluated.  The
                 evaluation and substitution happens in the namespace of the
                     The format string is parsed according to the following rules:
 .  A dollar sign and a name, possibly followed by any of:
                           - an open-paren, and anything up to the matching paren
                           - an open-bracket, and anything up to the matching bracket
                           - a period and a name
                         any number of times, is evaluated as a Python expression.
 .  A dollar sign immediately followed by an open-brace, and
                     self.format = format
                     self.codec = codec
                     self.encoding_errors = encoding_errors
                     namechars = "abcdefghijklmnopqrstuvwxyz" \
                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";
                     chunks = []
                     loc, glob = frame.f_locals, frame.f_globals
                     return self._str(glob,loc)
             class ItplNS(Itpl):
                 """Class representing a string with interpolation abilities.
                 efficient, as no traceback needs to be extracte.  It also allows the
                 caller to supply a different namespace for the interpolation to occur than
                 its own."""
                 def __init__(self, format,globals,locals=None,
                              codec='utf_8',encoding_errors='backslashreplace'):
                     """ItplNS(format,globals[,locals]) -> interpolating string instance.
                     self.globals = globals
                     self.locals = locals
                     Itpl.__init__(self,format,codec,encoding_errors)
                 def __str__(self):
                     """Evaluate and substitute the appropriate parts of the string."""
                     return self._str(self.globals,self.locals)
             def filter(file=sys.stdout):
                 """Return an ItplFile that filters writes to the given file object.
                 'file = filter(file)' replaces 'file' with a filtered object that
                 has a write() method.  When called with no argument, this creates
                 a filter to sys.stdout."""
             def unfilter(ifile=None):
                 """Return the original file that corresponds to the given ItplFile.
                 'file = unfilter(file)' undoes the effect of 'file = filter(file)'.
                 'sys.stdout = unfilter()' undoes the effect of 'sys.stdout = filter()'."""
                 return ifile and ifile.file or sys.stdout.file

IPython/external/decorator/_decorator.py

0 +11 -11

             ##   Copyright (c) 2005, Michele Simionato
             ##   All rights reserved.
             ##
             ##   Redistributions of source code must retain the above copyright
             ##   notice, this list of conditions and the following disclaimer.
             ##   Redistributions in bytecode form must reproduce the above copyright
             ##   notice, this list of conditions and the following disclaimer in
             ##   the documentation and/or other materials provided with the
             ##   distribution.
             ##   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
             ##   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
                     "A simple replacement of functools.partial"
                     def __init__(self, func, *args, **kw):
                         self.func = func
                         self.args = args
                         self.keywords = kw
                     def __call__(self, *otherargs, **otherkw):
                         kw = self.keywords.copy()
                         # func can be a class or a callable, but not an instance method
                         self.name = func.__name__
                         if self.name == '<lambda>': # small hack for lambda functions
                             self.name = '_lambda_'
                         self.doc = func.__doc__
                         self.module = func.__module__
                         if inspect.isfunction(func):
                     """
                     if isinstance(obj, str): # "name(signature)"
                         name, rest = obj.strip().split('(', 1)
                         signature = rest[:-1] #strip a right parens
                         func = None
                     else: # a function
                         name = None
                         func = obj
                     fun = cls(func, name, signature, defaults, doc, module)
                     ibody = '\n'.join('    ' + line for line in body.splitlines())
                     return fun.make('def %(name)s(%(signature)s):\n' + ibody,
                                     evaldict, addsource, **attrs)
             def decorator(caller, func=None):
                 """
                 decorator(caller) converts a caller function into a decorator;
                     # otherwise assume caller is a function
                     f = inspect.getargspec(caller)[0][0] # first arg
                     return FunctionMaker.create(
                         '%s(%s)' % (caller.__name__, f),
                         'return decorator(_call_, %s)' % f,
                         dict(_call_=caller, decorator=decorator), undecorated=caller,
                         doc=caller.__doc__, module=caller.__module__)
                 - doc (the docstring : str)
                 - module (the module name : str)
                 - dict (the function __dict__ : str)
                 >>> def f(self, x=1, y=2, *args, **kw): pass
                 >>> info = getinfo(f)
                 'f'
                 >>> info["argnames"]
                 ['self', 'x', 'y', 'args', 'kw']
                 >>> info["defaults"]
                 (1, 2)
             def new_wrapper(wrapper, model):
                 """
                 An improvement over functools.update_wrapper. The wrapper is a generic
                 callable object. It works by generating a copy of the wrapper with the
                 right signature and by updating the copy, not the original.
                 Moreovoer, 'model' can be a dictionary with keys 'name', 'doc', 'module',
                 'dict', 'defaults'.

IPython/external/decorators/_decorators.py

0 +3 -3

                     def get_msg(func,msg=None):
                         """Skip message with information about function being skipped."""
                         if msg is None:
                             out = 'Test skipped due to test condition'
                         else:
                             out = '\n'+msg
                         return "Skipping test: %s%s" % (func.__name__,out)
                         skipper = skipper_gen
                     else:
                         skipper = skipper_func
                     return nose.tools.make_decorator(f)(skipper)
                 return skip_decorator

IPython/external/guid/_guid.py

0 +28 -28

             #
             # Copyright (c) 2006 Conan C. Albrecht
             #
             # Permission is hereby granted, free of charge, to any person obtaining a copy
             # of this software and associated documentation files (the "Software"), to deal
             # in the Software without restriction, including without limitation the rights
             # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
             # copies of the Software, and to permit persons to whom the Software is furnished
             # to do so, subject to the following conditions:
             #
             # The above copyright notice and this permission notice shall be included in all
             # copies or substantial portions of the Software.
             #
             # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
             # INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
             # PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
             # FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
             # OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
             # DEALINGS IN THE SOFTWARE.
             ##################################################################################################
             ###   A globally-unique identifier made up of time and ip and 8 digits for a counter:
             ###   each GUID is 40 characters wide
             ###
             ###   A globally unique identifier that combines ip, time, and a counter.  Since the
             ###   time is listed first, you can sort records by guid.  You can also extract the time
             ###   and ip if needed.
             ###
             ###   Since the counter has eight hex characters, you can create up to
             ###   0xffffffff (4294967295) GUIDs every millisecond.  If your processor
             ###   is somehow fast enough to create more than that in a millisecond (looking
             ###   toward the future, of course), the function will wait until the next
             ###   millisecond to return.
             ###
             ###   GUIDs make wonderful database keys.  They require no access to the
             ###   database (to get the max index number), they are extremely unique, and they sort
             ###   automatically by time.   GUIDs prevent key clashes when merging
             ###   two databases together, combining data, or generating keys in distributed
             ###   systems.
             # December 2, 2003   Fixed duplicating GUIDs.  Sometimes they duplicate if multiples are created
             #                    in the same millisecond (it checks the last 100 GUIDs now and has a larger random part)
             # December 9, 2003   Fixed MAX_RANDOM, which was going over sys.maxint
             # June 12, 2004      Allowed a custom IP address to be sent in rather than always using the
             #                    local IP address.
             # November 4, 2005   Changed the random part to a counter variable.  Now GUIDs are totally
             #                    unique and more efficient, as long as they are created by only
             #                    on runtime on a given machine.  The counter part is after the time
             #                    part so it sorts correctly.
             #Makes a hex IP from a decimal dot-separated ip (eg: 127.0.0.1)
             make_hexip = lambda ip: ''.join(["%04x" % long(i) for i in ip.split('.')]) # leave space for ip v6 (65K in each sub)
             MAX_COUNTER = 0xfffffffe
             counter = 0L
             firstcounter = MAX_COUNTER
                 ip += '.' + str(rand.randrange(1, 0xffff))  # might as well use IPv6 range if we're making it up
               hexip = make_hexip(ip)
             #################################
             ###   Public module functions
                 # do we need to wait for the next millisecond (are we out of counters?)
                 now = long(time.time() * 1000)
                 while lasttime == now and counter == firstcounter:
                   time.sleep(.01)
                   now = long(time.time() * 1000)
                 if counter > MAX_COUNTER:
                   counter = 0
                 lasttime = now
                 parts.append("%08x" % (counter))
                 # ip part
                 parts.append(hexip)
                 return ''.join(parts)
               finally:
                 lock.release()
             def extract_time(guid):
               '''Extracts the time portion out of the guid and returns the
                  number of seconds since the epoch as a float'''
               return float(long(guid[0:16], 16)) / 1000.0

IPython/external/mglob/_mglob.py

0 +38 -38

             r""" mglob - enhanced file list expansion module
             Use as stand-alone utility (for xargs, `backticks` etc.),
             or a globbing library for own python programs. Globbing the sys.argv is something
             that almost every Windows script has to perform manually, and this module is here
             to help with that task. Also Unix users will benefit from enhanced modes
             such as recursion, exclusion, directory omission...
             Unlike glob.glob, directories are not included in the glob unless specified
             with 'dir:'
             'expand' is the function to use in python programs. Typical use
             to expand argv (esp. in windows)::
                 try:
                     import mglob
                     files = mglob.expand(sys.argv[1:])
                 except ImportError:
                     print "mglob not found; try 'easy_install mglob' for extra features"
                     files = sys.argv[1:]
             Note that for unix, shell expands *normal* wildcards (*.cpp, etc.) in argv.
             Therefore, you might want to use quotes with normal wildcards to prevent this
             expansion, in order for mglob to see the wildcards and get the wanted behaviour.
             Not quoting the wildcards is harmless and typically has equivalent results, though.
             globsyntax = """\
                 This program allows specifying filenames with "mglob" mechanism.
                 Supported syntax in globs (wilcard matching patterns)::
                  *.cpp ?ellowo*
                      - obvious. Differs from normal glob in that dirs are not included.
                        Unix users might want to write this as: "*.cpp" "?ellowo*"
                  rec:/usr/share=*.txt,*.doc
                      - get all *.txt and *.doc under /usr/share,
                        recursively
                  rec:/usr/share
                      - All files under /usr/share, recursively
                  rec:*.py
                      - All .py files under current working dir, recursively
                  foo
                      - File or dir foo
                  !*.bak readme*
                      - readme*, exclude files ending with .bak
                  !.svn/ !.hg/ !*_Data/ rec:.
                      - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
                        Trailing / is the key, \ does not work! Use !.*/ for all hidden.
                  dir:foo
                      - the directory foo if it exists (not files in foo)
                  dir:*
                      - all directories in current folder
                  foo.py bar.* !h* rec:*.py
                      - Obvious. !h* exclusion only applies for rec:*.py.
             import os,glob,fnmatch,sys,re
             def expand(flist,exp_dirs = False):
                 """ Expand the glob(s) in flist.
                 flist may be either a whitespace-separated list of globs/files
                 or an array of globs/files.
                 if exp_dirs is true, directory names in glob are expanded to the files
                 contained in them - otherwise, directory names are returned as is.
                 """
                 if isinstance(flist, basestring):
                     import shlex
                 denied_set = set()
                 cont_set = set()
                 cur_rejected_dirs = set()
                 def recfind(p, pats = ["*"]):
                     denied_dirs = [os.path.dirname(d) for d in denied_set if d.endswith("/")]
                     for (dp,dnames,fnames) in os.walk(p):
                                 break
                         if deny:
                             continue
                         #print "dp",dp
                         bname = os.path.basename(dp)
                         if deny:
                             continue
                         for f in fnames:
                             matched = False
                             for p in pats:
                                     matched = True
                                     break
                             if matched:
                                 yield os.path.join(dp,f)
                 def once_filter(seq):
                     for it in seq:
                                 if not re.search(pat,cont, re.IGNORECASE):
                                     deny = True
                                     break
                         if not deny:
                             yield it
                     return
                 res = []
                 for ent in flist:
                     ent = os.path.expanduser(os.path.expandvars(ent))
                     if ent.lower().startswith('rec:'):
                         fields = ent[4:].split('=')
                         if len(fields) == 2:
                             pth, patlist = fields
                         elif len(fields) == 1:
                             if os.path.isdir(fields[0]):
                                 # single arg is dir
                                 pth, patlist = fields[0], '*'
                             else:
                                 # single arg is pattern
                                 pth, patlist = '.', fields[0]
                         elif len(fields) == 0:
                             pth, pathlist = '.','*'
                         pats = patlist.split(',')
                         res.extend(once_filter(recfind(pth, pats)))
                     # filelist
                     # get all files in the specified dir
                     elif os.path.isdir(ent) and exp_dirs:
                         res.extend(once_filter(filter(os.path.isfile,glob.glob(ent + os.sep+"*"))))
                     # glob only files
                     elif '*' in ent or '?' in ent:
                     else:
                         res.extend(once_filter([ent]))
                 return res
             def test():
                 assert (
                     expand("*.py ~/.ipython/*.py rec:/usr/share/doc-base") ==
                     expand( ['*.py', '~/.ipython/*.py', 'rec:/usr/share/doc-base'] )
                     )
             def main():
                 if len(sys.argv) < 2:
                     print globsyntax
                     return
                 print "\n".join(expand(sys.argv[1:])),
             def mglob_f(self, arg):
             def init_ipython(ip):
                 """ register %mglob for IPython """
                 mglob_f.__doc__ = globsyntax
                 ip.define_magic("mglob",mglob_f)
             # test()
             if __name__ == "__main__":
                 main()

IPython/external/pyparsing/_pyparsing.py

0 +10 -10

             'htmlComment', 'javaStyleComment', 'keepOriginalText', 'line', 'lineEnd', 'lineStart', 'lineno',
             'makeHTMLTags', 'makeXMLTags', 'matchOnlyAtCol', 'matchPreviousExpr', 'matchPreviousLiteral',
             'nestedExpr', 'nullDebugAction', 'nums', 'oneOf', 'opAssoc', 'operatorPrecedence', 'printables',
             'punc8bit', 'pythonStyleComment', 'quotedString', 'removeQuotes', 'replaceHTMLEntity',
             'replaceWith', 'restOfLine', 'sglQuotedString', 'srange', 'stringEnd',
             'stringStart', 'traceParseAction', 'unicodeString', 'upcaseTokens', 'withAttribute',
             'indentedBlock', 'originalTextFor',
                             self[k] = v
                             if isinstance(v[0],ParseResults):
                                 v[0].__parent = wkref(self)
                     self.__toklist += other.__toklist
                     self.__accumNames.update( other.__accumNames )
                     del other
                    restore the parsed fields of an HTML start tag into the raw tag text itself, or to
                    revert separate tokens with intervening whitespace back to the original matching
                    input text. Simpler to use than the parse action keepOriginalText, and does not
                    require the inspect module to chase up the call stack.  By default, returns a
                    string containing the original parsed text.
                    If the optional asString argument is passed as False, then the return value is a
                    ParseResults containing any results names that were originally matched, and a
                    single token containing the original matched text from the input string.  So if
                    the expression passed to originalTextFor contains expressions with defined
                    results names, you must set asString to False if you want to preserve those
                    results name values."""
                         del t["_original_end"]
                 matchExpr.setParseAction(extractText)
                 return matchExpr
             # convenience constants for positional expressions
             empty       = Empty().setName("empty")
             lineStart   = LineStart().setName("lineStart")
                                             ).setParseAction(lambda t:t[0].strip()))
                         else:
                             if ignoreExpr is not None:
                                 content = (Combine(OneOrMore(~ignoreExpr +
                                                 ~Literal(opener) + ~Literal(closer) +
                                                 CharsNotIn(ParserElement.DEFAULT_WHITE_CHARS,exact=1))
                                             ).setParseAction(lambda t:t[0].strip()))

IPython/external/qt.py

0 +2 -2

                         QT_API = QT_API_PYQT
                     except ImportError:
                         raise ImportError('Cannot import PySide >= 1.0.3 or PyQt4 >= 4.7')
             elif QT_API == QT_API_PYQT:
                 # Note: This must be called *before* PyQt4 is imported.
                 prepare_pyqt4()
                 from PySide import QtCore, QtGui, QtSvg
             else:
                 raise RuntimeError('Invalid Qt API %r, valid values are: %r or %r' %
                                    (QT_API, QT_API_PYQT, QT_API_PYSIDE))

IPython/external/ssh/tunnel.py

0 +31 -31

                 """Attempt to make an ssh connection without a password.
                 This is mainly used for requiring password input only once
                 when many tunnels may be connected to the same server.
                 If paramiko is None, the default for the platform is chosen.
                 """
                 if paramiko is None:
             def tunnel_connection(socket, addr, server, keyfile=None, password=None, paramiko=None, timeout=60):
                 """Connect a socket to an address via an ssh tunnel.
                 This is a wrapper for socket.connect(addr), when addr is not accessible
                 from the local machine.  It simply creates an ssh tunnel using the remaining args,
                 and calls socket.connect('tcp://localhost:lport') where lport is the randomly
                 selected local port of the tunnel.
                 """
                 new_url, tunnel = open_tunnel(addr, server, keyfile=keyfile, password=password, paramiko=paramiko, timeout=timeout)
                 socket.connect(new_url)
             def open_tunnel(addr, server, keyfile=None, password=None, paramiko=None, timeout=60):
                 """Open a tunneled connection from a 0MQ url.
                 For use inside tunnel_connection.
                 Returns
                 -------
                 (url, tunnel): The 0MQ url that has been forwarded, and the tunnel object
                 """
                 lport = select_random_ports(1)[0]
                 transport, addr = addr.split('://')
                 ip,rport = addr.split(':')
                     tunnelf = paramiko_tunnel
                 else:
                     tunnelf = openssh_tunnel
                 tunnel = tunnelf(lport, rport, server, remoteip=ip, keyfile=keyfile, password=password, timeout=timeout)
                 return 'tcp://127.0.0.1:%i'%lport, tunnel
                 on this machine to localhost:rport on server.  The tunnel
                 will automatically close when not in use, remaining open
                 for a minimum of timeout seconds for an initial connection.
                 This creates a tunnel redirecting `localhost:lport` to `remoteip:rport`,
                 as seen from `server`.
                 keyfile and password may be specified, but ssh config is checked for defaults.
                 Parameters
                 ----------
                     lport : int
                         local port for connecting to the tunnel from this machine.
                     rport : int
                         The remote ip, specifying the destination of the tunnel.
                         Default is localhost, which means that the tunnel would redirect
                         localhost:lport on this machine to localhost:rport on the *server*.
                     keyfile : str; path to public key file
                         This specifies a key to be used in ssh login, default None.
                         Regular default ssh keys will be used without specifying this argument.
                     password : str;
                         Your ssh password to the ssh server. Note that if this is left None,
                         you will be prompted for it if passwordless key based login is unavailable.
                     timeout : int [default: 60]
                     raise ImportError("pexpect unavailable, use paramiko_tunnel")
                 ssh="ssh "
                 if keyfile:
                     ssh += "-i " + keyfile
                 cmd = ssh + " -f -L 127.0.0.1:%i:%s:%i %s sleep %i"%(lport, remoteip, rport, server, timeout)
                 tunnel = pexpect.spawn(cmd)
                 failed = False
                             password = getpass("%s's password: "%(server))
                         tunnel.sendline(password)
                         failed = True
             def _split_server(server):
                 if '@' in server:
                     username,server = server.split('@', 1)
             def paramiko_tunnel(lport, rport, server, remoteip='127.0.0.1', keyfile=None, password=None, timeout=60):
                 """launch a tunner with paramiko in a subprocess. This should only be used
                 when shell ssh is unavailable (e.g. Windows).
                 This creates a tunnel redirecting `localhost:lport` to `remoteip:rport`,
                 as seen from `server`.
                 If you are familiar with ssh tunnels, this creates the tunnel:
                 ssh server -L localhost:lport:remoteip:rport
                 keyfile and password may be specified, but ssh config is checked for defaults.
                 Parameters
                 ----------
                     lport : int
                         local port for connecting to the tunnel from this machine.
                     rport : int
                         The remote ip, specifying the destination of the tunnel.
                         Default is localhost, which means that the tunnel would redirect
                         localhost:lport on this machine to localhost:rport on the *server*.
                     keyfile : str; path to public key file
                         This specifies a key to be used in ssh login, default None.
                         Regular default ssh keys will be used without specifying this argument.
                     password : str;
                         Your ssh password to the ssh server. Note that if this is left None,
                         you will be prompted for it if passwordless key based login is unavailable.
                     timeout : int [default: 60]
                         The time (in seconds) after which no activity will result in the tunnel
                         closing.  This prevents orphaned tunnels from running forever.
                 """
                 if paramiko is None:
                     raise ImportError("Paramiko not available")
                 if password is None:
                     if not _try_passwordless_paramiko(server, keyfile):
                         password = getpass("%s's password: "%(server))
                 p = Process(target=_paramiko_tunnel,
                         args=(lport, rport, server, remoteip),
                         kwargs=dict(keyfile=keyfile, password=password))
                 p.daemon=False
                 p.start()
                 atexit.register(_shutdown_process, p)
                 return p
             def _shutdown_process(p):
                 if p.isalive():
                     p.terminate()
             else:
                 ssh_tunnel = openssh_tunnel
             __all__ = ['tunnel_connection', 'ssh_tunnel', 'openssh_tunnel', 'paramiko_tunnel', 'try_passwordless_ssh']

IPython/frontend/html/notebook/handlers.py

0 +9 -9

                         if not self.application.password:
                             user_id = 'anonymous'
                     return user_id
             class NBBrowserHandler(AuthenticatedHandler):
                 @web.authenticated
                     self.session = Session()
                     self.save_on_message = self.on_message
                     self.on_message = self.on_first_message
                 def get_current_user(self):
                     user_id = self.get_secure_cookie("user")
                     if user_id == '' or (user_id is None and not self.application.password):
                         user_id = 'anonymous'
                     return user_id
                 def _inject_cookie_message(self, msg):
                     """Inject the first message, which is the document cookie,
                     for authentication."""
                         self._cookies = Cookie.SimpleCookie(msg)
                     except:
                         logging.warn("couldn't parse cookie string: %s",msg, exc_info=True)
                 def on_first_message(self, msg):
                     self._inject_cookie_message(msg)
                     if self.get_current_user() is None:
                         logging.warn("Couldn't authenticate WebSocket connection")
                         raise web.HTTPError(403)
                     self.on_message = self.save_on_message
             class IOPubHandler(AuthenticatedZMQStreamHandler):
                     self._beating = False
                     self.iopub_stream = None
                     self.hb_stream = None
                 def on_first_message(self, msg):
                     try:
                         super(IOPubHandler, self).on_first_message(msg)
                     else:
                         self.iopub_stream.on_recv(self._on_zmq_reply)
                         self.start_hb(self.kernel_died)
                 def on_message(self, msg):
                     pass
                 def on_close(self):
                     # This method can be called twice, once by self.kernel_died and once
                     # from the WebSocket close event. If the WebSocket connection is
                     # closed before the ZMQ streams are setup, they could be None.
                     self.stop_hb()
                         self.iopub_stream.close()
                     if self.hb_stream is not None and not self.hb_stream.closed():
                         self.hb_stream.close()
                 def start_hb(self, callback):
                     """Start the heartbeating and call the callback if the kernel dies."""
                     if not self._beating:

IPython/frontend/qt/base_frontend_mixin.py

0 +5 -5

                 #---------------------------------------------------------------------------
                 # 'BaseFrontendMixin' concrete interface
                 #---------------------------------------------------------------------------
                 def _get_kernel_manager(self):
                     """ Returns the current kernel manager.
                     """
                         old_manager.stdin_channel.message_received.disconnect(self._dispatch)
                         old_manager.hb_channel.kernel_died.disconnect(
                             self._handle_kernel_died)
                         # Handle the case where the old kernel manager is still listening.
                         if old_manager.channels_running:
                             self._stopped_channels()
                     since_last_heartbeat : float
                         The time since the heartbeat was last received.
                     """
                 def _started_channels(self):
                     """ Called when the KernelManager channels have started listening or
                         when the frontend is assigned an already listening KernelManager.
                     """
                 #---------------------------------------------------------------------------
                 def _dispatch(self, msg):
                     """ Calls the frontend handler associated with the message type of the
                         given message.
                     """
                     msg_type = msg['header']['msg_type']

IPython/frontend/qt/console/ansi_code_processor.py

0 +8 -8

                     ----------
                     command : str
                         The code identifier, i.e. the final character in the sequence.
                     params : sequence of integers, optional
                         The parameter codes for the command.
                     """
                 def set_osc_code(self, params):
                     """ Set attributes based on OSC (Operating System Command) parameters.
                     Parameters
                     ----------
                     params : sequence of str
                             self.color_map[color] = self._parse_xterm_color_spec(spec)
                         except (IndexError, ValueError):
                             pass
                 def set_sgr_code(self, params):
                     """ Set attributes based on SGR (Select Graphic Rendition) codes.
                         self.underline = False
                     elif code >= 30 and code <= 37:
                         self.foreground_color = code - 30
                     elif code == 38 and params and params.pop(0) == 5:
                         # xterm-specific: 256 color support.
                         if params:
                             self.foreground_color = params.pop(0)
                     if spec.startswith('rgb:'):
                         return tuple(map(lambda x: int(x, 16), spec[4:].split('/')))
                     elif spec.startswith('rgbi:'):
                         return tuple(map(lambda x: int(float(x) * 255),
                                          spec[5:].split('/')))
                     elif spec == '?':
                         raise ValueError('Unsupported xterm color spec')
                     if special == '\f':
                         self.actions.append(ScrollAction('scroll', 'down', 'page', 1))
                     return ''
             class QtAnsiCodeProcessor(AnsiCodeProcessor):
                 """ Translates ANSI escape codes into QTextCharFormats.
                         return QtGui.QColor(*constructor)
                     return None
                 def get_format(self):
                     """ Returns a QTextCharFormat that encodes the current style attributes.
                     """
                     self.default_color_map = self.darkbg_color_map.copy()
                     if color.value() >= 127:
                         # Colors appropriate for a terminal with a light background. For
                         # now, only use non-bright colors...
                         for i in xrange(8):
                             self.default_color_map[i + 8] = self.default_color_map[i]

IPython/frontend/qt/console/bracket_matcher.py

0 +2 -2

                 """ Matches square brackets, braces, and parentheses based on cursor
                     position.
                 """
                 # Protected class variables.
                 _opening_map = { '(':')', '{':'}', '[':']' }
                 _closing_map = { ')':'(', '}':'{', ']':'[' }
                     selection = QtGui.QTextEdit.ExtraSelection()
                     cursor = self._text_edit.textCursor()
                     cursor.setPosition(position)
                     cursor.movePosition(QtGui.QTextCursor.NextCharacter,
                                         QtGui.QTextCursor.KeepAnchor)
                     selection.cursor = cursor
                     selection.format = self.format

IPython/frontend/qt/console/call_tip_widget.py

0 +4 -4

                             doc = doc[:match.end()] + '\n[Documentation continues...]'
                     else:
                         doc = ''
                     if call_line:
                         doc = '\n\n'.join([call_line, doc])
                     return self.show_tip(doc)
                     document = text_edit.document()
                     cursor = text_edit.textCursor()
                     search_pos = cursor.position() - 1
                     self._start_position, _ = self._find_parenthesis(search_pos,
                                                                      forward=False)
                     if self._start_position == -1:
                         return False
                     # Set the text and resize the widget accordingly.
                     self.setText(tip)
                     self.resize(self.sizeHint())
                     # Locate and show the widget. Place the tip below the current line
                     # unless it would be off the screen. In that case, place it above
                     # the current line.
                     self.move(point)
                     self.show()
                     return True
                 #--------------------------------------------------------------------------
                 # Protected interface
                 #--------------------------------------------------------------------------

IPython/frontend/qt/console/completion_lexer.py

0 +3 -3

             class CompletionLexer(object):
                 """ Uses Pygments and some auxillary information to lex code snippets for
                     symbol contexts.
                 """
                     if reversed_tokens and reversed_tokens[0][1].endswith('\n') and \
                             not string.endswith('\n'):
                         reversed_tokens.pop(0)
                     current_op = ''
                     for token, text in reversed_tokens:
                         self._name_separators = list(name_separators)
                 lexer = property(get_lexer, set_lexer)

IPython/frontend/qt/console/completion_widget.py

0 +6 -6

                         if etype == QtCore.QEvent.KeyPress:
                             key, text = event.key(), event.text()
                             if key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter,
                                        QtCore.Qt.Key_Tab):
                                 self._complete_current()
                                 return True
                             elif key == QtCore.Qt.Key_Escape:
                                 self.hide()
                                 return True
                             elif key in (QtCore.Qt.Key_Up, QtCore.Qt.Key_Down,
                                          QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown,
                                          QtCore.Qt.Key_Home, QtCore.Qt.Key_End):
                                 self.keyPressEvent(event)
                                 return True
                     """
                     cursor = self._text_edit.textCursor()
                     if cursor.position() >= self._start_position:
                         cursor.setPosition(self._start_position,
                                            QtGui.QTextCursor.KeepAnchor)
                     return cursor
                 def _update_current(self):
                     """ Updates the current item based on the current text.
                     """
                     prefix = self._current_text_cursor().selection().toPlainText()
                     if prefix:
                         items = self.findItems(prefix, (QtCore.Qt.MatchStartsWith |
                                                         QtCore.Qt.MatchCaseSensitive))
                         if items:
                             self.setCurrentItem(items[0])

IPython/frontend/qt/console/console_widget.py

0 +43 -43

             #-----------------------------------------------------------------------------
             class ConsoleWidget(LoggingConfigurable, QtGui.QWidget):
                 """ An abstract base class for console-type widgets. This class has
                     functionality for:
                         * Maintaining a prompt and editing region
                         * Providing the traditional Unix-style console keyboard shortcuts
                         * Performing tab completion
                         * Paging text
                         * Handling ANSI escape codes
                     """
                 )
                 # NOTE: this value can only be specified during initialization.
                 paging = Enum(['inside', 'hsplit', 'vsplit', 'custom', 'none'],
                               default_value='inside', config=True,
                     help="""
                     The type of paging to use. Valid values are:
                         'inside' : The widget pages like a traditional terminal.
                         'hsplit' : When paging is requested, the widget is split
                                    horizontally. The top pane contains the console, and the
                         key = event.key()
                         if self._control_key_down(event.modifiers()) and \
                                 key in self._ctrl_down_remap:
                             new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
                                                         self._ctrl_down_remap[key],
                                                         QtCore.Qt.NoModifier)
                             QtGui.qApp.sendEvent(obj, new_event)
                     """ Returns whether text can be cut to the clipboard.
                     """
                     cursor = self._control.textCursor()
                     return (cursor.hasSelection() and
                             self._in_buffer(cursor.anchor()) and
                             self._in_buffer(cursor.position()))
                 def can_paste(self):
                     """ Returns whether text can be pasted from the clipboard.
                     """
                     return False
                 def clear(self, keep_input=True):
                     """ Clear the console.
                     Parameters:
                     -----------
                     input.
                     Parameters:
                     -----------
                     source : str, optional
                         The source to execute. If not specified, the input buffer will be
                             source += '\n'
                     elif not hidden:
                         self.input_buffer = source
                     # Execute the source or show a continuation prompt if it is incomplete.
                     complete = self._is_complete(source, interactive)
                     if hidden:
                             self._execute(source, hidden)
                         else:
                             error = 'Incomplete noninteractive input: "%s"'
                             raise RuntimeError(error % source)
                     else:
                         if complete:
                             self._append_plain_text('\n')
                             # Perform actual execution.
                             self._execute(source, hidden)
                         else:
                             # Do this inside an edit block so continuation prompts are
                             # removed seamlessly via undo/redo.
                             cursor.endEditBlock()
                             # Do not do this inside the edit block. It works as expected
                             # when using a QPlainTextEdit control, but does not have an
                             # effect when using a QTextEdit. I believe this is a Qt bug.
                             self._control.moveCursor(QtGui.QTextCursor.End)
                         if self._get_cursor().blockNumber() < prompt_cursor.blockNumber():
                             self._set_cursor(prompt_cursor)
                         self._set_top_cursor(prompt_cursor)
                 def redo(self):
                     """ Redo the last operation. If there is no operation to redo, nothing
                         happens.
                 def _append_custom(self, insert, input, before_prompt=False):
                     """ A low-level method for appending content to the end of the buffer.
                     If 'before_prompt' is enabled, the content will be inserted before the
                     current prompt, if there is one.
                     """
                         diff = cursor.position() - start_pos
                         self._append_before_prompt_pos += diff
                         self._prompt_pos += diff
                     return result
                 def _append_html(self, html, before_prompt=False):
                     self._cancel_text_completion()
                     if len(items) == 1:
                         cursor.setPosition(self._control.textCursor().position(),
                                            QtGui.QTextCursor.KeepAnchor)
                         cursor.insertText(items[0])
                         if self.gui_completion:
                             cursor.movePosition(QtGui.QTextCursor.Left, n=len(prefix))
                             self._completion_widget.show_items(cursor, items)
                         else:
                             cursor.beginEditBlock()
                             self._append_plain_text('\n')
                     elif key in (QtCore.Qt.Key_Return, QtCore.Qt.Key_Enter):
                         intercepted = True
                         # Special handling when tab completing in text mode.
                         self._cancel_text_completion()
                         if key == QtCore.Qt.Key_B:
                             self._set_cursor(self._get_word_start_cursor(position))
                             intercepted = True
                         elif key == QtCore.Qt.Key_F:
                             self._set_cursor(self._get_word_end_cursor(position))
                             intercepted = True
                         elif key == QtCore.Qt.Key_Greater:
                             self._control.moveCursor(QtGui.QTextCursor.End)
                             intercepted = True
                         elif key == QtCore.Qt.Key_Less:
                             self._control.setTextCursor(self._get_prompt_cursor())
                             intercepted = True
                             anchormode = QtGui.QTextCursor.KeepAnchor
                         else:
                             anchormode = QtGui.QTextCursor.MoveAnchor
                         if key == QtCore.Qt.Key_Escape:
                             self._keyboard_quit()
                             intercepted = True
                             line, col = cursor.blockNumber(), cursor.columnNumber()
                             if line > self._get_prompt_cursor().blockNumber() and \
                                     col == len(self._continuation_prompt):
                                 self._control.moveCursor(QtGui.QTextCursor.PreviousBlock,
                                                          mode=anchormode)
                                 self._control.moveCursor(QtGui.QTextCursor.EndOfBlock,
                                                          mode=anchormode)
                                 intercepted = True
                             # Regular left movement
                             else:
                                 intercepted = not self._in_buffer(position - 1)
                         elif key == QtCore.Qt.Key_Right:
                             original_block_number = cursor.blockNumber()
                             cursor.movePosition(QtGui.QTextCursor.Right,
                                             mode=anchormode)
                             if cursor.blockNumber() != original_block_number:
                                 cursor.movePosition(QtGui.QTextCursor.Right,
                     return intercepted
                 def _event_filter_page_keypress(self, event):
                     """ Filter key events for the paging widget to create console-like
                         interface.
                     """
                     key = event.key()
                         if key == QtCore.Qt.Key_Greater:
                             self._page_control.moveCursor(QtGui.QTextCursor.End)
                             intercepted = True
                         elif key == QtCore.Qt.Key_Less:
                             self._page_control.moveCursor(QtGui.QTextCursor.Start)
                             intercepted = True
                         return True
                     elif key in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return):
                         new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
                                                     QtCore.Qt.Key_PageDown,
                                                     QtCore.Qt.NoModifier)
                         QtGui.qApp.sendEvent(self._page_control, new_event)
                         return True
                     elif key == QtCore.Qt.Key_Backspace:
                         new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress,
                                                     QtCore.Qt.Key_PageUp,
                                                     QtCore.Qt.NoModifier)
                         QtGui.qApp.sendEvent(self._page_control, new_event)
                         return True
                     width = self._control.viewport().width()
                     char_width = QtGui.QFontMetrics(self.font).width(' ')
                     displaywidth = max(10, (width / char_width) - 1)
                     return columnize(items, separator, displaywidth)
                 def _get_block_plain_text(self, block):
                     """
                     cursor = QtGui.QTextCursor(block)
                     cursor.movePosition(QtGui.QTextCursor.StartOfBlock)
                     cursor.movePosition(QtGui.QTextCursor.EndOfBlock,
                                         QtGui.QTextCursor.KeepAnchor)
                     return cursor.selection().toPlainText()
                     """ Convenience method that returns a cursor for the current position.
                     """
                     return self._control.textCursor()
                 def _get_end_cursor(self):
                     """ Convenience method that returns a cursor for the last character.
                     """
                                     self._set_top_cursor(cursor)
                                     cursor.joinPreviousEditBlock()
                                     cursor.deletePreviousChar()
                             format = self._ansi_processor.get_format()
                             cursor.insertText(substring, format)
                     else:
                         self._cancel_text_completion()
                     else:
                         self.input_buffer = ''
                 def _page(self, text, html=False):
                     """ Displays text using the pager if it exceeds the height of the
                     viewport.
                 def _prompt_started(self):
                     """ Called immediately after a new prompt is displayed.
                     """
                     # Temporarily disable the maximum block count to permit undo/redo and
                     # to ensure that the prompt position does not change due to truncation.
                     self._control.document().setMaximumBlockCount(0)
                     self._control.setUndoRedoEnabled(True)
                     self._control.moveCursor(QtGui.QTextCursor.End)
                 def _readline(self, prompt='', callback=None):
                     """ Reads one line of input from the user.
                     Parameters
                     ----------
                     else:
                         self._continuation_prompt = prompt
                         self._continuation_prompt_html = None
                 def _set_cursor(self, cursor):
                     """ Convenience method to set the current cursor.
                     """
                         as plain text, though ANSI color codes will be handled.
                     newline : bool, optional (default True)
                         If set, a new line will be written before showing the prompt if
                         there is not already a newline at the end of the buffer.
                     """
                     # Save the current end position to support _append*(before_prompt=True).
                     cursor = self._get_end_cursor()
                     self._append_before_prompt_pos = cursor.position()
                     # Insert a preliminary newline, if necessary.
                     if newline and cursor.position() > 0:
                         cursor.movePosition(QtGui.QTextCursor.Left,
                                             QtGui.QTextCursor.KeepAnchor)
                         if cursor.selection().toPlainText() != '\n':
                             self._append_plain_text('\n')

IPython/frontend/qt/console/frontend_widget.py

0 +10 -10

                 # Emitted when an exit request has been received from the kernel.
                 exit_requested = QtCore.Signal()
                 # Protected class variables.
                 _CallTipRequest = namedtuple('_CallTipRequest', ['id', 'pos'])
                 _CompletionRequest = namedtuple('_CompletionRequest', ['id', 'pos'])
                 #---------------------------------------------------------------------------
                 # 'object' interface
                 #---------------------------------------------------------------------------
                 def __init__(self, *args, **kw):
                     super(FrontendWidget, self).__init__(*args, **kw)
                     # Connect signal handlers.
                     document = self._control.document()
                     document.contentsChange.connect(self._document_contents_change)
                     # Set flag for whether we are connected via localhost.
                     self._local_kernel = kw.get('local_kernel',
                                                 FrontendWidget._local_kernel)
                 #---------------------------------------------------------------------------
                     self._hidden = hidden
                     if not hidden:
                         self.executing.emit(source)
                 def _prompt_started_hook(self):
                     """ Called immediately after a new prompt is displayed.
                     """
                         # to spaces so that output looks as expected regardless of this
                         # widget's tab width.
                         text = msg['content']['data'].expandtabs(8)
                         self._append_plain_text(text, before_prompt=True)
                         self._control.moveCursor(QtGui.QTextCursor.End)
                                     self.reset()
                 def _started_channels(self):
                     """ Called when the KernelManager channels have started listening or
                         when the frontend is assigned an already listening KernelManager.
                     """
                     self.reset()
                 def reset(self):
                     """ Resets the widget to its initial state. Similar to ``clear``, but
                         also re-writes the banner and aborts execution if necessary.
                     """
                     if self._executing:
                         self._executing = False
                         self._request_info['execute'] = None
                             '.'.join(context),                       # text
                             self._get_input_buffer_cursor_line(),    # line
                             self._get_input_buffer_cursor_column(),  # cursor_pos
                             self.input_buffer)                       # block
                         pos = self._get_cursor().position()
                         info = self._CompletionRequest(msg_id, pos)
                         self._request_info['complete'] = info
                     """
                     if cursor is None:
                         cursor = self._get_cursor()
                     cursor.movePosition(QtGui.QTextCursor.StartOfBlock,
                                         QtGui.QTextCursor.KeepAnchor)
                     text = cursor.selection().toPlainText()
                     return self._completion_lexer.get_context(text)

IPython/frontend/qt/console/history_console_widget.py

0 +10 -10

                 # an edit is made to a multi-line input buffer. To override the lock, use
                 # Shift in conjunction with the standard history cycling keys.
                 history_lock = Bool(False, config=True)
                 #---------------------------------------------------------------------------
                 # 'object' interface
                 #---------------------------------------------------------------------------
                         source, hidden, interactive)
                     if executed and not hidden:
                         # Save the command unless it was an empty string or was identical
                         # to the previous command.
                         history = history.rstrip()
                         if history and (not self._history or self._history[-1] != history):
                         # search.
                         cursor = self._get_prompt_cursor()
                         if self._history_prefix:
                             cursor.movePosition(QtGui.QTextCursor.Right,
                                                 n=len(self._history_prefix))
                         else:
                             cursor.movePosition(QtGui.QTextCursor.EndOfLine)
                             return False
                         # Perform the search.
                         replaced = self.history_next(self._history_prefix,
                                                         as_prefix=not shift_modifier)
                         # Emulate readline: keep the cursor position fixed for a prefix
                         # input buffer is set.)
                         if self._history_prefix and replaced:
                             cursor = self._get_prompt_cursor()
                             cursor.movePosition(QtGui.QTextCursor.Right,
                                                 n=len(self._history_prefix))
                             self._set_cursor(cursor)
                             or (not as_prefix and substring in history):
                             replace = True
                             break
                     if replace:
                         self._store_edits()
                         self._history_index = index
                             or (not as_prefix and substring in history):
                             replace = True
                             break
                     if replace:
                         self._store_edits()
                         self._history_index = index
                         The (maximum) number of history items to get.
                     """
                     return self._history[-n:]
                 #---------------------------------------------------------------------------
                 # 'HistoryConsoleWidget' protected interface
                 #---------------------------------------------------------------------------
                 def _history_locked(self):
                     """ Returns whether history movement is locked.
                     """
                     return (self.history_lock and
                             (self._get_edited_history(self._history_index) !=
                              self.input_buffer) and
                             (self._get_prompt_cursor().blockNumber() !=
                              self._get_end_cursor().blockNumber()))

IPython/frontend/qt/console/ipython_widget.py

0 +11 -11

 . Pygments: .c, .k, .o, etc. (see PygmentsHighlighter)
 . IPython: .error, .in-prompt, .out-prompt, etc
                     """)
                 syntax_style = Unicode(config=True,
                     help="""
                     If not empty, use this Pygments style for syntax highlighting.
                 #---------------------------------------------------------------------------
                 # 'object' interface
                 #---------------------------------------------------------------------------
                 def __init__(self, *args, **kw):
                     super(IPythonWidget, self).__init__(*args, **kw)
                     # IPythonWidget protected variables.
                     self._payload_handlers = {
                         self._payload_source_edit : self._handle_payload_edit,
                         self._payload_source_exit : self._handle_payload_exit,
                         self._payload_source_page : self._handle_payload_page,
                         # but the last component and then suitably decreasing the offset
                         # between the current cursor position and the start of completion.
                         if len(matches) > 1 and matches[0][:offset] == text:
                             parts = re.split(r'[./\\]', text)
                             sep_count = len(parts) - 1
                             if sep_count:
                                 chop_length = sum(map(len, parts[:sep_count])) + sep_count
                     """ The base handler for the ``display_data`` message.
                     """
                     self.log.debug("display: %s", msg.get('content', ''))
                     # For now, we don't display data from other frontends, but we
                     # eventually will as this allows all frontends to monitor the display
                     # data. But we need to figure out how to handle this in the GUI.
                     if not self._hidden and self._is_from_this_session(msg):
                     # text field. Readline-based frontends do get a real text field which
                     # they can use.
                     text = ''
                     # Send the completion request to the kernel
                     msg_id = self.kernel_manager.shell_channel.complete(
                         text,                                    # text
                         self._get_input_buffer_cursor_line(),    # line
                         self._get_input_buffer_cursor_column(),  # cursor_pos
                         self.input_buffer)                       # block
                     pos = self._get_cursor().position()
                     info = self._CompletionRequest(msg_id, pos)
                     self._request_info['complete'] = info
                         self._append_html(traceback)
                     else:
                         # This is the fallback for now, using plain text with ansi escapes
                         self._append_plain_text(traceback)
                 def _process_execute_payload(self, item):
                     """ Reimplemented to dispatch payloads to handler methods.
                     else:
                         handler(item)
                         return True
                 def _show_interpreter_prompt(self, number=None):
                     """ Reimplemented for IPython-style prompts.
                     """
                             # Remove the old prompt and insert a new prompt.
                             cursor = QtGui.QTextCursor(block)
                             cursor.movePosition(QtGui.QTextCursor.Right,
                                                 QtGui.QTextCursor.KeepAnchor,
                                                 self._previous_prompt_obj.length)
                             prompt = self._make_in_prompt(previous_prompt_number)
                             self._prompt = self._insert_html_fetching_plain_text(
                     space_count = len(prompt.lstrip('\n')) - len(end_chars)
                     body = '&nbsp;' * space_count + end_chars
                     return '<span class="in-prompt">%s</span>' % body
                 def _make_out_prompt(self, number):
                     """ Given a prompt number, returns an HTML Out prompt.
                     """

IPython/frontend/qt/console/kill_ring.py

0 +6 -6

             class KillRing(object):
                 """ A generic Emacs-style kill ring.
                 """
                 def __init__(self):
                     self.clear()
                 def rotate(self):
                     """ Rotate the kill ring, then yank back the new top.
                     Returns:
                     --------
                     A text string or None.
                     if self._index >= 0:
                         return self._ring[self._index]
                     return None
             class QtKillRing(QtCore.QObject):
                 """ A kill ring attached to Q[Plain]TextEdit.
                 """
                         if text:
                             self._skip_cursor = True
                             cursor = self._text_edit.textCursor()
                             cursor.movePosition(QtGui.QTextCursor.Left,
                                                 QtGui.QTextCursor.KeepAnchor,
                                                 n = len(self._prev_yank))
                             cursor.insertText(text)
                             self._prev_yank = text
                 #--------------------------------------------------------------------------
                 # Protected interface
                 #--------------------------------------------------------------------------

IPython/frontend/qt/console/pygments_highlighter.py

0 +2 -2

                 def __repr__(self):
                     attrs = ['syntax_stack']
                     kwds = ', '.join([ '%s=%r' % (attr, getattr(self, attr))
                                        for attr in attrs ])
                     return 'PygmentsBlockUserData(%s)' % kwds
                     return result
                 def _get_format_from_document(self, token, document):
                     """ Returns a QTextCharFormat for token by
                     """
                     code, html = self._formatter._format_lines([(token, 'dummy')]).next()
                     self._document.setHtml(html)

IPython/frontend/qt/console/rich_ipython_widget.py

0 +2 -2

                         if svg is not None:
                             menu.addSeparator()
                             menu.addAction('Copy SVG', lambda: svg_to_clipboard(svg))
                             menu.addAction('Save SVG As...',
                                            lambda: save_svg(svg, self._control))
                     else:
                         menu = super(RichIPythonWidget, self)._context_menu_make(pos)
                         # Chop stand-alone header from matplotlib SVG
                         offset = svg.find("<svg")
                         assert(offset > -1)
                         return svg[offset:]
                     else:

IPython/frontend/qt/kernelmanager.py

0 +8 -8

                 # Emitted when the first reply comes back.
                 first_reply = QtCore.Signal()
                 # Used by the first_reply signal logic to determine if a reply is the
                 # first.
                 _handlers_called = False
                 #---------------------------------------------------------------------------
                 # 'ShellSocketChannel' interface
                 #---------------------------------------------------------------------------
                 def call_handlers(self, msg):
                     """ Reimplemented to emit signals instead of making callbacks.
                     """
                     # Emit the generic signal.
                     self.message_received.emit(msg)
                     # Emit signals for specialized message types.
                     msg_type = msg['header']['msg_type']
                     signal = getattr(self, msg_type, None)
                 #---------------------------------------------------------------------------
                 # 'SubSocketChannel' interface
                 #---------------------------------------------------------------------------
                 def call_handlers(self, msg):
                     """ Reimplemented to emit signals instead of making callbacks.
                     """
                     """
                     # Emit the generic signal.
                     self.message_received.emit(msg)
                     # Emit signals for specialized message types.
                     msg_type = msg['header']['msg_type']
                     if msg_type == 'input_request':
                     super(QtKernelManager, self).start_kernel(*args, **kw)
                 #------ Channel management -------------------------------------------------
                 def start_channels(self, *args, **kw):
                     """ Reimplemented to emit signal.
                     """
                 def stop_channels(self):
                     """ Reimplemented to emit signal.
                     """
                     super(QtKernelManager, self).stop_channels()
                     self.stopped_channels.emit()
                 #---------------------------------------------------------------------------
                 # Protected interface
                 #---------------------------------------------------------------------------
                 def _first_reply(self):
                     """ Unpauses the heartbeat channel when the first reply is received on
                         the execute channel. Note that this will *not* start the heartbeat

IPython/frontend/qt/rich_text.py

0 +4 -4

                                 ib.setShortcut('I')
                                 eb = QtGui.QPushButton("&External")
                                 eb.setShortcut('E')
                                 box = QtGui.QMessageBox(QtGui.QMessageBox.Question,
                                                         dialog.windowTitle(), msg)
                                 box.setInformativeText(info)
                                 box.addButton(ib, QtGui.QMessageBox.NoRole)
                 """ Return (X)HTML mark-up for the image-tag given by match.
                 This default implementation merely removes the image, and exists mostly
                 for documentation purposes. More information than is present in the Qt
                 HTML is required to supply the images.
                 Parameters
                 ----------
                 match : re.SRE_Match
                     A match to an HTML image tag as exported by Qt, with match.group("Name")
                     containing the matched image ID.
             def fix_html(html):
                 """ Transforms a Qt-generated HTML string into a standards-compliant one.
                 Parameters:
                 -----------
                 html : str,

IPython/frontend/terminal/embed.py

0 +3 -3

                 figured out what you needed from it, you may then kill it and the program
                 will then continue to run without the interactive shell interfering again.
                 """
                 kill = ask_yes_no("Are you sure you want to kill this embedded instance "
                                  "(y/n)? [y/N] ",'n')
                 if kill:
                     with nested(self.builtin_trap, self.display_trap):
                         self.interact(display_banner=display_banner)
                         # now, purge out the user namespace from anything we might have added
                         # from the caller's local namespace
                         delvar = self.user_ns.pop
                     d = 40
                     embed
                 Full customization can be done by passing a :class:`Struct` in as the
                 config argument.
                 """
                 config = kwargs.get('config')

IPython/frontend/terminal/interactiveshell.py

0 +37 -37

                         self.system = self.system_piped
                     else:
                         self.system = self.system_raw
                     self.init_term_title()
                     self.init_usage(usage)
                     self.init_banner(banner1, banner2, display_banner)
                     If an optional banner argument is given, it will override the
                     internally created default banner.
                     """
                     with nested(self.builtin_trap, self.display_trap):
                         while 1:
                             try:
                                 self.interact(display_banner=display_banner)
                                 #self.interact_with_readline()
                                 # XXX for testing of a readline-decoupled repl loop, call
                                 # interact_with_readline above
                                 break
                 def interact(self, display_banner=None):
                     """Closely emulate the interactive Python console."""
                     # batch run -> do not interact
                     if self.exit_now:
                         return
                     if display_banner is None:
                         display_banner = self.display_banner
                     if isinstance(display_banner, basestring):
                         self.show_banner(display_banner)
                     elif display_banner:
                         self.show_banner()
                     more = False
                     # Mark activity in the builtins
                     __builtin__.__dict__['__IPYTHON__active'] += 1
                     if self.has_readline:
                         self.readline_startup_hook(self.pre_readline)
                     # exit_now is set by a call to %Exit or %Quit, through the
                                 self.showtraceback()
                             if self.autoindent:
                                 self.rl_do_indent = True
                         else:
                             try:
                                 prompt = self.hooks.generate_prompt(False)
                                 break
                             if self.autoindent:
                                 self.rl_do_indent = False
                         except KeyboardInterrupt:
                             #double-guard against keyboardinterrupts during kbdint handling
                             try:
                             if not more:
                                 source_raw = self.input_splitter.source_raw_reset()[1]
                                 self.run_cell(source_raw)
                     # We are off again...
                     __builtin__.__dict__['__IPYTHON__active'] -= 1
                     if self.has_readline:
                         self.set_readline_completer()
                     try:
                         line = py3compat.str_to_unicode(self.raw_input_original(prompt))
                     except ValueError:
                         if num_ini_spaces(line) > self.indent_current_nsp:
                             line = line[self.indent_current_nsp:]
                             self.indent_current_nsp = 0
                     return line
                 #-------------------------------------------------------------------------
                             try:
                                 f = file(err.filename)
                                 try:
                                     # This should be inside a display_trap block and I
                                     # think it is.
                                     sys.displayhook(f.read())
                                 finally:
                     if e.filename in ('<ipython console>','<input>','<string>',
                                       '<console>','<BackgroundJob compilation>',
                                       None):
                         return False
                     try:
                         if (self.autoedit_syntax and
                             not self.ask_yes_no('Return to editor to correct syntax error? '
                                           '[Y/n] ','y')):
                             return False
                             self.ask_exit()
                     else:
                         self.ask_exit()
                 #------------------------------------------------------------------------
                 # Magic overrides
                 #------------------------------------------------------------------------
                 @skip_doctest
                 def magic_cpaste(self, parameter_s=''):
                     """Paste & execute a pre-formatted code block from clipboard.
                     You must terminate the block with '--' (two minus-signs) alone on the
                     line. You can also provide your own sentinel with '%paste -s %%' ('%%'
                     is the new sentinel for this operation)
                     The block is dedented prior to execution to enable execution of method
                     definitions. '>' and '+' characters at the beginning of a line are
                     ignored, to allow pasting directly from e-mails, diff files and
                     doctests (the '...' continuation prompt is also stripped).  The
                     executed block is also assigned to variable named 'pasted_block' for
                     later editing with '%edit pasted_block'.
                     You can also pass a variable name as an argument, e.g. '%cpaste foo'.
                     This assigns the pasted block to variable 'foo' as string, without
                     dedenting or executing it (preceding >>> and + is still stripped)
                     '%cpaste -r' re-executes the block previously entered by cpaste.
                     Do not be alarmed by garbled output on Windows (it's a readline bug).
                     Just press enter and type -- (and press enter again) and the block
                     will be what was just pasted.
                     IPython statements (magics, shell escapes) are not supported (yet).
                     See also
                     --------
                     paste: automatically pull code from clipboard.
                     Examples
                     --------
                     ::
                       In [8]: %cpaste
                       Pasting code; enter '--' alone on the line to stop.
                       :>>> a = ["world!", "Hello"]
                       :--
                       Hello world!
                     """
                     opts,args = self.parse_options(parameter_s,'rs:',mode='string')
                     par = args.strip()
                     if opts.has_key('r'):
                         self._rerun_pasted()
                         return
                     sentinel = opts.get('s','--')
                     block = self._strip_pasted_lines_for_code(
                 def magic_paste(self, parameter_s=''):
                     """Paste & execute a pre-formatted code block from clipboard.
                     The text is pulled directly from the clipboard without user
                     intervention and printed back on the screen before execution (unless
                     the -q flag is given to force quiet mode).
                     doctests (the '...' continuation prompt is also stripped).  The
                     executed block is also assigned to variable named 'pasted_block' for
                     later editing with '%edit pasted_block'.
                     You can also pass a variable name as an argument, e.g. '%paste foo'.
                     This assigns the pasted block to variable 'foo' as string, without
                     dedenting or executing it (preceding >>> and + is still stripped)
                     Options
                     -------
                       -r: re-executes the block previously entered by cpaste.
                       -q: quiet mode: do not echo the pasted text back to the terminal.
                     IPython statements (magics, shell escapes) are not supported (yet).
                     See also
                         if not block.endswith('\n'):
                             write('\n')
                         write("## -- End pasted text --\n")
                     self._execute_block(block, par)
                 def showindentationerror(self):
                     super(TerminalInteractiveShell, self).showindentationerror()
                     print("If you want to paste code into IPython, try the %paste magic function.")

IPython/frontend/terminal/ipapp.py

0 +5 -5

                         PlainTextFormatter,
                         Completer,
                     ]
                 subcommands = Dict(dict(
                     qtconsole=('IPython.frontend.qt.console.qtconsoleapp.IPythonQtConsoleApp',
                         """Launch the IPython Qt Console."""
                         "Start a kernel without an attached frontend."
                     ),
                 ))
                 # *do* autocreate requested profile, but don't create the config file.
                 auto_create=Bool(True)
                 # configurables
                 def _force_interact_changed(self, name, old, new):
                     if new:
                         self.interact = True
                 def _file_to_run_changed(self, name, old, new):
                     if new and not self.force_interact:
                             self.interact = False
                                 sub = '--pylab='+gui
                                 argv.pop(idx+1)
                         argv[idx] = sub
                     return super(TerminalIPythonApp, self).parse_command_line(argv)
                 def initialize(self, argv=None):
                     sys.path.insert(0, '')
                     # Create an InteractiveShell instance.
                     # shell.display_banner should always be False for the terminal
                     # based app, because we call shell.show_banner() by hand below
                     # so the banner shows *before* all extension loading stuff.
                     self.shell = TerminalInteractiveShell.instance(config=self.config,

IPython/lib/clipboard.py

0 +3 -3

                     message = ("Getting text from the clipboard requires the pywin32 "
                         "extensions: http://sourceforge.net/projects/pywin32/")
                     raise TryNext(message)
                 win32clipboard.OpenClipboard()
                 text = win32clipboard.GetClipboardData(win32clipboard.CF_TEXT)
                 # FIXME: convert \r\n to \n?
                 win32clipboard.CloseClipboard()
                 return text
             def osx_clipboard_get():

IPython/lib/deepreload.py

0 +11 -11

             You can then disable it with::
                 __builtin__.reload = deepreload.original_reload
             Alternatively, you can add a dreload builtin alongside normal reload with::
                 __builtin__.dreload = deepreload.reload
             This code is almost entirely based on knee.py from the standard library.
             """
             # Replacement for __import__()
             def deep_import_hook(name, globals=None, locals=None, fromlist=None, level=-1):
                 # For now level is ignored, it's just there to prevent crash
                 # with from __future__ import absolute_import
                 parent = determine_parent(globals)
                 q, tail = find_head_package(parent, name)
                     # to:
                     mname = m.__name__
                     # This needs more testing!!! (I don't understand this module too well)
                     #print '** head,tail=|%s|->|%s|, mname=|%s|' % (head,tail,mname)  # dbg
                     m = import_module(head, mname, m)
                     if not m:
                 global found_now
                 if found_now.has_key(fqname):
                     try:
                         return sys.modules[fqname]
                     except KeyError:
                         pass
                 print 'Reloading', fqname #, sys.excepthook is sys.__excepthook__, \
                         #sys.displayhook is sys.__displayhook__
                 found_now[fqname] = 1
                 try:
                     fp, pathname, stuff = imp.find_module(partname,
                                                           parent and parent.__path__)
                 except ImportError:
                     return None
                 try:
                     m = imp.load_module(fqname, fp, pathname, stuff)
                 finally:
                     if fp: fp.close()
                 if parent:
                     setattr(parent, partname, m)
             def reload(module, exclude=['sys', '__builtin__', '__main__']):
                 """Recursively reload all modules used in the given module.  Optionally
                 takes a list of modules to exclude from reloading.  The default exclude
                 list contains sys, __main__, and __builtin__, to prevent, e.g., resetting
                 display, exception, and io hooks.
                 """
                 global found_now
                 for i in exclude:
                     found_now[i] = 1
                 original_import = __builtin__.__import__
                 __builtin__.__import__ = deep_import_hook
                 try:
                     ret = deep_reload_hook(module)
                 finally:

IPython/lib/demo.py

0 +23 -23

               - post_cmd(): run right after the execution of each block.  If the block
                 raises an exception, this is NOT called.
             Operation
             =========
               word 'stop', to help visually distinguish the blocks in a text editor:
               # <demo> --- stop ---
             # <demo> silent
               Make a block execute silently (and hence automatically).  Typically used in
               cases where you have some boilerplate or initialization code which you need
               executed but do not want to be seen in the demo.
             # <demo> auto
               Make a block execute automatically, but still being printed.  Useful for
             an IPython session, and type::
               %run demo-exercizer.py
             and then follow the directions.
             Example
                     IPython.Demo? in IPython to see it).
                     Inputs:
                       - src is either a file, or file-like object, or a
                           string that can be resolved to a filename.
                     Optional inputs:
                       - title: a string to use as the demo name.  Of most use when the demo
                       you are making comes from an object that has no filename, or if you
                       want an alternate denotation distinct from the filename.
                       - arg_str(''): a string of arguments, internally converted to a list
                     self.sys_argv = [src] + shlex.split(arg_str)
                     self.auto_all = auto_all
                     self.src = src
                     # get a few things from ipython.  While it's a bit ugly design-wise,
                     # it ensures that things like color scheme and the like are always in
                     # sync with the ipython mode being used.  This class is only meant to
                 def reload(self):
                     """Reload source from disk and initialize state."""
                     self.fload()
                     self.src     = self.fobj.read()
                     src_b        = [b.strip() for b in self.re_stop.split(self.src) if b]
                     self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
                     """Get the current block index, validating and checking status.
                     Returns None if the demo is finished"""
                     if index is None:
                         if self.finished:
                             print >>io.stdout, 'Demo finished.  Use <demo_name>.reset() if you want to rerun it.'
                     # that the default demo.edit() call opens up the sblock we've last run
                     if index>0:
                         index -= 1
                     filename = self.shell.mktempfile(self.src_blocks[index])
                     self.shell.hooks.editor(filename,1)
                     new_block = file_read(filename)
                     self.block_index = index
                     # call to run with the newly edited index
                     self()
                 def show(self,index=None):
                     """Show a single block on screen"""
                     """Execute a string with one or more lines of code"""
                     exec source in self.user_ns
                 def __call__(self,index=None):
                     """run a block of the demo.
                             self.post_cmd()
                         finally:
                             sys.argv = save_argv
                     except:
                         self.ip_showtb(filename=self.fname)
                     else:
                     """Execute a string with one or more lines of code"""
                     self.shell.run_cell(source)
             class LineDemo(Demo):
                 """Demo where each line is executed as a separate block.
                 Note: the input can not have *any* indentation, which means that only
                 single-lines of input are accepted, not even function definitions are
                 valid."""
                 def reload(self):
                     """Reload source from disk and initialize state."""
                     # read data and parse into blocks
             class ClearMixin(object):
                 """Use this mixin to make Demo classes with less visual clutter.
                 Demos using this mixin will clear the screen before every block and use
                 blank marquees.
                 Note that in order for the methods defined here to actually override those
                 of the classes it's mixed with, it must go /first/ in the inheritance
                 tree.  For example:
                     class ClearIPDemo(ClearMixin,IPythonDemo): pass
                 will provide an IPythonDemo class with the mixin's features.
                 """
                 def marquee(self,txt='',width=78,mark='*'):
                     """Blank marquee that returns '' no matter what the input."""
                     return ''
                 def pre_cmd(self):
                     """Method called before executing each block.
                     This one simply clears the screen."""
                     from IPython.utils.terminal import term_clear
                     term_clear()

IPython/lib/display.py

0 +11 -11

             class YouTubeVideo(object):
                 """Class for embedding a YouTube Video in an IPython session, based on its video id.
                 e.g. to embed the video on this page:
                 http://www.youtube.com/watch?v=foo
                 you would do:
                 vid = YouTubeVideo("foo")
                 display(vid)
                 """
                 def __init__(self, id, width=400, height=300):
                     self.id = id
                     self.width = width
                     self.height = height
                 def _repr_html_(self):
                     """return YouTube embed iframe for this video id"""
                     return """
                         <iframe
                             width="%i"
                             height="%i"
                             src="http://www.youtube.com/embed/%s"
                             frameborder="0"
                             allowfullscreen
                         ></iframe>
                     """%(self.width, self.height, self.id)

IPython/lib/guisupport.py

0 +3 -3

 . The terminal based IPython supports GUI event loops through Python's
                PyOS_InputHook. PyOS_InputHook is a hook that Python calls periodically
                whenever raw_input is waiting for a user to type code. We implement GUI
                support in the terminal by setting PyOS_InputHook to a function that
                iterates the event loop for a short while. It is important to note that
                in this situation, the real GUI event loop is NOT run in the normal
                manner, so you can't use the normal means to detect that it is running.
 . In the two process IPython kernel/frontend, the GUI event loop is run in
                the kernel. In this case, the event loop is run in the normal manner by
                calling the function or method of the GUI toolkit that starts the event
                loop.
               *must* use its value. If it has not been set, you can query the toolkit
               in the normal manner.
             * If you want GUI support and no one else has created an application or
               started the event loop you *must* do this. We don't want projects to
               attempt to defer these things to someone else if they themselves need it.
             The functions below implement this logic for each GUI toolkit. If you need

IPython/lib/inputhookglut.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/lib/inputhookpyglet.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/lib/inputhookwx.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/lib/irunner.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/lib/tests/test_irunner_pylab_magic.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/nbformat/v2/__init__.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/nbformat/v2/nbbase.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/nbformat/v2/nbpy.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/apps/ipclusterapp.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/apps/launcher.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/apps/winhpcjob.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/client/asyncresult.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/client/client.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/client/remotefunction.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/client/view.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/controller/dictdb.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/controller/heartmonitor.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/controller/hub.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/controller/scheduler.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/controller/sqlitedb.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/engine/engine.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/engine/streamkernel.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/parallel/error.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/InterpreterExec.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/clearcmd.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/envpersist.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ext_rescapture.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_completers.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_extutil.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_fsops.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_jot.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_lookfor.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_rehashdir.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_render.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_server.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_signals.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_system_conf.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_winpdb.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ipy_workdir.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/jobctrl.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/ledit.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/pspersistence.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/quarantine/win32clip.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/testing/decorators.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/testing/globalipapp.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/testing/iptest.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/testing/mkdoctests.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/testing/plugin/ipdoctest.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/testing/tests/test_ipunittest.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/testing/tools.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/autoattr.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/codeutil.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/coloransi.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/generics.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/growl.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/io.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/ipstruct.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/localinterfaces.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/notification.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/path.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/pickleshare.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/pickleutil.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/process.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/strdispatch.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/tests/test_notification.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/tests/test_path.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/tests/test_traitlets.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/text.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/traitlets.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/utils/wildcard.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/entry_point.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/frontend.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/ipkernel.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/kernelmanager.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/parentpoller.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/pykernel.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/session.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/tests/test_session.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

IPython/zmq/zmqshell.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/lib/gui-wx.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/fetchparse.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/multiengine1.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/options/mcpricer.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/pi/parallelpi.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/pi/pidigits.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/plotting/plotting_backend.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/rmt/rmt.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/task_profiler.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/wave2D/parallelwave-mpi.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/wave2D/parallelwave.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/newparallel/wave2D/wavesolver.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/examples/notebooks/text_analysis.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/source/conf.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/sphinxext/apigen.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

docs/sphinxext/ipython_console_highlighting.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

setup2.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

setupbase.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

setupext/setupext.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

tools/run_ipy_in_profiler.py

0 0 0

	1	NO CONTENT: modified file			NO CONTENT: modified file
The requested commit or file is too big and content was truncated. Show full diff

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