upstream/ipython Commit - r4874:a47e209c

Merge branch 'trailling'

Thomas Kluyver -

r4874:a47e209c

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,
+                 # 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
+                     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
+                         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
+                     :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
+                     # 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
+                         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
+                         # 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
+                     # 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
+                 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
+                 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
+                         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,
+                             # 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
+                 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
+                     """ 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
+             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,
+                 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,
+                             base_config,
                              path=self.config_file_paths
                          )
                      except IOError:
                      try:
                          Application.load_config_file(
                              self,
-                             self.config_file_name,
+                             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)
+                         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
+                         # 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)]
+                             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 +
+                         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 +
+                             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"""
+                     """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
+                     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)
+                             self.magic_escape + cmd)
                      else:
-                         try_magic = []
+                         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)
+                     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,
+                 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
+                         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:
+                 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
+                     # 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 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
+                     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
+                     # 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
+                         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
+                     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.
+                 nevertheless interrupt a macro / batch file.
                  """

IPython/core/excolors.py

0 +4 -4

                  >>> print ec.active_colors
                  None
-                 Now we activate a color scheme:
+                 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',
+                 ['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
+                 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
+                 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
+                 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
+                 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.
+                 #  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
+                     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:
                          # N.B. 'insert into' here is lower case because of a bug in the
                          # sqlite3 module that affects the Turkish locale. This should be
                          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):
+                         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
+                 # 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("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
+                 """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.
+                     """ 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):
+             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.).
+                 (%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
+                 """ 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)
+                 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,
+                     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'),
+                 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'),
+                 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
+                     # *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
+                     # 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
+                     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]
+                                     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(info.parent, '__class__')
+                                 # The object belongs to a class instance.
+                                 try:
                                      target = getattr(target, path[-1])
-                                     # The class defines the object.
+                                     # 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
+                     [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
+                     """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
+                         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,
+                             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.
+                     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
+                     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
+                     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)
+                             os.remove(self.logfname)
                          self.logfile = open(self.logfname,'w')
                      elif logmode == 'rotate':
                          if isfile(self.logfname):
-                             if isfile(self.logfname+'.001~'):
+                             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
+                 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
+             # 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
+                       - 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
+                     # 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,
+                             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
+                     Supported formats: -latex, -brief, -rest
                      """
                      mode = ''
                                  break
                          if mode == 'brief':
                              # only first line
-                             if fn.__doc__:
+                             if fn.__doc__:
                                  fndoc = fn.__doc__.split('\n',1)[0]
                              else:
                                  fndoc = 'No documentation'
                          else:
                              if fn.__doc__:
-                                 fndoc = fn.__doc__.rstrip()
+                                 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
+                       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):
+                             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.
+                     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,
+                     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.
+                             # 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):
+                                     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
+                                                 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
+                     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 !!
+                     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
+                     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
+                 @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.
+                           '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,
+                         #turn all non-space-escaping backslashes to slashes,
                          # for c:\windows\directory\names\
-                         parameter_s = re.sub(r'\\(?! )','/', parameter_s)
+                         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:
+                         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,
+                             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
+                             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)
+                         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
+                 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
+                 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 !!.
+                     # 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,
+                 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',
+                     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
+                     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.
+             * 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
+             * 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.
+             * 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
+             # ! 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:
+                 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:
+                     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)
+                 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")'),
+                      ("! 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'),
                       ('if 1:\n    ?fun 1 2', 'if 1:\n    ?fun 1 2'),
-                      # What about !!
+                      # What about !!
                       ])
                  # Objects which are instances of IPyAutocall are *always* autocalled
                  autocallable = Autocallable()
                  ip.user_ns['autocallable'] = autocallable
-                 # auto
+                 # auto
                  ip.magic('autocall 0')
                  # Only explicit escapes or instances of IPyAutocallable should get
                  # expanded
                  run([
-                     ('len "abc"',       'len "abc"'),
-                     ('autocallable',    'autocallable()'),
+                     ('len "abc"',       'len "abc"'),
+                     ('autocallable',    'autocallable()'),
                      (",list 1 2 3",     'list("1", "2", "3")'),
-                     (";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")'),
+                     (";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")'),
+                     (";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])'),
+                     ('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
+                         # 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 =
+                    escaped_quote2 =
                     [ (';f', 'f("")'),
                       (';f x', 'f("x")'),
                       ('  ;f y', '  f("y")'),
                       (';f a b', 'f("a b")'),
                       ],
                     # Simply apply parens
-                    escaped_paren =
+                    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)
+                 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
+                 @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
+             * 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,
+                         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,
+                         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.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(),
+                                                                   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,
+                              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
+                 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)]
+                         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)
+                         -------> 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
+             %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.
+                     """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'''
+                         '''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()
+                         self.instance._after_execute()
                      except KeyboardInterrupt:
                          pass
              ##############################################################################
              class NonBlockingIPShell(object):
                  '''
                  Create an IPython instance, running the commands in a separate,
-                 non-blocking thread.
+                 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
+                     #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 ----------------------
+                 #----------------------- 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
+                         #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()
+                             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()
+                         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)
+                     #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 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
+                     # 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,
+                     #self.RegisterImage(2,
                      #    wx.ArtProvider.GetBitmap(wx.ART_NEW, size=(16,16)))
-                     #self.RegisterImage(3,
+                     #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,
+                 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,
+                     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):
+                     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
+                 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':
+                                      '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
+                     # 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.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,
+                     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
+                 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,
+                              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
+                     #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)
+                         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()
+                         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':
+                                 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,
+                     # """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
+                     """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
+             # Creating one main frame for our
              # application with movables windows
              #-----------------------------------------
              class MyFrame(wx.Frame):
-                 """Creating one main frame for our
+                 """Creating one main frame for our
                  application with movables windows"""
-                 def __init__(self, parent=None, id=-1, title="WxIPython",
+                 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
+                     #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:
+                     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()
+                     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
+                 #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
+                     self._mgr.Update()
+                 #event to display History pannel
                  def OnShowHistoryPanel(self,event):
                      self._mgr.GetPane(self.history_panel).Show(True)
-                     self._mgr.Update()
+                     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)
+                     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,
+             Source, Peter J. Mohr and Barry N. Taylor,
              CODATA Recommended Values of the Fundamental
-             Physical Constants, 1998
-             Website: physics.nist.gov/constants
+             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 math import * # math MUST be imported BEFORE PhysicalQInteractive
              from IPython.extensions.PhysicalQInteractive import PhysicalQuantityInteractive
              # Math constants:
              # Atomic and Nuclear Constants
              # General
              #-------------------------------------------------------------------------
-             # fine-structure constant
+             # fine-structure constant
              alpha = 7.297352533E-3
              # electron-muon mass ratio
              memu = 4.83633210E-3
-             # electron-tau mass ratio
+             # electron-tau mass ratio
              metau = 2.87555E-4
-             # electron-proton mass ratio
+             # electron-proton mass ratio
              memp = 5.446170232E-4
-             # electron-neutron mass ratio
+             # electron-neutron mass ratio
              memn = 5.438673462E-4
-             # electron-deuteron mass ratio
+             # electron-deuteron mass ratio
              memd = 2.7244371170E-4
-             # electron to alpha particle mass ratio
+             # 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
+             # electron magnetic moment to Bohr magneton ratio
              ueuB = -1.0011596521869
-             # electron magnetic moment to nuclear magneton ratio
+             # electron magnetic moment to nuclear magneton ratio
              ueuN = -1838.2819660
-             # electron magnetic moment anomaly |ue|/uB - 1
+             # electron magnetic moment anomaly |ue|/uB - 1
              a_e = 1.1596521869E-3
-             # electron g-factor
+             # electron g-factor
              g_e = -2.0023193043737
-             # electron-muon magnetic moment ratio
+             # electron-muon magnetic moment ratio
              ueuu = 206.7669720
-             # electron-proton magnetic moment ratio
+             # 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
+             # electron-neutron magnetic moment ratio
              ueun = 960.92050
-             # electron-deuteron magnetic moment ratio
+             # 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
+             # muon-electron mass ratio
              mume = 206.7682657
              # muon-tau mass ratio
              # muon-proton mass ratio
              mump = 0.1126095173
-             # muon-neutron mass ratio
+             # 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
+             # ratio of muon magnetic moment to Bohr magneton ratio
              uuuB = -4.84197085E-3
-             # ratio of muon magnetic moment to nuclear magneton ratio
+             # ratio of muon magnetic moment to nuclear magneton ratio
              uuuN = -8.89059770
-             # muon magnetic moment anomaly |uu|/(e /2mu) - 1
+             # 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
+             # 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
+             # tau-electron mass ratio
              mtaume = 3477.60
-             # tau-muon mass ratio
+             # tau-muon mass ratio
              mtaumu = 16.8188
-             # tau-proton mass ratio
+             # tau-proton mass ratio
              mtaump = 1.89396
-             # tau-neutron mass ratio
+             # tau-neutron mass ratio
              mtaumn = 1.89135
              mpc2_MeV = PhysicalQuantityInteractive(938.271998 , 'MeV')
              mpc2_MeV.__doc__ = """energy equivalent in MeV  """
-             # proton-electron mass ratio
+             # proton-electron mass ratio
              mpme = 1836.1526675
              # proton-muon mass ratio
              mpmu = 8.88024408
-             # proton-tau mass ratio
+             # proton-tau mass ratio
              mpmtau = 0.527994
-             # proton-neutron mass ratio
+             # 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
+             # proton magnetic moment to Bohr magneton ratio
              upuB = 1.521032203E-3
-             # proton magnetic moment to nuclear magneton ratio
+             # proton magnetic moment to nuclear magneton ratio
              upuN = 2.792847337
-             # proton g-factor 2up/uN
+             # proton g-factor 2up/uN
              g_p = 5.585694675
-             # proton-neutron magnetic moment ratio
+             # 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
+             # shielded proton magnetic moment to Bohr magneton ratio
              uspuB = 1.520993132E-3
-             # shielded proton magnetic moment to nuclear magneton ratio
+             # 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
+             # neutron-electron mass ratio
              mnme = 1838.6836550
-             # neutron-muon mass ratio
+             # neutron-muon mass ratio
              mnmu = 8.89248478
-             # neutron-tau mass ratio
+             # neutron-tau mass ratio
              mnm = 0.528722
-             # neutron-proton mass ratio
+             # 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
+             # neutron magnetic moment to Bohr magneton ratio
              unuB = -1.04187563E-3
-             # neutron magnetic moment to nuclear magneton ratio
+             # neutron magnetic moment to nuclear magneton ratio
              unuN = -1.91304272
-             # neutron g-factor
+             # neutron g-factor
              g_n = -3.82608545
-             # neutron-electron magnetic moment ratio
+             # neutron-electron magnetic moment ratio
              unue = 1.04066882E-3
-             # neutron-proton magnetic moment ratio
+             # 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
+             # deuteron-electron mass ratio
              mdme = 3670.4829550
-             # deuteron-proton mass ratio
+             # 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
+             # deuteron magnetic moment to Bohr magneton ratio
              uduB = 0.4669754556E-3
-             # deuteron magnetic moment to nuclear magneton ratio
+             # deuteron magnetic moment to nuclear magneton ratio
              uduN = 0.8574382284
-             # deuteron-electron magnetic moment ratio
+             # deuteron-electron magnetic moment ratio
              udue = -4.664345537E-4
-             # deuteron-proton magnetic moment ratio
+             # deuteron-proton magnetic moment ratio
              udup = 0.3070122083
-             # deuteron-neutron magnetic moment ratio
+             # 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
+             # helion-electron mass ratio
              mhme = 5495.885238
-             # helion-proton mass ratio
+             # 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
+             # shielded helion magnetic moment to Bohr magneton ratio
              ushuB = -1.158671474E-3
-             # shielded helion magnetic moment to nuclear magneton ratio
+             # 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,
+             # 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
+             # alpha particle to electron mass ratio
              malphame = 7294.299508
-             # alpha particle to proton mass ratio
+             # 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
+             # T1 = 1 K, p0 = 100 kPa
              S_0R_1 = -1.1517048
-             # T1 = 1 K, p0 = 101.325 kPa
+             # 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.
+             """ 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).
+             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
+             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"
+             (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():
+             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
+                 # 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
+                 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...
+                 # 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")
+                 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():
+                     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()
+                     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(), '/')
+                             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
+             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
+             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:
+             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
+             # 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)
+                     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.
+                             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()
+                         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,
+                     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
+             """PyObjC classes to provide a Cocoa frontend to the
              IPython.kernel.engineservice.IEngineBase.
-             To add an IPython interpreter to a cocoa app, instantiate an
+             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
+             # 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
+                     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(),
+                     self.insert_text(self.input_prompt(),
                          textRange=self.current_block_range().inputPromptRange)
                  def next_block_ID(self):
-                     return guid.generate()
+                     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(),
+                     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,
+                     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
+                     """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)
+                         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,
+                                         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,
+                 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
+                     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,
+                 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
+             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
+             """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.
+             #       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
+             # 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
+             frontendbase provides an interface and base class for GUI frontends for
              IPython.kernel/IPython.kernel.core.
-             Frontend implementations will likely want to subclass FrontEndBase.
+             Frontend implementations will likely want to subclass FrontEndBase.
              Author: Barry Wark
              """
              from IPython.frontend.zopeinterface import (
-                 Interface,
-                 Attribute,
+                 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.
+                     """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
+                     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.
+                     """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
+                     """Returns the input prompt by subsituting into
                      self.input_prompt_template
                      """
                      pass
                  def output_prompt(number=''):
-                     """Returns the output prompt by subsituting into
+                     """Returns the output prompt by subsituting into
                      self.output_prompt_template
                      """
                      pass
                  def continuation_prompt():
-                     """Returns the continuation prompt by subsituting into
+                     """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.
+             # 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
+                     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")
+                                         "<string>", "exec")
                      except:
                          return False
                      lines = block.split('\n')
-                     return ((is_complete is not None)
+                     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.
+                             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
+                     """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.
+                     """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
+                     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.
+                     """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.
+                     """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.
+                 # 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)
+                         prefix = common_prefix(completions)
                          residual = complete_sep.split(line)[:-1]
                          line = line[:-len(residual)] + prefix
-                     return line, completions
+                     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.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.
+                     """ 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
+                     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'
+                             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.
+                     """ Do code completion on current line.
                      """
                      if self.debug:
-                         print >>sys.__stdout__, "complete_current_input",
+                         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
+                         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.
+                     """ 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
+                         # 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.
+             # 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',
+                     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,
+                         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
+                 # 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.
+                     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
+                     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)
+                         prefix = common_prefix(completions)
                          line = line[:-len(word)] + prefix
                      return line, completions
                  #--------------------------------------------------------------------------
-                 # LineFrontEndBase interface
+                 # 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
+                 # 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|=|,|:|\((?!.*\))|\[(?!.*\])|\{(?!.*\})'
+                     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.
+             # 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
+                         # 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
+                         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,
+             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,
+                 def __init__(self, command_string, out_callback,
                                      end_callback=None,):
                      """ command_string: the command line executed to start the
-                     process.
+                     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.
+             #  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
+             # Imports
              #---------------------------------------------------------------------------
              from twisted.trial import unittest
              from IPython.frontend.asyncfrontendbase import AsyncFrontEndBase
-             from IPython.frontend import frontendbase
+             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,
+                     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):
+                 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.
+             Test the basic functionality of frontendbase.
              """
              __docformat__ = "restructuredtext en"
              from IPython.frontend.frontendbase import FrontEndBase
              def test_iscomplete():
-                 """ Check that is_complete works.
+                 """ 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
+             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)
+                    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'
+                 #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"',
+                 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();"',
+                 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()
+                 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
+             # Constants
              #-------------------------------------------------------------------------------
              _COMPLETE_BUFFER_MARKER = 31
              _ERROR_MARKER = 30
                  # Default scintilla settings
                  'antialiasing'  : True,
                  'carret_color'  : 'BLACK',
-                 'background_color' :'WHITE',
+                 '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.
+             # 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':
+                            '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,
+                 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.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
+                     # 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.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
+                             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
+                     # 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,
+                     # 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
+                     # 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],
+                         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
+                     # 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])
+                     #    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
+                     """ 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
+                     """ 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(),
+                                     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.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()):
+                     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
+                     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)
+                         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.
+                     """ 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
+                 #       '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
+                         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()
+                     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,
+                     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()
+                     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"
+                         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
+                     """ Updates the popup completion menu if it exists. If create is
                          true, open the menu.
                      """
                      if self.debug:
-                         print >>sys.__stdout__, "_popup_completion"
+                         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
+                                 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,
+                         wx.CallAfter(self._buffer_flush_timer.Start,
                                                      milliseconds=100, oneShot=True)
                  #--------------------------------------------------------------------------
-                 # LineFrontEnd interface
+                 # 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,
+                         PrefilterFrontEnd.execute(self, python_string,
                                                          raw_string=raw_string)
                      wx.CallAfter(callback)
                          return True
-                 def save_output_hooks(self):
+                 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
+                 # FrontEndBase interface
                  #--------------------------------------------------------------------------
                  def render_error(self, e):
                      start_line = self.GetCurrentLine()
                      self.write('\n' + e + '\n')
                  #--------------------------------------------------------------------------
-                 # ConsoleWidget interface
+                 # 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
+                                 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):
+                         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(),
+                             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
+                     # 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,
+                     has_executed = PrefilterFrontEnd._on_enter(self,
                                                          new_line_pos=new_line_pos)
                      if old_prompt_num == self.current_prompt_pos:
-                         # No execution has happened
+                         # 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
+                     """ 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:
+             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."""
+                 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()
+                         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.
+                 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),
+                 ( ' ',         handle_normal),
                  # Trailing qmark combos.  Odd special cases abound
                  # ! always takes priority!
-                 ( '!thing?',      handle_shell_escape),
+                 ( '!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 ?',
+                         # 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
+             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('!=()<>+*/%^&|'):
+             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_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
+             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?
+             # Who loves auto-generating tests?
              run_handler_tests(bin_tests)
              # ============
              num_f = len(failures)
              if verbose:
-                 print
+                 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.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.
+                     # 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
+                     # 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)
+                     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()
+                     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:
+                     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()
+                     # 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()
+                             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()
+                             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...."
+                     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
+                     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]:
+                         Out[23]:
                          <Results List>
                          [0] In [6]: a = 10
                          [1] In [6]: a = 10
                          In [22]: %result 6
-                         Out[22]:
+                         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
+                     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]:
+                         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
+                     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
+                     """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,
+                             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
+.  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
+             ##   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.
+             ##   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.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.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
+                         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,
+                     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),
+                         '%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
+                 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:
+                         if msg is None:
                              out = 'Test skipped due to test condition'
-                         else:
+                         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
+             # 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
+             # 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
+             # 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:
+             ###   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.
+             ###   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
+             ###   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
+             ###
+             ###   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
+             # 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:
+                 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))
+                 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
+               '''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
+             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
+             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
+             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
+                     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:]
+                     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
+             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*
+                  *.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,
+                  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
+                  foo
                       - File or dir foo
-                  !*.bak readme*
+                  !*.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
+                  dir:foo
                       - the directory foo if it exists (not files in foo)
-                  dir:*
+                  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)
+                                 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('=')
+                         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:
+                             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'] )
+                     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)
+                 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',
+             '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
+                    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 +
+                                 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' %
+                 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;
+                     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
+                     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;
+                     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),
+                 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
+                     # 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
+                     """ 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
+                     """ 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:
+                     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),
+                         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
+                         # 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,
+                     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,
+                     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
+                 """ 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,
+                             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,
+                             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,
+                         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 |
+                         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
+                 """ 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
+                         * 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'],
+                 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,
+                             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
+                     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.
+                     """ 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)
+                             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
+                             # 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(),
+                         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)
+                             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,
+                                 self._control.moveCursor(QtGui.QTextCursor.PreviousBlock,
                                                           mode=anchormode)
-                                 self._control.moveCursor(QtGui.QTextCursor.EndOfBlock,
+                                 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,
+                             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
+                     """ 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,
+                         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.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,
+                     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
+                     # 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.
+                     """ 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
+                         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,
+                         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',
+                     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
+                     """ 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
+                             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,
+                     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
+                         # 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,
+                             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,
+                         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,
+                             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) !=
+                     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_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)
+                             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
+                     # 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
+                         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)
+                         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,
+                                                 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,
+                             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))
+                     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
+                     """ 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...',
+                             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
+                 # 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,
+                                 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
+                 for documentation purposes. More information than is present in the Qt
                  HTML is required to supply the images.
                  Parameters
                  ----------
-                 match : re.SRE_Match
+                 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
+                 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()
+                                 #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
+                     # 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
+                                     # 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
+                         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 %%' ('%%'
+                     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
+                     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
+                     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
+                     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
+                     # 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)
+                 win32clipboard.OpenClipboard()
+                 text = win32clipboard.GetClipboardData(win32clipboard.CF_TEXT)
                  # FIXME: convert \r\n to \n?
-                 win32clipboard.CloseClipboard()
+                 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
+                 # 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]
+                         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
+                 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
+                 __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
+                       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"
+                         <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
+                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
+. 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
+               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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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