upstream/ipython Commit - r4872:34c10438

remove all trailling spaces

Bernardo B. Marques -

r4872:34c10438

parent child

IPython/config/application.py

0 +39 -39

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

IPython/config/configurable.py

0 +26 -26

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

IPython/config/loader.py

0 +40 -40

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

IPython/core/alias.py

0 +13 -13

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

IPython/core/application.py

0 +20 -20

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

IPython/core/completer.py

0 +33 -33

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

IPython/core/completerlib.py

0 +16 -16

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

IPython/core/crashhandler.py

0 +6 -6

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

IPython/core/debugger.py

0 +21 -21

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

IPython/core/display.py

0 +2 -2

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

IPython/core/displayhook.py

0 +7 -7

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

IPython/core/displaypub.py

0 +2 -2

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

IPython/core/error.py

0 +3 -3

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

IPython/core/excolors.py

0 +4 -4

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

IPython/core/extensions.py

0 +2 -2

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

IPython/core/formatters.py

0 +10 -10

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

IPython/core/history.py

0 +93 -93

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

IPython/core/hooks.py

0 +28 -28

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

IPython/core/interactiveshell.py

0 +109 -109

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

IPython/core/logger.py

0 +9 -9

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

IPython/core/magic.py

0 +214 -214

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

IPython/core/oinspect.py

0 +33 -33

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

IPython/core/prefilter.py

0 +14 -14

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

IPython/core/profileapp.py

0 +13 -13

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

IPython/core/prompts.py

0 +6 -6

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

IPython/core/release.py

0 +3 -3

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

IPython/core/splitinput.py

0 +11 -11

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

IPython/core/tests/test_handlers.py

0 +10 -10

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

IPython/core/tests/test_history.py

0 +11 -11

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

IPython/core/tests/test_inputsplitter.py

0 +27 -27

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

IPython/core/tests/test_oinspect.py

0 +7 -7

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

IPython/core/tests/test_run.py

0 +6 -6

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

IPython/core/ultratb.py

0 +41 -41

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

IPython/core/usage.py

0 +14 -14

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

IPython/deathrow/Gnuplot2.py

0 +22 -22

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

IPython/deathrow/gui/wx/ipshell_nonblocking.py

0 +34 -34

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

IPython/deathrow/gui/wx/ipython_history.py

0 +22 -22

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

IPython/deathrow/gui/wx/ipython_view.py

0 +76 -76

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

IPython/deathrow/gui/wx/thread_ex.py

0 +11 -11

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

IPython/deathrow/gui/wx/wxIPython.py

0 +40 -40

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

IPython/deathrow/ipy_constants.py

0 +63 -63

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

IPython/deathrow/ipy_defaults.py

0 +5 -5

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

IPython/deathrow/ipy_profile_sh.py

0 +34 -34

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

IPython/deathrow/ipy_profile_zope.py

0 +3 -3

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

IPython/deathrow/ipy_vimserver.py

0 +4 -4

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

IPython/deathrow/numutils.py

0 +10 -10

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

IPython/deathrow/oldfrontend/asyncfrontendbase.py

0 +12 -12

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

IPython/deathrow/oldfrontend/cocoa/cocoa_frontend.py

0 +137 -137

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

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

0 +1 -1

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

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

0 +10 -10

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

IPython/deathrow/oldfrontend/frontendbase.py

0 +99 -99

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

IPython/deathrow/oldfrontend/linefrontendbase.py

0 +24 -24

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

IPython/deathrow/oldfrontend/prefilterfrontend.py

0 +16 -16

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

IPython/deathrow/oldfrontend/process/killableprocess.py

0 +6 -6

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

IPython/deathrow/oldfrontend/process/pipedprocess.py

0 +5 -5

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

IPython/deathrow/oldfrontend/tests/test_asyncfrontendbase.py

0 +24 -24

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

IPython/deathrow/oldfrontend/tests/test_frontendbase.py

0 +2 -2

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

IPython/deathrow/oldfrontend/tests/test_linefrontend.py

0 +1 -1

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

IPython/deathrow/oldfrontend/tests/test_prefilterfrontend.py

0 +5 -5

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

IPython/deathrow/oldfrontend/tests/test_process.py

0 +3 -3

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

IPython/deathrow/oldfrontend/wx/console_widget.py

0 +47 -47

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

IPython/deathrow/oldfrontend/wx/ipythonx.py

0 +5 -5

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

IPython/deathrow/oldfrontend/wx/wx_frontend.py

0 +34 -34

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

IPython/deathrow/oldfrontend/zopeinterface.py

0 +1 -1

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

IPython/deathrow/tests/test_prefilter.py

0 +25 -25

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

IPython/deathrow/twshell.py

0 +26 -26

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

IPython/extensions/parallelmagic.py

0 +20 -20

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

IPython/external/Itpl/_Itpl.py

0 +11 -11

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

IPython/external/decorator/_decorator.py

0 +11 -11

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

IPython/external/decorators/_decorators.py

0 +3 -3

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

IPython/external/guid/_guid.py

0 +28 -28

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

IPython/external/mglob/_mglob.py

0 +38 -38

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

IPython/external/pyparsing/_pyparsing.py

0 +10 -10

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

IPython/external/qt.py

0 +2 -2

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

IPython/external/ssh/tunnel.py

0 +31 -31

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

IPython/frontend/html/notebook/handlers.py

0 +9 -9

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

IPython/frontend/qt/base_frontend_mixin.py

0 +5 -5

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

IPython/frontend/qt/console/ansi_code_processor.py

0 +8 -8

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

IPython/frontend/qt/console/bracket_matcher.py

0 +2 -2

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

IPython/frontend/qt/console/call_tip_widget.py

0 +4 -4

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

IPython/frontend/qt/console/completion_lexer.py

0 +3 -3

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

IPython/frontend/qt/console/completion_widget.py

0 +6 -6

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

IPython/frontend/qt/console/console_widget.py

0 +43 -43

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

IPython/frontend/qt/console/frontend_widget.py

0 +10 -10

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

IPython/frontend/qt/console/history_console_widget.py

0 +10 -10

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

IPython/frontend/qt/console/ipython_widget.py

0 +11 -11

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

IPython/frontend/qt/console/kill_ring.py

0 +6 -6

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

IPython/frontend/qt/console/pygments_highlighter.py

0 +2 -2

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

IPython/frontend/qt/console/rich_ipython_widget.py

0 +2 -2

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

IPython/frontend/qt/kernelmanager.py

0 +8 -8

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

IPython/frontend/qt/rich_text.py

0 +4 -4

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

IPython/frontend/terminal/embed.py

0 +3 -3

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

IPython/frontend/terminal/interactiveshell.py

0 +37 -37

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

IPython/frontend/terminal/ipapp.py

0 +5 -5

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

IPython/lib/clipboard.py

0 +3 -3

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

IPython/lib/deepreload.py

0 +11 -11

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

IPython/lib/demo.py

0 +23 -23

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

IPython/lib/display.py

0 +11 -11

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

IPython/lib/guisupport.py

0 +3 -3

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

IPython/lib/inputhookglut.py

0 +6 -6

             # Frame per second : 60
             # Should probably be an IPython option
             glut_fps = 60
             # Display mode : double buffeed + rgba + depth
             # Should probably be an IPython option
             glutMainLoopEvent = None
             if sys.platform == 'darwin':
                 try:
                     glutCheckLoop = platform.createBaseFunction(
                         'glutCheckLoop', dll=platform.GLUT, resultType=None,
                         argTypes=[],
                         doc='glutCheckLoop(  ) -> None',
                         argNames=(),
                         )
                 except AttributeError:
             #-----------------------------------------------------------------------------
             def inputhook_glut():
                 """Run the pyglet event loop by processing pending events only.
                 This keeps processing pending events until stdin is ready.  After
                 processing all pending events, a call to time.sleep is inserted.  This is
                 needed, otherwise, CPU usage is at 100%.  This sleep time should be tuned
                     while not stdin_ready():
                         glutMainLoopEvent()
                         # We need to sleep at this point to keep the idle CPU load
                         # low.  However, if sleep to long, GUI response is poor.  As
                         # a compromise, we watch how often GUI events are being processed
                         # and switch between a short and long sleep time.  Here are some
                         # stats useful in helping to tune this.

IPython/lib/inputhookpyglet.py

0 +2 -2

             def inputhook_pyglet():
                 """Run the pyglet event loop by processing pending events only.
                 This keeps processing pending events until stdin is ready.  After
                 processing all pending events, a call to time.sleep is inserted.  This is
                 needed, otherwise, CPU usage is at 100%.  This sleep time should be tuned
                             flip(window)
                         # We need to sleep at this point to keep the idle CPU load
                         # low.  However, if sleep to long, GUI response is poor.  As
                         # a compromise, we watch how often GUI events are being processed
                         # and switch between a short and long sleep time.  Here are some
                         # stats useful in helping to tune this.

IPython/lib/inputhookwx.py

0 +9 -9

             def inputhook_wx1():
                 """Run the wx event loop by processing pending events only.
                 This approach seems to work, but its performance is not great as it
                 relies on having PyOS_InputHook called regularly.
                 """
                 try:
             def inputhook_wx2():
                 """Run the wx event loop, polling for stdin.
                 This version runs the wx eventloop for an undetermined amount of time,
                 during which it periodically checks to see if anything is ready on
                 stdin.  If anything is ready on stdin, the event loop exits.
                 The argument to elr.Run controls how often the event loop looks at stdin.
                 This determines the responsiveness at the keyboard.  A setting of 1000
                 enables a user to type at most 1 char per second.  I have found that a
                 setting of 10 gives good keyboard response.  We can shorten it further,
                 but eventually performance would suffer from calling select/kbhit too
                 often.
                 """
                 try:
             def inputhook_wx3():
                 """Run the wx event loop by processing pending events only.
                 This is like inputhook_wx1, but it keeps processing pending events
                 until stdin is ready.  After processing all pending events, a call to
                 time.sleep is inserted.  This is needed, otherwise, CPU usage is at 100%.
                 This sleep time should be tuned though for best performance.
                 """
                                 evtloop.Dispatch()
                             app.ProcessIdle()
                             # We need to sleep at this point to keep the idle CPU load
                             # low.  However, if sleep to long, GUI response is poor.  As
                             # a compromise, we watch how often GUI events are being processed
                             # and switch between a short and long sleep time.  Here are some
                             # stats useful in helping to tune this.

IPython/lib/irunner.py

0 +15 -15

                 self.close() will trigger an exception because it tries to call os.close(),
                 and os is now None.
                 """
                 if pexpect.__version__[:3] >= '2.2':
                     # No need to patch, fix is already the upstream version.
                     return
                 def __del__(self):
                     """This makes sure that no system resources are left open.
                     Python only garbage collects Python objects. OS file descriptors
             # The generic runner class
             class InteractiveRunner(object):
                 """Class to run a sequence of commands through an interactive program."""
                 def __init__(self,program,prompts,args=None,out=sys.stdout,echo=True):
                     """Construct a runner.
                       increase this value (it is measured in seconds).  Note that this
                       variable is not honored at all by older versions of pexpect.
                     """
                     self.program = program
                     self.prompts = prompts
                     if args is None: args = []
                     else:
                         # Quiet mode, all writes are no-ops
                         write = lambda s: None
                     c = self.child
                     prompts = c.compile_pattern_list(self.prompts)
                     prompt_idx = c.expect_list(prompts)
                     if get_output:
                         output = []
                         store_output = output.append
                     for cmd in source:
                         # skip blank lines for all matches to the 'main' prompt, while the
                         # secondary prompts do not
                             write(c.before)
                             end_normal = False
                             break
                         write(c.before)
                         # With an echoing process, the output we get in c.before contains
                     # hangs on the second invocation.
                     if c.isalive():
                         c.send('\n')
                     # Return any requested output
                     if get_output:
                         return ''.join(output)
                 def main(self,argv=None):
                     """Run as a command-line script."""
                 pexpect need to be matched to the actual prompts, so user-customized
                 prompts would break this.
                 """
                 def __init__(self,program = 'ipython',args=None,out=sys.stdout,echo=True):
                     """New runner, optionally passing the ipython command to use."""
                     args0 = ['--colors=NoColor',
             class SAGERunner(InteractiveRunner):
                 """Interactive SAGE runner.
                 WARNING: this runner only works if you manually adjust your SAGE
                 configuration so that the 'color' option in the configuration file is set to
                 'NoColor', because currently the prompt matching regexp does not identify
                 color sequences."""
                 def __init__(self,program='sage',args=None,out=sys.stdout,echo=True):
                 def __init__(self,out=sys.stdout):
                     """Instantiate a code runner."""
                     self.out = out
                     self.runner = None
                     self.runnerClass = None
                     self.runnerClass = runnerClass
                     self.runner = runnerClass(out=self.out)
                     return self.runner
                 def __call__(self,fname):
                     """Return a runner for the given filename."""

IPython/lib/tests/test_irunner_pylab_magic.py

0 +2 -2

             """Test suite for pylab_import_all magic
             Modified from the irunner module but using regex.
             """
             # Global to make tests extra verbose and help debugging
                 def _test_runner(self,runner,source,output):
                     """Test that a given runner's input/output match."""
                     runner.run_source(source)
                     out = self.out.getvalue()
                     #out = ''

IPython/nbformat/v2/__init__.py

0 +3 -3

                 format (json/py) and the notebook name. This logic can be
                 summarized as follows:
                 * notebook.ipynb -> (notebook.ipynb, notebook, json)
                 * notebook.json  -> (notebook.json, notebook, json)
                 * notebook.py    -> (notebook.py, notebook, py)
                 * notebook       -> (notebook.ipynb, notebook, json)
                 Returns
                 -------
                 (fname, name, format) : (unicode, unicode, unicode)
                     The filename, notebook name and format.
                 """
                 if fname.endswith(u'.ipynb'):
                     format = u'json'

IPython/nbformat/v2/nbbase.py

0 +2 -2

             """The basic dict based notebook format.
             The Python representation of a notebook is a nested structure of
             dictionary subclasses that support attribute access
             (IPython.utils.ipstruct.Struct). The functions in this module are merely
             helpers to build the structs in the right form.
             def new_output(output_type=None, output_text=None, output_png=None,
                 output_html=None, output_svg=None, output_latex=None, output_json=None,
                 output_javascript=None, output_jpeg=None, prompt_number=None,
                 etype=None, evalue=None, traceback=None):
                 """Create a new code cell with input and output"""

IPython/nbformat/v2/nbpy.py

0 +1 -1

                                 cells.append(cell)
                             state = u'codecell'
                             cell_lines = []
                         elif line.startswith(u'# <htmlcell>'):
                             cell = self.new_cell(state, cell_lines)
                             if cell is not None:
                                 cells.append(cell)

IPython/parallel/apps/ipclusterapp.py

0 +31 -31

             from IPython.utils.daemonize import daemonize
             from IPython.utils.importstring import import_item
             from IPython.utils.sysinfo import num_cpus
             from IPython.utils.traitlets import (Int, Unicode, Bool, CFloat, Dict, List,
                                                     DottedObjectName)
             from IPython.parallel.apps.baseapp import (
             directory. Cluster directories contain configuration, log and
             security related files and are named using the convention
             'profile_<name>' and should be creating using the 'start'
             subcommand of 'ipcluster'. If your cluster directory is in
             the cwd or the ipython directory, you can simply refer to it
             using its profile name, 'ipcluster start --n=4 --profile=<profile>`,
             otherwise use the 'profile-dir' option.
             Stop a running ipython cluster by its profile name or cluster
             directory. Cluster directories are named using the convention
             'profile_<name>'. If your cluster directory is in
             the cwd or the ipython directory, you can simply refer to it
             using its profile name, 'ipcluster stop --profile=<profile>`, otherwise
             use the '--profile-dir' option.
             Cluster directories contain configuration, log and
             security related files and are named using the convention
             'profile_<name>' and should be creating using the 'start'
             subcommand of 'ipcluster'. If your cluster directory is in
             the cwd or the ipython directory, you can simply refer to it
             using its profile name, 'ipcluster engines --n=4 --profile=<profile>`,
             otherwise use the 'profile-dir' option.
                 description = stop_help
                 examples = _stop_examples
                 config_file_name = Unicode(default_config_file_name)
                 signal = Int(signal.SIGINT, config=True,
                     help="signal to use for stopping processes.")
                 aliases = Dict(stop_aliases)
                 def start(self):
                     """Start the app for the stop subcommand."""
                     try:
                         # can watch for to learn how I existed.
                         self.remove_pid_file()
                         self.exit(ALREADY_STOPPED)
                     if not self.check_pid(pid):
                         self.log.critical(
                             'Cluster [pid=%r] is not running.' % pid
                         # Here I exit with a unusual exit status that other processes
                         # can watch for to learn how I existed.
                         self.exit(ALREADY_STOPPED)
                     elif os.name=='posix':
                         sig = self.signal
                         self.log.info(
                             self.log.error("Stopping cluster failed, assuming already dead.",
                                 exc_info=True)
                         self.remove_pid_file()
             engine_aliases = {}
             engine_aliases.update(base_aliases)
             engine_aliases.update(dict(
                     launchers = launcher.all_launchers
                     eslaunchers = [ l for l in launchers if 'EngineSet' in l.__name__]
                     return [ProfileDir]+eslaunchers
                 n = Int(num_cpus(), config=True,
                     help="""The number of engines to start. The default is to use one for each
                     CPU on your machine""")
                     to use various batch systems to launch your engines, such as PBS,SGE,MPIExec,etc.
                     Each launcher class has its own set of configuration options, for making sure
                     it will work in your environment.
                     You can also write your own launcher, and specify it's absolute import path,
                     as in 'mymodule.launcher.FTLEnginesLauncher`.
                     Examples include:
                         LocalEngineSetLauncher : start engines locally as subprocesses [default]
                         MPIExecEngineSetLauncher : use mpiexec to launch in an MPI environment
                         PBSEngineSetLauncher : use PBS (qsub) to submit engines to a batch queue
                     super(IPClusterEngines, self).initialize(argv)
                     self.init_signal()
                     self.init_launchers()
                 def init_launchers(self):
                     self.engine_launcher = self.build_launcher(self.engine_launcher_class, 'EngineSet')
                     self.engine_launcher.on_stop(lambda r: self.loop.stop())
                 def init_signal(self):
                     # Setup signals
                     signal.signal(signal.SIGINT, self.sigint_handler)
                 def build_launcher(self, clsname, kind=None):
                     """import and instantiate a Launcher based on importstring"""
                     if '.' not in clsname:
                         profile_dir=self.profile_dir.location, cluster_id=self.cluster_id,
                     )
                     return launcher
                 def start_engines(self):
                     self.log.info("Starting %i engines"%self.n)
                     self.engine_launcher.start(self.n)
                 def sigint_handler(self, signum, frame):
                     self.log.debug("SIGINT received, stopping launchers...")
                     self.stop_launchers()
                 def start_logging(self):
                     # Remove old log files of the controller and engine
                     if self.clean_logs:
                     """Start the app for the engines subcommand."""
                     self.log.info("IPython cluster: started")
                     # First see if the cluster is already running
                     # Now log and daemonize
                     self.log.info(
                         'Starting engines with [daemon=%r]' % self.daemonize
                 def _classes_default(self,):
                     from IPython.parallel.apps import launcher
                     return [ProfileDir] + [IPClusterEngines] + launcher.all_launchers
                 clean_logs = Bool(True, config=True,
                     help="whether to cleanup old logs before starting")
                 delay = CFloat(1., config=True,
                     config=True,
                     helep="""The class for launching a Controller. Change this value if you want
                     your controller to also be launched by a batch system, such as PBS,SGE,MPIExec,etc.
                     Each launcher class has its own set of configuration options, for making sure
                     it will work in your environment.
                     Examples include:
                         LocalControllerLauncher : start engines locally as subprocesses
                         MPIExecControllerLauncher : use mpiexec to launch engines in an MPI universe
                         PBSControllerLauncher : use PBS (qsub) to submit engines to a batch queue
                 reset = Bool(False, config=True,
                     help="Whether to reset config files as part of '--create'."
                     )
                 # flags = Dict(flags)
                 aliases = Dict(start_aliases)
                     self.controller_launcher = self.build_launcher(self.controller_launcher_class, 'Controller')
                     self.engine_launcher = self.build_launcher(self.engine_launcher_class, 'EngineSet')
                     self.controller_launcher.on_stop(self.stop_launchers)
                 def start_controller(self):
                     self.controller_launcher.start()
                 def stop_controller(self):
                     # self.log.info("In stop_controller")
                     if self.controller_launcher and self.controller_launcher.running:
                             self.exit(ALREADY_STARTED)
                         else:
                             self.remove_pid_file()
                     # Now log and daemonize
                     self.log.info(
                             'stop' : (base+'Stop', stop_help),
                             'engines' : (base+'Engines', engines_help),
                 }
                 # no aliases or flags for parent App
                 aliases = Dict()
                 flags = Dict()
                 def start(self):
                     if self.subapp is None:
                         print "No subcommand specified. Must specify one of: %s"%(self.subcommands.keys())

IPython/parallel/apps/launcher.py

0 +50 -50

                 # the work_dir option.
                 work_dir = Unicode(u'.')
                 loop = Instance('zmq.eventloop.ioloop.IOLoop')
                 start_data = Any()
                 stop_data = Any()
                 def _loop_default(self):
                     return ioloop.IOLoop.instance()
                 ``self.work_dir``.
                 """
                 # This is used to to construct self.args, which is passed to
                 # spawnProcess.
                 cmd_and_args = List([])
                 poll_frequency = Int(100) # in ms
                     self.killer.start()
                 # callbacks, etc:
                 def handle_stdout(self, fd, events):
                     if WINDOWS:
                         line = self.stdout.recv()
                         self.log.info(line[:-1])
                     else:
                         self.poll()
                 def handle_stderr(self, fd, events):
                     if WINDOWS:
                         line = self.stderr.recv()
                         self.log.error(line[:-1])
                     else:
                         self.poll()
                 def poll(self):
                     status = self.process.poll()
                     if status is not None:
                     This can help force the engines to get their ids in order, or limit
                     process flood when starting many engines."""
                 )
                 # launcher class
                 launcher_class = LocalEngineLauncher
                 launchers = Dict()
                 stop_data = Dict()
                 def __init__(self, work_dir=u'.', config=None, **kwargs):
                     super(LocalEngineSetLauncher, self).__init__(
                         work_dir=work_dir, config=config, **kwargs
                         el = self.launcher_class(work_dir=self.work_dir, config=self.config, log=self.log,
                                                 profile_dir=self.profile_dir, cluster_id=self.cluster_id,
                         )
                         # Copy the engine args over to each engine launcher.
                         el.engine_cmd = copy.deepcopy(self.engine_cmd)
                         el.engine_args = copy.deepcopy(self.engine_args)
                 def stop(self):
                     return self.interrupt_then_kill()
                 def _notice_engine_stopped(self, data):
                     pid = data['pid']
                     for idx,el in self.launchers.iteritems():
                 @property
                 def program(self):
                     return self.controller_cmd
                 @property
                 def program_args(self):
                     return self.cluster_args + self.controller_args
                 @property
                 def program(self):
                     return self.engine_cmd
                 @property
                 def program_args(self):
                     return self.cluster_args + self.engine_args
                         self.hostname = hostname
                     if user is not None:
                         self.user = user
                     return super(SSHLauncher, self).start()
                 def signal(self, sig):
                     if self.state == 'running':
                         # send escaped ssh connection-closer
                         self.process.stdin.write('~.')
                         self.process.stdin.flush()
             class SSHControllerLauncher(SSHLauncher, ControllerMixin):
                 @property
                 def program(self):
                     return self.controller_cmd
                 @property
                 def program_args(self):
                     return self.cluster_args + self.controller_args
                 @property
                 def program(self):
                     return self.engine_cmd
                 @property
                 def program_args(self):
                     return self.cluster_args + self.engine_args
             class SSHEngineSetLauncher(LocalEngineSetLauncher):
                 launcher_class = SSHEngineLauncher
                 engines = Dict(config=True,
                     help="""dict of engines to launch.  This is a dict by hostname of ints,
                     corresponding to the number of engines to start on that host.""")
                 def start(self, n):
                     """Start engines by profile or profile_dir.
                     `n` is ignored, and the `engines` config property is used instead.
                     """
                     dlist = []
                     for host, n in self.engines.iteritems():
                         if isinstance(n, (tuple, list)):
                             n, args = n
                         else:
                             args = copy.deepcopy(self.engine_args)
                         if '@' in host:
                             user,host = host.split('@',1)
                         else:
                             el = self.launcher_class(work_dir=self.work_dir, config=self.config, log=self.log,
                                                     profile_dir=self.profile_dir, cluster_id=self.cluster_id,
                             )
                             # Copy the engine args over to each engine launcher.
                             el.engine_cmd = self.engine_cmd
                             el.engine_args = args
                             dlist.append(d)
                     self.notify_start(dlist)
                     return dlist
             #-----------------------------------------------------------------------------
                 def find_args(self):
                     return [u'job.exe']
                 def parse_job_id(self, output):
                     """Take the output of the submit command and return the job id."""
                     m = re.search(self.job_id_regexp, output)
                     job = IPControllerJob(config=self.config)
                     t = IPControllerTask(config=self.config)
                     # The tasks work directory is *not* the actual work directory of
                     # the controller. It is used as the base path for the stdout/stderr
                     # files that the scheduler redirects to.
                     t.work_directory = self.profile_dir
                     for i in range(n):
                         t = IPEngineTask(config=self.config)
                         # The tasks work directory is *not* the actual work directory of
                         # the engine. It is used as the base path for the stdout/stderr
                         # files that the scheduler redirects to.
                         t.work_directory = self.profile_dir
                     help="The filename of the instantiated batch script.")
                 queue = Unicode(u'', config=True,
                     help="The PBS Queue.")
                 def _queue_changed(self, name, old, new):
                     self.context[name] = new
                 n = Int(1)
                 _n_changed = _queue_changed
                 # not configurable, override in subclasses
                 # PBS Job Array regex
                 job_array_regexp = Unicode('')
                 # the Formatter instance for rendering the templates:
                 formatter = Instance(EvalFormatter, (), {})
                 def find_args(self):
                     return self.submit_command + [self.batch_file]
                 def __init__(self, work_dir=u'.', config=None, **kwargs):
                     super(BatchSystemLauncher, self).__init__(
                         work_dir=work_dir, config=config, **kwargs
                     if not self.batch_template:
                         # third (last) priority is default_template
                         self.batch_template = self.default_template
                         # add jobarray or queue lines to user-specified template
                         # note that this is *only* when user did not specify a template.
                         regex = re.compile(self.job_array_regexp)
                             self.log.info("adding job array settings to batch script")
                             firstline, rest = self.batch_template.split('\n',1)
                             self.batch_template = u'\n'.join([firstline, self.job_array_template, rest])
                         regex = re.compile(self.queue_regexp)
                         # print regex.search(self.batch_template)
                         if self.queue and not regex.search(self.batch_template):
                             self.log.info("adding PBS queue settings to batch script")
                             firstline, rest = self.batch_template.split('\n',1)
                             self.batch_template = u'\n'.join([firstline, self.queue_template, rest])
                     script_as_string = self.formatter.format(self.batch_template, **self.context)
                     self.log.info('Writing instantiated batch script: %s' % self.batch_file)
                     with open(self.batch_file, 'w') as f:
                         f.write(script_as_string)
                     os.chmod(self.batch_file, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
                     # can be used in the batch script template as {profile_dir}
                     self.write_batch_script(n)
                     output = check_output(self.args, env=os.environ)
                     job_id = self.parse_job_id(output)
                     self.notify_start(job_id)
                     return job_id
                     help="The PBS delete command ['qsub']")
                 job_id_regexp = Unicode(r'\d+', config=True,
                     help="Regular expresion for identifying the job ID [r'\d+']")
                 batch_file = Unicode(u'')
                 job_array_regexp = Unicode('#PBS\W+-t\W+[\w\d\-\$]+')
                 job_array_template = Unicode('#PBS -t 1-{n}')
             %s --log-to-file --profile-dir="{profile_dir}" --cluster-id="{cluster_id}"
             """%(' '.join(ipcontroller_cmd_argv)))
                 def start(self):
                     """Start the controller by profile or profile_dir."""
                     self.log.info("Starting PBSControllerLauncher: %r" % self.args)
             class LSFLauncher(BatchSystemLauncher):
                 """A BatchSystemLauncher subclass for LSF."""
                 submit_command = List(['bsub'], config=True,
                                       help="The PBS submit command ['bsub']")
                 delete_command = List(['bkill'], config=True,
                                       help="The PBS delete command ['bkill']")
                 job_id_regexp = Unicode(r'\d+', config=True,
                                         help="Regular expresion for identifying the job ID [r'\d+']")
                 batch_file = Unicode(u'')
                 job_array_regexp = Unicode('#BSUB[ \t]-J+\w+\[\d+-\d+\]')
                 job_array_template = Unicode('#BSUB -J ipengine[1-{n}]')
                 queue_regexp = Unicode('#BSUB[ \t]+-q[ \t]+\w+')
                 queue_template = Unicode('#BSUB -q {queue}')
                 def start(self, n):
                     """Start n copies of the process using LSF batch system.
                     This cant inherit from the base class because bsub expects
             class LSFControllerLauncher(LSFLauncher, BatchClusterAppMixin):
                 """Launch a controller using LSF."""
                 batch_file_name = Unicode(u'lsf_controller', config=True,
                                           help="batch file name for the controller job.")
                 default_template= Unicode("""#!/bin/sh
                 #BSUB -J ipcontroller
                 #BSUB -oo ipcontroller.o.%%J
                 #BSUB -eo ipcontroller.e.%%J
                 %s --log-to-file --profile-dir="{profile_dir}" --cluster-id="{cluster_id}"
                 """%(' '.join(ipcontroller_cmd_argv)))
                 def start(self):
                     """Start the controller by profile or profile_dir."""
                     self.log.info("Starting LSFControllerLauncher: %r" % self.args)
                 batch_file_name = Unicode(u'lsf_engines', config=True,
                                           help="batch file name for the engine(s) job.")
                 default_template= Unicode(u"""#!/bin/sh
                 #BSUB -oo ipengine.o.%%J
                 #BSUB -eo ipengine.e.%%J
                 %s --profile-dir="{profile_dir}" --cluster-id="{cluster_id}"
                 """%(' '.join(ipengine_cmd_argv)))
                 def start(self, n):
                     """Start n engines by profile or profile_dir."""
                     self.log.info('Starting %i engines with LSFEngineSetLauncher: %r' % (n, self.args))

IPython/parallel/apps/winhpcjob.py

0 +3 -3

             # encoding: utf-8
             """
             Job and task components for writing .xml files that the Windows HPC Server
 can use to start jobs.
             Authors:
                     the_uuid = uuid.uuid1()
                     self.std_out_file_path = os.path.join('log','ipengine-%s.out' % the_uuid)
                     self.std_err_file_path = os.path.join('log','ipengine-%s.err' % the_uuid)
                 @property
                 def command_line(self):
                     return ' '.join(self.engine_cmd + self.engine_args)
             # j.job_name = 'IPCluster'
             # j.username = 'GNET\\bgranger'
             # j.requested_nodes = 'GREEN'
+            #
             # t = WinHPCTask(None)
             # t.task_name = 'Controller'
             # t.command_line = r"\\blue\domainusers$\bgranger\Python\Python25\Scripts\ipcontroller.exe --log-to-file -p default --log-level 10"

IPython/parallel/client/asyncresult.py

0 +42 -42

             class AsyncResult(object):
                 """Class for representing results of non-blocking calls.
                 Provides the same interface as :py:class:`multiprocessing.pool.AsyncResult`.
                 """
                 msg_ids = None
                 _targets = None
                 _tracker = None
                 _single_result = False
                 def __init__(self, client, msg_ids, fname='unknown', targets=None, tracker=None):
                     if isinstance(msg_ids, basestring):
                         # always a list
                         self._single_result = not isinstance(targets, (list, tuple))
                     else:
                         self._single_result = False
                 def __repr__(self):
                     if self._ready:
                         return "<%s: finished>"%(self.__class__.__name__)
                     else:
                         return "<%s: %s>"%(self.__class__.__name__,self._fname)
                 def _reconstruct_result(self, res):
                     """Reconstruct our result from actual result list (always a list)
                     Override me in subclasses for turning a list of results
                     into the expected form.
                     """
                         return res[0]
                     else:
                         return res
                 def get(self, timeout=-1):
                     """Return the result when it arrives.
                     If `timeout` is not ``None`` and the result does not arrive within
                     `timeout` seconds then ``TimeoutError`` is raised. If the
                     remote call raised an exception then that exception will be reraised
                     """
                     if not self.ready():
                         self.wait(timeout)
                     if self._ready:
                         if self._success:
                             return self._result
                             raise self._exception
                     else:
                         raise error.TimeoutError("Result not ready.")
                 def ready(self):
                     """Return whether the call has completed."""
                     if not self._ready:
                         self.wait(0)
                     return self._ready
                 def wait(self, timeout=-1):
                     """Wait until the result is available or until `timeout` seconds pass.
                     This method always returns None.
                     """
                     if self._ready:
                             self._success = True
                         finally:
                             self._metadata = map(self._client.metadata.get, self.msg_ids)
                 def successful(self):
                     """Return whether the call completed without raising an exception.
                     Will raise ``AssertionError`` if the result is not ready.
                     """
                     assert self.ready()
                     return self._success
                 #----------------------------------------------------------------
                 # Extra methods not in mp.pool.AsyncResult
                 #----------------------------------------------------------------
                 def get_dict(self, timeout=-1):
                     """Get the results as a dict, keyed by engine_id.
                     timeout behavior is described in `get()`.
                     """
                     results = self.get(timeout)
                     engine_ids = [ md['engine_id'] for md in self._metadata ]
                     bycount = sorted(engine_ids, key=lambda k: engine_ids.count(k))
                     if maxcount > 1:
                         raise ValueError("Cannot build dict, %i jobs ran on engine #%i"%(
                                 maxcount, bycount[-1]))
                     return dict(zip(engine_ids,results))
                 @property
                 def result(self):
                     """result property wrapper for `get(timeout=0)`."""
                     return self.get()
                 # abbreviated alias:
                 r = result
                 @property
                 @check_ready
                 def metadata(self):
                         return self._metadata[0]
                     else:
                         return self._metadata
                 @property
                 def result_dict(self):
                     """result property as a dict."""
                     return self.get_dict()
                 def __dict__(self):
                     return self.get_dict(0)
                 def abort(self):
                     """abort my tasks."""
                     assert not self.ready(), "Can't abort, I am already done!"
                 def sent(self):
                     """check whether my messages have been sent."""
                     return self._tracker.done
                 def wait_for_send(self, timeout=-1):
                     """wait for pyzmq send to complete.
                     This is necessary when sending arrays that you intend to edit in-place.
                     `timeout` is in seconds, and will raise TimeoutError if it is reached
                     before the send completes.
                 #-------------------------------------
                 # dict-access
                 #-------------------------------------
                 @check_ready
                 def __getitem__(self, key):
                     """getitem returns result value(s) if keyed by int/slice, or metadata if key is str.
                             return values
                     else:
                         raise TypeError("Invalid key type %r, must be 'int','slice', or 'str'"%type(key))
                 @check_ready
                 def __getattr__(self, key):
                     """getattr maps to getitem for convenient attr access to metadata."""
                         raise AttributeError("%r object has no attribute %r"%(
                                 self.__class__.__name__, key))
                     return self.__getitem__(key)
                 # asynchronous iterator:
                 def __iter__(self):
                     if self._single_result:
                             yield r
             class AsyncMapResult(AsyncResult):
                 """Class for representing results of non-blocking gathers.
                 This will properly reconstruct the gather.
                 """
                 def __init__(self, client, msg_ids, mapObject, fname=''):
                     AsyncResult.__init__(self, client, msg_ids, fname=fname)
                     self._mapObject = mapObject
                     self._single_result = False
                 def _reconstruct_result(self, res):
                     """Perform the gather on the actual results."""
                     return self._mapObject.joinPartitions(res)
                 # asynchronous iterator:
                 def __iter__(self):
                     try:
             class AsyncHubResult(AsyncResult):
                 """Class to wrap pending results that must be requested from the Hub.
                 Note that waiting/polling on these objects requires polling the Hubover the network,
                 so use `AsyncHubResult.wait()` sparingly.
                 """
                 def wait(self, timeout=-1):
                     """wait for result to complete."""
                     start = time.time()
                             self._success = True
                         finally:
                             self._metadata = map(self._client.metadata.get, self.msg_ids)
             __all__ = ['AsyncResult', 'AsyncMapResult', 'AsyncHubResult']

IPython/parallel/client/client.py

0 +198 -198

             class Metadata(dict):
                 """Subclass of dict for initializing metadata values.
                 Attribute access works on keys.
                 These objects have a strict set of keys - errors will raise if you try
                 to add new keys.
                 """
                         }
                     self.update(md)
                     self.update(dict(*args, **kwargs))
                 def __getattr__(self, key):
                     """getattr aliased to getitem"""
                     if key in self.iterkeys():
                         self[key] = value
                     else:
                         raise AttributeError(key)
                 def __setitem__(self, key, value):
                     """strict static key enforcement"""
                     if key in self.iterkeys():
                         dict.__setitem__(self, key, value)
                     else:
                         raise KeyError(key)
             class Client(HasTraits):
                 """A semi-synchronous client to the IPython ZMQ cluster
                 Parameters
                 ----------
                 url_or_file : bytes or unicode; zmq url or path to ipcontroller-client.json
                     Connection information for the Hub's registration.  If a json connector
                     file is given, then likely no further configuration is necessary.
                     Pass an existing zmq.Context instance, otherwise the client will create its own.
                 debug : bool
                     flag for lots of message printing for debug purposes
                 timeout : int/float
                     time (in seconds) to wait for connection replies from the Hub
                     [Default: 10]
                 #-------------- session related args ----------------
                 config : Config object
                     If specified, this will be relayed to the Session for configuration
                 username : str
                 unpacker : str (import_string) or callable
                     The inverse of packer.  Only necessary if packer is specified as *not* one
                     of 'json' or 'pickle'.
                 #-------------- ssh related args ----------------
                 # These are args for configuring the ssh tunnel to be used
                 # credentials are used to forward connections over ssh to the Controller
                 # Note that the ip given in `addr` needs to be relative to sshserver
                 # The most basic case is to leave addr as pointing to localhost (127.0.0.1),
                 # and set sshserver as the same machine the Controller is on. However,
                 # the only requirement is that sshserver is able to see the Controller
                 # (i.e. is within the same trusted network).
                 sshserver : str
                     A string of the form passed to ssh, i.e. 'server.tld' or 'user@server.tld:port'
                     If keyfile or password is specified, and this is not, it will default to
                 sshkey : str; path to ssh private key file
                     This specifies a key to be used in ssh login, default None.
                     Regular default ssh keys will be used without specifying this argument.
                 password : str
                     Your ssh password to sshserver. Note that if this is left None,
                     you will be prompted for it if passwordless key based login is unavailable.
                 paramiko : bool
                     flag for whether to use paramiko instead of shell ssh for tunneling.
                     [default: True on win32, False else]
                 ------- exec authentication args -------
                 If even localhost is untrusted, you can have some protection against
                 unauthorized execution by signing messages with HMAC digests.
                 Messages are still sent as cleartext, so if someone can snoop your
                 loopback traffic this will not protect your privacy, but will prevent
                 unauthorized execution.
                 exec_key : str
                     an authentication key or file containing a key
                     default: None
                 Attributes
                 ----------
                 ids : list of int engine IDs
                     requesting the ids attribute always synchronizes
                     the registration state. To request ids without synchronization,
                     use semi-private _ids attributes.
                 history : list of msg_ids
                     a list of msg_ids, keeping track of all the execution
                     messages you have submitted in order.
                 outstanding : set of msg_ids
                     a set of msg_ids that have been submitted, but whose
                     results have not yet been received.
                 results : dict
                     a dict of all our results, keyed by msg_id
                 block : bool
                     determines default behavior when block not specified
                     in execution methods
                 Methods
                 -------
                 spin
                     flushes incoming results and registration state changes
                     control methods spin, and requesting `ids` also ensures up to date
                 wait
                     wait on one or more msg_ids
                 execution methods
                     apply
                     legacy: execute, run
                 data movement
                     push, pull, scatter, gather
                 query methods
                     queue_status, get_result, purge, result_status
                 control methods
                     abort, shutdown
                 """
                 block = Bool(False)
                 outstanding = Set()
                 results = Instance('collections.defaultdict', (dict,))
                 metadata = Instance('collections.defaultdict', (Metadata,))
                 history = List()
                 debug = Bool(False)
                 profile=Unicode()
                 def _profile_default(self):
                     if BaseIPythonApplication.initialized():
                             return u'default'
                     else:
                         return u'default'
                 _outstanding_dict = Instance('collections.defaultdict', (set,))
                 _ids = List()
                 _connected=Bool(False)
                 _closed = False
                 _ignored_control_replies=Int(0)
                 _ignored_hub_replies=Int(0)
                 def __new__(self, *args, **kw):
                     # don't raise on positional args
                     return HasTraits.__new__(self, **kw)
                 def __init__(self, url_or_file=None, profile=None, profile_dir=None, ipython_dir=None,
                         context=None, debug=False, exec_key=None,
                         sshserver=None, sshkey=None, password=None, paramiko=None,
                     if context is None:
                         context = zmq.Context.instance()
                     self._context = context
                     self._setup_profile_dir(self.profile, profile_dir, ipython_dir)
                     if self._cd is not None:
                         if url_or_file is None:
                             url_or_file = pjoin(self._cd.security_dir, 'ipcontroller-client.json')
                     assert url_or_file is not None, "I can't find enough information to connect to a hub!"\
                         " Please specify at least one of url_or_file or profile."
                     try:
                         util.validate_url(url_or_file)
                     except AssertionError:
                             cfg = json.loads(f.read())
                     else:
                         cfg = {'url':url_or_file}
                     # sync defaults from args, json:
                     if sshserver:
                         cfg['ssh'] = sshserver
                     elif not sshserver:
                         # otherwise sync with cfg
                         sshserver = cfg['ssh']
                     self._config = cfg
                     self._ssh = bool(sshserver or sshkey or password)
                     if self._ssh and sshserver is None:
                         # default to ssh via localhost
                         else:
                             password = getpass("SSH Password for %s: "%sshserver)
                     ssh_kwargs = dict(keyfile=sshkey, password=password, paramiko=paramiko)
                     # configure and construct the session
                     if exec_key is not None:
                         if os.path.isfile(exec_key):
                             exec_key = util.asbytes(exec_key)
                             extra_args['key'] = exec_key
                     self.session = Session(**extra_args)
                     self._query_socket = self._context.socket(zmq.DEALER)
                     self._query_socket.setsockopt(zmq.IDENTITY, self.session.bsession)
                     if self._ssh:
                         tunnel.tunnel_connection(self._query_socket, url, sshserver, **ssh_kwargs)
                     else:
                         self._query_socket.connect(url)
                     self.session.debug = self.debug
                     self._notification_handlers = {'registration_notification' : self._register_engine,
                                                 'unregistration_notification' : self._unregister_engine,
                                                 'shutdown_notification' : lambda msg: self.close(),
                     self._queue_handlers = {'execute_reply' : self._handle_execute_reply,
                                             'apply_reply' : self._handle_apply_reply}
                     self._connect(sshserver, ssh_kwargs, timeout)
                 def __del__(self):
                     """cleanup sockets, but _not_ context."""
                     self.close()
                 def _setup_profile_dir(self, profile, profile_dir, ipython_dir):
                     if ipython_dir is None:
                         ipython_dir = get_ipython_dir()
                         except ProfileDirError:
                             pass
                     self._cd = None
                 def _update_engines(self, engines):
                     """Update our engines dict and _ids from a dict of the form: {id:uuid}."""
                     for k,v in engines.iteritems():
                     if sorted(self._engines.keys()) != range(len(self._engines)) and \
                                     self._task_scheme == 'pure' and self._task_socket:
                         self._stop_scheduling_tasks()
                 def _stop_scheduling_tasks(self):
                     """Stop scheduling tasks because an engine has been unregistered
                     from a pure ZMQ scheduler.
                         msg += " If you were running tasks when this happened, " +\
                                "some `outstanding` msg_ids may never resolve."
                     warnings.warn(msg, RuntimeWarning)
                 def _build_targets(self, targets):
                     """Turn valid target IDs or 'all' into two lists:
                     (int_ids, uuids).
                         # flush notification socket if no engines yet, just in case
                         if not self.ids:
                             raise error.NoEnginesRegistered("Can't build targets without any engines")
                     if targets is None:
                         targets = self._ids
                     elif isinstance(targets, basestring):
                         if targets not in self._ids:
                             raise IndexError("No such engine: %i"%targets)
                         targets = [targets]
                     if isinstance(targets, slice):
                         indices = range(len(self._ids))[targets]
                         ids = self.ids
                         targets = [ ids[i] for i in indices ]
                     if not isinstance(targets, (tuple, list, xrange)):
                         raise TypeError("targets by int/slice/collection of ints only, not %s"%(type(targets)))
                     return [util.asbytes(self._engines[t]) for t in targets], list(targets)
                 def _connect(self, sshserver, ssh_kwargs, timeout):
                     """setup all our socket connections to the cluster. This is called from
                     __init__."""
                     # Maybe allow reconnecting?
                     if self._connected:
                         return
                             return tunnel.tunnel_connection(s, url, sshserver, **ssh_kwargs)
                         else:
                             return s.connect(url)
                     self.session.send(self._query_socket, 'connection_request')
                     # use Poller because zmq.select has wrong units in pyzmq 2.1.7
                     poller = zmq.Poller()
                     else:
                         self._connected = False
                         raise Exception("Failed to connect!")
                 #--------------------------------------------------------------------------
                 # handlers and callbacks for incoming messages
                 #--------------------------------------------------------------------------
                 def _unwrap_exception(self, content):
                     """unwrap exception, and remap engine_id to int."""
                     e = error.unwrap_exception(content)
                         eid = self._engines[e_uuid]
                         e.engine_info['engine_id'] = eid
                     return e
                 def _extract_metadata(self, header, parent, content):
                     md = {'msg_id' : parent['msg_id'],
                           'received' : datetime.now(),
                           'after' : parent.get('after', []),
                           'status' : content['status'],
                         }
                     if md['engine_uuid'] is not None:
                         md['engine_id'] = self._engines.get(md['engine_uuid'], None)
                     if 'date' in parent:
                         md['submitted'] = parent['date']
                     if 'started' in header:
                     if 'date' in header:
                         md['completed'] = header['date']
                     return md
                 def _register_engine(self, msg):
                     """Register a new engine, and update our connection info."""
                     content = msg['content']
                     if eid in self._ids:
                         self._ids.remove(eid)
                         uuid = self._engines.pop(eid)
                         self._handle_stranded_msgs(eid, uuid)
                     if self._task_socket and self._task_scheme == 'pure':
                         self._stop_scheduling_tasks()
                 def _handle_stranded_msgs(self, eid, uuid):
                     """Handle messages known to be on an engine when the engine unregisters.
                     It is possible that this will fire prematurely - that is, an engine will
                     go down after completing a result, and the client will be notified
                     of the unregistration and later receive the successful result.
                     """
                     outstanding = self._outstanding_dict[uuid]
                     for msg_id in list(outstanding):
                         if msg_id in self.results:
                             # we already
                             continue
                         try:
                             raise error.EngineError("Engine %r died while running task %r"%(eid, msg_id))
                         header['date'] = datetime.now()
                         msg = dict(parent_header=parent, header=header, content=content)
                         self._handle_apply_reply(msg)
                 def _handle_execute_reply(self, msg):
                     """Save the reply to an execute_request into our results.
                     execute messages are never actually used. apply is used instead.
                     """
                     parent = msg['parent_header']
                     msg_id = parent['msg_id']
                     if msg_id not in self.outstanding:
                     else:
                         self.outstanding.remove(msg_id)
                     self.results[msg_id] = self._unwrap_exception(msg['content'])
                 def _handle_apply_reply(self, msg):
                     """Save the reply to an apply_request into our results."""
                     parent = msg['parent_header']
                         self.outstanding.remove(msg_id)
                     content = msg['content']
                     header = msg['header']
                     # construct metadata:
                     md = self.metadata[msg_id]
                     md.update(self._extract_metadata(header, parent, content))
                     # is this redundant?
                     self.metadata[msg_id] = md
                     e_outstanding = self._outstanding_dict[md['engine_uuid']]
                     if msg_id in e_outstanding:
                         e_outstanding.remove(msg_id)
                     # construct result:
                     if content['status'] == 'ok':
                         self.results[msg_id] = util.unserialize_object(msg['buffers'])[0]
                         pass
                     else:
                         self.results[msg_id] = self._unwrap_exception(content)
                 def _flush_notifications(self):
                     """Flush notifications of engine registrations waiting
                     in ZMQ queue."""
                         else:
                             handler(msg)
                         idents,msg = self.session.recv(self._notification_socket, mode=zmq.NOBLOCK)
                 def _flush_results(self, sock):
                     """Flush task or queue results waiting in ZMQ queue."""
                     idents,msg = self.session.recv(sock, mode=zmq.NOBLOCK)
                         else:
                             handler(msg)
                         idents,msg = self.session.recv(sock, mode=zmq.NOBLOCK)
                 def _flush_control(self, sock):
                     """Flush replies from the control channel waiting
                     in the ZMQ queue.
                     Currently: ignore them."""
                     if self._ignored_control_replies <= 0:
                         return
                         if self.debug:
                             pprint(msg)
                         idents,msg = self.session.recv(sock, mode=zmq.NOBLOCK)
                 def _flush_ignored_control(self):
                     """flush ignored control replies"""
                     while self._ignored_control_replies > 0:
                         self.session.recv(self._control_socket)
                         self._ignored_control_replies -= 1
                 def _flush_ignored_hub_replies(self):
                     ident,msg = self.session.recv(self._query_socket, mode=zmq.NOBLOCK)
                     while msg is not None:
                         ident,msg = self.session.recv(self._query_socket, mode=zmq.NOBLOCK)
                 def _flush_iopub(self, sock):
                     """Flush replies from the iopub channel waiting
                     in the ZMQ queue.
                         content = msg['content']
                         header = msg['header']
                         msg_type = msg['header']['msg_type']
                         # init metadata:
                         md = self.metadata[msg_id]
                         if msg_type == 'stream':
                             name = content['name']
                             s = md[name] or ''
                             md.update({'pyin' : content['code']})
                         else:
                             md.update({msg_type : content.get('data', '')})
                         # reduntant?
                         self.metadata[msg_id] = md
                         idents,msg = self.session.recv(sock, mode=zmq.NOBLOCK)
                 #--------------------------------------------------------------------------
                 # len, getitem
                 #--------------------------------------------------------------------------
                 def __len__(self):
                     """len(client) returns # of engines."""
                     return len(self.ids)
                 def __getitem__(self, key):
                     """index access returns DirectView multiplexer objects
                     Must be int, slice, or list/tuple/xrange of ints"""
                     if not isinstance(key, (int, slice, tuple, list, xrange)):
                         raise TypeError("key by int/slice/iterable of ints only, not %s"%(type(key)))
                     else:
                         return self.direct_view(key)
                 #--------------------------------------------------------------------------
                 # Begin public methods
                 #--------------------------------------------------------------------------
                 @property
                 def ids(self):
                     """Always up-to-date ids property."""
                     self._flush_notifications()
                     # always copy:
                     return list(self._ids)
                 def close(self):
                     if self._closed:
                         return
                         if isinstance(socket, zmq.Socket) and not socket.closed:
                             socket.close()
                     self._closed = True
                 def spin(self):
                     """Flush any registration notifications and execution results
                     waiting in the ZMQ queue.
                         self._flush_iopub(self._iopub_socket)
                     if self._query_socket:
                         self._flush_ignored_hub_replies()
                 def wait(self, jobs=None, timeout=-1):
                     """waits on one or more `jobs`, for up to `timeout` seconds.
                     Parameters
                     ----------
                     jobs : int, str, or list of ints and/or strs, or one or more AsyncResult objects
                             ints are indices to self.history
                             strs are msg_ids
                     timeout : float
                             a time in seconds, after which to give up.
                             default is -1, which means no timeout
                     Returns
                     -------
                     True : when all msg_ids are done
                     False : timeout reached, some msg_ids still outstanding
                     """
                         time.sleep(1e-3)
                         self.spin()
                     return len(theids.intersection(self.outstanding)) == 0
                 #--------------------------------------------------------------------------
                 # Control methods
                 #--------------------------------------------------------------------------
                 @spin_first
                 def clear(self, targets=None, block=None):
                     """Clear the namespace in target(s)."""
                         self._ignored_control_replies += len(targets)
                     if error:
                         raise error
                 @spin_first
                 def abort(self, jobs=None, targets=None, block=None):
                     """Abort specific jobs from the execution queues of target(s).
                     This is a mechanism to prevent jobs that have already been submitted
                     from executing.
                     Parameters
                     ----------
                     jobs : msg_id, list of msg_ids, or AsyncResult
                         The jobs to be aborted
                     """
                     block = self.block if block is None else block
                     targets = self._build_targets(targets)[0]
                             msg_ids.append(j)
                     content = dict(msg_ids=msg_ids)
                     for t in targets:
                         self.session.send(self._control_socket, 'abort_request',
                                 content=content, ident=t)
                     error = False
                     if block:
                         self._ignored_control_replies += len(targets)
                     if error:
                         raise error
                 @spin_first
                 def shutdown(self, targets=None, restart=False, hub=False, block=None):
                     """Terminates one or more engine processes, optionally including the hub."""
                         targets = 'all'
                     targets = self._build_targets(targets)[0]
                     for t in targets:
                         self.session.send(self._control_socket, 'shutdown_request',
                                     content={'restart':restart},ident=t)
                     error = False
                     if block or hub:
                                 error = self._unwrap_exception(msg['content'])
                     else:
                         self._ignored_control_replies += len(targets)
                     if hub:
                         time.sleep(0.25)
                         self.session.send(self._query_socket, 'shutdown_request')
                             pprint(msg)
                         if msg['content']['status'] != 'ok':
                             error = self._unwrap_exception(msg['content'])
                     if error:
                         raise error
                 #--------------------------------------------------------------------------
                 # Execution related methods
                 #--------------------------------------------------------------------------
                 def _maybe_raise(self, result):
                     """wrapper for maybe raising an exception if apply failed."""
                     if isinstance(result, error.RemoteError):
                         raise result
                     return result
                 def send_apply_message(self, socket, f, args=None, kwargs=None, subheader=None, track=False,
                                         ident=None):
                     """construct and send an apply message via a socket.
                     This is the principal method with which all engine execution is performed by views.
                     """
                     assert not self._closed, "cannot use me anymore, I'm closed!"
                     # defaults:
                     args = args if args is not None else []
                     kwargs = kwargs if kwargs is not None else {}
                     subheader = subheader if subheader is not None else {}
                     # validate arguments
                     if not callable(f):
                         raise TypeError("f must be callable, not %s"%type(f))
                         raise TypeError("kwargs must be dict, not %s"%type(kwargs))
                     if not isinstance(subheader, dict):
                         raise TypeError("subheader must be dict, not %s"%type(subheader))
                     bufs = util.pack_apply_message(f,args,kwargs)
                     msg = self.session.send(socket, "apply_request", buffers=bufs, ident=ident,
                                         subheader=subheader, track=track)
                     msg_id = msg['header']['msg_id']
                     self.outstanding.add(msg_id)
                     if ident:
                             self._outstanding_dict[ident].add(msg_id)
                     self.history.append(msg_id)
                     self.metadata[msg_id]['submitted'] = datetime.now()
                     return msg
                 #--------------------------------------------------------------------------
                 # construct a View object
                 #--------------------------------------------------------------------------
                 def load_balanced_view(self, targets=None):
                     """construct a DirectView object.
                     If no arguments are specified, create a LoadBalancedView
                     using all engines.
                     Parameters
                     ----------
                     targets: list,slice,int,etc. [default: use all engines]
                         The subset of engines across which to load-balance
                     """
                     if targets is not None:
                         targets = self._build_targets(targets)[1]
                     return LoadBalancedView(client=self, socket=self._task_socket, targets=targets)
                 def direct_view(self, targets='all'):
                     """construct a DirectView object.
                     If no targets are specified, create a DirectView
                     using all engines.
                     Parameters
                     ----------
                     targets: list,slice,int,etc. [default: use all engines]
                         The engines to use for the View
                     """
                     if single:
                         targets = targets[0]
                     return DirectView(client=self, socket=self._mux_socket, targets=targets)
                 #--------------------------------------------------------------------------
                 # Query methods
                 #--------------------------------------------------------------------------
                 @spin_first
                 def get_result(self, indices_or_msg_ids=None, block=None):
                     """Retrieve a result by msg_id or history index, wrapped in an AsyncResult object.
                     If the client already has the results, no request to the Hub will be made.
                     This is a convenient way to construct AsyncResult objects, which are wrappers
                     that include metadata about execution, and allow for awaiting results that
                     were not submitted by this Client.
                     It can also be a convenient way to retrieve the metadata associated with
                     blocking execution, since it always retrieves
                     Examples
                     --------
                     ::
                         In [10]: r = client.apply()
                     Parameters
                     ----------
                     indices_or_msg_ids : integer history index, str msg_id, or list of either
                         The indices or msg_ids of indices to be retrieved
                     block : bool
                         Whether to wait for the result to be done
                     Returns
                     -------
                     AsyncResult
                         A single AsyncResult object will always be returned.
                     AsyncHubResult
                         A subclass of AsyncResult that retrieves results from the Hub
                     """
                     block = self.block if block is None else block
                     if indices_or_msg_ids is None:
                         indices_or_msg_ids = -1
                     if not isinstance(indices_or_msg_ids, (list,tuple)):
                         indices_or_msg_ids = [indices_or_msg_ids]
                     theids = []
                     for id in indices_or_msg_ids:
                         if isinstance(id, int):
                         if not isinstance(id, basestring):
                             raise TypeError("indices must be str or int, not %r"%id)
                         theids.append(id)
                     local_ids = filter(lambda msg_id: msg_id in self.history or msg_id in self.results, theids)
                     remote_ids = filter(lambda msg_id: msg_id not in local_ids, theids)
                     if remote_ids:
                         ar = AsyncHubResult(self, msg_ids=theids)
                     else:
                         ar = AsyncResult(self, msg_ids=theids)
                     if block:
                         ar.wait()
                     return ar
                 @spin_first
                         ar.wait()
                     return ar
                 @spin_first
                 def result_status(self, msg_ids, status_only=True):
                     """Check on the status of the result(s) of the apply request with `msg_ids`.
                     If status_only is False, then the actual results will be retrieved, else
                     only the status of the results will be checked.
                     Parameters
                     ----------
                     msg_ids : list of msg_ids
                         if int:
                             Passed as index to self.history for convenience.
                     status_only : bool (default: True)
                         if False:
                             Retrieve the actual results of completed tasks.
                     Returns
                     -------
                     results : dict
                         There will always be the keys 'pending' and 'completed', which will
                         be lists of msg_ids that are incomplete or complete. If `status_only`
                     """
                     if not isinstance(msg_ids, (list,tuple)):
                         msg_ids = [msg_ids]
                     theids = []
                     for msg_id in msg_ids:
                         if isinstance(msg_id, int):
                         if not isinstance(msg_id, basestring):
                             raise TypeError("msg_ids must be str, not %r"%msg_id)
                         theids.append(msg_id)
                     completed = []
                     local_results = {}
                     # comment this block out to temporarily disable local shortcut:
                     for msg_id in theids:
                         if msg_id in self.results:
                             completed.append(msg_id)
                             local_results[msg_id] = self.results[msg_id]
                             theids.remove(msg_id)
                     if theids: # some not locally cached
                         content = dict(msg_ids=theids, status_only=status_only)
                         msg = self.session.send(self._query_socket, "result_request", content=content)
                         buffers = msg['buffers']
                     else:
                         content = dict(completed=[],pending=[])
                     content['completed'].extend(completed)
                     if status_only:
                         return content
                     failures = []
                     # load cached results into result:
                     content.update(local_results)
                     # update cache with results:
                     for msg_id in sorted(theids):
                         if msg_id in content['completed']:
                             iodict = rec['io']
                             if isinstance(rcontent, str):
                                 rcontent = self.session.unpack(rcontent)
                             md = self.metadata[msg_id]
                             md.update(self._extract_metadata(header, parent, rcontent))
                             md.update(iodict)
                             if rcontent['status'] == 'ok':
                                 res,buffers = util.unserialize_object(buffers)
                             else:
                                 print rcontent
                                 res = self._unwrap_exception(rcontent)
                                 failures.append(res)
                             self.results[msg_id] = res
                             content[msg_id] = res
                     if len(theids) == 1 and failures:
                             raise failures[0]
                     error.collect_exceptions(failures, "result_status")
                     return content
                 @spin_first
                 def queue_status(self, targets='all', verbose=False):
                     """Fetch the status of engine queues.
                     Parameters
                     ----------
                     targets : int/str/list of ints/strs
                             the engines whose states are to be queried.
                             default : all
                         return content[targets]
                     else:
                         return content
                 @spin_first
                 def purge_results(self, jobs=[], targets=[]):
                     """Tell the Hub to forget results.
                     Individual results can be purged by msg_id, or the entire
                     history of specific targets can be purged.
                     Use `purge_results('all')` to scrub everything from the Hub's db.
                     Parameters
                     ----------
                     jobs : str or list of str or AsyncResult objects
                             the msg_ids whose results should be forgotten.
                     targets : int/str/list of ints/strs
                             The targets, by int_id, whose entire history is to be purged.
                             default : None
                     """
                     if not targets and not jobs:
                         raise ValueError("Must specify at least one of `targets` and `jobs`")
                     if targets:
                         targets = self._build_targets(targets)[1]
                     # construct msg_ids from jobs
                     if jobs == 'all':
                         msg_ids = jobs
                 @spin_first
                 def hub_history(self):
                     """Get the Hub's history
                     Just like the Client, the Hub has a history, which is a list of msg_ids.
                     This will contain the history of all clients, and, depending on configuration,
                     may contain history across multiple cluster sessions.
                     Any msg_id returned here is a valid argument to `get_result`.
                     Returns
                     -------
                     msg_ids : list of strs
                             list of all msg_ids, ordered by task submission time.
                     """
                     self.session.send(self._query_socket, "history_request", content={})
                     idents, msg = self.session.recv(self._query_socket, 0)
                     if self.debug:
                         pprint(msg)
                     content = msg['content']
                 @spin_first
                 def db_query(self, query, keys=None):
                     """Query the Hub's TaskRecord database
                     This will return a list of task record dicts that match `query`
                     Parameters
                     ----------
                     query : mongodb query dict
                         The search dict. See mongodb query docs for details.
                     keys : list of strs [optional]
                     content = msg['content']
                     if content['status'] != 'ok':
                         raise self._unwrap_exception(content)
                     records = content['records']
                     buffer_lens = content['buffer_lens']
                     result_buffer_lens = content['result_buffer_lens']
                     buffers = msg['buffers']
                         if has_rbufs:
                             blen = result_buffer_lens[i]
                             rec['result_buffers'], buffers = buffers[:blen],buffers[blen:]
                     return records
             __all__ = [ 'Client' ]

IPython/parallel/client/remotefunction.py

0 +28 -28

             @skip_doctest
             def remote(view, block=None, **flags):
                 """Turn a function into a remote function.
                 This method can be used for map:
                 In [1]: @remote(view,block=True)
                    ...: def func(a):
                    ...:    pass
                 """
                 def remote_function(f):
                     return RemoteFunction(view, f, block=block, **flags)
                 return remote_function
             @skip_doctest
             def parallel(view, dist='b', block=None, **flags):
                 """Turn a function into a parallel remote function.
                 This method can be used for map:
                 In [1]: @parallel(view, block=True)
                    ...: def func(a):
                    ...:    pass
                 """
                 def parallel_function(f):
                     return ParallelFunction(view, f, dist=dist, block=block, **flags)
                 return parallel_function
             class RemoteFunction(object):
                 """Turn an existing function into a remote function.
                 Parameters
                 ----------
                 view : View instance
                     The view to be used for execution
                 f : callable
                 block : bool [default: None]
                     Whether to wait for results or not.  The default behavior is
                     to use the current `block` attribute of `view`
                 **flags : remaining kwargs are passed to View.temp_flags
                 """
                 view = None # the remote connection
                 func = None # the wrapped function
                 block = None # whether to block
                 flags = None # dict of extra kwargs for temp_flags
                 def __init__(self, view, f, block=None, **flags):
                     self.view = view
                     self.func = f
                     self.block=block
                     self.flags=flags
                 def __call__(self, *args, **kwargs):
                     block = self.view.block if self.block is None else self.block
                     with self.view.temp_flags(block=block, **self.flags):
                         return self.view.apply(self.func, *args, **kwargs)
             class ParallelFunction(RemoteFunction):
                 """Class for mapping a function to sequences.
                 This will distribute the sequences according the a mapper, and call
                 the function on each sub-sequence.  If called via map, then the function
                 will be called once on each element, rather that each sub-sequence.
                 Parameters
                 ----------
                 view : View instance
                     The view to be used for execution
                 f : callable
                     The size of chunk to use when breaking up sequences in a load-balanced manner
                 **flags : remaining kwargs are passed to View.temp_flags
                 """
                 chunksize=None
                 mapObject=None
                 def __init__(self, view, f, dist='b', block=None, chunksize=None, **flags):
                     super(ParallelFunction, self).__init__(view, f, block=block, **flags)
                     self.chunksize = chunksize
                     mapClass = Map.dists[dist]
                     self.mapObject = mapClass()
                 def __call__(self, *sequences):
                     # check that the length of sequences match
                     len_0 = len(sequences[0])
                         # multiplexed:
                         targets = self.view.targets
                         nparts = len(targets)
                     msg_ids = []
                     # my_f = lambda *a: map(self.func, *a)
                     client = self.view.client
                                 args.append(part)
                         if not args:
                             continue
                         # print (args)
                         if hasattr(self, '_map'):
                             if sys.version_info[0] >= 3:
                             args = [self.func]+args
                         else:
                             f=self.func
                         view = self.view if balanced else client[t]
                         with view.temp_flags(block=False, **self.flags):
                             ar = view.apply(f, *args)
                         msg_ids.append(ar.msg_ids[0])
                     r = AsyncMapResult(self.view.client, msg_ids, self.mapObject, fname=self.func.__name__)
                     if self.block:
                         try:
                             return r.get()
                             return r
                     else:
                         return r
                 def map(self, *sequences):
                     """call a function on each element of a sequence remotely.
                     This should behave very much like the builtin map, but return an AsyncMapResult
                     if self.block is False.
                     """

IPython/parallel/client/view.py

0 +194 -194

             @skip_doctest
             class View(HasTraits):
                 """Base View class for more convenint apply(f,*args,**kwargs) syntax via attributes.
                 Don't use this class, use subclasses.
                 Methods
                 -------
                 spin
                     flushes incoming results and registration state changes
                     control methods spin, and requesting `ids` also ensures up to date
                 wait
                     wait on one or more msg_ids
                 execution methods
                     apply
                     legacy: execute, run
                 data movement
                     push, pull, scatter, gather
                 query methods
                     get_result, queue_status, purge_results, result_status
                 control methods
                     abort, shutdown
                 """
                 # flags
                 block=Bool(False)
                 track=Bool(True)
                 targets = Any()
                 history=List()
                 outstanding = Set()
                 results = Dict()
                 client = Instance('IPython.parallel.Client')
                 _socket = Instance('zmq.Socket')
                 _flag_names = List(['targets', 'block', 'track'])
                 _targets = Any()
                 _idents = Any()
                 def __init__(self, client=None, socket=None, **flags):
                     super(View, self).__init__(client=client, _socket=socket)
                     self.block = client.block
                     self.set_flags(**flags)
                     assert not self.__class__ is View, "Don't use base View objects, use subclasses"
                 def __repr__(self):
                     strtargets = str(self.targets)
                 def set_flags(self, **kwargs):
                     """set my attribute flags by keyword.
                     Views determine behavior with a few attributes (`block`, `track`, etc.).
                     These attributes can be set all at once by name with this method.
                     Parameters
                     ----------
                     block : bool
                         whether to wait for results
                     track : bool
                         whether to create a MessageTracker to allow the user to
                         safely edit after arrays and buffers during non-copying
                         sends.
                     """
                             raise KeyError("Invalid name: %r"%name)
                         else:
                             setattr(self, name, value)
                 @contextmanager
                 def temp_flags(self, **kwargs):
                     """temporarily set flags, for use in `with` statements.
                     See set_flags for permanent setting of flags
                     Examples
                     --------
                     >>> view.track=False
                     ...
                     >>> with view.temp_flags(track=True):
                     ...    ar.tracker.wait() # wait for send to finish
                     >>> view.track
                     False
                     """
                     # preflight: save flags, and set temporaries
                     saved_flags = {}
                     finally:
                         # postflight: restore saved flags
                         self.set_flags(**saved_flags)
                 #----------------------------------------------------------------
                 # apply
                 #----------------------------------------------------------------
                 @sync_results
                 @save_ids
                 def _really_apply(self, f, args, kwargs, block=None, **options):
                     """wrapper for client.send_apply_message"""
                     raise NotImplementedError("Implement in subclasses")
                 def apply(self, f, *args, **kwargs):
                     """calls f(*args, **kwargs) on remote engines, returning the result.
                     This method sets all apply flags via this View's attributes.
                     if self.block is False:
                         returns AsyncResult
                     else:
                 def apply_async(self, f, *args, **kwargs):
                     """calls f(*args, **kwargs) on remote engines in a nonblocking manner.
                     returns AsyncResult
                     """
                     return self._really_apply(f, args, kwargs, block=False)
                 def apply_sync(self, f, *args, **kwargs):
                     """calls f(*args, **kwargs) on remote engines in a blocking manner,
                      returning the result.
                     returns: actual result of f(*args, **kwargs)
                     """
                     return self._really_apply(f, args, kwargs, block=True)
                 def spin(self):
                     """spin the client, and sync"""
                     self.client.spin()
                 @sync_results
                 def wait(self, jobs=None, timeout=-1):
                     """waits on one or more `jobs`, for up to `timeout` seconds.
                     Parameters
                     ----------
                     jobs : int, str, or list of ints and/or strs, or one or more AsyncResult objects
                             ints are indices to self.history
                             strs are msg_ids
                     timeout : float
                             a time in seconds, after which to give up.
                             default is -1, which means no timeout
                     Returns
                     -------
                     True : when all msg_ids are done
                     False : timeout reached, some msg_ids still outstanding
                     """
                     if jobs is None:
                         jobs = self.history
                     return self.client.wait(jobs, timeout)
                 def abort(self, jobs=None, targets=None, block=None):
                     """Abort jobs on my engines.
                     Parameters
                     ----------
                     jobs : None, str, list of strs, optional
                         if None: abort all jobs.
                         else: abort specific msg_id(s).
                     """Fetch the Queue status of my engines"""
                     targets = targets if targets is not None else self.targets
                     return self.client.queue_status(targets=targets, verbose=verbose)
                 def purge_results(self, jobs=[], targets=[]):
                     """Instruct the controller to forget specific results."""
                     if targets is None or targets == 'all':
                         targets = self.targets
                     return self.client.purge_results(jobs=jobs, targets=targets)
                 def shutdown(self, targets=None, restart=False, hub=False, block=None):
                     """Terminates one or more engine processes, optionally including the hub.
                     """
                     if targets is None or targets == 'all':
                         targets = self.targets
                     return self.client.shutdown(targets=targets, restart=restart, hub=hub, block=block)
                 @spin_after
                 def get_result(self, indices_or_msg_ids=None):
                     """return one or more results, specified by history index or msg_id.
                     See client.get_result for details.
                     """
                     if indices_or_msg_ids is None:
                         indices_or_msg_ids = -1
                     if isinstance(indices_or_msg_ids, int):
                             if isinstance(index, int):
                                 indices_or_msg_ids[i] = self.history[index]
                     return self.client.get_result(indices_or_msg_ids)
                 #-------------------------------------------------------------------
                 # Map
                 #-------------------------------------------------------------------
                 def map(self, f, *sequences, **kwargs):
                     """override in subclasses"""
                     raise NotImplementedError
                 def map_async(self, f, *sequences, **kwargs):
                     """Parallel version of builtin `map`, using this view's engines.
                     This is equivalent to map(...block=False)
                     See `self.map` for details.
                     """
                     if 'block' in kwargs:
                         raise TypeError("map_async doesn't take a `block` keyword argument.")
                     kwargs['block'] = False
                     return self.map(f,*sequences,**kwargs)
                 def map_sync(self, f, *sequences, **kwargs):
                     """Parallel version of builtin `map`, using this view's engines.
                     This is equivalent to map(...block=True)
                     See `self.map` for details.
                     """
                     if 'block' in kwargs:
                         raise TypeError("map_sync doesn't take a `block` keyword argument.")
                     kwargs['block'] = True
                     return self.map(f,*sequences,**kwargs)
                 def imap(self, f, *sequences, **kwargs):
                     """Parallel version of `itertools.imap`.
                     See `self.map` for details.
                     """
                     return iter(self.map_async(f,*sequences, **kwargs))
                 #-------------------------------------------------------------------
                 # Decorators
                 #-------------------------------------------------------------------
                 def remote(self, block=True, **flags):
                     """Decorator for making a RemoteFunction"""
                     block = self.block if block is None else block
                     return remote(self, block=block, **flags)
                 def parallel(self, dist='b', block=None, **flags):
                     """Decorator for making a ParallelFunction"""
                     block = self.block if block is None else block
             @skip_doctest
             class DirectView(View):
                 """Direct Multiplexer View of one or more engines.
                 These are created via indexed access to a client:
                 >>> dv_1 = client[1]
                 >>> dv_all = client[:]
                 >>> dv_even = client[::2]
                 >>> dv_some = client[1:3]
                 This object provides dictionary access to engine namespaces:
                 # push a=5:
                 >>> dv['a'] = 5
                 # pull 'foo':
                 >>> db['foo']
                 """
                 def __init__(self, client=None, socket=None, targets=None):
                     super(DirectView, self).__init__(client=client, socket=socket, targets=targets)
                 @property
                 def importer(self):
                     """sync_imports(local=True) as a property.
                     See sync_imports for details.
                     """
                     return self.sync_imports(True)
                 @contextmanager
                 def sync_imports(self, local=True):
                     """Context Manager for performing simultaneous local and remote imports.
                     'import x as y' will *not* work.  The 'as y' part will simply be ignored.
                     >>> with view.sync_imports():
                     ...    from numpy import recarray
                     importing recarray from numpy on engine(s)
                     """
                     import __builtin__
                     local_import = __builtin__.__import__
                                 user_ns[key] = getattr(mod, key)
                         else:
                             user_ns[name] = sys.modules[name]
                     def view_import(name, globals={}, locals={}, fromlist=[], level=-1):
                         """the drop-in replacement for __import__, that optionally imports
                         locally as well.
                         # don't override nested imports
                         save_import = __builtin__.__import__
                         __builtin__.__import__ = local_import
                         if imp.lock_held():
                             # this is a side-effect import, don't do it remotely, or even
                             # ignore the local effects
                             return local_import(name, globals, locals, fromlist, level)
                         imp.acquire_lock()
                         if local:
                             mod = local_import(name, globals, locals, fromlist, level)
                         else:
                             raise NotImplementedError("remote-only imports not yet implemented")
                         imp.release_lock()
                         key = name+':'+','.join(fromlist or [])
                         if level == -1 and key not in modules:
                             modules.add(key)
                             results.append(self.apply_async(remote_import, name, fromlist, level))
                         # restore override
                         __builtin__.__import__ = save_import
                         return mod
                     # override __import__
                     __builtin__.__import__ = view_import
                     try:
                     finally:
                         # always restore __import__
                         __builtin__.__import__ = local_import
                     for r in results:
                         # raise possible remote ImportErrors here
                         r.get()
                 @sync_results
                 @save_ids
                 def _really_apply(self, f, args=None, kwargs=None, targets=None, block=None, track=None):
                     """calls f(*args, **kwargs) on remote engines, returning the result.
                     This method sets all of `apply`'s flags via this View's attributes.
                     Parameters
                     ----------
                     f : callable
                     args : list [default: empty]
                     kwargs : dict [default: empty]
                     targets : target list [default: self.targets]
                         where to run
                     block : bool [default: self.block]
                         whether to block
                     track : bool [default: self.track]
                         whether to ask zmq to track the message, for safe non-copying sends
                     Returns
                     -------
                     if self.block is False:
                         returns AsyncResult
                     else:
                     block = self.block if block is None else block
                     track = self.track if track is None else track
                     targets = self.targets if targets is None else targets
                     _idents = self.client._build_targets(targets)[0]
                     msg_ids = []
                     trackers = []
                         except KeyboardInterrupt:
                             pass
                     return ar
                 @spin_after
                 def map(self, f, *sequences, **kwargs):
                     """view.map(f, *sequences, block=self.block) => list|AsyncMapResult
                     Parallel version of builtin `map`, using this View's `targets`.
                     There will be one task per target, so work will be chunked
                     if the sequences are longer than `targets`.
                     Results can be iterated as they are ready, but will become available in chunks.
                     Parameters
                     ----------
                     f : callable
                         function to be mapped
                     *sequences: one or more sequences of matching length
                         the sequences to be distributed and passed to `f`
                     block : bool
                         whether to wait for the result or not [default self.block]
                     Returns
                     -------
                     if block=False:
                         AsyncMapResult
                             An object like AsyncResult, but which reassembles the sequence of results
                         list
                             the result of map(f,*sequences)
                     """
                     block = kwargs.pop('block', self.block)
                     for k in kwargs.keys():
                         if k not in ['block', 'track']:
                             raise TypeError("invalid keyword arg, %r"%k)
                     assert len(sequences) > 0, "must have some sequences to map onto!"
                     pf = ParallelFunction(self, f, block=block, **kwargs)
                     return pf.map(*sequences)
                 def execute(self, code, targets=None, block=None):
                     """Executes `code` on `targets` in blocking or nonblocking manner.
                     ``execute`` is always `bound` (affects engine namespace)
                     Parameters
                     ----------
                     code : str
                             the code string to be executed
                     block : bool
                             default: self.block
                     """
                     return self._really_apply(util._execute, args=(code,), block=block, targets=targets)
                 def run(self, filename, targets=None, block=None):
                     """Execute contents of `filename` on my engine(s).
                     This simply reads the contents of the file and calls `execute`.
                     Parameters
                     ----------
                     filename : str
                             The path to the file
                     targets : int/str/list of ints/strs
                     block : bool
                             whether or not to wait until done
                             default: self.block
                     """
                     with open(filename, 'r') as f:
                         # add newline in case of trailing indented whitespace
                         # which will cause SyntaxError
                         code = f.read()+'\n'
                     return self.execute(code, block=block, targets=targets)
                 def update(self, ns):
                     """update remote namespace with dict `ns`
                     See `push` for details.
                     """
                     return self.push(ns, block=self.block, track=self.track)
                 def push(self, ns, targets=None, block=None, track=None):
                     """update remote namespace with dict `ns`
                     Parameters
                     ----------
                     ns : dict
                         dict of keys with which to update engine namespace(s)
                     block : bool [default : self.block]
                         whether to wait to be notified of engine receipt
                     """
                     block = block if block is not None else self.block
                     track = track if track is not None else self.track
                     targets = targets if targets is not None else self.targets
                 def get(self, key_s):
                     """get object(s) by `key_s` from remote namespace
                     see `pull` for details.
                     """
                     # block = block if block is not None else self.block
                     return self.pull(key_s, block=True)
                 def pull(self, names, targets=None, block=None):
                     """get object(s) by `name` from remote namespace
                     will return one object if it is a key.
                     can also take a list of keys, in which case it will return a list of objects.
                     """
                     else:
                         raise TypeError("names must be strs, not %r"%names)
                     return self._really_apply(util._pull, (names,), block=block, targets=targets)
                 def scatter(self, key, seq, dist='b', flatten=False, targets=None, block=None, track=None):
                     """
                     Partition a Python sequence and send the partitions to a set of engines.
                     block = block if block is not None else self.block
                     track = track if track is not None else self.track
                     targets = targets if targets is not None else self.targets
                     mapObject = Map.dists[dist]()
                     nparts = len(targets)
                     msg_ids = []
                         msg_ids.extend(r.msg_ids)
                         if track:
                             trackers.append(r._tracker)
                     if track:
                         tracker = zmq.MessageTracker(*trackers)
                     else:
                         tracker = None
                     r = AsyncResult(self.client, msg_ids, fname='scatter', targets=targets, tracker=tracker)
                     if block:
                         r.wait()
                     else:
                         return r
                 @sync_results
                 @save_ids
                 def gather(self, key, dist='b', targets=None, block=None):
                     targets = targets if targets is not None else self.targets
                     mapObject = Map.dists[dist]()
                     msg_ids = []
                     for index, engineid in enumerate(targets):
                         msg_ids.extend(self.pull(key, block=False, targets=engineid).msg_ids)
                     r = AsyncMapResult(self.client, msg_ids, mapObject, fname='gather')
                     if block:
                         try:
                             return r.get()
                         except KeyboardInterrupt:
                             pass
                     return r
                 def __getitem__(self, key):
                     return self.get(key)
                 def __setitem__(self,key, value):
                     self.update({key:value})
                 def clear(self, targets=None, block=False):
                     """Clear the remote namespaces on my engines."""
                     block = block if block is not None else self.block
                     targets = targets if targets is not None else self.targets
                     return self.client.clear(targets=targets, block=block)
                 def kill(self, targets=None, block=True):
                     """Kill my engines."""
                     block = block if block is not None else self.block
                     targets = targets if targets is not None else self.targets
                     return self.client.kill(targets=targets, block=block)
                 #----------------------------------------
                 # activate for %px,%autopx magics
                 #----------------------------------------
                 def activate(self):
                     """Make this `View` active for parallel magic commands.
                     IPython has a magic command syntax to work with `MultiEngineClient` objects.
                     In a given IPython session there is a single active one.  While
                     there can be many `Views` created and used by the user,
                     there is only one active one.  The active `View` is used whenever
                     the magic commands %px and %autopx are used.
                     The activate() method is called on a given `View` to make it
                     active.  Once this has been done, the magic commands can be used.
                     """
                     try:
                         # This is injected into __builtins__.
                         ip = get_ipython()
             @skip_doctest
             class LoadBalancedView(View):
                 """An load-balancing View that only executes via the Task scheduler.
                 Load-balanced views can be created with the client's `view` method:
                 >>> v = client.load_balanced_view()
                 or targets can be specified, to restrict the potential destinations:
                 >>> v = client.client.load_balanced_view(([1,3])
                 which would restrict loadbalancing to between engines 1 and 3.
                 """
                 follow=Any()
                 after=Any()
                 timeout=CFloat()
                 retries = CInt(0)
                 _task_scheme = Any()
                 _flag_names = List(['targets', 'block', 'track', 'follow', 'after', 'timeout', 'retries'])
                 def __init__(self, client=None, socket=None, **flags):
                     super(LoadBalancedView, self).__init__(client=client, socket=socket, **flags)
                     self._task_scheme=client._task_scheme
                 def _validate_dependency(self, dep):
                     """validate a dependency.
                     For use in `set_flags`.
                     """
                     if dep is None or isinstance(dep, (basestring, AsyncResult, Dependency)):
                                 return False
                     else:
                         return False
                     return True
                 def _render_dependency(self, dep):
                     """helper for building jsonable dependencies from various input forms."""
                     if isinstance(dep, Dependency):
                 def set_flags(self, **kwargs):
                     """set my attribute flags by keyword.
                     A View is a wrapper for the Client's apply method, but with attributes
                     that specify keyword arguments, those attributes can be set by keyword
                     argument with this method.
                     Parameters
                     ----------
                     block : bool
                         whether to wait for results
                     track : bool
                         whether to create a MessageTracker to allow the user to
                         safely edit after arrays and buffers during non-copying
                         sends.
                     retries : int
                         Number of times a task will be retried on failure.
                     """
                     super(LoadBalancedView, self).set_flags(**kwargs)
                     for name in ('follow', 'after'):
                         if name in kwargs:
                             if t < 0:
                                 raise ValueError("Invalid timeout: %s"%t)
                         self.timeout = t
                 @sync_results
                 @save_ids
                 def _really_apply(self, f, args=None, kwargs=None, block=None, track=None,
                                                     after=None, follow=None, timeout=None,
                                                     targets=None, retries=None):
                     """calls f(*args, **kwargs) on a remote engine, returning the result.
                     This method temporarily sets all of `apply`'s flags for a single call.
                     Parameters
                     ----------
                     f : callable
                     args : list [default: empty]
                     kwargs : dict [default: empty]
                     block : bool [default: self.block]
                         whether to block
                     track : bool [default: self.track]
                         whether to ask zmq to track the message, for safe non-copying sends
                     !!!!!! TODO: THE REST HERE  !!!!
                     Returns
                     -------
                     if self.block is False:
                         returns AsyncResult
                     else:
                             msg += " because the pure ZMQ scheduler cannot handle"
                             msg += " disappearing engines."
                         raise RuntimeError(msg)
                     if self._task_scheme == 'pure':
                         # pure zmq scheme doesn't support extra features
                         msg = "Pure ZMQ scheduler doesn't support the following flags:"
                         if isinstance(f, dependent):
                             # soft warn on functional dependencies
                             warnings.warn(msg, RuntimeWarning)
                     # build args
                     args = [] if args is None else args
                     kwargs = {} if kwargs is None else kwargs
                     follow = self.follow if follow is None else follow
                     timeout = self.timeout if timeout is None else timeout
                     targets = self.targets if targets is None else targets
                     if not isinstance(retries, int):
                         raise TypeError('retries must be int, not %r'%type(retries))
                         idents = self.client._build_targets(targets)[0]
                         # ensure *not* bytes
                         idents = [ ident.decode() for ident in idents ]
                     after = self._render_dependency(after)
                     follow = self._render_dependency(follow)
                     subheader = dict(after=after, follow=follow, timeout=timeout, targets=idents, retries=retries)
                     msg = self.client.send_apply_message(self._socket, f, args, kwargs, track=track,
                                             subheader=subheader)
                     tracker = None if track is False else msg['tracker']
                     ar = AsyncResult(self.client, msg['header']['msg_id'], fname=f.__name__, targets=None, tracker=tracker)
                     if block:
                         try:
                             return ar.get()
                         except KeyboardInterrupt:
                             pass
                     return ar
                 @spin_after
                 @save_ids
                 def map(self, f, *sequences, **kwargs):
                     """view.map(f, *sequences, block=self.block, chunksize=1) => list|AsyncMapResult
                     Parallel version of builtin `map`, load-balanced by this View.
                     `block`, and `chunksize` can be specified by keyword only.
                     Each `chunksize` elements will be a separate task, and will be
                     load-balanced. This lets individual elements be available for iteration
                     as soon as they arrive.
                     Parameters
                     ----------
                     f : callable
                         function to be mapped
                     *sequences: one or more sequences of matching length
                     block : bool
                         whether to wait for the result or not [default self.block]
                     track : bool
                         whether to create a MessageTracker to allow the user to
                         safely edit after arrays and buffers during non-copying
                         sends.
                     chunksize : int
                         how many elements should be in each task [default 1]
                     Returns
                     -------
                     if block=False:
                         AsyncMapResult
                             An object like AsyncResult, but which reassembles the sequence of results
                             results are complete.
                         else:
                             the result of map(f,*sequences)
                     """
                     # default
                     block = kwargs.get('block', self.block)
                     chunksize = kwargs.get('chunksize', 1)
                     keyset = set(kwargs.keys())
                     extra_keys = keyset.difference_update(set(['block', 'chunksize']))
                     if extra_keys:
                         raise TypeError("Invalid kwargs: %s"%list(extra_keys))
                     assert len(sequences) > 0, "must have some sequences to map onto!"
                     pf = ParallelFunction(self, f, block=block,  chunksize=chunksize)
                     return pf.map(*sequences)

IPython/parallel/controller/dictdb.py

0 +21 -21

             """A Task logger that presents our DB interface,
             but exists entirely in memory and implemented with dicts.
             Authors:
             class CompositeFilter(object):
                 """Composite filter for matching multiple properties."""
                 def __init__(self, dikt):
                     self.tests = []
                     self.values = []
             class DictDB(BaseDB):
                 """Basic in-memory dict-based object for saving Task Records.
                 This is the first object to present the DB interface
                 for logging tasks out of memory.
                 The interface is based on MongoDB, so adding a MongoDB
                 backend should be straightforward.
                 """
                 _records = Dict()
                 def _match_one(self, rec, tests):
                     """Check if a specific record matches tests."""
                     for key,test in tests.iteritems():
                         if not test(rec.get(key, None)):
                             return False
                     return True
                 def _match(self, check):
                     """Find all the matches for a check dict."""
                     matches = []
                             tests[k] = CompositeFilter(v)
                         else:
                             tests[k] = lambda o: o==v
                     for rec in self._records.itervalues():
                         if self._match_one(rec, tests):
                             matches.append(rec)
                     return matches
                 def _extract_subdict(self, rec, keys):
                     """extract subdict of keys"""
                     d = {}
                     for key in keys:
                         d[key] = rec[key]
                     return d
                 def add_record(self, msg_id, rec):
                     """Add a new Task Record, by msg_id."""
                     if self._records.has_key(msg_id):
                         raise KeyError("Already have msg_id %r"%(msg_id))
                     self._records[msg_id] = rec
                 def get_record(self, msg_id):
                     """Get a specific Task Record, by msg_id."""
                     if not self._records.has_key(msg_id):
                         raise KeyError("No such msg_id %r"%(msg_id))
                     return self._records[msg_id]
                 def update_record(self, msg_id, rec):
                     """Update the data in an existing record."""
                     self._records[msg_id].update(rec)
                 def drop_matching_records(self, check):
                     """Remove a record from the DB."""
                     matches = self._match(check)
                     for m in matches:
                         del self._records[m['msg_id']]
                 def drop_record(self, msg_id):
                     """Remove a record from the DB."""
                     del self._records[msg_id]
                 def find_records(self, check, keys=None):
                     """Find records matching a query dict, optionally extracting subset of keys.
                     Returns dict keyed by msg_id of matching records.
                     Parameters
                     ----------
                     check: dict
                         mongodb-style query argument
                     keys: list of strs [optional]
                         return [ self._extract_subdict(rec, keys) for rec in matches ]
                     else:
                         return matches
                 def get_history(self):
                     """get all msg_ids, ordered by time submitted."""
                     msg_ids = self._records.keys()

IPython/parallel/controller/heartmonitor.py

0 +23 -23

                 """A basic heart object for responding to a HeartMonitor.
                 This is a simple wrapper with defaults for the most common
                 Device model for responding to heartbeats.
                 It simply builds a threadsafe zmq.FORWARDER Device, defaulting to using
                 SUB/XREQ for in/out.
                 You can specify the XREQ's IDENTITY via the optional heart_id argument."""
                 device=None
                 id=None
                         heart_id = uuid.uuid4().bytes
                     self.device.setsockopt_out(zmq.IDENTITY, heart_id)
                     self.id = heart_id
                 def start(self):
                     return self.device.start()
             class HeartMonitor(LoggingConfigurable):
                 """A basic HeartMonitor class
                 pingstream: a PUB stream
                 pongstream: an XREP stream
                 period: the period of the heartbeat in milliseconds"""
                 period=CFloat(1000, config=True,
                     help='The frequency at which the Hub pings the engines for heartbeats '
                     ' (in ms) [default: 100]',
                 )
                 pingstream=Instance('zmq.eventloop.zmqstream.ZMQStream')
                 pongstream=Instance('zmq.eventloop.zmqstream.ZMQStream')
                 loop = Instance('zmq.eventloop.ioloop.IOLoop')
                 def _loop_default(self):
                     return ioloop.IOLoop.instance()
                 # not settable:
                 hearts=Set()
                 responses=Set()
                 _failure_handlers = Set()
                 lifetime = CFloat(0)
                 tic = CFloat(0)
                 def __init__(self, **kwargs):
                     super(HeartMonitor, self).__init__(**kwargs)
                     self.pongstream.on_recv(self.handle_pong)
                 def start(self):
                     self.caller = ioloop.PeriodicCallback(self.beat, self.period, self.loop)
                     self.caller.start()
                 def add_new_heart_handler(self, handler):
                     """add a new handler for new hearts"""
                     self.log.debug("heartbeat::new_heart_handler: %s"%handler)
                     self._new_handlers.add(handler)
                 def add_heart_failure_handler(self, handler):
                     """add a new handler for heart failure"""
                     self.log.debug("heartbeat::new heart failure handler: %s"%handler)
                     self._failure_handlers.add(handler)
                 def beat(self):
                     self.pongstream.flush()
                     self.last_ping = self.lifetime
                     toc = time.time()
                     self.lifetime += toc-self.tic
                     self.tic = toc
                     # print self.on_probation, self.hearts
                     # self.log.debug("heartbeat::beat %.3f, %i beating hearts"%(self.lifetime, len(self.hearts)))
                     self.pingstream.send(asbytes(str(self.lifetime)))
                 def handle_new_heart(self, heart):
                     if self._new_handlers:
                         for handler in self._new_handlers:
                     else:
                         self.log.info("heartbeat::yay, got new heart %s!"%heart)
                     self.hearts.add(heart)
                 def handle_heart_failure(self, heart):
                     if self._failure_handlers:
                         for handler in self._failure_handlers:
                     else:
                         self.log.info("heartbeat::Heart %s failed :("%heart)
                     self.hearts.remove(heart)
                 def handle_pong(self, msg):
                     "a heart just beat"
                     current = asbytes(str(self.lifetime))
                 pub.bind('tcp://127.0.0.1:5555')
                 xrep = context.socket(zmq.ROUTER)
                 xrep.bind('tcp://127.0.0.1:5556')
                 outstream = zmqstream.ZMQStream(pub, loop)
                 instream = zmqstream.ZMQStream(xrep, loop)
                 hb = HeartMonitor(loop, outstream, instream)
                 loop.start()

IPython/parallel/controller/hub.py

0 +132 -132

                     'stdout': '',
                     'stderr': '',
                 }
             def init_record(msg):
                 """Initialize a TaskRecord based on a request."""
                 header = msg['header']
             class HubFactory(RegistrationFactory):
                 """The Configurable for setting up a Hub."""
                 # port-pairs for monitoredqueues:
                 hb = Tuple(Int,Int,config=True,
                     help="""XREQ/SUB Port pair for Engine heartbeats""")
                 mux = Tuple(Int,Int,config=True,
                     help="""Engine/Client Port pair for MUX queue""")
                 def _mux_default(self):
                     return tuple(util.select_random_ports(2))
                 task = Tuple(Int,Int,config=True,
                     help="""Engine/Client Port pair for Task queue""")
                 def _task_default(self):
                 control = Tuple(Int,Int,config=True,
                     help="""Engine/Client Port pair for Control queue""")
                 def _control_default(self):
                     return tuple(util.select_random_ports(2))
                 iopub = Tuple(Int,Int,config=True,
                     help="""Engine/Client Port pair for IOPub relay""")
                 def _iopub_default(self):
                     return tuple(util.select_random_ports(2))
                 # single ports:
                 mon_port = Int(config=True,
                     help="""Monitor (SUB) port for queue traffic""")
                 def _mon_port_default(self):
                     return util.select_random_ports(1)[0]
                 notifier_port = Int(config=True,
                     help="""PUB port for sending engine status notifications""")
                 def _notifier_port_default(self):
                     return util.select_random_ports(1)[0]
                 engine_ip = Unicode('127.0.0.1', config=True,
                     help="IP on which to listen for engine connections. [default: loopback]")
                 engine_transport = Unicode('tcp', config=True,
                     help="0MQ transport for engine connections. [default: tcp]")
                 client_ip = Unicode('127.0.0.1', config=True,
                     help="IP on which to listen for client connections. [default: loopback]")
                 client_transport = Unicode('tcp', config=True,
                     help="0MQ transport for client connections. [default : tcp]")
                 monitor_ip = Unicode('127.0.0.1', config=True,
                     help="IP on which to listen for monitor messages. [default: loopback]")
                 monitor_transport = Unicode('tcp', config=True,
                     help="0MQ transport for monitor messages. [default : tcp]")
                 monitor_url = Unicode('')
                 db_class = DottedObjectName('IPython.parallel.controller.dictdb.DictDB',
                     config=True, help="""The class to use for the DB backend""")
                 # not configurable
                 db = Instance('IPython.parallel.controller.dictdb.BaseDB')
                 heartmonitor = Instance('IPython.parallel.controller.heartmonitor.HeartMonitor')
                 def _ip_changed(self, name, old, new):
                     self.engine_ip = new
                     self.client_ip = new
                     self.monitor_ip = new
                     self._update_monitor_url()
                 def _update_monitor_url(self):
                     self.monitor_url = "%s://%s:%i"%(self.monitor_transport, self.monitor_ip, self.mon_port)
                 def _transport_changed(self, name, old, new):
                     self.engine_transport = new
                     self.client_transport = new
                     self.monitor_transport = new
                     self._update_monitor_url()
                 def __init__(self, **kwargs):
                     super(HubFactory, self).__init__(**kwargs)
                     self._update_monitor_url()
                 def construct(self):
                     self.init_hub()
                 def start(self):
                     self.heartmonitor.start()
                     self.log.info("Heartmonitor started")
                 def init_hub(self):
                     """construct"""
                     client_iface = "%s://%s:"%(self.client_transport, self.client_ip) + "%i"
                     engine_iface = "%s://%s:"%(self.engine_transport, self.engine_ip) + "%i"
                     ctx = self.context
                     loop = self.loop
                     # Registrar socket
                     q = ZMQStream(ctx.socket(zmq.ROUTER), loop)
                     q.bind(client_iface % self.regport)
                     if self.client_ip != self.engine_ip:
                         q.bind(engine_iface % self.regport)
                         self.log.info("Hub listening on %s for registration."%(engine_iface%self.regport))
                     ### Engine connections ###
                     # heartbeat
                     sub.bind(self.monitor_url)
                     sub.bind('inproc://monitor')
                     sub = ZMQStream(sub, loop)
                     # connect the db
                     self.log.info('Hub using DB backend: %r'%(self.db_class.split()[-1]))
                     # cdir = self.config.Global.cluster_dir
                     self.db = import_item(str(self.db_class))(session=self.session.session,
                                                         config=self.config, log=self.log)
                     time.sleep(.25)
                     try:
                             query=q, notifier=n, resubmit=r, db=self.db,
                             engine_info=self.engine_info, client_info=self.client_info,
                             log=self.log)
             class Hub(SessionFactory):
                 """The IPython Controller Hub with 0MQ connections
                 Parameters
                 ==========
                 loop: zmq IOLoop instance
                 incoming_registrations=Dict()
                 registration_timeout=Int()
                 _idcounter=Int(0)
                 # objects from constructor:
                 query=Instance(ZMQStream)
                 monitor=Instance(ZMQStream)
                 db=Instance(object)
                 client_info=Dict()
                 engine_info=Dict()
                 def __init__(self, **kwargs):
                     """
                     # universal:
                     engine_info: zmq address/protocol dict for engine connections
                     client_info: zmq address/protocol dict for client connections
                     """
                     super(Hub, self).__init__(**kwargs)
                     self.registration_timeout = max(5000, 2*self.heartmonitor.period)
                     # validate connection dicts:
                     for k,v in self.client_info.iteritems():
                         if k == 'task':
                             util.validate_url_container(v)
                     # util.validate_url_container(self.client_info)
                     util.validate_url_container(self.engine_info)
                     # register our callbacks
                     self.query.on_recv(self.dispatch_query)
                     self.monitor.on_recv(self.dispatch_monitor_traffic)
                     self.heartmonitor.add_heart_failure_handler(self.handle_heart_failure)
                     self.heartmonitor.add_new_heart_handler(self.handle_new_heart)
                     self.monitor_handlers = {b'in' : self.save_queue_request,
                                             b'out': self.save_queue_result,
                                             b'intask': self.save_task_request,
                                             b'outcontrol': _passer,
                                             b'iopub': self.save_iopub_message,
                     }
                     self.query_handlers = {'queue_request': self.queue_status,
                                             'result_request': self.get_results,
                                             'history_request': self.get_history,
                                             'unregistration_request' : self.unregister_engine,
                                             'connection_request': self.connection_request,
                     }
                     # ignore resubmit replies
                     self.resubmit.on_recv(lambda msg: None, copy=False)
                     self.log.info("hub::created hub")
                 @property
                 def _next_id(self):
                     """gemerate a new ID.
                     No longer reuse old ids, just count from 0."""
                     newid = self._idcounter
                     self._idcounter += 1
                     # while newid in self.ids or newid in incoming:
                     #     newid += 1
                     # return newid
                 #-----------------------------------------------------------------------------
                 # message validation
                 #-----------------------------------------------------------------------------
                 def _validate_targets(self, targets):
                     """turn any valid targets argument into a list of integer ids"""
                     if targets is None:
                         # default to all
                         targets = self.ids
                     if isinstance(targets, (int,str,unicode)):
                         # only one target specified
                         targets = [targets]
                     if not targets:
                         raise IndexError("No Engines Registered")
                     return targets
                 #-----------------------------------------------------------------------------
                 # dispatch methods (1 per stream)
                 #-----------------------------------------------------------------------------
                 def dispatch_monitor_traffic(self, msg):
                     """all ME and Task queue messages come through here, as well as
                     IOPub traffic."""
                         handler(idents, msg)
                     else:
                         self.log.error("Invalid monitor topic: %r"%switch)
                 def dispatch_query(self, msg):
                     """Route registration requests and queries from clients."""
                     try:
                     except Exception:
                         content = error.wrap_exception()
                         self.log.error("Bad Query Message: %r"%msg, exc_info=True)
                         self.session.send(self.query, "hub_error", ident=client_id,
                                 content=content)
                         return
                     # print client_id, header, parent, content
                     except:
                         content = error.wrap_exception()
                         self.log.error("Bad Message Type: %r"%msg_type, exc_info=True)
                         self.session.send(self.query, "hub_error", ident=client_id,
                                 content=content)
                         return
                     else:
                         handler(idents, msg)
                 def dispatch_db(self, msg):
                     """"""
                     raise NotImplementedError
                 #---------------------------------------------------------------------------
                 # handler methods (1 per event)
                 #---------------------------------------------------------------------------
                 #----------------------- Heartbeat --------------------------------------
                 def handle_new_heart(self, heart):
                     """handler to attach to heartbeater.
                     Called when a new heart starts to beat.
                         self.log.info("heartbeat::ignoring new heart: %r"%heart)
                     else:
                         self.finish_registration(heart)
                 def handle_heart_failure(self, heart):
                     """handler to attach to heartbeater.
                     called when a previously registered heart fails to respond to beat request.
                         self.log.info("heartbeat::ignoring heart failure %r"%heart)
                     else:
                         self.unregister_engine(heart, dict(content=dict(id=eid, queue=queue)))
                 #----------------------- MUX Queue Traffic ------------------------------
                 def save_queue_request(self, idents, msg):
                     if len(idents) < 2:
                         self.log.error("invalid identity prefix: %r"%idents)
                     except Exception:
                         self.log.error("queue::client %r sent invalid message to %r: %r"%(client_id, queue_id, msg), exc_info=True)
                         return
                     eid = self.by_ident.get(queue_id, None)
                     if eid is None:
                         self.log.error("queue::target %r not registered"%queue_id)
                             self.db.add_record(msg_id, record)
                         except Exception:
                             self.log.error("DB Error adding record %r"%msg_id, exc_info=True)
                     self.pending.add(msg_id)
                     self.queues[eid].append(msg_id)
                 def save_queue_result(self, idents, msg):
                     if len(idents) < 2:
                         self.log.error("invalid identity prefix: %r"%idents)
                         return
                     client_id, queue_id = idents[:2]
                     try:
                         msg = self.session.unserialize(msg)
                         self.log.error("queue::engine %r sent invalid message to %r: %r"%(
                                 queue_id,client_id, msg), exc_info=True)
                         return
                     eid = self.by_ident.get(queue_id, None)
                     if eid is None:
                         self.log.error("queue::unknown engine %r is sending a reply: "%queue_id)
                         return
                     parent = msg['parent_header']
                     if not parent:
                         return
                         self.db.update_record(msg_id, result)
                     except Exception:
                         self.log.error("DB Error updating record %r"%msg_id, exc_info=True)
                 #--------------------- Task Queue Traffic ------------------------------
                 def save_task_request(self, idents, msg):
                     """Save the submission of a task."""
                     client_id = idents[0]
                     try:
                         msg = self.session.unserialize(msg)
                     except Exception:
                             self.log.error("DB Error adding record %r"%msg_id, exc_info=True)
                     except Exception:
                         self.log.error("DB Error saving task request %r"%msg_id, exc_info=True)
                 def save_task_result(self, idents, msg):
                     """save the result of a completed task."""
                     client_id = idents[0]
                         self.log.error("task::invalid task result message send to %r: %r"%(
                                 client_id, msg), exc_info=True)
                         return
                     parent = msg['parent_header']
                     if not parent:
                         # print msg
                     msg_id = parent['msg_id']
                     if msg_id in self.unassigned:
                         self.unassigned.remove(msg_id)
                     header = msg['header']
                     engine_uuid = header.get('engine', None)
                     eid = self.by_ident.get(engine_uuid, None)
                     if msg_id in self.pending:
                         self.pending.remove(msg_id)
                         self.all_completed.add(msg_id)
                             self.db.update_record(msg_id, result)
                         except Exception:
                             self.log.error("DB Error saving task request %r"%msg_id, exc_info=True)
                     else:
                         self.log.debug("task::unknown task %r finished"%msg_id)
                 def save_task_destination(self, idents, msg):
                     try:
                         msg = self.session.unserialize(msg, content=True)
                     msg_id = content['msg_id']
                     engine_uuid = content['engine_id']
                     eid = self.by_ident[util.asbytes(engine_uuid)]
                     self.log.info("task::task %r arrived on %r"%(msg_id, eid))
                     if msg_id in self.unassigned:
                         self.unassigned.remove(msg_id)
                     # else:
                     #     self.log.debug("task::task %r not listed as MIA?!"%(msg_id))
                     self.tasks[eid].append(msg_id)
                     # self.pending[msg_id][1].update(received=datetime.now(),engine=(eid,engine_uuid))
                     try:
                         self.db.update_record(msg_id, dict(engine_uuid=engine_uuid))
                     except Exception:
                         self.log.error("DB Error saving task destination %r"%msg_id, exc_info=True)
                 def mia_task_request(self, idents, msg):
                     raise NotImplementedError
                     client_id = idents[0]
                     # content = dict(mia=self.mia,status='ok')
                     # self.session.send('mia_reply', content=content, idents=client_id)
                 #--------------------- IOPub Traffic ------------------------------
                 def save_iopub_message(self, topics, msg):
                     """save an iopub message into the db"""
                     # print (topics)
                     except Exception:
                         self.log.error("iopub::invalid IOPub message", exc_info=True)
                         return
                     parent = msg['parent_header']
                     if not parent:
                         self.log.error("iopub::invalid IOPub message: %r"%msg)
                     msg_id = parent['msg_id']
                     msg_type = msg['header']['msg_type']
                     content = msg['content']
                     # ensure msg_id is in db
                     try:
                         rec = self.db.get_record(msg_id)
                         name = content['name']
                         s = rec[name] or ''
                         d[name] = s + content['data']
                     elif msg_type == 'pyerr':
                         d['pyerr'] = content
                     elif msg_type == 'pyin':
                         d['pyin'] = content['code']
                     else:
                         d[msg_type] = content.get('data', '')
                     try:
                         self.db.update_record(msg_id, d)
                     except Exception:
                         self.log.error("DB Error saving iopub message %r"%msg_id, exc_info=True)
                 #-------------------------------------------------------------------------
                 # Registration requests
                 #-------------------------------------------------------------------------
                 def connection_request(self, client_id, msg):
                     """Reply with connection addresses for clients."""
                     self.log.info("client::client %r connected"%client_id)
                             jsonable[str(k)] = v.decode('ascii')
                     content['engines'] = jsonable
                     self.session.send(self.query, 'connection_reply', content, parent=msg, ident=client_id)
                 def register_engine(self, reg, msg):
                     """Register a new engine."""
                     content = msg['content']
                     """register a new engine, and create the socket(s) necessary"""
                     eid = self._next_id
                     # print (eid, queue, reg, heart)
                     self.log.debug("registration::register_engine(%i, %r, %r, %r)"%(eid, queue, reg, heart))
                     content = dict(id=eid,status='ok')
                     content.update(self.engine_info)
                     # check if requesting available IDs:
                                     self.log.error("queue_id %r in use"%queue, exc_info=True)
                                     content = error.wrap_exception()
                                 break
                     msg = self.session.send(self.query, "registration_reply",
                             content=content,
                             ident=reg)
                     if content['status'] == 'ok':
                         if heart in self.heartmonitor.hearts:
                             # already beating
                     else:
                         self.log.error("registration::registration %i failed: %r"%(eid, content['evalue']))
                     return eid
                 def unregister_engine(self, ident, msg):
                     """Unregister an engine that explicitly requested to leave."""
                     try:
                     self.dead_engines.add(uuid)
                     # self.ids.remove(eid)
                     # uuid = self.keytable.pop(eid)
+                    #
                     # ec = self.engines.pop(eid)
                     # self.hearts.pop(ec.heartbeat)
                     # self.by_ident.pop(ec.queue)
                     dc = ioloop.DelayedCallback(handleit, self.registration_timeout, self.loop)
                     dc.start()
                     ############## TODO: HANDLE IT ################
                     if self.notifier:
                         self.session.send(self.notifier, "unregistration_notification", content=content)
                 def _handle_stranded_msgs(self, eid, uuid):
                     """Handle messages known to be on an engine when the engine unregisters.
                     It is possible that this will fire prematurely - that is, an engine will
                     go down after completing a result, and the client will be notified
                     that the result failed and later receive the actual result.
                     """
                     outstanding = self.queues[eid]
                     for msg_id in outstanding:
                         self.pending.remove(msg_id)
                         self.all_completed.add(msg_id)
                             self.db.update_record(msg_id, rec)
                         except Exception:
                             self.log.error("DB Error handling stranded msg %r"%msg_id, exc_info=True)
                 def finish_registration(self, heart):
                     """Second half of engine registration, called after our HeartMonitor
                     has received a beat from the Engine's Heart."""
                     try:
                         (eid,queue,reg,purge) = self.incoming_registrations.pop(heart)
                     except KeyError:
                         self.log.error("registration::tried to finish nonexistant registration", exc_info=True)
                     control = queue
                     self.ids.add(eid)
                     self.keytable[eid] = queue
                     self.engines[eid] = EngineConnector(id=eid, queue=queue, registration=reg,
                                                 control=control, heartbeat=heart)
                     self.by_ident[queue] = eid
                     self.queues[eid] = list()
                     if self.notifier:
                         self.session.send(self.notifier, "registration_notification", content=content)
                     self.log.info("engine::Engine Connected: %i"%eid)
                 def _purge_stalled_registration(self, heart):
                     if heart in self.incoming_registrations:
                         eid = self.incoming_registrations.pop(heart)[0]
                         self.log.info("registration::purging stalled registration: %i"%eid)
                     else:
                         pass
                 #-------------------------------------------------------------------------
                 # Client Requests
                 #-------------------------------------------------------------------------
                 def shutdown_request(self, client_id, msg):
                     """handle shutdown request."""
                     self.session.send(self.query, 'shutdown_reply', content={'status': 'ok'}, ident=client_id)
                     self.session.send(self.notifier, 'shutdown_notice', content={'status': 'ok'})
                     dc = ioloop.DelayedCallback(lambda : self._shutdown(), 1000, self.loop)
                     dc.start()
                 def _shutdown(self):
                     self.log.info("hub::hub shutting down.")
                     time.sleep(0.1)
                     sys.exit(0)
                 def check_load(self, client_id, msg):
                     content = msg['content']
                     try:
                         targets = self._validate_targets(targets)
                     except:
                         content = error.wrap_exception()
                         self.session.send(self.query, "hub_error",
                                 content=content, ident=client_id)
                         return
                     content = dict(status='ok')
                     # loads = {}
                     for t in targets:
                         content[bytes(t)] = len(self.queues[t])+len(self.tasks[t])
                     self.session.send(self.query, "load_reply", content=content, ident=client_id)
                 def queue_status(self, client_id, msg):
                     """Return the Queue status of one or more targets.
                     if verbose: return the msg_ids
                         targets = self._validate_targets(targets)
                     except:
                         content = error.wrap_exception()
                         self.session.send(self.query, "hub_error",
                                 content=content, ident=client_id)
                         return
                     verbose = content.get('verbose', False)
                     content['unassigned'] = list(self.unassigned) if verbose else len(self.unassigned)
                     # print (content)
                     self.session.send(self.query, "queue_reply", content=content, ident=client_id)
                 def purge_results(self, client_id, msg):
                     """Purge results from memory. This method is more valuable before we move
                     to a DB based message storage mechanism."""
                                 except Exception:
                                     reply = error.wrap_exception()
                                     break
                     self.session.send(self.query, 'purge_reply', content=reply, ident=client_id)
                 def resubmit_task(self, client_id, msg):
                     """Resubmit one or more tasks."""
                     def finish(reply):
                     finish(dict(status='ok'))
                 def _extract_record(self, rec):
                     """decompose a TaskRecord dict into subsection of reply for get_result"""
                     io_dict = {}
                         buffers = map(bytes, rec['result_buffers'])
                     else:
                         buffers = []
                     return content, buffers
                 def get_results(self, client_id, msg):
                     """Get the result of 1 or more messages."""
                     content = msg['content']
                                 records[rec['msg_id']] = rec
                         except Exception:
                             content = error.wrap_exception()
                             self.session.send(self.query, "result_reply", content=content,
                                                                 parent=msg, ident=client_id)
                             return
                     else:
                             except:
                                 content = error.wrap_exception()
                             break
                     self.session.send(self.query, "result_reply", content=content,
                                                         parent=msg, ident=client_id,
                                                         buffers=buffers)
                         content = error.wrap_exception()
                     else:
                         content = dict(status='ok', history=msg_ids)
                     self.session.send(self.query, "history_reply", content=content,
                                                         parent=msg, ident=client_id)
                 def db_query(self, client_id, msg):
                         else:
                             buffer_lens = []
                             result_buffer_lens = []
                         for rec in records:
                             # buffers may be None, so double check
                             if buffer_lens is not None:
                         content = dict(status='ok', records=records, buffer_lens=buffer_lens,
                                                 result_buffer_lens=result_buffer_lens)
                     # self.log.debug (content)
                     self.session.send(self.query, "db_reply", content=content,
                                                         parent=msg, ident=client_id,
                                                         buffers=buffers)

IPython/parallel/controller/scheduler.py

0 +79 -79

             def lru(loads):
                 """Always pick the front of the line.
                 The content of `loads` is ignored.
                 Assumes LRU ordering of loads, with oldest first.
                 """
                 return 0
             def twobin(loads):
                 """Pick two at random, use the LRU of the two.
                 The content of loads is ignored.
                 Assumes LRU ordering of loads, with oldest first.
                 """
                 n = len(loads)
             def weighted(loads):
                 """Pick two at random using inverse load as weight.
                 Return the less loaded of the two.
                 """
                 # weight 0 a million times more than 1:
             def leastload(loads):
                 """Always choose the lowest load.
                 If the lowest load occurs more than once, the first
                 occurance will be used.  If loads has LRU ordering, this means
                 the LRU of those with the lowest load is chosen.
             class TaskScheduler(SessionFactory):
                 """Python TaskScheduler object.
                 This is the simplest object that supports msg_id based
                 DAG dependencies. *Only* task msg_ids are checked, not
                 msg_ids of jobs submitted via the MUX queue.
                 """
                 hwm = Int(0, config=True, shortname='hwm',
                     help="""specify the High Water Mark (HWM) for the downstream
                     socket in the Task scheduler. This is the maximum number
                 def _scheme_name_changed(self, old, new):
                     self.log.debug("Using scheme %r"%new)
                     self.scheme = globals()[new]
                 # input arguments:
                 scheme = Instance(FunctionType) # function for determining the destination
                 def _scheme_default(self):
                 engine_stream = Instance(zmqstream.ZMQStream) # engine-facing stream
                 notifier_stream = Instance(zmqstream.ZMQStream) # hub-facing sub stream
                 mon_stream = Instance(zmqstream.ZMQStream) # hub-facing pub stream
                 # internals:
                 graph = Dict() # dict by msg_id of [ msg_ids that depend on key ]
                 retries = Dict() # dict by msg_id of retries remaining (non-neg ints)
                 all_ids = Set() # set of all submitted task IDs
                 blacklist = Dict() # dict by msg_id of locations where a job has encountered UnmetDependency
                 auditor = Instance('zmq.eventloop.ioloop.PeriodicCallback')
                 ident = CBytes() # ZMQ identity. This should just be self.session.session
                                  # but ensure Bytes
                 def _ident_default(self):
                     return self.session.bsession
                 def start(self):
                     self.engine_stream.on_recv(self.dispatch_result, copy=False)
                     self._notification_handlers = dict(
                     self.auditor = ioloop.PeriodicCallback(self.audit_timeouts, 2e3, self.loop) # 1 Hz
                     self.auditor.start()
                     self.log.info("Scheduler started [%s]"%self.scheme_name)
                 def resume_receiving(self):
                     """Resume accepting jobs."""
                     self.client_stream.on_recv(self.dispatch_submission, copy=False)
                 def stop_receiving(self):
                     """Stop accepting jobs while there are no engines.
                     Leave them in the ZMQ queue."""
                     self.client_stream.on_recv(None)
                 #-----------------------------------------------------------------------
                 # [Un]Registration Handling
                 #-----------------------------------------------------------------------
                 def dispatch_notification(self, msg):
                     """dispatch register/unregister events."""
                     try:
                     except ValueError:
                         self.log.warn("task::Unauthorized message from: %r"%idents)
                         return
                     msg_type = msg['header']['msg_type']
                     handler = self._notification_handlers.get(msg_type, None)
                     if handler is None:
                         self.log.error("Unhandled message type: %r"%msg_type)
                             handler(asbytes(msg['content']['queue']))
                         except Exception:
                             self.log.error("task::Invalid notification msg: %r",msg)
                 def _register_engine(self, uid):
                     """New engine with ident `uid` became available."""
                     # head of the line:
                     if len(self.targets) == 1:
                         # this was our only engine
                         self.stop_receiving()
                     # handle any potentially finished tasks:
                     self.engine_stream.flush()
                     # don't pop destinations, because they might be used later
                     # map(self.destinations.pop, self.completed.pop(uid))
                     # map(self.destinations.pop, self.failed.pop(uid))
                     idx = self.targets.index(uid)
                     self.targets.pop(idx)
                     self.loads.pop(idx)
                     # wait 5 seconds before cleaning up pending jobs, since the results might
                     # still be incoming
                     if self.pending[uid]:
                         self.completed.pop(uid)
                         self.failed.pop(uid)
                 def handle_stranded_tasks(self, engine):
                     """Deal with jobs resident in an engine that died."""
                     lost = self.pending[engine]
                     # finally scrub completed/failed lists
                     self.completed.pop(engine)
                     self.failed.pop(engine)
                 #-----------------------------------------------------------------------
                 # Job Submission
                 #-----------------------------------------------------------------------
                     except Exception:
                         self.log.error("task::Invaid task msg: %r"%raw_msg, exc_info=True)
                         return
                     # send to monitor
                     self.mon_stream.send_multipart([b'intask']+raw_msg, copy=False)
                     header = msg['header']
                     msg_id = header['msg_id']
                     self.all_ids.add(msg_id)
                     # get targets as a set of bytes objects
                     # from a list of unicode objects
                     targets = header.get('targets', [])
                     targets = map(asbytes, targets)
                     targets = set(targets)
                     retries = header.get('retries', 0)
                     self.retries[msg_id] = retries
                     # time dependencies
                     after = header.get('after', None)
                     if after:
                             after = MET
                     else:
                         after = MET
                     # location dependencies
                     follow = Dependency(header.get('follow', []))
                     # turn timeouts into datetime objects:
                     timeout = header.get('timeout', None)
                     if timeout:
                         timeout = datetime.now() + timedelta(0,timeout,0)
                     args = [raw_msg, targets, after, follow, timeout]
                     # validate and reduce dependencies:
                     for dep in after,follow:
                         if not dep: # empty dependency
                         if dep.unreachable(self.all_completed, self.all_failed):
                             self.depending[msg_id] = args
                             return self.fail_unreachable(msg_id)
                     if after.check(self.all_completed, self.all_failed):
                         # time deps already met, try to run
                         if not self.maybe_run(msg_id, *args):
                                 self.save_unmet(msg_id, *args)
                     else:
                         self.save_unmet(msg_id, *args)
                 def audit_timeouts(self):
                     """Audit all waiting tasks for expired timeouts."""
                     now = datetime.now()
                             raw,after,targets,follow,timeout = self.depending[msg_id]
                             if timeout and timeout < now:
                                 self.fail_unreachable(msg_id, error.TaskTimeout)
                 def fail_unreachable(self, msg_id, why=error.ImpossibleDependency):
                     """a task has become unreachable, send a reply with an ImpossibleDependency
                     error."""
                     for mid in follow.union(after):
                         if mid in self.graph:
                             self.graph[mid].remove(msg_id)
                     # FIXME: unpacking a message I've already unpacked, but didn't save:
                     idents,msg = self.session.feed_identities(raw_msg, copy=False)
                     header = self.session.unpack(msg[1].bytes)
                     try:
                         raise why()
                     except:
                         content = error.wrap_exception()
                     self.all_done.add(msg_id)
                     self.all_failed.add(msg_id)
                     msg = self.session.send(self.client_stream, 'apply_reply', content,
                                                             parent=header, ident=idents)
                     self.session.send(self.mon_stream, msg, ident=[b'outtask']+idents)
                     self.update_graph(msg_id, success=False)
                 def maybe_run(self, msg_id, raw_msg, targets, after, follow, timeout):
                     """check location dependencies, and run if they are met."""
                     blacklist = self.blacklist.setdefault(msg_id, set())
                                 return False
                             # check follow
                             return follow.check(self.completed[target], self.failed[target])
                         indices = filter(can_run, range(len(self.targets)))
                         if not indices:
                             return False
                     else:
                         indices = None
                     self.submit_task(msg_id, raw_msg, targets, follow, timeout, indices)
                     return True
                 def save_unmet(self, msg_id, raw_msg, targets, after, follow, timeout):
                     """Save a message for later submission when its dependencies are met."""
                     self.depending[msg_id] = [raw_msg,targets,after,follow,timeout]
                         if dep_id not in self.graph:
                             self.graph[dep_id] = set()
                         self.graph[dep_id].add(msg_id)
                 def submit_task(self, msg_id, raw_msg, targets, follow, timeout, indices=None):
                     """Submit a task to any of a subset of our targets."""
                     if indices:
                     self.pending[target][msg_id] = (raw_msg, targets, MET, follow, timeout)
                     # notify Hub
                     content = dict(msg_id=msg_id, engine_id=target.decode('ascii'))
                     self.session.send(self.mon_stream, 'task_destination', content=content,
                                     ident=[b'tracktask',self.ident])
                 #-----------------------------------------------------------------------
                 # Result Handling
                 #-----------------------------------------------------------------------
                             self.mon_stream.send_multipart([b'outtask']+raw_msg, copy=False)
                     else:
                         self.handle_unmet_dependency(idents, parent)
                 def handle_result(self, idents, parent, raw_msg, success=True):
                     """handle a real task result, either success or failure"""
                     # first, relay result to client
                         self.all_failed.add(msg_id)
                     self.all_done.add(msg_id)
                     self.destinations[msg_id] = engine
                     self.update_graph(msg_id, success)
                 def handle_unmet_dependency(self, idents, parent):
                     """handle an unmet dependency"""
                     engine = idents[0]
                     msg_id = parent['msg_id']
                     if msg_id not in self.blacklist:
                         self.blacklist[msg_id] = set()
                     self.blacklist[msg_id].add(engine)
                     args = self.pending[engine].pop(msg_id)
                     raw,targets,after,follow,timeout = args
                     if self.blacklist[msg_id] == targets:
                         self.depending[msg_id] = args
                         self.fail_unreachable(msg_id)
                         if msg_id not in self.all_failed:
                             # put it back in our dependency tree
                             self.save_unmet(msg_id, *args)
                     if self.hwm:
                         try:
                             idx = self.targets.index(engine)
                         else:
                             if self.loads[idx] == self.hwm-1:
                                 self.update_graph(None)
                 def update_graph(self, dep_id=None, success=True):
                     """dep_id just finished. Update our dependency
                     graph and submit any jobs that just became runable.
                     Called with dep_id=None to update entire graph for hwm, but without finishing
                     a task.
                     """
                     # or b) dep_id was given as None
                     if dep_id is None or self.hwm and any( [ load==self.hwm-1 for load in self.loads ]):
                         jobs = self.depending.keys()
                     for msg_id in jobs:
                         raw_msg, targets, after, follow, timeout = self.depending[msg_id]
                         if after.unreachable(self.all_completed, self.all_failed)\
                                 or follow.unreachable(self.all_completed, self.all_failed):
                             self.fail_unreachable(msg_id)
                         elif after.check(self.all_completed, self.all_failed): # time deps met, maybe run
                             if self.maybe_run(msg_id, raw_msg, targets, MET, follow, timeout):
                                 self.depending.pop(msg_id)
                                 for mid in follow.union(after):
                                     if mid in self.graph:
                                         self.graph[mid].remove(msg_id)
                 #----------------------------------------------------------------------
                 # methods to be overridden by subclasses
                 #----------------------------------------------------------------------
                 def add_job(self, idx):
                     """Called after self.targets[idx] just got the job with header.
                     Override with subclasses.  The default ordering is simple LRU.
                     self.loads[idx] += 1
                     for lis in (self.targets, self.loads):
                         lis.append(lis.pop(idx))
                 def finish_job(self, idx):
                     """Called after self.targets[idx] just finished a job.
                     Override with subclasses."""
                     self.loads[idx] -= 1
             def launch_scheduler(in_addr, out_addr, mon_addr, not_addr, config=None,
                                     logname='root', log_url=None, loglevel=logging.DEBUG,
                                     identity=b'task', in_thread=False):
                 ZMQStream = zmqstream.ZMQStream
                 if config:
                     # unwrap dict back into Config
                     config = Config(config)
                     ctx = zmq.Context.instance()
                     loop = ioloop.IOLoop.instance()
                 else:
                     # in a process, don't use instance()
                     # for safety with multiprocessing
                     ctx = zmq.Context()
                     loop = ioloop.IOLoop()
                 ins = ZMQStream(ctx.socket(zmq.ROUTER),loop)
                 ins.setsockopt(zmq.IDENTITY, identity)
                 ins.bind(in_addr)
                 outs = ZMQStream(ctx.socket(zmq.ROUTER),loop)
                 outs.setsockopt(zmq.IDENTITY, identity)
                 outs.bind(out_addr)
                 nots = zmqstream.ZMQStream(ctx.socket(zmq.SUB),loop)
                 nots.setsockopt(zmq.SUBSCRIBE, b'')
                 nots.connect(not_addr)
                 # setup logging.
                 if in_thread:
                     log = Application.instance().log
                         log = connect_logger(logname, ctx, log_url, root="scheduler", loglevel=loglevel)
                     else:
                         log = local_logger(logname, loglevel)
                 scheduler = TaskScheduler(client_stream=ins, engine_stream=outs,
                                         mon_stream=mons, notifier_stream=nots,
                                         loop=loop, log=log,

IPython/parallel/controller/sqlitedb.py

0 +31 -31

             class SQLiteDB(BaseDB):
                 """SQLite3 TaskRecord backend."""
                 filename = Unicode('tasks.db', config=True,
                     help="""The filename of the sqlite task database. [default: 'tasks.db']""")
                 location = Unicode('', config=True,
                     a new table will be created with the Hub's IDENT.  Specifying the table will result
                     in tasks from previous sessions being available via Clients' db_query and
                     get_result methods.""")
                 _db = Instance('sqlite3.Connection')
                 # the ordered list of column names
                 _keys = List(['msg_id' ,
                         'stdout' : 'text',
                         'stderr' : 'text',
                     })
                 def __init__(self, **kwargs):
                     super(SQLiteDB, self).__init__(**kwargs)
                     if not self.table:
                         else:
                             self.location = u'.'
                     self._init_db()
                     # register db commit as 2s periodic callback
                     # to prevent clogging pipes
                     # assumes we are being run in a zmq ioloop app
                     loop = ioloop.IOLoop.instance()
                     pc = ioloop.PeriodicCallback(self._db.commit, 2000, loop)
                     pc.start()
                 def _defaults(self, keys=None):
                     """create an empty record"""
                     d = {}
                     for key in keys:
                         d[key] = None
                     return d
                 def _check_table(self):
                     """Ensure that an incorrect table doesn't exist
                     If a bad (old) table does exist, return False
                     """
                     cursor = self._db.execute("PRAGMA table_info(%s)"%self.table)
                             )
                             return False
                     return True
                 def _init_db(self):
                     """Connect to the database and get new session number."""
                     # register adapters
                     sqlite3.register_converter('bufs', _convert_bufs)
                     # connect to the db
                     dbfile = os.path.join(self.location, self.filename)
                     self._db = sqlite3.connect(dbfile, detect_types=sqlite3.PARSE_DECLTYPES,
                         # isolation_level = None)#,
                          cached_statements=64)
                     # print dir(self._db)
                             "Table %s exists and doesn't match db format, trying %s"%
                             (first_table,self.table)
                         )
                     self._db.execute("""CREATE TABLE IF NOT EXISTS %s
                             (msg_id text PRIMARY KEY,
                             header dict text,
                             content dict text,
                             stderr text)
                             """%self.table)
                     self._db.commit()
                 def _dict_to_list(self, d):
                     """turn a mongodb-style record dict into a list."""
                     return [ d[key] for key in self._keys ]
                 def _list_to_dict(self, line, keys=None):
                     """Inverse of dict_to_list"""
                     keys = self._keys if keys is None else keys
                     d = self._defaults(keys)
                     for key,value in zip(keys, line):
                         d[key] = value
                     return d
                 def _render_expression(self, check):
                     """Turn a mongodb-style search dict into an SQL query."""
                     expressions = []
                     args = []
                     skeys = set(check.keys())
                     skeys.difference_update(set(self._keys))
                     skeys.difference_update(set(['buffers', 'result_buffers']))
                     if skeys:
                         raise KeyError("Illegal testing key(s): %s"%skeys)
                     for name,sub_check in check.iteritems():
                         if isinstance(sub_check, dict):
                             for test,value in sub_check.iteritems():
                                     raise KeyError("Unsupported operator: %r"%test)
                                 if isinstance(op, tuple):
                                     op, join = op
                                 if value is None and op in null_operators:
                                         expr = "%s %s"%null_operators[op]
                                 else:
                             else:
                                 expressions.append("%s = ?"%name)
                                 args.append(sub_check)
                     expr = " AND ".join(expressions)
                     return expr, args
                 def add_record(self, msg_id, rec):
                     """Add a new Task Record, by msg_id."""
                     d = self._defaults()
                     tups = '(%s)'%(','.join(['?']*len(line)))
                     self._db.execute("INSERT INTO %s VALUES %s"%(self.table, tups), line)
                     # self._db.commit()
                 def get_record(self, msg_id):
                     """Get a specific Task Record, by msg_id."""
                     cursor = self._db.execute("""SELECT * FROM %s WHERE msg_id==?"""%self.table, (msg_id,))
                     if line is None:
                         raise KeyError("No such msg: %r"%msg_id)
                     return self._list_to_dict(line)
                 def update_record(self, msg_id, rec):
                     """Update the data in an existing record."""
                     query = "UPDATE %s SET "%self.table
                     values.append(msg_id)
                     self._db.execute(query, values)
                     # self._db.commit()
                 def drop_record(self, msg_id):
                     """Remove a record from the DB."""
                     self._db.execute("""DELETE FROM %s WHERE msg_id==?"""%self.table, (msg_id,))
                     # self._db.commit()
                 def drop_matching_records(self, check):
                     """Remove a record from the DB."""
                     expr,args = self._render_expression(check)
                     query = "DELETE FROM %s WHERE %s"%(self.table, expr)
                     self._db.execute(query,args)
                     # self._db.commit()
                 def find_records(self, check, keys=None):
                     """Find records matching a query dict, optionally extracting subset of keys.
                     Returns list of matching records.
                     Parameters
                     ----------
                     check: dict
                         mongodb-style query argument
                     keys: list of strs [optional]
                         bad_keys = [ key for key in keys if key not in self._keys ]
                         if bad_keys:
                             raise KeyError("Bad record key(s): %s"%bad_keys)
                     if keys:
                         # ensure msg_id is present and first:
                         if 'msg_id' in keys:
                         rec = self._list_to_dict(line, keys)
                         records.append(rec)
                     return records
                 def get_history(self):
                     """get all msg_ids, ordered by time submitted."""
                     query = """SELECT msg_id FROM %s ORDER by submitted ASC"""%self.table

IPython/parallel/engine/engine.py

0 +33 -33

             from IPython.utils.traitlets import (
                 Instance, Dict, Int, Type, CFloat, Unicode, CBytes, Bool
             )
             # from IPython.utils.localinterfaces import LOCALHOST
             from IPython.parallel.controller.heartmonitor import Heart
             from IPython.parallel.factory import RegistrationFactory
             class EngineFactory(RegistrationFactory):
                 """IPython engine"""
                 # configurables:
                 out_stream_factory=Type('IPython.zmq.iostream.OutStream', config=True,
                     help="""The OutStream for handling stdout/err.
                     help="""The SSH private key file to use when tunneling connections to the Controller.""")
                 paramiko=Bool(sys.platform == 'win32', config=True,
                     help="""Whether to use paramiko instead of openssh for tunnels.""")
                 # not configurable:
                 user_ns=Dict()
                 id=Int(allow_none=True)
                 registrar=Instance('zmq.eventloop.zmqstream.ZMQStream')
                 kernel=Instance(Kernel)
                 bident = CBytes()
                 ident = Unicode()
                 def _ident_changed(self, name, old, new):
                     self.bident = asbytes(new)
                 using_ssh=Bool(False)
                 def __init__(self, **kwargs):
                     super(EngineFactory, self).__init__(**kwargs)
                     self.ident = self.session.session
                 def init_connector(self):
                     """construct connection function, which handles tunnels."""
                     self.using_ssh = bool(self.sshkey or self.sshserver)
                     if self.sshkey and not self.sshserver:
                         # We are using ssh directly to the controller, tunneling localhost to localhost
                         self.sshserver = self.url.split('://')[1].split(':')[0]
                     if self.using_ssh:
                         if tunnel.try_passwordless_ssh(self.sshserver, self.sshkey, self.paramiko):
                             password=False
                             password = getpass("SSH Password for %s: "%self.sshserver)
                     else:
                         password = False
                     def connect(s, url):
                         url = disambiguate_url(url, self.location)
                         if self.using_ssh:
                             )
                         else:
                             return s.connect(url)
                     def maybe_tunnel(url):
                         """like connect, but don't complete the connection (for use by heartbeat)"""
                         url = disambiguate_url(url, self.location)
                             )
                         return url
                     return connect, maybe_tunnel
                 def register(self):
                     """send the registration_request"""
                     self.log.info("Registering with controller at %s"%self.url)
                     ctx = self.context
                     connect,maybe_tunnel = self.init_connector()
                     reg.setsockopt(zmq.IDENTITY, self.bident)
                     connect(reg, self.url)
                     self.registrar = zmqstream.ZMQStream(reg, self.loop)
                     content = dict(queue=self.ident, heartbeat=self.ident, control=self.ident)
                     self.registrar.on_recv(lambda msg: self.complete_registration(msg, connect, maybe_tunnel))
                     # print (self.session.key)
                     self.session.send(self.registrar, "registration_request",content=content)
                 def complete_registration(self, msg, connect, maybe_tunnel):
                     # print msg
                     self._abort_dc.stop()
                     identity = self.bident
                     idents,msg = self.session.feed_identities(msg)
                     msg = Message(self.session.unserialize(msg))
                     if msg.content.status == 'ok':
                         self.id = int(msg.content.id)
                         # launch heartbeat
                         hb_addrs = msg.content.heartbeat
                         # possibly forward hb ports with tunnels
                         hb_addrs = [ maybe_tunnel(addr) for addr in hb_addrs ]
                         heart = Heart(*map(str, hb_addrs), heart_id=identity)
                         heart.start()
                         # create Shell Streams (MUX, Task, etc.):
                         queue_addr = msg.content.mux
                         shell_addrs = [ str(queue_addr) ]
                         task_addr = msg.content.task
                         if task_addr:
                             shell_addrs.append(str(task_addr))
                         # Uncomment this to go back to two-socket model
                         # shell_streams = []
                         # for addr in shell_addrs:
                         #     stream.setsockopt(zmq.IDENTITY, identity)
                         #     stream.connect(disambiguate_url(addr, self.location))
                         #     shell_streams.append(stream)
                         # Now use only one shell stream for mux and tasks
                         stream = zmqstream.ZMQStream(ctx.socket(zmq.ROUTER), loop)
                         stream.setsockopt(zmq.IDENTITY, identity)
                         for addr in shell_addrs:
                             connect(stream, addr)
                         # end single stream-socket
                         # control stream:
                         control_addr = str(msg.content.control)
                         control_stream = zmqstream.ZMQStream(ctx.socket(zmq.ROUTER), loop)
                         control_stream.setsockopt(zmq.IDENTITY, identity)
                         connect(control_stream, control_addr)
                         # create iopub stream:
                         iopub_addr = msg.content.iopub
                         iopub_stream = zmqstream.ZMQStream(ctx.socket(zmq.PUB), loop)
                         iopub_stream.setsockopt(zmq.IDENTITY, identity)
                         connect(iopub_stream, iopub_addr)
                         # # Redirect input streams and set a display hook.
                         if self.out_stream_factory:
                             sys.stdout = self.out_stream_factory(self.session, iopub_stream, u'stdout')
                             sys.displayhook = self.display_hook_factory(self.session, iopub_stream)
                             sys.displayhook.topic = 'engine.%i.pyout'%self.id
                         self.kernel = Kernel(config=self.config, int_id=self.id, ident=self.ident, session=self.session,
                                 control_stream=control_stream, shell_streams=shell_streams, iopub_stream=iopub_stream,
                                 loop=loop, user_ns = self.user_ns, log=self.log)
                         self.kernel.start()
                     else:
                         self.log.fatal("Registration Failed: %s"%msg)
                         raise Exception("Registration Failed: %s"%msg)
                     self.log.info("Completed registration with id %i"%self.id)
                 def abort(self):
                     self.log.fatal("Registration timed out after %.1f seconds"%self.timeout)
                     self.session.send(self.registrar, "unregistration_request", content=dict(id=self.id))
                     time.sleep(1)
                     sys.exit(255)
                 def start(self):
                     dc = ioloop.DelayedCallback(self.register, 0, self.loop)
                     dc.start()

IPython/parallel/engine/streamkernel.py

0 +63 -63

             class _Passer(zmqstream.ZMQStream):
                 """Empty class that implements `send()` that does nothing.
                 Subclass ZMQStream for Session typechecking
                 """
                 def __init__(self, *args, **kwargs):
                     pass
                 def send(self, *args, **kwargs):
                     pass
                 send_multipart = send
             #-----------------------------------------------------------------------------
             # Main kernel class
                 #---------------------------------------------------------------------------
                 # Kernel interface
                 #---------------------------------------------------------------------------
                 # kwargs:
                 exec_lines = List(Unicode, config=True,
                     help="List of lines to execute")
                 # identities:
                 int_id = Int(-1)
                 bident = CBytes()
                 ident = Unicode()
                 def _ident_changed(self, name, old, new):
                     self.bident = asbytes(new)
                 user_ns = Dict(config=True,  help="""Set the user's namespace of the Kernel""")
                 control_stream = Instance(zmqstream.ZMQStream)
                 task_stream = Instance(zmqstream.ZMQStream)
                 iopub_stream = Instance(zmqstream.ZMQStream)
                 client = Instance('IPython.parallel.Client')
                 # internals
                 shell_streams = List()
                 compiler = Instance(CommandCompiler, (), {})
                 completer = Instance(KernelCompleter)
                 aborted = Set()
                 shell_handlers = Dict()
                 control_handlers = Dict()
                 def _set_prefix(self):
                     self.prefix = "engine.%s"%self.int_id
                 def _connect_completer(self):
                     self.completer = KernelCompleter(self.user_ns)
                 def __init__(self, **kwargs):
                     super(Kernel, self).__init__(**kwargs)
                     self._set_prefix()
                     self._connect_completer()
                     self.on_trait_change(self._set_prefix, 'id')
                     self.on_trait_change(self._connect_completer, 'user_ns')
                     # Build dict of handlers for message types
                     for msg_type in ['execute_request', 'complete_request', 'apply_request',
                             'clear_request']:
                         self.shell_handlers[msg_type] = getattr(self, msg_type)
                     for msg_type in ['shutdown_request', 'abort_request']+self.shell_handlers.keys():
                         self.control_handlers[msg_type] = getattr(self, msg_type)
                     self._initial_exec_lines()
                 def _wrap_exception(self, method=None):
                     e_info = dict(engine_uuid=self.ident, engine_id=self.int_id, method=method)
                     content=wrap_exception(e_info)
                     return content
                 def _initial_exec_lines(self):
                     s = _Passer()
                     content = dict(silent=True, user_variable=[],user_expressions=[])
                         content.update({'code':line})
                         msg = self.session.msg('execute_request', content)
                         self.execute_request(s, [], msg)
                 #-------------------- control handlers -----------------------------
                 def abort_queues(self):
                     for stream in self.shell_streams:
                         if stream:
                             self.abort_queue(stream)
                 def abort_queue(self, stream):
                     while True:
                         idents,msg = self.session.recv(stream, zmq.NOBLOCK, content=True)
                         if msg is None:
                             return
                         self.log.info("Aborting:")
                         self.log.info(str(msg))
                         msg_type = msg['header']['msg_type']
                         # reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
                         # self.reply_socket.send(ident,zmq.SNDMORE)
                         # self.reply_socket.send_json(reply_msg)
                         reply_msg = self.session.send(stream, reply_type,
                                     content={'status' : 'aborted'}, parent=msg, ident=idents)
                         self.log.debug(str(reply_msg))
                         # We need to wait a bit for requests to come in. This can probably
                         # be set shorter for true asynchronous clients.
                         time.sleep(0.05)
                 def abort_request(self, stream, ident, parent):
                     """abort a specifig msg by id"""
                     msg_ids = parent['content'].get('msg_ids', None)
                         self.abort_queues()
                     for mid in msg_ids:
                         self.aborted.add(str(mid))
                     content = dict(status='ok')
                     reply_msg = self.session.send(stream, 'abort_reply', content=content,
                             parent=parent, ident=ident)
                     self.log.debug(str(reply_msg))
                 def shutdown_request(self, stream, ident, parent):
                     """kill ourself.  This should really be handled in an external process"""
                     try:
                     self.log.debug(str(msg))
                     dc = ioloop.DelayedCallback(lambda : sys.exit(0), 1000, self.loop)
                     dc.start()
                 def dispatch_control(self, msg):
                     idents,msg = self.session.feed_identities(msg, copy=False)
                     try:
                         return
                     else:
                         self.log.debug("Control received, %s", msg)
                     header = msg['header']
                     msg_id = header['msg_id']
                     msg_type = header['msg_type']
                         self.log.error("UNKNOWN CONTROL MESSAGE TYPE: %r"%msg_type)
                     else:
                         handler(self.control_stream, idents, msg)
                 #-------------------- queue helpers ------------------------------
                 def check_dependencies(self, dependencies):
                     if not dependencies:
                         return True
                     results = self.client.get_results(dependencies,status_only=True)
                     if results['status'] != 'ok':
                         return False
                     if anyorall == 'any':
                         if not results['completed']:
                             return False
                     else:
                         if results['pending']:
                             return False
                     return True
                 def check_aborted(self, msg_id):
                     return msg_id in self.aborted
                 #-------------------- queue handlers -----------------------------
                 def clear_request(self, stream, idents, parent):
                     """Clear our namespace."""
                     self.user_ns = {}
                     msg = self.session.send(stream, 'clear_reply', ident=idents, parent=parent,
                             content = dict(status='ok'))
                     self._initial_exec_lines()
                 def execute_request(self, stream, ident, parent):
                     self.log.debug('execute request %s'%parent)
                     try:
                         reply_content = exc_content
                     else:
                         reply_content = {'status' : 'ok'}
                     reply_msg = self.session.send(stream, u'execute_reply', reply_content, parent=parent,
                                 ident=ident, subheader = dict(started=started))
                     self.log.debug(str(reply_msg))
                     if reply_msg['content']['status'] == u'error':
                 def complete(self, msg):
                     return self.completer.complete(msg.content.line, msg.content.text)
                 def apply_request(self, stream, ident, parent):
                     # flush previous reply, so this request won't block it
                     stream.flush(zmq.POLLOUT)
                             sys.stderr.set_parent(parent)
                         # exec "f(*args,**kwargs)" in self.user_ns, self.user_ns
                         working = self.user_ns
                         # suffix =
                         prefix = "_"+str(msg_id).replace("-","")+"_"
                         f,args,kwargs = unpack_apply_message(bufs, working, copy=False)
                         # if bound:
                         #     bound_ns = Namespace(working)
                         #     args = [bound_ns]+list(args)
                         fname = getattr(f, '__name__', 'f')
                         fname = prefix+"f"
                         argname = prefix+"args"
                         kwargname = prefix+"kwargs"
                         resultname = prefix+"result"
                         ns = { fname : f, argname : args, kwargname : kwargs , resultname : None }
                         # print ns
                         working.update(ns)
                                 working.pop(key)
                         # if bound:
                         #     working.update(bound_ns)
                         packed_result,buf = serialize_object(result)
                         result_buf = [packed_result]+buf
                     except:
                                             ident=asbytes('%s.pyerr'%self.prefix))
                         reply_content = exc_content
                         result_buf = []
                         if exc_content['ename'] == 'UnmetDependency':
                             sub['dependencies_met'] = False
                     else:
                         reply_content = {'status' : 'ok'}
                     # put 'ok'/'error' status in header, for scheduler introspection:
                     sub['status'] = reply_content['status']
                     reply_msg = self.session.send(stream, u'apply_reply', reply_content,
                                 parent=parent, ident=ident,buffers=result_buf, subheader=sub)
                     # flush i/o
                     # should this be before reply_msg is sent, like in the single-kernel code,
                     # or should nothing get in the way of real results?
                     sys.stdout.flush()
                     sys.stderr.flush()
                 def dispatch_queue(self, stream, msg):
                     self.control_stream.flush()
                     idents,msg = self.session.feed_identities(msg, copy=False)
                         return
                     else:
                         self.log.debug("Message received, %s", msg)
                     header = msg['header']
                     msg_id = header['msg_id']
                     msg_type = msg['header']['msg_type']
                         self.log.error("UNKNOWN MESSAGE TYPE: %r"%msg_type)
                     else:
                         handler(stream, idents, msg)
                 def start(self):
                     #### stream mode:
                     if self.control_stream:
                         self.control_stream.on_recv(self.dispatch_control, copy=False)
                         self.control_stream.on_err(printer)
                     def make_dispatcher(stream):
                         def dispatcher(msg):
                             return self.dispatch_queue(stream, msg)
                         return dispatcher
                     for s in self.shell_streams:
                         s.on_recv(make_dispatcher(s), copy=False)
                         s.on_err(printer)
                     if self.iopub_stream:
                         self.iopub_stream.on_err(printer)
                     #### while True mode:
                     # while True:
                     #     idle = True
                     #     else:
                     #         idle=False
                     #         self.dispatch_queue(self.shell_stream, msg)
+                    #
                     #     if not self.task_stream.empty():
                     #         idle=False
                     #         msg = self.task_stream.recv_multipart()

IPython/parallel/error.py

0 +11 -11

                 def __repr__(self):
                     return '<NotDefined: %s>' % self.name
                 __str__ = __repr__
                 evalue=None
                 traceback=None
                 engine_info=None
                 def __init__(self, ename, evalue, traceback, engine_info=None):
                     self.ename=ename
                     self.evalue=evalue
                     self.traceback=traceback
                     self.engine_info=engine_info or {}
                     self.args=(ename, evalue)
                 def __repr__(self):
                     engineid = self.engine_info.get('engine_id', ' ')
                     return "<Remote[%s]:%s(%s)>"%(engineid, self.ename, self.evalue)
                 def __str__(self):
                     sig = "%s(%s)"%(self.ename, self.evalue)
                     if self.traceback:
                         return sig + '\n' + self.traceback
                     else:
                         return sig
             class TaskRejectError(KernelError):
                 """Exception to raise when a task should be rejected by an engine.
                 This exception can be used to allow a task running on an engine to test
                 if the engine (or the user's namespace on the engine) has the needed
                 task dependencies.  If not, the task should raise this exception.  For
                 the task to be retried on another engine, the task should be created
                 with the `retries` argument > 1.
                 The advantage of this approach over our older properties system is that
                 tasks have full access to the user's namespace on the engines and the
                 properties don't have to be managed or tested by the controller.
                         engine_str = self._get_engine_str(ei)
                         s = s + '\n' + engine_str + en + ': ' + str(ev)
                     return s
                 def __repr__(self):
                     return "CompositeError(%i)"%len(self.elist)
                         else:
                             print (self._get_engine_str(ei))
                             print (etb or 'No traceback available')
                 def raise_exception(self, excid=0):
                     try:
                         en,ev,etb,ei = self.elist[excid]
                     if isinstance(r, RemoteError):
                         en, ev, etb, ei = r.ename, r.evalue, r.traceback, r.engine_info
                         # Sometimes we could have CompositeError in our list.  Just take
                         # the errors out of them and put them in our new list.  This
                         # has the effect of flattening lists of CompositeErrors into one
                         # CompositeError
                         if en=='CompositeError':
                 return exc_content
             def unwrap_exception(content):
                 err = RemoteError(content['ename'], content['evalue'],
                             ''.join(content['traceback']),
                             content.get('engine_info', {}))
                 return err

IPython/quarantine/InterpreterExec.py

0 +5 -5

                 """Pysh is a set of modules and extensions to IPython which make shell-like
                 usage with Python syntax more convenient.  Keep in mind that pysh is NOT a
                 full-blown shell, so don't try to make it your /etc/passwd entry!
                 In particular, it has no job control, so if you type Ctrl-Z (under Unix),
                 you'll suspend pysh itself, not the process you just started.
                 ALIASES
                 -------
                 All of your $PATH has been loaded as IPython aliases, so you should be
                 able to type any normal system command and have it executed.  See %alias?
                 and %unalias? for details on the alias facilities.
                 SPECIAL SYNTAX
                     sys.platform is: linux2
                 IPython's input history handling is still active, which allows you to
                 rerun a single block of multi-line input by simply using exec:
                     fperez[~/test]|14> $$alist = ls *.eps
                     fperez[~/test]|15> exec _i11
                     file image2.eps    921 image2.eps
                 automatically loaded.  Some additional functions, useful for shell usage,
                 are listed below.  You can request more help about them with '?'.
                 shell   - execute a command in the underlying system shell
                 system  - like shell(), but return the exit status of the command
                 sout    - capture the output of a command as a string
                 lout    - capture the output of a command as a list (split on '\\n')
                 PROMPT CUSTOMIZATION
                 --------------------
                 The supplied ipythonrc-pysh profile comes with an example of a very
                 colored and detailed prompt, mainly to serve as an illustration.  The
                 valid escape sequences, besides color names, are:

IPython/quarantine/clearcmd.py

0 +8 -8

             def clear_f(self,arg):
                 """ Clear various data (e.g. stored history data)
                 %clear in  - clear input history
                 %clear out - clear output history
                 %clear shadow_compress - Compresses shadow history (to speed up ipython)
                 %clear shadow_nuke - permanently erase all entries in shadow history
                 %clear dhist - clear dir history
                 %clear array - clear only variables that are NumPy arrays
                 Examples:
                 In [1]: clear in
                 In [4]: clear dhist
                 Clearing directory history
                 """
                 api = self.getapi()
                 user_ns = self.user_ns  # local lookup, heavily used
                 for target in arg.split():
                     if target == 'out':
                                 del user_ns[key]
                             except: pass
                         # must be done in-place
                         self.history_manager.input_hist_parsed[:] = ['\n'] * pc
                         self.history_manager.input_hist_raw[:] = ['\n'] * pc
                     elif target == 'array':
                     elif target == 'shadow_compress':
                         print "Compressing shadow history"
                         api.db.hcompress('shadowhist')
                     elif target == 'shadow_nuke':
                         print "Erased all keys from shadow history "
                         for k in ip.db.keys('shadowhist/*'):
                         print "Clearing directory history"
                         del user_ns['_dh'][:]
                 gc.collect()
             # Activate the extension
             ip.define_magic("clear",clear_f)

IPython/quarantine/envpersist.py

0 +18 -18

             import os,sys
             def restore_env(self):
                 ip = self.getapi()
                 env = ip.db.get('stored_env', {'set' : {}, 'add' : [], 'pre' : []})
                 for k,v in env['set'].items():
                 for k,v in env['pre']:
                     os.environ[k] = v + os.environ.get(k,"")
                 raise TryNext
             ip.set_hook('late_startup_hook', restore_env)
             def persist_env(self, parameter_s=''):
                 """ Store environment variables persistently
                 IPython remembers the values across sessions, which is handy to avoid
                 editing startup files.
                 %env - Show all environment variables
                 %env VISUAL=jed  - set VISUAL to jed
                 %env PATH+=;/foo - append ;foo to PATH
                 %env PATH+=;/bar - also append ;bar to PATH
                 %env PATH-=/wbin; - prepend /wbin; to PATH
                 %env -d VISUAL   - forget VISUAL persistent val
                 %env -p          - print all persistent env modifications
                 """
                 if not parameter_s.strip():
                     return os.environ.data
                 ip = self.getapi()
                 db = ip.db
                 env = ip.db.get('stored_env', {'set' : {}, 'add' : [], 'pre' : []})
                 if parameter_s.startswith('-p'):
                     return env
                 elif parameter_s.startswith('-d'):
                     parts = (parameter_s.split()[1], '<del>')
                 else:
                     parts = parameter_s.strip().split('=')
                 if len(parts) == 2:
                     k,v = [p.strip() for p in parts]
                 if v == '<del>':
                     if k in env['set']:
                         del env['set'][k]
                     env['add'] = [el for el in env['add'] if el[0] != k]
                     env['pre'] = [el for el in env['pre'] if el[0] != k]
                     print "Forgot '%s' (for next session)" % k
                 elif k.endswith('+'):
                     k = k[:-1]
                     env['add'].append((k,v))
                     env['pre'].append((k,v))
                     os.environ[k] = v + os.environ.get(k,"")
                     print k,"after prepend =",os.environ[k]
                 else:
                     env['set'][k] = v
                     print "Setting",k,"to",v
                     os.environ[k] = v
                 db['stored_env'] = env
             def env_completer(self,event):

IPython/quarantine/ext_rescapture.py

0 +5 -5

             # -*- coding: utf-8 -*-
             """ IPython extension: new prefilters for output grabbing
             Provides
             var = %magic blah blah
                 install_re_handler('(?P<varname>[\w\.]+)\s*=\s*%(?P<cmd>.*)',
                                    hnd_magic
                                    )
                 install_re_handler('(?P<varname>[\w\.]+)\s*=\s*!(?P<cmd>.*)',
                                    hnd_syscmd
                                    )
                     mo = pat.match(line)
                     if mo:
                         return handler(line,mo)
                 raise TryNext
             ip.set_hook('input_prefilter', regex_prefilter_f)

IPython/quarantine/ipy_completers.py

0 +3 -3

                     return __bzr_commands
                 out = os.popen('bzr help commands')
                 __bzr_commands = [l.split()[0] for l in out]
                 return __bzr_commands
             def bzr_completer(self,event):
                 """ Completer for bazaar commands """
                 for p in out:
                     if p.startswith(prefix):
                         yield p.rstrip()
             apt_commands = """\
             update upgrade install remove purge source build-dep dist-upgrade
             dselect-upgrade clean autoclean check"""

IPython/quarantine/ipy_extutil.py

0 +5 -5

             class ExtUtil:
                 """ IPython extensios (ipy_* etc.) management utilities """
                 def describe(self):
                     for n,mod in self._active():
                         doc = inspect.getdoc(mod)
                         if doc:
                             print '== %s ==' % n
                             print indent(doc)
                 def ls(self):
                     """ Show list of installed extensions. """
                     for n,m in self._active():
                         o = getattr(m, 'ip', None)
                         if isinstance(o, InteractiveShell):
                             act.append((mname,m))
                     act.sort()
                     return act
             extutil = ExtUtil()
             ip.push('extutil')

IPython/quarantine/ipy_fsops.py

0 +38 -38

             def parse_args(args):
                 """ Given arg string 'CMD files... target', return ([files], target) """
                 tup = args.split(None, 1)
                 if len(tup) == 1:
                     raise UsageError("Expected arguments for " + tup[0])
                 tup2 = shlex.split(tup[1])
                 flist, trg = mglob.expand(tup2[0:-1]), tup2[-1]
                 if not flist:
                     raise UsageError("No files found:" + str(tup2[0:-1]))
                 return flist, trg
             def icp(ip,arg):
                 """ icp files... targetdir
                 Copy all files to target, creating dirs for target if necessary
                 icp srcdir dstdir
                 Copy srcdir to distdir
                 """
                 import distutils.dir_util
                 fs, targetdir = parse_args(arg)
                 if not os.path.isdir(targetdir) and len(fs) > 1:
                     distutils.dir_util.mkpath(targetdir,verbose =1)
             def imv(ip,arg):
                 """ imv src tgt
                 Move source to target.
                 """
                 fs, target = parse_args(arg)
                 if len(fs) > 1:
                     assert os.path.isdir(target)
                 for f in fs:
                     shutil.move(f, target)
                 return fs
             ip.define_alias("imv",imv)
             def irm(ip,arg):
                 """ irm path[s]...
                 Remove file[s] or dir[s] path. Dirs are deleted recursively.
                 """
                 try:
             def imkdir(ip,arg):
                 """ imkdir path
                 Creates dir path, and all dirs on the road
                 """
                 import distutils.dir_util
                 targetdir = arg.split(None,1)[1]
                 distutils.dir_util.mkpath(targetdir,verbose =1)
             ip.define_alias("imkdir",imkdir)
             def igrep(ip,arg):
                 """ igrep PAT files...
                 Very dumb file scan, case-insensitive.
                 e.g.
                 igrep "test this" rec:*.py
                 """
                 elems = shlex.split(arg)
                 dummy, pat, fs = elems[0], elems[1], mglob.expand(elems[2:])
                             print l.rstrip()
                 return res
             ip.define_alias("igrep",igrep)
             def collect(ip,arg):
                 """ collect foo/a.txt rec:bar=*.py
                 Copies foo/a.txt to ~/_ipython/collect/foo/a.txt and *.py from bar,
                 likewise
                 Without args, try to open ~/_ipython/collect dir (in win32 at least).
                 """
                 from IPython.external.path import path
                 basedir = path(ip.ipython_dir + '/collect')
                 try:
                     fs = mglob.expand(arg.split(None,1)[1])
                 except IndexError:
                     os.startfile(basedir)
                     print f,"=>",trg
                     shutil.copy2(f,trg)
             ip.define_alias("collect",collect)
             def inote(ip,arg):
                 """ inote Hello world
                 Adds timestamp and Hello world to ~/_ipython/notes.txt
                 Without args, opens notes.txt for editing.
                 """
                 import time
                 fname = ip.ipython_dir + '/notes.txt'
                 try:
                     entry = " === " + time.asctime() + ': ===\n' + arg.split(None,1)[1] + '\n'
                     f= open(fname, 'a').write(entry)
                 except IndexError:
                     ip.hooks.editor(fname)
             ip.define_alias("inote",inote)
                 return s.replace('__',' ').replace('DOT','.')
             class PathObj(path):
                 def __init__(self,p):
                     self.path = p
                             sep = ''
                         else:
                             sep = '/'
                         tgt = self.path + sep + pathobj_unmangle(name)
                         #print "tgt",tgt
                         if os.path.isdir(tgt):
                     raise AttributeError, name  # <<< DON'T FORGET THIS LINE !!
                 def __str__(self):
                     return self.path
                 def __repr__(self):
                     return "<PathObj to %s>" % self.path
                 def __call__(self):
                     print "cd:",self.path
                     os.chdir(self.path)
             def complete_pathobj(obj, prev_completions):
                 if hasattr(obj,'__complete__'):
                     res = obj.__complete__()
                     if res:
                 startmenu = PathObj("d:/Documents and Settings/All Users/Start Menu/Programs")
                 cwd = PathObj('.')
                 ip.push("rootdir startmenu cwd")
             #test_pathobj()

IPython/quarantine/ipy_jot.py

0 +40 -40

             """
             from datetime import datetime
             from IPython.core import ipapi
             ip = ipapi.get()
             import inspect,pickle,os,sys,textwrap
             from IPython.core.fakemodule import FakeModule
             from IPython.utils.ipstruct import Struct
             from IPython.utils.warn import error
                             print "Restored", justkey
                         else:
                             ip.user_ns[origname] = obj['val']
                             print "Restored", origname
             def read_variables(ip, key=None):
                 db = ip.db
                 for key in keys:
                     # strip autorestore
                     justkey = os.path.basename(key)
                     print "restoring from ", justkey
                     try:
                         obj = db[key]
                     except KeyError:
             def detail_variables(ip, key=None):
                 db, get = ip.db, ip.db.get
                 if key is None:
                     keys = db.keys('jot/*')
                 else:
                 for key in keys:
                     v = get(key,'<unavailable>')
                     justkey = os.path.basename(key)
                     try:
                         print fmthead % (justkey, datetime.ctime(v.get('time','<unavailable>')))
                         print fmtbody % (v.get('comment','<unavailable>'))
                         d = v.get('val','unavailable')
                 write obj data to the note database, with whatever that should be noted.
                 """
                 had = self.db.keys('jot/'+name+'*')
                 # if it the same name but a later version, we stupidly add a number to the
                 # so the name doesn't collide. Any better idea?
                 suffix = ''
                 if len(had)>0:
                 uname = 'jot/'+name+suffix
                 # which one works better?
                 #all = ip.shadowhist.all()
                 all = ip.shell.history_manager.input_hist_parsed
                 # We may actually want to make snapshot of files that are run-ned.
                 # get the comment
                 try:
                     comment = ip.magic_edit('-x').strip()
                 except:
                     print "No comment is recorded."
                     comment = ''
                 self.db[uname] = Struct({'val':obj,
                             'time'  :   datetime.now(),
                             'hist'  :   all,
                             'name'  :   name,
                             'comment' : comment,})
                 print "Jotted down notes for '%s' (%s)" % (uname, obj.__class__.__name__)
             def magic_jot(self, parameter_s=''):
                 """Lightweight persistence for python variables.
                 Example:
                 ville@badger[~]|1> A = ['hello',10,'world']\\
                 ville@badger[~]|2> %jot A\\
                 ville@badger[~]|3> Exit
                 (IPython session is closed and started again...)
                 ville@badger:~$ ipython -p pysh\\
                 ville@badger[~]|1> print A
                 ['hello', 10, 'world']
                 Usage:
                 %jot          - Show list of all variables and their current values\\
                 %jot -l       - Show list of all variables and their current values in detail\\
                 %jot -l <var> - Show one variable and its current values in detail\\
                 %jot -z       - Remove all variables from storage (disabled)\\
                 %jot -r <var> - Refresh/Load variable from jot (delete current vals)\\
                 %jot foo >a.txt  - Store value of foo to new file a.txt\\
                 %jot foo >>a.txt - Append value of foo to file a.txt\\
                 It should be noted that if you change the value of a variable, you
                 need to %note it again if you want to persist the new value.
                 Note also that the variables will need to be pickleable; most basic
                 python types can be safely %stored.
                 """
                 opts,argsl = self.parse_options(parameter_s,'drzl',mode='string')
                 args = argsl.split(None,1)
                 ip = self.getapi()
                     else:
                         print "Details for", tolist, ":"
                         detail_variables(ip, tolist)
                 # run without arguments -> list noted variables & notes
                 elif not args:
                     vars = self.db.keys('jot/*')
                     vars.sort()
                     if vars:
                         size = max(map(len,vars)) - 4
                     else:
                         size = 0
                     print 'Variables and their in-db values:'
                     fmt = '%-'+str(size)+'s [%s] -> %s'
                     get = db.get
                     for var in vars:
                         justkey = os.path.basename(var)
                         v = get(var,'<unavailable>')
                         try:
                             print fmt % (justkey,\
                                 datetime.ctime(v.get('time','<unavailable>')),\
                                 v.get('comment','<unavailable>')[:70].replace('\n',' '),)
                         except AttributeError:
                             print fmt % (justkey, '<unavailable>', '<unavailable>', repr(v)[:50])
                 # default action - store the variable
                 else:
                     # %store foo >file.txt or >>file.txt
                         print "Writing '%s' (%s) to file '%s'." % (args[0],
                           obj.__class__.__name__, fnam)
                         if not isinstance (obj,basestring):
                             from pprint import pprint
                             pprint(obj,fil)
                             fil.write(obj)
                             if not obj.endswith('\n'):
                                 fil.write('\n')
                         fil.close()
                         return
                     # %note foo
                     try:
                         obj = ip.user_ns[args[0]]
                         # this should not be alias, for aliases, use %store
                         print
                         print "Error: %s doesn't exist." % args[0]
                         print
                         print "Use %note -r <var> to retrieve variables. This should not be used " +\
                               "to store alias, for saving aliases, use %store"
                         return
                     else:
                         if isinstance(inspect.getmodule(obj), FakeModule):
                             print textwrap.dedent("""\
                             Warning:%s is %s
                             Proper storage of interactively declared classes (or instances
                             of those classes) is not possible! Only instances
                             of classes in real modules on file system can be %%store'd.
                             """ % (args[0], obj) )
                             return
                         #pickled = pickle.dumps(obj)
                         #self.db[ 'jot/' + args[0] ] = obj
             def magic_read(self, parameter_s=''):
                 """
                 %read <var> - Load variable from data that is jotted down.\\
                 """
                 opts,argsl = self.parse_options(parameter_s,'drzl',mode='string')
                 args = argsl.split(None,1)
                 ip = self.getapi()

IPython/quarantine/ipy_lookfor.py

0 +6 -6

                         cache.update(c)
                     except ImportError:
                         pass
                 # Search
                 # XXX: maybe using a real stemming search engine would be better?
                 found = []
                 if not whats: return
                 for name, (docstring, kind, index) in cache.iteritems():
                     if kind in ('module', 'object'):
                         # don't show modules or objects
                         continue
                     ok = True
                 # XXX: this is full Harrison-Stetson heuristics now,
                 # XXX: it probably could be improved
                 kind_relevance = {'func': 1000, 'class': 1000,
                                   'module': -1000, 'object': -1000}
                 def relevance(name, docstr, kind, index):
                 cache : dict {obj_full_name: (docstring, kind, index), ...}
                     Docstring cache for the module, either cached one (regenerate=False)
                     or newly generated.
                 """
                 global _lookfor_caches
                     index += 1
                     kind = "object"
                     if inspect.ismodule(item):
                         kind = "module"
                         try:
                             stack.append(("%s.%s" % (name, n), v))
                     elif callable(item):
                         kind = "func"
                     doc = inspect.getdoc(item)
                     if doc is not None:
                         cache[name] = (doc, kind, index)

IPython/quarantine/ipy_rehashdir.py

0 +18 -18

             Usage:
             %rehashdir c:/bin c:/tools
               - Add all executables under c:/bin and c:/tools to alias table, in
               order to make them directly executable from any directory.
             This also serves as an example on how to extend ipython
             with new magic functions.
             def selflaunch(ip,line):
                 """ Launch python script with 'this' interpreter
                 e.g. d:\foo\ipykit.exe a.py
                 """
                 tup = line.split(None,1)
                 if len(tup) == 1:
                     print "Launching nested ipython session"
                     os.system(sys.executable)
                     return
                 cmd = sys.executable + ' ' + tup[1]
                 print ">",cmd
                 os.system(cmd)
             class PyLauncher:
                 """ Invoke selflanucher on the specified script
                 This is mostly useful for associating with scripts using::
                     _ip.define_alias('foo',PyLauncher('foo_script.py'))
                 """
                 def __init__(self,script):
                     self.script = os.path.abspath(script)
                             tail = ' ' + tup[1]
                         else:
                             tail = ''
                         selflaunch(ip,"py " + self.script + tail)
                 def __repr__(self):
                     return 'PyLauncher("%s")' % self.script
             def rehashdir_f(self,arg):
                 """ Add executables in all specified dirs to alias table
                 Usage:
                 %rehashdir c:/bin;c:/tools
                   - Add all executables under c:/bin and c:/tools to alias table, in
                   order to make them directly executable from any directory.
                   Without arguments, add all executables in current directory.
                 """
                 # most of the code copied from Magic.magic_rehashx
                         if fnmatch.fnmatch(fname, j):
                             return True
                     return False
                 created = []
                 if not arg:
                     arg = '.'
                 path = map(os.path.abspath,arg.split(';'))
                 alias_table = self.shell.alias_manager.alias_table
                 if os.name == 'posix':
                     isexec = lambda fname:os.path.isfile(fname) and \
                              os.access(fname,os.X_OK)
                         winext = 'exe|com|bat|py'
                     if 'py' not in winext:
                         winext += '|py'
                     execre = re.compile(r'(.*)\.(%s)$' % winext,re.IGNORECASE)
                     isexec = lambda fname:os.path.isfile(fname) and execre.match(fname)
                 savedir = os.getcwdu()
                                     # where N is the number of positional arguments of the
                                     # alias.
                                     src,tgt = os.path.splitext(ff)[0], os.path.abspath(ff)
                                     created.append(src)
                                     alias_table[src] = (0,tgt)
                     else:
                         for pdir in path:
                                 if isexec(ff) and not isjunk(ff):
                                     src, tgt = execre.sub(r'\1',ff), os.path.abspath(ff)
                                     src = src.lower()
                                     created.append(src)
                                     alias_table[src] = (0,tgt)
                     # Make sure the alias table doesn't contain keywords or builtins
                     self.shell.alias_table_validate()

IPython/quarantine/ipy_render.py

0 +10 -10

             def toclip_w32(s):
                 """ Places contents of s to clipboard
                 Needs pyvin32 to work:
                 http://sourceforge.net/projects/pywin32/
                 """
                 cl.CloseClipboard()
             try:
                 import win32clipboard
                 toclip = toclip_w32
             except ImportError:
                 def toclip(s): pass
             def render(tmpl):
                 """ Render a template (Itpl format) from ipython variables
                 Example:
                 $ import ipy_render
                 $ my_name = 'Bob'  # %store this for convenience
                 $ t_submission_form = "Submission report, author: $my_name"  # %store also
                 $ render t_submission_form
                 => returns "Submission report, author: Bob" and copies to clipboard on win32
                 # if template exist as a file, read it. Note: ;f hei vaan => f("hei vaan")
                 $ ;render c:/templates/greeting.txt
                 Template examples (Ka-Ping Yee's Itpl library):
                 Here is a $string.
                 Here is a $module.member.
                 Here is an $object.member.
                 Here is an $array[3] member.
                 Here is a $dictionary['member'].
                 """
                 if os.path.isfile(tmpl):
                     tmpl = open(tmpl).read()
                 res = itplns(tmpl, ip.user_ns)
                 toclip(res)
                 return res

IPython/quarantine/ipy_server.py

0 +1 -1

             ipy_server.serve_thread(16455)
             Now, to execute the statements in this ipython instance, open a TCP socket
             (port 16455), write out the statements, and close the socket.
             You can use e.g. "telnet localhost 16455" or a script to do this.
             This is a bit like 'M-x server-start" or gnuserv in the emacs world.

IPython/quarantine/ipy_signals.py

0 +15 -16

             def new_ipsystem_posix(cmd):
                 """ ctrl+c ignoring replacement for system() command in iplib.
                 Ignore ctrl + c in IPython process during the command execution.
                 The subprocess will still get the ctrl + c signal.
                 posix implementation
                 """
                 p =  subprocess.Popen(cmd, shell = True)
                 old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
                 pid,status = os.waitpid(p.pid,0)
                 signal.signal(signal.SIGINT, old_handler)
                 if status and ip.options.verbose:
                     print "[exit status: %d]" % status
             def new_ipsystem_win32(cmd):
                 """ ctrl+c ignoring replacement for system() command in iplib.
                 Ignore ctrl + c in IPython process during the command execution.
                 The subprocess will still get the ctrl + c signal.
                 win32 implementation
                 """
                 old_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
                 signal.signal(signal.SIGINT, old_handler)
                 if status and ip.options.verbose:
                     print "[exit status: %d]" % status
             def init():
                 o = ip.options
                 try:
                 except AttributeError:
                     o.allow_new_attr (True )
                     o.verbose = 0
                 ip.system = (sys.platform == 'win32' and new_ipsystem_win32 or
                                 new_ipsystem_posix)
             init()
-  No newline at end of file

IPython/quarantine/ipy_system_conf.py

0 +2 -2

             This will be imported by ipython for all users.
             After this ipy_user_conf.py is imported, user specific configuration
             should reside there.
              """
             ip = ipapi.get()
             # add system wide configuration information, import extensions etc. here.
             # nothing here is essential
             import sys

IPython/quarantine/ipy_winpdb.py

0 +15 -15

             Usage:
             %wdb test.py
                 run test.py, with a winpdb breakpoint at start of the file
             %wdb pass
                 Change the password (e.g. if you have forgotten the old one)
             def wdb_f(self, arg):
                 """ Debug a script (like %run -d) in IPython process, Using WinPdb
                 Usage:
                 %wdb test.py
                     run test.py, with a winpdb breakpoint at start of the file
                 %wdb pass
                     Change the password (e.g. if you have forgotten the old one)
                 Note that after the script has been run, you need to do "Go" (f5)
                 in WinPdb to resume normal IPython operation.
                 """
                 if not arg.strip():
                     print __doc__
                     return
                 if arg.strip() == 'pass':
                     passwd = raw_input('Enter new winpdb session password: ')
                     ip.db['winpdb_pass'] = passwd
                     print "Winpdb password changed"
                     if rpdb_started:
                         print "You need to restart IPython to use the new password"
                     return
                 path = os.path.abspath(arg)
                 if not os.path.isfile(path):
                     raise UsageError("%%wdb: file %s does not exist" % path)
                         import textwrap
                         print textwrap.dedent("""\
                         Winpdb sessions need a password that you use for attaching the external
                         winpdb session. IPython will remember this. You can change the password later
                         by '%wpdb pass'
                         """)
                         passwd = raw_input('Enter new winpdb session password: ')
                         ip.db['winpdb_pass'] = passwd
                     print "Starting rpdb2 in IPython process"
                     rpdb2.start_embedded_debugger(passwd, timeout = 0)
                     rpdb_started = True
                 rpdb2.set_temp_breakpoint(path)
                 print 'It is time to attach with WinPdb (launch WinPdb if needed, File -> Attach)'
                 ip.magic('%run ' + arg)
             ip.define_magic('wdb', wdb_f)

IPython/quarantine/ipy_workdir.py

0 +5 -5

             workdir = None
             def workdir_f(ip,line):
                 """ Exceute commands residing in cwd elsewhere
                 Example::
                   workdir /myfiles
                   cd bin
                   workdir myscript.py
                 executes myscript.py (stored in bin, but not in path) in /myfiles
                 """
                 global workdir

IPython/quarantine/jobctrl.py

0 +20 -20

             """ Preliminary "job control" extensions for IPython
             requires python 2.4 (or separate 'subprocess' module
                 [Q:/ipython]|4>
             (you don't need to specify PID for %kill if only one task is running)
             """
             from subprocess import *
             import os,shlex,sys,time
             else:
                 def kill_process(pid):
                     os.system('kill -9 %d' % pid)
             class IpyPopen(Popen):
                 def go(self):
                 def kill(self):
                     kill_process(self.pid)
             def startjob(job):
                 p = IpyPopen(shlex.split(job), stdout=PIPE, shell = False)
                 p.line = job
                             self.output.append("** Discarding: '%s' - %s" % (cmd,cwd))
                             continue
                         self.output.append("** Task started: '%s' - %s" % (cmd,cwd))
                         p = Popen(cmd, shell=True, stdout=PIPE, stderr=STDOUT, cwd = cwd)
                         out = p.stdout.read()
                         self.output.append("** Task complete: '%s'\n" % cmd)
                 def add(self,cmd):
                     self.q.put_nowait((cmd, os.getcwdu()))
                 def dumpoutput(self):
                     while self.output:
                         item = self.output.pop(0)
                         print item
             _jobq = None
             def jobqueue_f(self, line):
                 global _jobq
                 if not _jobq:
                     print "Starting jobqueue - do '&some_long_lasting_system_command' to enqueue"
                 if line.strip() == 'start':
                     _jobq.stop = False
                     return
             def jobctrl_prefilter_f(self,line):
                 if line.startswith('&'):
                     pre,fn,rest = self.split_user_input(line[1:])
                     line = ip.expand_aliases(fn,rest)
                     if not _jobq:
                         return 'get_ipython().startjob(%s)' % make_quoted_expr(line)
                 A 'task' is a process that has been started in IPython when 'jobctrl' extension is enabled.
                 Tasks can be killed with %kill.
                 '%tasks clear' clears the task list (from stale tasks)
                 """
                 ip = self.getapi()
                         print "Clearing",ip.db[k]
                         del ip.db[k]
                     return
                 ents = job_list(ip)
                 if not ents:
                     print "No tasks running"
                     else:
                         magic_tasks(self,line)
                     return
                 try:
                     pid = int(line)
                     kill_process(pid)
                 except ValueError:
                     magic_tasks(self,line)
             if sys.platform == 'win32':
                 shell_internal_commands = 'break chcp cls copy ctty date del erase dir md mkdir path prompt rd rmdir start time type ver vol'.split()
                 PopenExc = WindowsError
             else:
                 # todo linux commands
                 shell_internal_commands = []
                 PopenExc = OSError
                         else:
                             # have to go via shell, sucks
                             p = Popen(cmd,shell = True)
                     jobentry = 'tasks/t' + str(p.pid)
                     ip.db[jobentry] = (p.pid,cmd,os.getcwdu(),time.time())
                     p.communicate()
                 finally:
                     if jobentry:
                 ip.define_magic('kill',magic_kill)
                 ip.define_magic('tasks',magic_tasks)
                 ip.define_magic('jobqueue',jobqueue_f)
                 ip.set_hook('pre_prompt_hook', jobq_output_hook)
             install()

IPython/quarantine/ledit.py

0 +10 -10

             """ Fun magic line editor for ipython
             Use this to easily edit lists of strings gradually without crafting long
             list comprehensions.
             'l' is the magic variable name for every line (array element). Save the current
             result (or more exactly, retrieve the last ipython computation result into
             %led work area) by running '%led s'. Just run '%led' to show the current work
             area data.
             def line_edit_f(self, cmd ):
                 global curdata
                 if not cmd:
                     print "Magic line editor (for lists of strings)"
                     if curdata:
                         print "current data is:"
                         print "No current data, you should set it by running '%led s'"
                         print "When you have your data in _ (result of last computation)."
                     return
                 if cmd == 's':
                     curdata = ip.ev('_')
                     print "Data set from last result (_)"
                     newlines = curdata
                 else:
                     # simple method call, e.g. upper
                     if cmd.isalpha():
                             continue
                         newlines.append(l2)
                 return newlines
             def line_edit_complete_f(self,event):
                 """ Show all string methods in completions """
                 if event.symbol.startswith('l.'):
                     return ['l.' + func for func in dir('')]
                 return dir('') + ['l.' + func for func in dir('')]
             ip.set_hook('complete_command', line_edit_complete_f , str_key = '%led')
             ip.define_magic('led', line_edit_f)

IPython/quarantine/pspersistence.py

0 +25 -25

                     else:
                         #print "restored",justkey,"=",obj #dbg
                         ip.user_ns[justkey] = obj
             def restore_dhist(ip):
                 db = ip.db
                 ip.user_ns['_dh'] = db.get('dhist',[])
             def restore_data(self):
                 ip = self.getapi()
                 refresh_variables(ip)
                 restore_aliases(self)
                 restore_dhist(self)
                 raise TryNext
             ip.set_hook('late_startup_hook', restore_data)
             def magic_store(self, parameter_s=''):
                 """Lightweight persistence for python variables.
                 Example:
                 ville@badger[~]|1> A = ['hello',10,'world']\\
                 ville@badger[~]|2> %store A\\
                 ville@badger[~]|3> Exit
                 (IPython session is closed and started again...)
                 ville@badger:~$ ipython -p pysh\\
                 ville@badger[~]|1> print A
                 ['hello', 10, 'world']
                 Usage:
                 %store          - Show list of all variables and their current values\\
                 %store <var>    - Store the *current* value of the variable to disk\\
                 %store -d <var> - Remove the variable and its value from storage\\
                 %store -z       - Remove all variables from storage\\
                 %store -r       - Refresh all variables from store (delete current vals)\\
                 %store foo >a.txt  - Store value of foo to new file a.txt\\
                 %store foo >>a.txt - Append value of foo to file a.txt\\
                 It should be noted that if you change the value of a variable, you
                 need to %store it again if you want to persist the new value.
                 Note also that the variables will need to be pickleable; most basic
                 python types can be safely %stored.
                 Also aliases can be %store'd across sessions.
                 """
                 opts,argsl = self.parse_options(parameter_s,'drz',mode='string')
                 args = argsl.split(None,1)
                 ip = self.getapi()
                 elif opts.has_key('r'):
                     refresh_variables(ip)
                 # run without arguments -> list variables & values
                 elif not args:
                     vars = self.db.keys('autorestore/*')
                     vars.sort()
                     if vars:
                         size = max(map(len,vars))
                     else:
                         size = 0
                     print 'Stored variables and their in-db values:'
                     fmt = '%-'+str(size)+'s -> %s'
                     get = db.get
                         justkey = os.path.basename(var)
                         # print 30 first characters from every var
                         print fmt % (justkey,repr(get(var,'<unavailable>'))[:50])
                 # default action - store the variable
                 else:
                     # %store foo >file.txt or >>file.txt
                         print "Writing '%s' (%s) to file '%s'." % (args[0],
                           obj.__class__.__name__, fnam)
                         if not isinstance (obj,basestring):
                             from pprint import pprint
                             pprint(obj,fil)
                             fil.write(obj)
                             if not obj.endswith('\n'):
                                 fil.write('\n')
                         fil.close()
                         return
                     # %store foo
                     try:
                         obj = ip.user_ns[args[0]]
                         if args[0] in self.alias_table:
                             staliases = db.get('stored_aliases',{})
                             staliases[ args[0] ] = self.alias_table[ args[0] ]
                             db['stored_aliases'] = staliases
                             print "Alias stored:", args[0], self.alias_table[ args[0] ]
                             return
                         else:
                             raise UsageError("Unknown variable '%s'" % args[0])
                     else:
                         if isinstance(inspect.getmodule(obj), FakeModule):
                             print textwrap.dedent("""\
                             Warning:%s is %s
                             Proper storage of interactively declared classes (or instances
                             of those classes) is not possible! Only instances
                             of classes in real modules on file system can be %%store'd.
                             """ % (args[0], obj) )
                             return
                         #pickled = pickle.dumps(obj)
                         self.db[ 'autorestore/' + args[0] ] = obj

IPython/quarantine/win32clip.py

0 +6 -6

                 This function uses the same syntax as %macro for line extraction, but
                 instead of creating a macro it saves the resulting string to the
                 clipboard.
                 When used without arguments, this returns the text contents of the clipboard.
                 E.g.
                 mytext = %clip
                 """
                 import win32clipboard as cl
                     cl.CloseClipboard()
                     return data
                 api = self.getapi()
                 if parameter_s.lstrip().startswith('='):
                     rest = parameter_s[parameter_s.index('=')+1:].strip()
                     val = str(api.ev(rest))
                 cl.CloseClipboard()
                 print 'The following text was written to the clipboard'
                 print val
             ip.define_magic( "clip", clip_f )

IPython/testing/decorators.py

0 +12 -12

                     labels = [label]
                 else:
                     labels = label
                 # Validate that the given label(s) are OK for use in setattr() by doing a
                 # dry run on a dummy function.
                 tmp = lambda : None
                     for label in labels:
                         setattr(f,label,True)
                     return f
                 # Apply the user's docstring, or autogenerate a basic one
                 if ds is None:
                     ds = "Labels a test as %r." % label
                 decor.__doc__ = ds
                 return decor
                 Parameters
                 ----------
                 skip_condition : bool or callable.
                 Flag to determine whether to skip test.  If the condition is a
                 callable, it is used at runtime to dynamically make the decision.  This
                 is useful for tests that may require costly imports, to delay the cost
                 until the test suite is actually executed.
                 msg : string
                     Message to give on raising a SkipTest exception
                 '''
                 def skip_decorator(f):
                     # Local import to avoid a hard nose dependency and only incur the
                     # import time overhead at actual test-time.
                     import nose
                     # Allow for both boolean or callable skip conditions.
                         if skip_val():
                             raise nose.SkipTest(get_msg(f,msg))
                         else:
                             return f(*args, **kwargs)
                     def skipper_gen(*args, **kwargs):
                         """Skipper for test generators."""
                         skipper = skipper_gen
                     else:
                         skipper = skipper_func
                     return nose.tools.make_decorator(f)(skipper)
                 return skip_decorator

IPython/testing/globalipapp.py

0 +17 -17

             class StreamProxy(io.IOStream):
                 """Proxy for sys.stdout/err.  This will request the stream *at call time*
                 allowing for nose's Capture plugin's redirection of sys.stdout/err.
                 Parameters
                 ----------
                 name : str
                     The name of the stream. This will be requested anew at every call
                 """
                 def __init__(self, name):
                     self.name=name
                 @property
                 def stream(self):
                     return getattr(sys, self.name)
                 def flush(self):
                     self.stream.flush()
             class py_file_finder(object):
                 def __init__(self,test_filename):
                     self.test_filename = test_filename
                 def __call__(self,name,win32=False):
                     from IPython.utils.path import get_py_filename
                     try:
                         test_dir = os.path.dirname(self.test_filename)
                         new_path = os.path.join(test_dir,name)
                         return get_py_filename(new_path,win32=win32)
             def _run_ns_sync(self,arg_s,runner=None):
                 """Modified version of %run that syncs testing namespaces.
                 which is needed because of how Python's doctest machinery operates with
                 '_'.  See constructor and :meth:`update` for details.
                 """
                 def __init__(self,*a):
                     dict.__init__(self,*a)
                     self._savedict = {}
                     # remove a key named '_'.  This is so that such a dict can be used as a
                     # namespace in doctests that call '_'.
                     self.protect_underscore = False
                 def clear(self):
                     dict.clear(self)
                     self.update(self._savedict)
                 def _checkpoint(self):
                     self._savedict.clear()
                     self._savedict.update(self)
                     # correct for that ourselves, to ensure consitency with the 'real'
                     # ipython.
                     self['__builtins__'] = builtin_mod
                 def __delitem__(self, key):
                     """Part of the test suite checks that we can release all
                     references to an object. So we need to make sure that we're not
                 if hasattr(start_ipython, 'already_called'):
                     return
                 start_ipython.already_called = True
                 # Store certain global objects that IPython modifies
                 _displayhook = sys.displayhook
                 _excepthook = sys.excepthook
                 config = tools.default_config()
                 # Create and initialize our test-friendly IPython instance.
                 shell = TerminalInteractiveShell.instance(config=config,
                                                           user_ns=ipnsdict(),
                                                           user_global_ns={}
                                                           )
                 # A few more tweaks needed for playing nicely with doctests...
                 # remove history file
                 shell.tempfiles.append(config.HistoryManager.hist_file)
                 # These traps are normally only active for interactive use, set them
                 # permanently since we'll be mocking interactive sessions.
                 shell.builtin_trap.activate()
                 # can capture subcommands and print them to Python's stdout, otherwise the
                 # doctest machinery would miss them.
                 shell.system = py3compat.MethodType(xsys, shell)
                 shell._showtraceback = py3compat.MethodType(_showtraceback, shell)
                 # IPython is ready, now clean up some global state...
                 # Deactivate the various python system hooks added by ipython for
                 # interactive convenience so we don't confuse the doctest system
                 sys.modules['__main__'] = _main
                 get_ipython = _ip.get_ipython
                 builtin_mod._ip = _ip
                 builtin_mod.get_ipython = get_ipython
                 # To avoid extra IPython messages during testing, suppress io.stdout/stderr
                 io.stdout = StreamProxy('stdout')
                 io.stderr = StreamProxy('stderr')

IPython/testing/iptest.py

0 +23 -23

             def test_for(item, min_version=None, callback=extract_version):
                 """Test to see if item is importable, and optionally check against a minimum
                 version.
                 If min_version is given, the default behavior is to check against the
                 `__version__` attribute of the item, but specifying `callback` allows you to
                 extract the value you are interested in. e.g::
                     In [1]: import sys
                     In [2]: from IPython.testing.iptest import test_for
                     In [3]: test_for('sys', (2,6), callback=lambda sys: sys.version_info)
                     Out[3]: True
                 """
                 try:
                     check = import_item(item)
                         if callback:
                             # extra processing step to get version to compare
                             check = callback(check)
                         return check >= min_version
                     else:
                         return True
                 avail = []
                 not_avail = []
                 for k, is_avail in have.items():
                     if is_avail:
                         avail.append(k)
                     out.append('\nTools and libraries NOT available at test time:\n')
                     not_avail.sort()
                     out.append('   ' + ' '.join(not_avail)+'\n')
                 return ''.join(out)
                 # Simple utility to make IPython paths more readably, we need a lot of
                 # these below
                 ipjoin = lambda *paths: pjoin('IPython', *paths)
                 exclusions = [ipjoin('external'),
                               pjoin('IPython_doctest_plugin'),
                               ipjoin('quarantine'),
                 if not have['wx']:
                     exclusions.append(ipjoin('lib', 'inputhookwx'))
                 # We do this unconditionally, so that the test suite doesn't import
                 # gtk, changing the default encoding and masking some unicode bugs.
                 exclusions.append(ipjoin('lib', 'inputhookgtk'))
                     exclusions.append(ipjoin('parallel'))
                 elif not have['qt']:
                     exclusions.append(ipjoin('frontend', 'qt'))
                 if not have['pymongo']:
                     exclusions.append(ipjoin('parallel', 'controller', 'mongodb'))
                     exclusions.append(ipjoin('parallel', 'tests', 'test_mongodb'))
                 call_args = None
                 #: list, process ids of subprocesses we start (for cleanup)
                 pids = None
                 def __init__(self, runner='iptest', params=None):
                     """Create new test runner."""
                     p = os.path
                         retcode = subp.wait()
                         self.pids.pop()
                         return retcode
                 def run(self):
                     """Run the stored commands"""
                     try:
                     if not hasattr(os, 'kill'):
                         return
                     for pid in self.pids:
                         try:
                             print 'Cleaning stale PID:', pid
                         except OSError:
                             # This is just a best effort, if we fail or the process was
                             # really gone, ignore it.
                             pass
             def make_runners():
                 # Packages to be tested via nose, that only depend on the stdlib
                 nose_pkg_names = ['config', 'core', 'extensions', 'frontend', 'lib',
                                  'scripts', 'testing', 'utils', 'nbformat' ]
                 if have['zmq']:
                     nose_pkg_names.append('parallel')
                 # For debugging this code, only load quick stuff
                 #nose_pkg_names = ['core', 'extensions']  # dbg
                 # Make runners
                 runners = [ (v, IPTester('iptest', params=v)) for v in nose_packages ]
                 return runners
             def run_iptest():
                 """Run the IPython test suite using nose.
                 This function is called when this script is **not** called with the form
                 `iptest all`.  It simply calls nose with appropriate command line flags
                 and accepts all of the standard nose arguments.
                 """
                 warnings.filterwarnings('ignore',
                     'This will be removed soon.  Use IPython.testing.util instead')
                 argv = sys.argv + [ '--detailed-errors',  # extra info in tracebacks
                                     # Loading ipdoctest causes problems with Twisted, but
                                     # our test suite runner now separates things and runs
                                     # all Twisted tests with trial.
                                     '--with-ipdoctest',
                                     '--ipdoctest-tests','--ipdoctest-extension=txt',
                                     # We add --exe because of setuptools' imbecility (it
                                     # blindly does chmod +x on ALL files).  Nose does the
                                     # right thing and it tries to avoid executables,
             def run_iptestall():
                 """Run the entire IPython test suite by calling nose and trial.
                 This function constructs :class:`IPTester` instances for all IPython
                 modules and package and then runs each of them.  This causes the modules
                 and packages of IPython to be tested each in their own subprocess using

IPython/testing/mkdoctests.py

0 +6 -6

                 Instances of this class trap output to a given stream and first reformat it
                 to indent every input line."""
                 def __init__(self,out=sys.stdout,indent=4):
                     """Create an indented writer.
                     - `indent` : int
                       Number of spaces to indent every input line by.
                     """
                     self.indent_text = ' '*indent
                     self.indent = re.compile('^',re.MULTILINE).sub
                     self.out = out
                         data = ''.join(self.buffer)
                         self.buffer[:] = []
                         self._write(self.indent(self.indent_text,data))
                 def close(self):
                     self.flush()
                     self._closed = True
                 def __init__(self,out=sys.stdout):
                     """Instantiate a code runner."""
                     self.out = out
                     self.runner = None
                     self.runnerClass = None
                     self.runnerClass = runnerClass
                     self.runner = runnerClass(out=self.out)
                     return self.runner
                 def __call__(self,fname):
                     """Return a runner for the given filename."""
                     outfile = open(outfname,'w')
                 # all output from included files will be indented
                 indentOut = IndentOut(outfile,4)
                 getRunner = RunnerFactory(indentOut)

IPython/testing/plugin/ipdoctest.py

0 +14 -14

             Limitations:
             - When generating examples for use as doctests, make sure that you have
               pretty-printing OFF.  This can be done either by setting the
               ``PlainTextFormatter.pprint`` option in your configuration file to  False, or
               by interactively disabling it with  %Pprint.  This is required so that IPython
               output matches that of normal Python, which is used by doctest for internal
               execution.
             - Do not rely on specific prompt numbers for results (such as using
             class DocTestSkip(object):
                 """Object wrapper for doctests to be skipped."""
                 ds_skip = """Doctest to skip.
                 >>> 1 #doctest: +SKIP
                 """
             class IPDoctestOutputChecker(doctest.OutputChecker):
                 """Second-chance checker with support for random tests.
                 If the default comparison doesn't pass, this checker looks in the expected
                 output string for flags that tell us to ignore the output.
                 """
                 random_re = re.compile(r'#\s*random\s+')
                 def check_output(self, want, got, optionflags):
                     """Check output, accepting special markers embedded in the output.
                 def runTest(self):
                     test = self._dt_test
                     runner = self._dt_runner
                     old = sys.stdout
                     new = StringIO()
                     optionflags = self._dt_optionflags
                         # Restore the behavior of the '_' key in the user namespace to
                         # normal after each doctest, so that unittests behave normally
                         _ip.user_ns.protect_underscore = False
                     # XXX - fperez: I am not sure if this is truly a bug in nose 0.11, but
                     # it does look like one to me: its tearDown method tries to run
                     #
                 # Mark tests to be executed in an external process - currently unsupported.
                 _EXTERNAL_IP = re.compile(r'#\s*ipdoctest:\s*EXTERNAL')
                 def ip2py(self,source):
                     """Convert input IPython source into valid Python."""
                     out = []
                         # Append the random-output marker (it defaults to empty in most
                         # cases, it's only non-empty for 'all-random' tests):
                         want += random_marker
                         if Example is IPExternalExample:
                             options[doctest.NORMALIZE_WHITESPACE] = True
                             want += '\n'
             class IPDocTestRunner(doctest.DocTestRunner,object):
                 """Test runner that synchronizes the IPython namespace with test globals.
                 """
                 def run(self, test, compileflags=None, out=None, clear_globs=True):
                     # Hack: ipython needs access to the execution context of the example,
                     #_ip._ipdoctest_test_filename = test.filename
                     test.globs.update(_ip.user_ns)
                     return super(IPDocTestRunner,self).run(test,
                                                            compileflags,out,clear_globs)
                 def loadTestsFromModule(self, module):
                     #print '*** ipdoctest - lTM',module  # dbg
                     if not self.matches(module.__name__):
                         log.debug("Doctest doesn't want module %s", module)
                         return
                             continue
                         if not test.filename:
                             test.filename = module_file
                         yield DocTestCase(test,
                                           optionflags=optionflags,
                                           checker=self.checker)

IPython/testing/tests/test_ipunittest.py

0 +7 -7

             - running this script with python (it has a __main__ section at the end) misses
               one docstring test, the one embedded in the Foo object method.  Since our
               approach relies on using decorators that create standalone TestCase
               instances, it can only be used for functions, not for methods of objects.
             Authors
             -------
             In [26]: for i in range(10):
                ....:     print i,
                ....:
                ....:
 1 2 3 4 5 6 7 8 9
             In [27]: 3+4
                 In [26]: for i in range(10):
                    ....:     print i,
                    ....:
                    ....:
 1 2 3 4 5 6 7 8 9
                 In [27]: 3+4
                     In [26]: for i in range(10):
                        ....:     print i,
                        ....:
                        ....:
 1 2 3 4 5 6 7 8 9
                     In [27]: 3+4

IPython/testing/tools.py

0 +11 -11

                     nerr = int(err_m.group(1))
                     nfail = 0
                     return  nerr, nfail
                 fail_m = re.search(r'^FAILED \(failures=(\d+)\)', txt, re.MULTILINE)
                 if fail_m:
                     nerr = 0
                     nerr = int(both_m.group(1))
                     nfail = int(both_m.group(2))
                     return  nerr, nfail
                 # If the input didn't match any of these forms, assume no error/failures
                 return 0, 0
                 (stdout, stderr) of ipython subprocess.
                 """
                 if options is None: options = []
                 # For these subprocess calls, eliminate all prompt printing so we only see
                 # output from script execution
                 prompt_opts = [ '--InteractiveShell.prompt_in1=""',
                                 '--InteractiveShell.prompt_in2=""',
                                 '--InteractiveShell.prompt_out=""'
                 ]
                 cmdargs = ' '.join(default_argv() + prompt_opts + options)
                 _ip = get_ipython()
                 test_dir = os.path.dirname(__file__)
                 """
                 import nose.tools as nt
                 out, err = ipexec(fname)
                 #print 'OUT', out  # dbg
                 #print 'ERR', err  # dbg
                 """Utility class to create temporary Python/IPython files.
                 Meant as a mixin class for test cases."""
                 def mktmp(self, src, ext='.py'):
                     """Make a valid python temp file."""
                     fname, f = temp_pyfile(src, ext)
                             "Got:\n"
                             "  {3!r}\n")
             def check_pairs(func, pairs):
                 """Utility function for the common case of checking a function with a
                 sequence of input/output pairs.
                 Parameters
                 ----------
                 func : callable
                   The function to be tested. Should accept a single argument.
                 pairs : iterable
                   A list of (input, expected_output) tuples.
                 Returns
                 -------
                 None. Raises an AssertionError if any output does not match the expected

IPython/utils/autoattr.py

0 +5 -5

             Notes
             -----
             This module is taken from the NiPy project
             (http://neuroimaging.scipy.org/site/index.html), and is BSD licensed.
             Authors
                ...     def y(self):
                ...         print '*** y computation executed ***'
                ...         return self.x / 2.0
                ...
                >>> a = A(10)
                Changing x
                >>> a.x = 20
                a.y doesn't change to 10, since it is a static attribute:
                >>> a.y
 .0
                     Parameters
                     ----------
                       func : method
                         The method that will be called the first time to compute a value.
                         Afterwards, the method's name will be a standard attribute holding
                         the value of this computation.
                 ...     @auto_attr
                 ...     def a(self):
                 ...         return 99
                 ...
                 >>> x = MagicProp()
                 >>> 'a' in x.__dict__
                 False

IPython/utils/codeutil.py

0 +2 -2

             """Utilities to enable code objects to be pickled.
             Any process that import this module will be able to pickle code objects.  This
             includes the func_code attribute of any function.  Once unpickled, new
             functions can be built using new.function(code, globals()).  Eventually
             we need to automate all of this so that functions themselves can be pickled.
             def code_ctor(*args):
                 return types.CodeType(*args)
             def reduce_code(co):
                 if co.co_freevars or co.co_cellvars:
                     raise ValueError("Sorry, cannot pickle code objects with closures")

IPython/utils/coloransi.py

0 +11 -11

                 """Build a set of color attributes in a class.
                 Helper function for building the *TermColors classes."""
                 color_templates = (
                     # Dark colors
                     ("Black"       , "0;30"),
                     ("LightBlue"   , "1;34"),
                     ("LightPurple" , "1;35"),
                     ("LightCyan"   , "1;36"),
                     ("White"       , "1;37"),
                     # Blinking colors.  Probably should not be used in anything serious.
                     ("BlinkBlack"  , "5;30"),
                     ("BlinkRed"    , "5;31"),
             class TermColors:
                 """Color escape sequences.
                 This class defines the escape sequences for all the standard (ANSI?)
                 colors in terminals. Also defines a NoColor escape which is just the null
                 string, suitable for defining 'dummy' color schemes in terminals which get
                 confused by color escapes.
                 This class should be used as a mixin for building color schemes."""
                 NoColor = ''  # for color schemes in color-less terminals.
                 Normal = '\033[0m'   # Reset normal coloring
                 _base  = '\033[%sm'  # Template for all other colors
                 can wrap lines accordingly.  Use this class for any colored text which
                 needs to be used in input prompts, such as in calls to raw_input().
                 This class defines the escape sequences for all the standard (ANSI?)
                 colors in terminals. Also defines a NoColor escape which is just the null
                 string, suitable for defining 'dummy' color schemes in terminals which get
                 confused by color escapes.
                 This class should be used as a mixin for building color schemes."""
                 NoColor = ''  # for color schemes in color-less terminals.
                 if os.name == 'nt' and os.environ.get('TERM','dumb') == 'emacs':
                     if name is None:
                         name = self.name
                     return ColorScheme(name, self.colors.dict())
             class ColorSchemeTable(dict):
                 """General class to handle tables of color schemes.
                 It's basically a dict of color schemes with a couple of shorthand
                 attributes and some convenient methods.
                 active_scheme_name -> obvious
                 active_colors -> actual color table of the active scheme"""
                     created with a list of valid color schemes AND the specification for
                     the default active scheme.
                     """
                     # create object attributes to be set later
                     self.active_scheme_name = ''
                     self.active_colors = None
                     if scheme_list:
                         if default_scheme == '':
                             raise ValueError,'you must specify the default color scheme'
                     if not isinstance(new_scheme,ColorScheme):
                         raise ValueError,'ColorSchemeTable only accepts ColorScheme instances'
                     self[new_scheme.name] = new_scheme
                 def set_active_scheme(self,scheme,case_sensitive=0):
                     """Set the currently active scheme.

IPython/utils/generics.py

0 +1 -1

                     List of attributes discovered so far.
                 This should return the list of attributes in obj. If you only wish to
                 add to the attributes already discovered normally, return
                 own_attrs + prev_completions.
                 """
                 raise TryNext

IPython/utils/growl.py

0 +1 -1

                 def _notify(self, title, msg):
                     if self.g_notifier is not None:
                         self.g_notifier.notify('core', title, msg)
                 def notify(self, title, msg):
                     self._notify(title, msg)

IPython/utils/io.py

0 +8 -8

                             raise ValueError("fallback required, but not specified")
                     self.stream = stream
                     self._swrite = stream.write
                     # clone all methods not overridden:
                     def clone(meth):
                         return not hasattr(self, meth) and not meth.startswith('_')
                     for meth in filter(clone, dir(stream)):
                         setattr(self, meth, getattr(stream, meth))
                 def write(self,data):
                     try:
                         self._swrite(data)
                             # if we get here, something is seriously broken.
                             print('ERROR - failed to write data to stream:', self.stream,
                                   file=sys.stderr)
                 def writelines(self, lines):
                     if isinstance(lines, basestring):
                         lines = [lines]
                 @property
                 def closed(self):
                     return self.stream.closed
                 def close(self):
                     pass
                     mode : optional, valid mode for open().
                       If a filename was give, open with this mode.
                     channel : str, one of ['stdout', 'stderr']
                     """
                     if channel not in ['stdout', 'stderr']:
                         raise ValueError('Invalid channel spec %s' % channel)
                     if hasattr(file_or_name, 'write') and hasattr(file_or_name, 'seek'):
                         self.file = file_or_name
                     else:
             def raw_print(*args, **kw):
                 """Raw print to sys.__stdout__, otherwise identical interface to print()."""
                 print(*args, sep=kw.get('sep', ' '), end=kw.get('end', '\n'),
                       file=sys.__stdout__)
                 sys.__stdout__.flush()
             def raw_print_err(*args, **kw):
                 """Raw print to sys.__stderr__, otherwise identical interface to print()."""
                 print(*args, sep=kw.get('sep', ' '), end=kw.get('end', '\n'),
                       file=sys.__stderr__)
                 sys.__stderr__.flush()

IPython/utils/ipstruct.py

0 +25 -25

             # encoding: utf-8
             """A dict subclass that supports attribute style access.
             Authors:
             * Fernando Perez (original)
             * Brian Granger (refactoring to a dict subclass)
                     ...     s['b'] = 20
                     ... except KeyError:
                     ...     print 'this is not allowed'
                     ...
                     this is not allowed
                     """
                     if not self._allownew and not self.has_key(key):
                 def __setattr__(self, key, value):
                     """Set an attr with protection of class members.
                     This calls :meth:`self.__setitem__` but convert :exc:`KeyError` to
                     :exc:`AttributeError`.
                     Examples
                     ...     s.get = 10
                     ... except AttributeError:
                     ...     print "you can't set a class member"
                     ...
                     you can't set a class member
                     """
                     # If key is an str it might be a class member or instance var
                     if isinstance(key, str):
                         # I can't simply call hasattr here because it calls getattr, which
                         # calls self.__getattr__, which returns True for keys in
                         # self._data.  But I only want keys in the class and in
                         # self.__dict__
                         if key in self.__dict__ or hasattr(Struct, key):
                 def __getattr__(self, key):
                     """Get an attr by calling :meth:`dict.__getitem__`.
                     Like :meth:`__setattr__`, this method converts :exc:`KeyError` to
                     :exc:`AttributeError`.
                     Examples
                     ...     s.b
                     ... except AttributeError:
                     ...     print "I don't have that key"
                     ...
                     I don't have that key
                     """
                     try:
                 def __iadd__(self, other):
                     """s += s2 is a shorthand for s.merge(s2).
                     Examples
                     --------
                     >>> s = Struct(a=10,b=30)
                     >>> s2 = Struct(a=20,c=40)
                     >>> s += s2
                 def __add__(self,other):
                     """s + s2 -> New Struct made from s.merge(s2).
                     Examples
                     --------
                     >>> s1 = Struct(a=10,b=30)
                     >>> s2 = Struct(a=20,c=40)
                     >>> s = s1 + s2
                 def __sub__(self,other):
                     """s1 - s2 -> remove keys in s2 from s1.
                     Examples
                     --------
                     >>> s1 = Struct(a=10,b=30)
                     >>> s2 = Struct(a=40)
                     >>> s = s1 - s2
                 def __isub__(self,other):
                     """Inplace remove keys from self that are in other.
                     Examples
                     --------
                     >>> s1 = Struct(a=10,b=30)
                     >>> s2 = Struct(a=40)
                     >>> s1 -= s2
                     return self
                 def __dict_invert(self, data):
                     """Helper function for merge.
                     Takes a dictionary whose values are lists and returns a dict with
                     the elements of each list as keys and the original keys as values.
                     """
                     outdict = {}
                 def copy(self):
                     """Return a copy as a Struct.
                     Examples
                     --------
                     >>> s = Struct(a=10,b=30)
                     >>> s2 = s.copy()
                     >>> s2
                     The `__conflict_solve` dict is a dictionary of binary functions which will be used to
                     solve key conflicts.  Here is an example::
                         __conflict_solve = dict(
                             func1=['a','b','c'],
                             func2=['d','e']
                         )
                     In this case, the function :func:`func1` will be used to resolve
                     keys 'a', 'b' and 'c' and the function :func:`func2` will be used for
                     keys 'd' and 'e'.  This could also be written as::
                         __conflict_solve = dict(func1='a b c',func2='d e')
                     --------
                     This show the default policy:
                     >>> s = Struct(a=10,b=30)
                     >>> s2 = Struct(a=20,c=40)
                     >>> s.merge(s2)
                     >>> s
                     {'a': 10, 'c': 40, 'b': 30}
                     Now, show how to specify a conflict dict:
                     >>> s = Struct(a=10,b=30)
                     >>> s2 = Struct(a=20,b=40)
                     >>> conflict = {'update':'a','add':'b'}

IPython/utils/localinterfaces.py

0 +1 -1

             """Simple utility for building a list of local IPs using the socket module.
             This module defines two constants:
             LOCALHOST : The loopback interface, or the first interface that points to this
                         machine.  It will *almost* always be '127.0.0.1'
             LOCAL_IPS : A list of IP addresses, loopback first, that point to this machine.

IPython/utils/notification.py

0 +8 -8

             class NotificationCenter(object):
                 """Synchronous notification center.
                 Examples
                 --------
                 Here is a simple example of how to use this::
                             "Notification type and sender are required.")
                     # If there are no registered observers for the type/sender pair
                     if((ntype not in self.registered_types and
                             None not in self.registered_types) or
                         (sender not in self.registered_senders and
                             None not in self.registered_senders)):
                         return
                 def add_observer(self, callback, ntype, sender):
                     """Add an observer callback to this notification center.
                     The given callback will be called upon posting of notifications of
                     the given type/sender and will receive any additional arguments passed
                     to post_notification.
                     Parameters
                     ----------
                     callback : callable
                     self.registered_types.add(ntype)
                     self.registered_senders.add(sender)
                     self.observers.setdefault((ntype,sender), set()).add(callback)
                 def remove_all_observers(self):
                     """Removes all observers from this notification center"""
                     self._init_observers()
             shared_center = NotificationCenter()

IPython/utils/path.py

0 +27 -27

                 If the given name is not a file, it adds '.py' and searches again.
                 Raises IOError with an informative message if the file isn't found.
                 On Windows, apply Windows semantics to the filename. In particular, remove
                 any quoting that has been applied to it. This option can be forced for
                 testing purposes.
                 Will find the file in the users home directory.  This function does not
                 automatically try any paths, such as the cwd or the user's home directory.
                 Parameters
                 ----------
                 filename : str
                     put into a sequence and the searched.  If a sequence, walk through
                     each element and join with ``filename``, calling :func:`expandvars`
                     and :func:`expanduser` before testing for existence.
                 Returns
                 -------
                 Raises :exc:`IOError` or returns absolute path to file.
                 """
                 # If paths are quoted, abspath gets confused, strip them...
                 filename = filename.strip('"').strip("'")
                 # If the input is an absolute path, just check it exists
                 if os.path.isabs(filename) and os.path.isfile(filename):
                     return filename
                 if path_dirs is None:
                     path_dirs = ("",)
                 elif isinstance(path_dirs, basestring):
                     path_dirs = (path_dirs,)
                 for path in path_dirs:
                     if path == '.': path = os.getcwdu()
                     testname = expand_path(os.path.join(path, filename))
                     if os.path.isfile(testname):
                         return os.path.abspath(testname)
                 raise IOError("File %r does not exist in any of the search paths: %r" %
                               (filename, path_dirs) )
                   - Registry hack for My Documents
                   - %HOME%: rare, but some people with unix-like setups may have defined it
                 * On Dos C:\
                 Currently only Posix and NT are implemented, a HomeDirError exception is
                 raised for all other OSes.
                 """
                 if hasattr(sys, "frozen"): #Is frozen by py2exe
                     if '\\library.zip\\' in IPython.__file__.lower():#libraries compressed to zip-file
                         root, rest = IPython.__file__.lower().split('library.zip')
                     else:
                         root=os.path.join(os.path.split(IPython.__file__)[0],"../../")
                     root=os.path.abspath(root).rstrip('\\')
                     if _writable_dir(os.path.join(root, '_ipython')):
                         # still knows it - reported once as:
                         # https://github.com/ipython/ipython/issues/154
                         from subprocess import Popen, PIPE
                         homedir = Popen('echo $HOME', shell=True,
                                         stdout=PIPE).communicate()[0].strip()
                         if homedir:
                             return py3compat.cast_unicode(homedir, fs_encoding)
                     # For some strange reason all of these return 'nt' for os.name.
                     # First look for a network home directory. This will return the UNC
                     # path (\\server\\Users\%username%) not the mapped path (Z:\). This
                     # is needed when running IPython on cluster where all paths have to
                     # be UNC.
                     try:
                         homedir = env['HOMESHARE']
             def get_xdg_dir():
                 """Return the XDG_CONFIG_HOME, if it is defined and exists, else None.
                 This is only for posix (Linux,Unix,OS X, etc) systems.
                 """
                 env = os.environ
                 if os.name == 'posix':
                     # Linux, Unix, AIX, OS X
                     # use ~/.config if not set OR empty
                     xdg = env.get("XDG_CONFIG_HOME", None) or os.path.join(get_home_dir(), '.config')
                     if xdg and _writable_dir(xdg):
                         return py3compat.cast_unicode(xdg, fs_encoding)
                 return None
             def get_ipython_dir():
                 """Get the IPython directory for this platform and user.
                 This uses the logic in `get_home_dir` to find the home directory
                 and then adds .ipython to the end of the path.
                 """
                 env = os.environ
                 pjoin = os.path.join
                 ipdir_def = '.ipython'
                 xdg_def = 'ipython'
                 home_dir = get_home_dir()
                 xdg_dir = get_xdg_dir()
                 # import pdb; pdb.set_trace()  # dbg
                     if xdg_dir:
                         # use XDG, as long as the user isn't already
                         # using $HOME/.ipython and *not* XDG/ipython
                         xdg_ipdir = pjoin(xdg_dir, xdg_def)
                         if _writable_dir(xdg_ipdir) or not _writable_dir(home_ipdir):
                             ipdir = xdg_ipdir
                     if ipdir is None:
                         # not using XDG
                         ipdir = home_ipdir
                 ipdir = os.path.normpath(os.path.expanduser(ipdir))
                 if os.path.exists(ipdir) and not _writable_dir(ipdir):
                     # ipdir exists, but is not writable
                     warn.warn("IPython dir '%s' is not a writable location,"
                 """Expand $VARS and ~names in a string, like a shell
                 :Examples:
                    In [2]: os.environ['FOO']='test'
                    In [3]: expand_path('variable FOO is $FOO')
                         else:
                             warn.warn("Found old IPython config file %r (modified by user)"%f)
                             warned = True
                 if warned:
                     warn.info("""
               The IPython configuration system has changed as of 0.11, and these files will

IPython/utils/pickleshare.py

0 +65 -65

             """ PickleShare - a small 'shelve' like datastore with concurrency support
             Like shelve, a PickleShareDB object acts like a normal dictionary. Unlike
             shelve, many processes can access the database simultaneously. Changing a
             value in database is immediately visible to other processes accessing the
             same database.
             Concurrency is possible because the values are stored in separate files. Hence
             the "database" is a directory where *all* files are governed by PickleShare.
             Example usage::
                 from pickleshare import *
                 db = PickleShareDB('~/testpickleshare')
                 db.clear()
                 print db.keys()
                 del db['aku ankka']
             This module is certainly not ZODB, but can be used for low-load
             (non-mission-critical) situations where tiny code size trumps the
             advanced features of a "real" object database.
             Installation guide: easy_install pickleshare
                         self.root.makedirs()
                     # cache has { 'key' : (obj, orig_mod_time) }
                     self.cache = {}
                 def __getitem__(self,key):
                     """ db['key'] reading """
                         obj = pickle.load(fil.open())
                     except:
                         raise KeyError(key)
                     self.cache[fil] = (obj,mtime)
                     return obj
                 def __setitem__(self,key,value):
                     """ db['key'] = 5 """
                     fil = self.root / key
                     except OSError,e:
                         if e.errno != 2:
                             raise
                 def hset(self, hashroot, key, value):
                     """ hashed set """
                     hroot = self.root / hashroot
                     hfile = hroot / gethashfile(key)
                     d = self.get(hfile, {})
                     d.update( {key : value})
                     self[hfile] = d
                 def hget(self, hashroot, key, default = _sentinel, fast_only = True):
                     """ hashed get """
                     hroot = self.root / hashroot
                     hfile = hroot / gethashfile(key)
                     d = self.get(hfile, _sentinel )
                     #print "got dict",d,"from",hfile
                     if d is _sentinel:
                         if fast_only:
                             if default is _sentinel:
                                 raise KeyError(key)
                             return default
                         # slow mode ok, works even after hcompress()
                         d = self.hdict(hashroot)
                     return d.get(key, default)
                 def hdict(self, hashroot):
                     if last.endswith('xx'):
                         # print "using xx"
                         hfiles = [last] + hfiles[:-1]
                     all = {}
                     for f in hfiles:
                         # print "using",f
                         try:
                         except KeyError:
                             print "Corrupt",f,"deleted - hset is not threadsafe!"
                             del self[f]
                         self.uncache(f)
                     return all
                 def hcompress(self, hashroot):
                     """ Compress category 'hashroot', so hset is fast again
                     hget will fail if fast_only is True for compressed items (that were
                     hset before hcompress).
                     """
                     hfiles = self.keys(hashroot + "/*")
                     all = {}
                         # print "using",f
                         all.update(self[f])
                         self.uncache(f)
                     self[hashroot + '/xx'] = all
                     for f in hfiles:
                         p = self.root / f
                         if p.basename() == 'xx':
                             continue
                         p.remove()
                 def __delitem__(self,key):
                     """ del db["key"] """
                     fil = self.root / key
                         # notfound and permission denied are ok - we
                         # lost, the other process wins the conflict
                         pass
                 def _normalized(self, p):
                     """ Make a key suitable for user's eyes """
                     return str(self.root.relpathto(p)).replace('\\','/')
                 def keys(self, globpat = None):
                     """ All keys in DB, or all keys matching a glob"""
                     if globpat is None:
                         files = self.root.walkfiles()
                     else:
                         files = [Path(p) for p in glob.glob(self.root/globpat)]
                     return [self._normalized(p) for p in files if p.isfile()]
                 def __iter__(self):
                     return iter(keys)
                 def __len__(self):
                     return len(keys)
                 def uncache(self,*items):
                     """ Removes all, or specified items from cache
                     Use this after reading a large amount of large objects
                     to free up memory, when you won't be needing the objects
                     for a while.
                     """
                     if not items:
                         self.cache = {}
                     for it in items:
                         self.cache.pop(it,None)
                 def waitget(self,key, maxwaittime = 60 ):
                     """ Wait (poll) for a key to get a value
                     Will wait for `maxwaittime` seconds before raising a KeyError.
                     The call exits normally if the `key` field in db gets a value
                     within the timeout period.
                     Use this for synchronizing different processes or for ensuring
                     that an unfortunately timed "db['key'] = newvalue" operation
                     in another process (which causes all 'get' operation to cause a
                     KeyError for the duration of pickling) won't screw up your program
                     logic.
                     """
                     wtimes = [0.2] * 3 + [0.5] * 2 + [1]
                     tries = 0
                     waited = 0
                             return val
                         except KeyError:
                             pass
                         if waited > maxwaittime:
                             raise KeyError(key)
                         time.sleep(wtimes[tries])
                         waited+=wtimes[tries]
                         if tries < len(wtimes) -1:
                             tries+=1
                 def getlink(self,folder):
                     """ Get a convenient link for accessing items  """
                     return PickleShareLink(self, folder)
                 def __repr__(self):
                     return "PickleShareDB('%s')" % self.root
             class PickleShareLink:
                 """ A shortdand for accessing nested PickleShare data conveniently.
                     lnk = db.getlink('myobjects/test')
                     lnk.foo = 2
                     lnk.bar = lnk.foo + 5
                 """
                 def __init__(self, db, keydir ):
                     self.__dict__.update(locals())
                 def __getattr__(self,key):
                     return self.__dict__['db'][self.__dict__['keydir']+'/' + key]
                 def __setattr__(self,key,val):
                     return "<PickleShareLink '%s': %s>" % (
                         self.__dict__['keydir'],
                         ";".join([Path(k).basename() for k in keys]))
             def test():
                 db = PickleShareDB('~/testpickleshare')
                 db.clear()
                         if j%33 == 0:
                             time.sleep(0.02)
                         db[str(j)] = db.get(str(j), []) + [(i,j,"proc %d" % os.getpid())]
                         db.hset('hash',j, db.hget('hash',j,15) + 1 )
                     print i,
                     sys.stdout.flush()
                     if i % 10 == 0:
                         db.uncache()
             def main():
                 import textwrap
                 usage = textwrap.dedent("""\
                 pickleshare - manage PickleShare databases
                 Usage:
                     pickleshare dump /path/to/db > dump.txt
                     pickleshare load /path/to/db < dump.txt
                     pickleshare test /path/to/db
                 if len(sys.argv) < 2:
                     print usage
                     return
                 cmd = sys.argv[1]
                 args = sys.argv[2:]
                 if cmd == 'dump':
                 elif cmd == 'test':
                     test()
                     stress()
             if __name__== "__main__":
                 main()

IPython/utils/pickleutil.py

0 +10 -10

                     self.obj = copy.copy(obj)
                     for key in keys:
                         setattr(self.obj, key, can(getattr(obj, key)))
                 def getObject(self, g=None):
                     if g is None:
                         g = globals()
                     if not isinstance(name, basestring):
                         raise TypeError("illegal name: %r"%name)
                     self.name = name
                 def __repr__(self):
                     return "<Reference: %r>"%self.name
                 def getObject(self, g=None):
                     if g is None:
                         g = globals()
                         return g[self.name]
                     except KeyError:
                         raise NameError("name %r is not defined"%self.name)
             class CannedFunction(CannedObject):
                 def __init__(self, f):
                     self._checkType(f)
                     self.code = f.func_code
                     self.defaults = f.func_defaults
                     self.module = f.__module__ or '__main__'
                     self.__name__ = f.__name__
                 def _checkType(self, obj):
                     assert isinstance(obj, FunctionType), "Not a function type"
                 def getObject(self, g=None):
                     # try to load function back into its module:
                     if not self.module.startswith('__'):
                             pass
                         else:
                             g = sys.modules[self.module].__dict__
                     if g is None:
                         g = globals()
                     newFunc = FunctionType(self.code, g, self.__name__, self.defaults)

IPython/utils/process.py

0 +4 -4

             def find_cmd(cmd):
                 """Find absolute path to executable cmd in a cross platform manner.
                 This function tries to determine the full path to a command line program
                 using `which` on Unix/Linux/OS X and `win32api` on Windows.  Most of the
                 time it will use the version that is first on the users `PATH`.  If
                 Warning, don't use this to find IPython command line programs as there
                 is a risk you will find the wrong one.  Instead find those using the
                 following code and looking for the application itself::
                     from IPython.utils.path import get_ipython_module_path
                     from IPython.utils.process import pycmd2argv
                     argv = pycmd2argv(get_ipython_module_path('IPython.frontend.terminal.ipapp'))
                 sure the right version is used.
                 For a given path ``cmd``, this returns [cmd] if cmd's extension is .exe,
                 .com or .bat, and [, cmd] otherwise.
                 Parameters
                 ----------
                     if sys.platform == 'win32':
                         # The -u option here turns on unbuffered output, which is required
                         # on Win32 to prevent wierd conflict and problems with Twisted.
                         # Also, use sys.executable to make sure we are picking up the
                         # right python exe.
                         return [sys.executable, '-u', cmd]
                     else:

IPython/utils/strdispatch.py

0 +7 -7

                 >>> print list(dis.flat_matches('hei'))
                 [123, 34, 686]
                 """
                 def __init__(self):
                     self.strs = {}
                     self.regexs = {}
                 def add_s(self, s, obj, priority= 0 ):
                     """ Adds a target 'string' for dispatching """
                     chain = self.strs.get(s, CommandChainDispatcher())
                     chain.add(obj,priority)
                     self.strs[s] = chain
                 def add_re(self, regex, obj, priority= 0 ):
                     """ Adds a target regexp for dispatching """
                     chain = self.regexs.get(regex, CommandChainDispatcher())
                     chain.add(obj,priority)
                     self.regexs[regex] = chain
                     """ Get a seq of Commandchain objects that match key """
                     if key in self.strs:
                         yield self.strs[key]
                     for r, obj in self.regexs.items():
                         if re.match(r, key):
                             yield obj
                         else:
                             #print "nomatch",key  # dbg
                             pass
                 def __repr__(self):
                     return "<Strdispatch %s, %s>" % (self.strs, self.regexs)
                 def s_matches(self, key):
                     if key not in self.strs:
                          return
                     for el in self.strs[key]:
                         yield el[1]
                 def flat_matches(self, key):
                     """ Yield all 'value' targets, without priority """
                     for val in self.dispatch(key):

IPython/utils/tests/test_notification.py

0 +10 -10

             class Observer(object):
                 def __init__(self, expected_ntype, expected_sender,
                                 center=shared_center, *args, **kwargs):
                     super(Observer, self).__init__()
                     self.expected_ntype = expected_ntype
                     self.expected_args = args
                     self.expected_kwargs = kwargs
                     self.recieved = False
                     center.add_observer(self.callback,
                                         self.expected_ntype,
                                         self.expected_sender)
                 def callback(self, ntype, sender, *args, **kwargs):
                     assert(ntype == self.expected_ntype or
                             self.expected_ntype == None)
                     assert(args == self.expected_args)
                     assert(kwargs == self.expected_kwargs)
                     self.recieved = True
                 def verify(self):
                     assert(self.recieved)
                 def reset(self):
                     self.recieved = False
                 def tearDown(self):
                     shared_center.remove_all_observers()
                 def test_notification_delivered(self):
                     """Test that notifications are delivered"""
                 def test_sender_specificity(self):
                     """Test that observers are registered by sender"""
                     expected_ntype = "EXPECTED_TYPE"
                     sender1 = Notifier(expected_ntype)
                     sender2 = Notifier(expected_ntype)
                     for i in xrange(10):
                         Observer('TYPE', None, center=shared_center)
                     self.assert_(len(shared_center.observers[('TYPE',None)]) >= 10,
                         "observers registered")
                     shared_center.remove_all_observers()
                 def test_post_performance(self):
                     """Test that post_notification, even with many registered irrelevant
                     observers is fast"""
                     for i in xrange(10):
                         Observer("UNRELATED_TYPE", None)

IPython/utils/tests/test_path.py

0 +16 -16

                 import _winreg as wreg
                 #Add entries that needs to be stubbed by the testing code
                 (wreg.OpenKey, wreg.QueryValueEx,) = (None, None)
             try:
                 reload
             except NameError:   # Python 3
             def setup():
                 """Setup testenvironment for the module:
                         - Adds dummy home dir tree
                 """
                 # Do not mask exceptions here.  In particular, catching WindowsError is a
             def teardown():
                 """Teardown testenvironment for the module:
                         - Remove dummy home dir tree
                 """
                 # Note: we remove the parent test dir, which is the root of all test
             def setup_environment():
                 """Setup testenvironment for some functions that are tested
                 in this module. In particular this functions stores attributes
                 and other things that we need to stub in some test functions.
                 This needs to be done on a function level and not module level because
                 each testfunction needs a pristine environment.
                 """
                 global oldstuff, platformstuff
                 (oldenv, os.name, path.get_home_dir, IPython.__file__, old_wd) = oldstuff
                 os.chdir(old_wd)
                 reload(path)
                 for key in env.keys():
                     if key not in oldenv:
                         del env[key]
                 """Testcase for py2exe logic, un-compressed lib
                 """
                 sys.frozen = True
                 #fake filename for IPython.__init__
                 IPython.__file__ = abspath(join(HOME_TEST_DIR, "Lib/IPython/__init__.py"))
                 home_dir = path.get_home_dir()
                 nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
                 sys.frozen = True
                 #fake filename for IPython.__init__
                 IPython.__file__ = abspath(join(HOME_TEST_DIR, "Library.zip/IPython/__init__.py")).lower()
                 home_dir = path.get_home_dir()
                 nt.assert_equal(home_dir, abspath(HOME_TEST_DIR).lower())
             @with_environment
             @skip_win32
             def test_get_home_dir_4():
                 """Testcase $HOME is not set, os=='posix'.
                 This should fail with HomeDirError"""
                 os.name = 'posix'
                 if 'HOME' in env: del env['HOME']
                 nt.assert_raises(path.HomeDirError, path.get_home_dir)
                 home_dir = path.get_home_dir()
                 nt.assert_equal(home_dir, abspath(HOME_TEST_DIR))
             # Should we stub wreg fully so we can run the test on all platforms?
             @skip_if_not_win32
             @with_environment
             def test_get_home_dir_8():
                 """Using registry hack for 'My Documents', os=='nt'
                 HOMESHARE, HOMEDRIVE, HOMEPATH, USERPROFILE and others are missing.
                 """
                 os.name = 'nt'
                 env.pop('IPYTHON_DIR', None)
                 env.pop('IPYTHONDIR', None)
                 env.pop('XDG_CONFIG_HOME', None)
                 nt.assert_equal(path.get_xdg_dir(), os.path.join('somewhere', '.config'))
                 env.pop('XDG_CONFIG_HOME', None)
                 cfgdir=os.path.join(path.get_home_dir(), '.config')
                 os.makedirs(cfgdir)
                 nt.assert_equal(path.get_xdg_dir(), cfgdir)
             def test_filefind():
             @dec.skip_if_not_win32
             def test_get_long_path_name_win32():
                 p = path.get_long_path_name('c:\\docume~1')
                 nt.assert_equals(p,u'c:\\Documents and Settings')
             @dec.skip_win32

IPython/utils/tests/test_traitlets.py

0 +13 -13

                             return -1
                     class A(HasTraitsStub):
                         tt = MyTT
                     a = A()
                     a.tt = 10
                     self.assertEquals(a.tt, -1)
                     traits = a.traits(config_key='VALUE1', other_thing='VALUE2')
                     self.assertEquals(traits, dict(i=A.i))
                     # This passes, but it shouldn't because I am replicating a bug in
                     # traits.
                     traits = a.traits(config_key=lambda v: True)
                     self.assertEquals(traits, dict(i=A.i, f=A.f, j=A.j))
                     class C(object): pass
                     class A(HasTraits):
                         klass = Type(B)
                     a = A()
                     self.assertEquals(a.klass, B)
                     self.assertRaises(TraitError, setattr, a, 'klass', C)
                     a = A()
                     a.klass = Struct
                     self.assertEquals(a.klass, Struct)
                     self.assertRaises(TraitError, setattr, a, 'klass', 10)
             class TestInstance(TestCase):
                     class Foo(object): pass
                     class Bar(Foo): pass
                     class Bah(object): pass
                     class A(HasTraits):
                         inst = Instance(Foo)
                     class A(HasTraits):
                         inst = Instance(Foo, allow_none=False)
                     self.assertRaises(TraitError, A)
                 def test_instance(self):
                     def inner():
                         class A(HasTraits):
                             inst = Instance(Foo())
                     self.assertRaises(TraitError, inner)
                 def test_this_inst(self):
                     class Foo(HasTraits):
                         this = This()
                     f = Foo()
                     f.this = Foo()
                     self.assert_(isinstance(f.this, Foo))
                 obj = ComplexTrait()
                 _default_value = 99.0-99.0j
                 _good_values   = [10, -10, 10.1, -10.1, 10j, 10+10j, 10-10j,
 .1j, 10.1+10.1j, 10.1-10.1j]
                 _bad_values    = [10L, -10L, u'10L', u'-10L', 'ten', [10], {'ten': 10},(10,), None]
                 obj = UnicodeTrait()
                 _default_value = u'unicode'
                 _good_values   = ['10', '-10', '10L', '-10L', '10.1',
                                   '-10.1', '', u'', 'string', u'string', u"€"]
                 _bad_values    = [10, -10, 10L, -10L, 10.1, -10.1, 1j,
                                   [10], ['ten'], [u'ten'], {'ten': 10},(10,), None]
             class ObjectNameTrait(HasTraits):
                 value = ObjectName("abc")
             class TestObjectName(TraitTestBase):
                 obj = ObjectNameTrait()
                 _default_value = "abc"
                 _good_values = ["a", "gh", "g9", "g_", "_G", u"a345_"]
                 _bad_values = [1, "", u"€", "9g", "!", "#abc", "aj@", "a.b", "a()", "a[0]",
             class TestDottedObjectName(TraitTestBase):
                 obj = DottedObjectNameTrait()
                 _default_value = "a.b"
                 _good_values = ["A", "y.t", "y765.__repr__", "os.path.join", u"os.path.join"]
                 _bad_values = [1, u"abc.€", "_.@", ".", ".abc", "abc.", ".abc."]

IPython/utils/text.py

0 +31 -31

             # won't need to make changes all over IPython.
             def getdefaultencoding():
                 """Return IPython's guess for the default encoding for bytes as text.
                 Asks for stdin.encoding first, to match the calling Terminal, but that
                 is often None for subprocesses.  Fall back on locale.getpreferredencoding()
                 which should be a sensible platform default (that respects LANG environment),
             #     """ Prettier (non-repr-like) and more informative printer for LSString """
             #     print "LSString (.p, .n, .l, .s available). Value:"
             #     print arg
+            #
+            #
             # print_lsstring = result_display.when_type(LSString)(print_lsstring)
             #     if hasattr(arg,  'hideonce') and arg.hideonce:
             #         arg.hideonce = False
             #         return
+            #
             #     nlprint(arg)
+            #
             # print_slist = result_display.when_type(SList)(print_slist)
                 """Indent a string a given number of spaces or tabstops.
                 indent(str,nspaces=4,ntabs=0) -> indent str by ntabs+nspaces.
                 Parameters
                 ----------
                 instr : basestring
                     The string to be indented.
                 nspaces : int (default: 4)
                     Whether to scrub existing indentation.  If True, all lines will be
                     aligned to the same indentation.  If False, existing indentation will
                     be strictly increased.
                 Returns
                 -------
                 str|unicode : string indented by ntabs and nspaces.
                 """
                 if instr is None:
                     return
             def dedent(text):
                 """Equivalent of textwrap.dedent that ignores unindented first line.
                 This means it will still dedent strings like:
                 '''foo
                 is a bar
                 '''
                 For use in wrap_paragraphs.
                 """
                 if text.startswith('\n'):
                     # text starts with blank line, don't ignore the first line
                     return textwrap.dedent(text)
                 # split first line
                 splits = text.split('\n',1)
                 if len(splits) == 1:
                     # only one line
                     return textwrap.dedent(text)
                 first, rest = splits
                 # dedent everything but the first line
                 rest = textwrap.dedent(rest)
             def wrap_paragraphs(text, ncols=80):
                 """Wrap multiple paragraphs to fit a specified width.
                 This is equivalent to textwrap.wrap, but with support for multiple
                 paragraphs, as separated by empty lines.
                 Returns
                 -------
                 list of complete paragraphs, wrapped to fill `ncols` columns.
                 """
                 paragraph_re = re.compile(r'\n(\s*\n)+', re.MULTILINE)
                 out_ps = []
                 indent_re = re.compile(r'\n\s+', re.MULTILINE)
                 for p in paragraphs:
                     # presume indentation that survives dedent is meaningful formatting,
                     # so don't fill unless text is flush.
                     if indent_re.search(p) is None:
                         # wrap paragraph
                         p = textwrap.fill(p, ncols)
                     out_ps.append(p)
                 return out_ps
             class EvalFormatter(Formatter):
                 """A String Formatter that allows evaluation of simple expressions.
                 Any time a format key is not found in the kwargs,
                 it will be tried as an expression in the kwargs namespace.
                 This is to be used in templating cases, such as the parallel batch
                 script templates, where simple arithmetic on arguments is useful.
                 Examples
                 --------
                 In [1]: f = EvalFormatter()
                 In [2]: f.format('{n//4}', n=8)
                 Out[2]: '2'
                 In [3]: f.format('{list(range(3))}')
                 Out[3]: '[0, 1, 2]'
                 In [4]: f.format('{3*2}')
                 Out[4]: '6'
                 """
                 # should we allow slicing by disabling the format_spec feature?
                 allow_slicing = True
                 # copied from Formatter._vformat with minor changes to allow eval
                 # and replace the format_spec code with slicing
                 def _vformat(self, format_string, args, kwargs, used_args, recursion_depth):
                 displaywidth : int, optional [default is 80]
                     Width of the display in number of characters.
                 Returns
                 -------
                 The formatted string.
                 # Some degenerate cases.
                 size = len(items)
                 if size == 0:
                     return '\n'
                 elif size == 1:
                     return '%s\n' % items[0]
                             colwidth = max(colwidth, len_x)
                         colwidths.append(colwidth)
                         totwidth += colwidth + len(separator)
                         if totwidth > displaywidth:
                             break
                     if totwidth <= displaywidth:
                         break
                 # The smallest number of rows computed and the max widths for each

IPython/utils/traitlets.py

0 +36 -36

                 ClassTypes = (ClassType, type)
             except:
                 ClassTypes = (type,)
             from .importstring import import_item
             from IPython.utils import py3compat
             def parse_notifier_name(name):
                 """Convert the name argument to a list of names.
                 Examples
                 --------
                 >>> parse_notifier_name('a')
                 ['a']
                 >>> parse_notifier_name(['a','b'])
             def getmembers(object, predicate=None):
                 """A safe version of inspect.getmembers that handles missing attributes.
                 This is useful when there are descriptor based attributes that for
                 some reason raise AttributeError even though they exist.  This happens
                 in zope.inteface with the __provides__ attribute.
                 """
                    This is used by the :class:`This` trait to allow subclasses to
                    accept superclasses for :class:`This` values.
                 """
                 metadata = {}
                 default_value = Undefined
                     created.
                     This method trigger the creation and validation of default values
                     and also things like the resolution of str given class names in
                     :class:`Type` and :class`Instance`.
                     Parameters
                     """Set the default value on a per instance basis.
                     This method is called by :meth:`instance_init` to create and
                     validate the default value.  The creation and validation of
                     default values must be delayed until the parent :class:`HasTraits`
                     class has been instantiated.
                     """
                     """Get the value of the trait by self.name for the instance.
                     Default values are instantiated when :meth:`HasTraits.__new__`
                     is called.  Thus by the time this method gets called either the
                     default value or a user defined value (they called :meth:`__set__`)
                     is in the :class:`HasTraits` instance.
                     """
             class MetaHasTraits(type):
                 """A metaclass for HasTraits.
                 This metaclass makes sure that any TraitType class attributes are
                 instantiated and sets their name attribute.
                 """
                 def __new__(mcls, name, bases, classdict):
                     """Create the HasTraits class.
                     This instantiates all TraitTypes in the class dict and sets their
                     :attr:`name` attribute.
                     """
                 def __init__(cls, name, bases, classdict):
                     """Finish initializing the HasTraits class.
                     This sets the :attr:`this_class` attribute of each TraitType in the
                     class dict to the newly created class ``cls``.
                     """
                     inst._trait_notifiers = {}
                     inst._trait_dyn_inits = {}
                     # Here we tell all the TraitType instances to set their default
                     # values on the instance.
                     for key in dir(cls):
                         # Some descriptors raise AttributeError like zope.interface's
                         # __provides__ attributes even though they exist.  This causes
                         else:
                             raise TraitError('a trait changed callback '
                                                 'must be callable.')
                 def _add_notifiers(self, handler, name):
                     if not self._trait_notifiers.has_key(name):
                     """Setup a handler to be called when a trait changes.
                     This is used to setup dynamic notifications of trait changes.
                     Static handlers can be created by creating methods on a HasTraits
                     subclass with the naming convention '_[traitname]_changed'.  Thus,
                     to create static handler for the trait 'a', create the method
                     _a_changed(self, name, old, new) (fewer arguments can be used, see
                     below).
                     Parameters
                     ----------
                     handler : callable
                         A callable that is called when a trait changes.  Its
                         signature can be handler(), handler(name), handler(name, new)
                         or handler(name, old, new).
                     name : list, str, None
                     default_value : class, str or None
                         The default value must be a subclass of klass.  If an str,
                         the str must be a fully specified class name, like 'foo.bar.Bah'.
                         The string is resolved into real class, when the parent
                         :class:`HasTraits` class is instantiated.
                     klass : class, str, None
                         Values of this trait must be a subclass of klass.  The klass
                         may be specified in a string like: 'foo.bar.MyClass'.
                         The string is resolved into real class, when the parent
                         :class:`HasTraits` class is instantiated.
                     allow_none : boolean
                         Indicates whether None is allowed as an assignable value. Even if
             class Instance(ClassBasedTraitType):
                 """A trait whose value must be an instance of a specified class.
                 The value can also be an instance of a subclass of the specified class.
                 """
                 def __init__(self, klass=None, args=None, kw=None,
                              allow_none=True, **metadata ):
                     """Construct an Instance trait.
                     -------------
                     If both ``args`` and ``kw`` are None, then the default value is None.
                     If ``args`` is a tuple and ``kw`` is a dict, then the default is
                     created as ``klass(*args, **kw)``.  If either ``args`` or ``kw`` is
                     not (but not both), None is replace by ``()`` or ``{}``.
                     """
                         raise TraitError('The klass argument must be a class'
                                             ' you gave: %r' % klass)
                     self.klass = klass
                     # self.klass is a class, so handle default_value
                     if args is None and kw is None:
                         default_value = None
                         elif kw is None:
                             # args is not None
                             kw = {}
                         if not isinstance(kw, dict):
                             raise TraitError("The 'kw' argument must be a dict or None.")
                         if not isinstance(args, tuple):
                             raise TraitError("The 'args' argument must be a tuple or None.")
                         default_value = DefaultValueGenerator(*args, **kw)
                     super(Instance, self).__init__(default_value, **metadata)
                 def get_default_value(self):
                     """Instantiate a default value instance.
                     This is called when the containing HasTraits classes'
                     :meth:`__new__` method is called to ensure that a unique instance
                     is created for each HasTraits instance.
                 """A trait for instances of the class containing this trait.
                 Because how how and when class bodies are executed, the ``This``
                 trait can only have a default value of None.  This, and because we
                 always validate default values, ``allow_none`` is *always* true.
                 """
                         return unicode(value)
                     except:
                         self.error(obj, value)
             class ObjectName(TraitType):
                 """A string holding a valid object name in this version of Python.
                 This does not check that the name exists in any scope."""
                 info_text = "a valid object identifier in Python"
                 if py3compat.PY3:
                     # Python 3:
                     coerce_str = staticmethod(lambda _,s: s)
                 else:
                     # Python 2:
                     def coerce_str(self, obj, value):
                             except UnicodeEncodeError:
                                 self.error(obj, value)
                         return value
                 def validate(self, obj, value):
                     value = self.coerce_str(obj, value)
                     if isinstance(value, str) and py3compat.isidentifier(value):
                         return value
                     self.error(obj, value)
                 """A string holding a valid dotted object name in Python, such as A.b3._c"""
                 def validate(self, obj, value):
                     value = self.coerce_str(obj, value)
                     if isinstance(value, str) and py3compat.isidentifier(value, dotted=True):
                         return value
                     self.error(obj, value)
                 def __init__(self, default_value=None, allow_none=True, **metadata):
                     """Create a dict trait type from a dict.
                     The default value is created by doing ``dict(default_value)``,
                     which creates a copy of the ``default_value``.
                     """
                     if default_value is None:
                     else:
                         raise TypeError('default value of Dict was %s' % default_value)
                     super(Dict,self).__init__(klass=dict, args=args,
                                               allow_none=allow_none, **metadata)
             class TCPAddress(TraitType):

IPython/utils/wildcard.py

0 +6 -6

                 objects from the types package, and vice versa."""
                 typenamelist = [tname for tname in dir(types) if tname.endswith("Type")]
                 typestr2type, type2typestr = {}, {}
                 for tname in typenamelist:
                     name = tname[:-4].lower()          # Cut 'Type' off the end of the name
                     obj = getattr(types, tname)
             typestr2type, type2typestr = create_typestr2type_dicts()
             def is_type(obj, typestr_or_type):
                 """is_type(obj, typestr_or_type) verifies if obj is of a certain type. It
                 can take strings or actual python types for the second argument, i.e.
                 'tuple'<->TupleType. 'all' matches all types.
                 TODO: Should be extended for choosing more than one type."""
                 if typestr_or_type == "all":
                     return True
                    except AttributeError:
                        pass
                 return ns
             def filter_ns(ns, name_pattern="*", type_pattern="all", ignore_case=True,
                         show_all=True):
                 """Filter a namespace dictionary by name pattern and item type."""
                     reg = re.compile(pattern+"$", re.I)
                 else:
                     reg = re.compile(pattern+"$")
                 # Check each one matches regex; shouldn't be hidden; of correct type.
                 return dict((key,obj) for key, obj in ns.iteritems() if reg.match(key) \
                                                         and show_hidden(key, show_all) \
                                         ignore_case=ignore_case, show_all=show_all)
                     results = {}
                     for name, obj in filtered.iteritems():
                         ns = list_namespace(dict_dir(obj), type_pattern,
                                             ".".join(pattern_list[1:]),
                                             ignore_case=ignore_case, show_all=show_all)
                         for inner_name, inner_obj in ns.iteritems():

IPython/zmq/entry_point.py

0 +6 -6

                 executable : str, optional (default sys.executable)
                     The Python executable to use for the kernel process.
                 independent : bool, optional (default False)
                     If set, the kernel process is guaranteed to survive if this process
                     dies. If not set, an effort is made to ensure that the kernel is killed
                     when this process dies. Note that in this case it is still good practice
                 # If this process in running on pythonw, we know that stdin, stdout, and
                 # stderr are all invalid.
                 redirect_out = sys.executable.endswith('pythonw.exe')
                 if redirect_out:
                     _stdout = PIPE if stdout is None else stdout
                     _stderr = PIPE if stderr is None else stderr
                 else:
                     _stdout, _stderr = stdout, stderr
                 # Spawn a kernel.
                 if sys.platform == 'win32':
                     # Launch the kernel process.
                     if independent:
                         proc = Popen(arguments,
                                      creationflags=512, # CREATE_NEW_PROCESS_GROUP
                                      stdin=_stdin, stdout=_stdout, stderr=_stderr)
                     else:
                         from _subprocess import DuplicateHandle, GetCurrentProcess, \
                             DUPLICATE_SAME_ACCESS
                         pid = GetCurrentProcess()
                         handle = DuplicateHandle(pid, pid, pid, 0,
                                                  True, # Inheritable by new processes.
                                                  DUPLICATE_SAME_ACCESS)
                         proc = Popen(arguments + ['--parent=%i'%int(handle)],
                         proc.stdout.close()
                     if stderr is None:
                         proc.stderr.close()
                 return proc, shell_port, iopub_port, stdin_port, hb_port

IPython/zmq/frontend.py

0 +7 -7

                 def print_pyerr(self, err):
                     print >> sys.stderr, err.etype,':', err.evalue
                     print >> sys.stderr, ''.join(err.traceback)
                 def handle_pyerr(self, omsg):
                     if omsg.parent_header.session == self.session.session:
                         return
                     print >> sys.stderr, '[ERR from %s]' % omsg.parent_header.username
                     self.print_pyerr(omsg.content)
                 def handle_stream(self, omsg):
                     if omsg.content.name == 'stdout':
                         outstream = sys.stdout
                     if rep is None:
                         return
                     if rep.content.status == 'error':
                         self.print_pyerr(rep.content)
                     elif rep.content.status == 'aborted':
                         print >> sys.stderr, "ERROR: ABORTED"
                         ab = self.messages[rep.parent_header.msg_id].content
                     omsg = self.session.send(self.request_socket,
                                              'execute_request', dict(code=src))
                     self.messages[omsg.header.msg_id] = omsg
                     # Fake asynchronicity by letting the user put ';' at the end of the line
                     if src.endswith(';'):
                         self.backgrounded += 1
                     self.sub_socket = sub_socket
                     self.console = Console(None, '<zmq-console>',
                                            session, request_socket, sub_socket)
                 def interact(self):
                     self.console.interact()
                 connection = ('tcp://%s' % ip) + ':%i'
                 req_conn = connection % port_base
                 sub_conn = connection % (port_base+1)
                 # Create initial sockets
                 c = zmq.Context()
                 request_socket = c.socket(zmq.DEALER)
                 request_socket.connect(req_conn)
                 sub_socket = c.socket(zmq.SUB)
                 sub_socket.connect(sub_conn)
                 sub_socket.setsockopt(zmq.SUBSCRIBE, '')

IPython/zmq/ipkernel.py

0 +19 -19

                     self.shell._reply_content = None
                     # Build dict of handlers for message types
                     msg_types = [ 'execute_request', 'complete_request',
                                   'object_info_request', 'history_request',
                                   'connect_request', 'shutdown_request']
                     self.handlers = {}
                     # We now require 2.0.8 or above, so we can uncomment for safety.
                     # print(ident,msg, file=sys.__stdout__)
                     assert ident is not None, "Missing message part."
                     # Print some info about this message and leave a '--->' marker, so it's
                     # easier to trace visually the message chain when debugging.  Each
                     # handler prints its message at the end.
                         self.log.error("UNKNOWN MESSAGE TYPE:" +str(msg))
                     else:
                         handler(ident, msg)
                     # Check whether we should exit, in case the incoming message set the
                     # exit flag on
                     if self.shell.exit_now:
                             # reason for this to be anything less than ~ 0.1s
                             # since it is a real poller and will respond
                             # to events immediately
                             # double nested try/except, to properly catch KeyboardInterrupt
                             # due to pyzmq Issue #130
                             try:
                     pyin_msg = self.session.send(self.iopub_socket, u'pyin',{u'code':code}, parent=parent)
                 def execute_request(self, ident, parent):
                     status_msg = self.session.send(self.iopub_socket,
                         u'status',
                         {u'execution_state':u'busy'},
                         parent=parent
                     )
                     try:
                         content = parent[u'content']
                         code = content[u'code']
                         silent = content[u'silent']
                     except:
                         self.log.error("Got bad msg: ")
                         self.log.error(str(Message(parent)))
                     shell = self.shell # we'll need this a lot here
                     # Replace raw_input. Note that is not sufficient to replace
                     # raw_input in the user namespace.
                     raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
                     if py3compat.PY3:
                         status = u'ok'
                     reply_content[u'status'] = status
                     # Return the execution counter so clients can display prompts
                     reply_content['execution_count'] = shell.execution_count -1
                     # to better understand what's going on.
                     if self._execute_sleep:
                         time.sleep(self._execute_sleep)
                     # Send the reply.
                     reply_content = json_clean(reply_content)
                     reply_msg = self.session.send(self.shell_socket, u'execute_reply',
                         n = parent['content']['n']
                         hist = self.shell.history_manager.get_tail(n, raw=raw, output=output,
                                                                         include_latest=True)
                     elif hist_access_type == 'range':
                         session = parent['content']['session']
                         start = parent['content']['start']
                         stop = parent['content']['stop']
                         hist = self.shell.history_manager.get_range(session, start, stop,
                                                                     raw=raw, output=output)
                     elif hist_access_type == 'search':
                         pattern = parent['content']['pattern']
                         hist = self.shell.history_manager.search(pattern, raw=raw, output=output)
                     else:
                         hist = []
                     content = {'history' : list(hist)}
                         self.log.error(str(Message(parent)))
                         value = ''
                     return value
                 def _complete(self, msg):
                     c = msg['content']
                     try:
                             self.app = Tkinter.Tk()
                             self.app.withdraw()
                             self.func = func
                         def on_timer(self):
                             self.func()
                             self.app.after(poll_interval, self.on_timer)
                         def start(self):
                             self.on_timer()  # Call it once to get things going.
                             self.app.mainloop()
             class GTKKernel(Kernel):
                 """A Kernel subclass with GTK support."""
                 def start(self):
                     """Start the kernel, coordinating with the GTK event loop"""
                     from .gui.gtkembed import GTKEmbed
                     gtk_kernel = GTKEmbed(self)
                     gtk_kernel.start()
                         import_all = self.pylab_import_all
                         pylabtools.import_pylab(kernel.shell.user_ns, backend, import_all,
                                                 shell=kernel.shell)
                 def init_shell(self):
                     self.shell = self.kernel.shell

IPython/zmq/kernelmanager.py

0 +23 -23

                                 raise
                         else:
                             break
                 def stop(self):
                     """Stop the channel's activity.
                     This calls :method:`Thread.join` and returns when the thread
                     terminates. :class:`RuntimeError` will be raised if
                     :method:`self.start` is called again.
                     """
                     self.join()
                 @property
                 def address(self):
                     """Get the channel's address as an (ip, port) tuple.
                     By the default, the address is (localhost, 0), where 0 means a random
                     port.
                     """
                     self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
                     self.socket.connect('tcp://%s:%i' % self.address)
                     self.iostate = POLLERR|POLLIN
                     self.ioloop.add_handler(self.socket, self._handle_events,
                                             self.iostate)
                     self._run_loop()
                     ----------
                     code : str
                         A string of Python code.
                     silent : bool, optional (default False)
                         If set, the kernel will execute the code as quietly possible.
                         A list of variable names to pull from the user's namespace.  They
                         will come back as a dict with these names as keys and their
                         :func:`repr` as values.
                     user_expressions : dict, optional
                         A dict with string keys and  to pull from the user's
                         namespace.  They will come back as a dict with these names as keys
                         user_variables = []
                     if user_expressions is None:
                         user_expressions = {}
                     # Don't waste network traffic if inputs are invalid
                     if not isinstance(code, basestring):
                         raise ValueError('code %r must be a string' % code)
                     text : str
                         The text to complete.
                     line : str
                         The full line of text that is the surrounding context for the
                         text to complete.
                     cursor_pos : int
                         The position of the cursor in the line where the completion was
                     ----------
                     oname : str
                         A string specifying the object name.
                     Returns
                     -------
                     The msg_id of the message sent.
                     hist_access_type : str
                         'range' (fill in session, start and stop params), 'tail' (fill in n)
                          or 'search' (fill in pattern param).
                     session : int
                         For a range request, the session from which to get lines. Session
                         numbers are positive integers; negative ones count back from the
                         The first line number of a history range.
                     stop : int
                         The final (excluded) line number of a history range.
                     n : int
                         The number of lines of history to get for a tail request.
                     pattern : str
                         The glob-syntax pattern for a search request.
                     self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
                     self.socket.connect('tcp://%s:%i' % self.address)
                     self.iostate = POLLIN|POLLERR
                     self.ioloop.add_handler(self.socket, self._handle_events,
                                             self.iostate)
                     self._run_loop()
                     self.socket.setsockopt(zmq.IDENTITY, self.session.bsession)
                     self.socket.connect('tcp://%s:%i' % self.address)
                     self.iostate = POLLERR|POLLIN
                     self.ioloop.add_handler(self.socket, self._handle_events,
                                             self.iostate)
                     self._run_loop()
                                                             raise
                                                     else:
                                                         break
                                             since_last_heartbeat = time.time()-request_time
                                             if since_last_heartbeat > self.time_to_dead:
                                                 self.call_handlers(since_last_heartbeat)
                 The SUB channel is for the frontend to receive messages published by the
                 kernel.
                 The REQ channel is for the frontend to make requests of the kernel.
                 The REP channel is for the kernel to request stdin (raw_input) from the
                 frontend.
                 """
                 # config object for passing to child configurables
                 config = Instance(Config)
                 # The PyZMQ Context to use for communication with the kernel.
                 context = Instance(zmq.Context)
                 def _context_default(self):
                 # The kernel process with which the KernelManager is communicating.
                 kernel = Instance(Popen)
                 # The addresses for the communication channels.
                 shell_address = TCPAddress((LOCALHOST, 0))
                 sub_address = TCPAddress((LOCALHOST, 0))
                 stdin_address = TCPAddress((LOCALHOST, 0))
                                            "configured properly. "
                                            "Currently valid addresses are: %s"%LOCAL_IPS
                                            )
                     self._launch_args = kw.copy()
                     launch_kernel = kw.pop('launcher', None)
                     if launch_kernel is None:
                         # OK, we've waited long enough.
                         if self.has_kernel:
                             self.kill_kernel()
                 def restart_kernel(self, now=False, **kw):
                     """Restarts a kernel with the arguments that were used to launch it.
                     If the old kernel was launched with random ports, the same ports will be
                     used for the new kernel.
                     """Get the heartbeat socket channel object to check that the
                     kernel is alive."""
                     if self._hb_channel is None:
                         self._hb_channel = self.hb_channel_class(self.context,
                                                                    self.session,
                                                                    self.hb_address)
                     return self._hb_channel

IPython/zmq/parentpoller.py

0 +6 -6

             class ParentPollerUnix(Thread):
                 """ A Unix-specific daemon thread that terminates the program immediately
                 when the parent process no longer exists.
                 """
                 def __init__(self):
                     super(ParentPollerUnix, self).__init__()
                     self.daemon = True
                 def run(self):
                     # We cannot use os.waitpid because it works only for child processes.
                     from errno import EINTR
                 signals an interrupt and, optionally, terminates the program immediately
                 when the parent process no longer exists.
                 """
                 def __init__(self, interrupt_handle=None, parent_handle=None):
                     """ Create the poller. At least one of the optional parameters must be
                     provided.
                         handle is signaled.
                     parent_handle : HANDLE (int), optional
                         If provided, the program will terminate immediately when this
                         handle is signaled.
                     """
                     assert(interrupt_handle or parent_handle)
                     # handle by new processes.
                     # FIXME: We can clean up this mess by requiring pywin32 for IPython.
                     class SECURITY_ATTRIBUTES(ctypes.Structure):
                         _fields_ = [ ("nLength", ctypes.c_int),
                                      ("lpSecurityDescriptor", ctypes.c_void_p),
                                      ("bInheritHandle", ctypes.c_int) ]
                     sa = SECURITY_ATTRIBUTES()
                     sa_p = ctypes.pointer(sa)

IPython/zmq/pykernel.py

0 +4 -4

                     self.completer = KernelCompleter(self.user_ns)
                     # Build dict of handlers for message types
                     msg_types = [ 'execute_request', 'complete_request',
                                   'object_info_request', 'shutdown_request' ]
                     self.handlers = {}
                     for msg_type in msg_types:
                     try:
                         comp_code = self.compiler(code, '<zmq-kernel>')
                         # Replace raw_input. Note that is not sufficient to replace
                         # raw_input in the user namespace.
                         raw_input = lambda prompt='': self._raw_input(prompt, ident, parent)
                         if py3compat.PY3:
                         reply_content = exc_content
                     else:
                         reply_content = { 'status' : 'ok', 'payload' : {} }
                     # Flush output before sending the reply.
                     sys.stderr.flush()
                     sys.stdout.flush()
             def launch_kernel(*args, **kwargs):
                 """ Launches a simple Python kernel, binding to the specified ports.
                 This function simply calls entry_point.base_launch_kernel with the right first
                 command to start a pykernel.  See base_launch_kernel for arguments.

IPython/zmq/session.py

0 +63 -63

                 """The Base class for configurables that have a Session, Context, logger,
                 and IOLoop.
                 """
                 logname = Unicode('')
                 def _logname_changed(self, name, old, new):
                     self.log = logging.getLogger(new)
                 # not configurable:
                 context = Instance('zmq.Context')
                 def _context_default(self):
                     return zmq.Context.instance()
                 session = Instance('IPython.zmq.session.Session')
                 loop = Instance('zmq.eventloop.ioloop.IOLoop', allow_none=False)
                 def _loop_default(self):
                     return IOLoop.instance()
                 def __init__(self, **kwargs):
                     super(SessionFactory, self).__init__(**kwargs)
                     if self.session is None:
                         # construct the session
                         self.session = Session(**kwargs)
             class Message(object):
                 """A simple message object that maps dict keys to attributes.
                 A Message can be created from a dict and a dict from a Message instance
                 simply by calling dict(msg_obj)."""
                 def __init__(self, msg_dict):
                     dct = self.__dict__
                     for k, v in dict(msg_dict).iteritems():
                 # Having this iterator lets dict(msg_obj) work out of the box.
                 def __iter__(self):
                     return iter(self.__dict__.iteritems())
                 def __repr__(self):
                     return repr(self.__dict__)
             class Session(Configurable):
                 """Object for handling serialization and sending of messages.
                 The Session object handles building messages and sending them
                 with ZMQ sockets or ZMQStream objects.  Objects can communicate with each
                 other over the network via Session objects, and only need to work with the
                 dict-based IPython message spec. The Session will handle
                 serialization/deserialization, security, and metadata.
                 Sessions support configurable serialiization via packer/unpacker traits,
                 and signing with HMAC digests via the key/keyfile traits.
                 Parameters
                 ----------
                 debug : bool
                     whether to trigger extra debugging statements
                 packer/unpacker : str : 'json', 'pickle' or import_string
                     importstrings for methods to serialize message parts.  If just
                     'json' or 'pickle', predefined JSON and pickle packers will be used.
                     Otherwise, the entire importstring must be used.
                     The functions must accept at least valid JSON input, and output *bytes*.
                     For example, to use msgpack:
                     packer = 'msgpack.packb', unpacker='msgpack.unpackb'
                 pack/unpack : callables
                 keyfile : filepath
                     The file containing a key.  If this is set, `key` will be initialized
                     to the contents of the file.
                 """
                 debug=Bool(False, config=True, help="""Debug output in the Session""")
                 packer = DottedObjectName('json',config=True,
                         help="""The name of the packer for serializing messages.
                         Should be one of 'json', 'pickle', or an import name
                         self.unpack = pickle_unpacker
                     else:
                         self.unpack = import_item(str(new))
                 session = CUnicode(u'', config=True,
                     help="""The UUID identifying this session.""")
                 def _session_default(self):
                     u = unicode(uuid.uuid4())
                     self.bsession = u.encode('ascii')
                     return u
                 def _session_changed(self, name, old, new):
                     self.bsession = self.session.encode('ascii')
                 # bsession is the session as bytes
                 bsession = CBytes(b'')
                 username = Unicode(os.environ.get('USER',u'username'), config=True,
                     help="""Username for the Session. Default is your system username.""")
                 # message signature related traits:
                 key = CBytes(b'', config=True,
                     help="""execution key, for extra authentication.""")
                         self.auth = None
                 auth = Instance(hmac.HMAC)
                 digest_history = Set()
                 keyfile = Unicode('', config=True,
                     help="""path to file containing execution key.""")
                 def _keyfile_changed(self, name, old, new):
                 def _pack_changed(self, name, old, new):
                     if not callable(new):
                         raise TypeError("packer must be callable, not %s"%type(new))
                 unpack = Any(default_unpacker) # the actual packer function
                 def _unpack_changed(self, name, old, new):
                     # unpacker is not checked - it is assumed to be
                     if not callable(new):
                         raise TypeError("unpacker must be callable, not %s"%type(new))
                 def __init__(self, **kwargs):
                     """create a Session object
                     Parameters
                     ----------
                         You can also set the pack/unpack callables for serialization
                         directly.
                     session : unicode (must be ascii)
                         the ID of this Session object.  The default is to generate a new
                         UUID.
                     bsession : bytes
                         The session as bytes
                         The key used to initialize an HMAC signature.  If unset, messages
                         will not be signed or checked.
                     keyfile : filepath
                         The file containing a key.  If this is set, `key` will be
                         initialized to the contents of the file.
                     """
                     super(Session, self).__init__(**kwargs)
                     """check packers for binary data and datetime support."""
                     pack = self.pack
                     unpack = self.unpack
                     # check simple serialization
                     msg = dict(a=[1,'hi'])
                     try:
                         packed = pack(msg)
                     except Exception:
                         raise ValueError("packer could not serialize a simple message")
                     # ensure packed message is bytes
                     if not isinstance(packed, bytes):
                         raise ValueError("message packed to %r, but bytes are required"%type(packed))
                     # check that unpack is pack's inverse
                     try:
                         unpacked = unpack(packed)
                     except Exception:
                         raise ValueError("unpacker could not handle the packer's output")
                     # check datetime support
                     msg = dict(t=datetime.now())
                     try:
                     except Exception:
                         self.pack = lambda o: pack(squash_dates(o))
                         self.unpack = lambda s: extract_dates(unpack(s))
                 def msg_header(self, msg_type):
                     return msg_header(self.msg_id, msg_type, self.username, self.session)
                     Parameters
                     ----------
                     msg_list : list
                         The [p_header,p_parent,p_content] part of the message list.
                     """
                     if self.auth is None:
                         return b''
                     for m in msg_list:
                         h.update(m)
                     return str_to_bytes(h.hexdigest())
                 def serialize(self, msg, ident=None):
                     """Serialize the message components to bytes.
                         content = content.encode('utf8')
                     else:
                         raise TypeError("Content incorrect type: %s"%type(content))
                     real_message = [self.pack(msg['header']),
                                     self.pack(msg['parent_header']),
                                     content
                     ]
                     to_send = []
                     if isinstance(ident, list):
                     elif ident is not None:
                         to_send.append(ident)
                     to_send.append(DELIM)
                     signature = self.sign(real_message)
                     to_send.append(signature)
                     to_send.extend(real_message)
                     return to_send
                 def send(self, stream, msg_or_type, content=None, parent=None, ident=None,
                          buffers=None, subheader=None, track=False, header=None):
                     """Build and send a message via stream or socket.
                     The message format used by this function internally is as follows:
                     [ident1,ident2,...,DELIM,HMAC,p_header,p_parent,p_content,
                      buffer1,buffer2,...]
                     The serialize/unserialize methods convert the nested message dict into this
                     format.
                     Parameters
                     ----------
                     stream : zmq.Socket or ZMQStream
                         The socket-like object used to send the data.
                     msg_or_type : str or Message/dict
                         Normally, msg_or_type will be a msg_type unless a message is being
                         sent more than once. If a header is supplied, this can be set to
                         None and the msg_type will be pulled from the header.
                     content : dict or None
                         The content of the message (ignored if msg_or_type is a message).
                     header : dict or None
                     track : bool
                         Whether to track.  Only for use with Sockets, because ZMQStream
                         objects cannot track messages.
                     Returns
                     -------
                     msg : dict
                         The constructed message.
                     (msg,tracker) : (dict, MessageTracker)
                         if track=True, then a 2-tuple will be returned,
                         the first element being the constructed
                         message, and the second being the MessageTracker
                     """
                     if not isinstance(stream, (zmq.Socket, ZMQStream)):
                         raise TypeError("stream must be Socket or ZMQStream, not %r"%type(stream))
                     elif track and isinstance(stream, ZMQStream):
                         raise TypeError("ZMQStream cannot track messages")
                     if isinstance(msg_or_type, (Message, dict)):
                         # We got a Message or message dict, not a msg_type so don't
                         # build a new Message.
                         msg = msg_or_type
                     else:
                         msg = self.msg(msg_or_type, content=content, parent=parent,
                                        subheader=subheader, header=header)
                     buffers = [] if buffers is None else buffers
                         pprint.pprint(msg)
                         pprint.pprint(to_send)
                         pprint.pprint(buffers)
                     msg['tracker'] = tracker
                     return msg
                 def send_raw(self, stream, msg_list, flags=0, copy=True, ident=None):
                     to_send.append(self.sign(msg_list))
                     to_send.extend(msg_list)
                     stream.send_multipart(msg_list, flags, copy=copy)
                 def recv(self, socket, mode=zmq.NOBLOCK, content=True, copy=True):
                     """Receive and unpack a message.
                     except Exception as e:
                         # TODO: handle it
                         raise e
                 def feed_identities(self, msg_list, copy=True):
                     """Split the identities from the rest of the message.
                     Feed until DELIM is reached, then return the prefix as idents and
                     remainder as msg_list. This is easily broken by setting an IDENT to DELIM,
                     but that would be silly.
                     Parameters
                     ----------
                     msg_list : a list of Message or bytes objects
                         The message to be split.
                     copy : bool
                         flag determining whether the arguments are bytes or Messages
                     Returns
                     -------
                     (idents, msg_list) : two lists
                             raise ValueError("DELIM not in msg_list")
                         idents, msg_list = msg_list[:idx], msg_list[idx+1:]
                         return [m.bytes for m in idents], msg_list
                 def unserialize(self, msg_list, content=True, copy=True):
                     """Unserialize a msg_list to a nested message dict.
                         message['content'] = self.unpack(msg_list[3])
                     else:
                         message['content'] = msg_list[3]
                     message['buffers'] = msg_list[4:]
                     return message
                 am['y'] = dict(z=1)
                 ao = Message(am)
                 assert ao.y.z == am['y']['z']
                 k1, k2 = 'y', 'z'
                 assert ao[k1][k2] == am[k1][k2]
                 am2 = dict(ao)
                 assert am['x'] == am2['x']
                 assert am['y']['z'] == am2['y']['z']

IPython/zmq/tests/test_session.py

0 +17 -17

             from IPython.zmq import session as ss
             class SessionTestCase(BaseZMQTestCase):
                 def setUp(self):
                     BaseZMQTestCase.setUp(self)
                     self.session = ss.Session()
                     return self.data
             class TestSession(SessionTestCase):
                 def test_msg(self):
                     """message format"""
                     msg = self.session.msg('execute')
                     self.assertEquals(new_msg['msg_type'],msg['msg_type'])
                     self.assertEquals(new_msg['header'],msg['header'])
                     self.assertEquals(new_msg['content'],msg['content'])
                     self.assertEquals(new_msg['parent_header'],msg['parent_header'])
                     self.assertEquals(new_msg['buffers'],[b'bar'])
                     socket.data = []
                     self.assertEquals(new_msg['msg_type'],msg['msg_type'])
                     self.assertEquals(new_msg['header'],msg['header'])
                     self.assertEquals(new_msg['content'],msg['content'])
                     self.assertEquals(new_msg['parent_header'],msg['parent_header'])
                     self.assertEquals(new_msg['buffers'],[b'bar'])
                     socket.data = []
                     self.assertEquals(new_msg['msg_type'],msg['msg_type'])
                     self.assertEquals(new_msg['header'],msg['header'])
                     self.assertEquals(new_msg['content'],msg['content'])
                     self.assertEquals(new_msg['parent_header'],msg['parent_header'])
                     self.assertEquals(new_msg['buffers'],[b'bar'])
                     socket.close()
                     self.assertTrue(s.pack is ss.default_packer)
                     self.assertTrue(s.unpack is ss.default_unpacker)
                     self.assertEquals(s.username, os.environ.get('USER', u'username'))
                     s = ss.Session()
                     self.assertEquals(s.username, os.environ.get('USER', u'username'))
                     self.assertRaises(TypeError, ss.Session, pack='hi')
                     self.assertRaises(TypeError, ss.Session, unpack='hi')
                     u = str(uuid.uuid4())
                     s = ss.Session(username=u'carrot', session=u)
                     self.assertEquals(s.session, u)
                     self.assertEquals(s.username, u'carrot')
                 def test_tracking(self):
                     """test tracking messages"""
                     a,b = self.create_bound_pair(zmq.PAIR, zmq.PAIR)
                     self.assertRaises(zmq.NotDone, t.wait, .1)
                     del M
                     t.wait(1) # this will raise
                 # def test_rekey(self):
                 #     """rekeying dict around json str keys"""
                 #     d = {'0': uuid.uuid4(), 0:uuid.uuid4()}
                 #     self.assertRaises(KeyError, ss.rekey, d)
+                #
                 #     d = {'0': uuid.uuid4(), 1:uuid.uuid4(), 'asdf':uuid.uuid4()}
                 #     d2 = {0:d['0'],1:d[1],'asdf':d['asdf']}
                 #     rd = ss.rekey(d)
                 #     self.assertEquals(d2,rd)
+                #
                 #     d = {'1.5':uuid.uuid4(),'1':uuid.uuid4()}
                 #     d2 = {1.5:d['1.5'],1:d['1']}
                 #     rd = ss.rekey(d)
                 #     self.assertEquals(d2,rd)
+                #
                 #     d = {'1.0':uuid.uuid4(),'1':uuid.uuid4()}
                 #     self.assertRaises(KeyError, ss.rekey, d)
+                #
                 def test_unique_msg_ids(self):
                     """test that messages receive unique ids"""
                     ids = set()
                         msg_id = h['msg_id']
                         self.assertTrue(msg_id not in ids)
                         ids.add(msg_id)
                 def test_feed_identities(self):
                     """scrub the front for zmq IDENTITIES"""
                     theids = "engine client other".split()
                     content = dict(code='whoda',stuff=object())
                     themsg = self.session.msg('execute',content=content)
                     pmsg = theids
                 def test_session_id(self):
                     session = ss.Session()
                     # get bs before us
                     # get us before bs
                     self.assertEquals(session.bsession, session.session.encode('ascii'))
                     self.assertEquals(b'stuff', session.bsession)

IPython/zmq/zmqshell.py

0 +17 -17

                 displayhook_class = Type(ZMQShellDisplayHook)
                 display_pub_class = Type(ZMQDisplayPublisher)
                 # Override the traitlet in the parent class, because there's no point using
                 # readline for the kernel. Can be removed when the readline code is moved
                 # to the terminal frontend.
                 # autoindent has no meaning in a zmqshell, and attempting to enable it
                 # will print a warning in the absence of readline.
                 autoindent = CBool(False)
                 exiter = Instance(ZMQExitAutocall)
                 def _exiter_default(self):
                     return ZMQExitAutocall(self)
                         transformed_input=new,
                         )
                     self.payload_manager.write_payload(payload)
                 def ask_exit(self):
                     """Engage the exit actions."""
                     payload = dict(
                     exc_content[u'status'] = u'error'
                     self._reply_content = exc_content
                     # /FIXME
                     return exc_content
                 #------------------------------------------------------------------------
                     save_dstore('rc_pprint', ptformatter.pprint)
                     save_dstore('rc_plain_text_only',disp_formatter.plain_text_only)
                     save_dstore('xmode', shell.InteractiveTB.mode)
                     if mode == False:
                         # turn on
                         ptformatter.pprint = False
                     dstore.mode = bool(1-int(mode))
                     mode_label = ['OFF','ON'][dstore.mode]
                     print('Doctest mode is:', mode_label)
                     # Send the payload back so that clients can modify their prompt display
                     payload = dict(
                         source='IPython.zmq.zmqshell.ZMQInteractiveShell.magic_doctest_mode',
                     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.
                     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!
                     hello again
                     Out[7]: "print 'hello again'n"
                     """
                     opts,args = self.parse_options(parameter_s,'prn:')
                     try:
                         filename, lineno, _ = self._find_edit_target(args, opts, last_call)
                     except MacroToEdit as e:
                     magic_cls = magic_clear
                 # Terminal pagers won't work over pexpect, but we do have our own pager
                 def magic_less(self, arg_s):
                     """Show a file through the pager.
                     """Show a basic reference about the GUI console."""
                     from IPython.core.usage import gui_reference
                     page.page(gui_reference, auto_html=True)
                 def set_next_input(self, text):
                     """Send the specified text to the frontend to be presented at the next
                     input cell."""
                     payload = dict(
                         source='IPython.zmq.zmqshell.ZMQInteractiveShell.set_next_input',
                         text=text
                     )
                     self.payload_manager.write_payload(payload)

docs/examples/lib/gui-wx.py

0 +2 -2

             Ref: Modified from wxPython source code wxPython/samples/simple/simple.py
             This example can only be run once in a given IPython session because when
             the frame is closed, wx goes through its shutdown sequence, killing further
             attempts.  I am sure someone who knows wx can fix this issue.
                     # Create the menubar
                     menuBar = wx.MenuBar()
                     # and a menu
                     menu = wx.Menu()
                     # add an item to the menu, using \tKeyName automatically

docs/examples/newparallel/fetchparse.py

0 +9 -9

             Updated for newparallel by Min Ragan-Kelley <benjaminrk@gmail.com>
             This module gives an example of how the task interface to the
             IPython controller works.  Before running this script start the IPython controller
             and some engines using something like::
                     return links
             class DistributedSpider(object):
                 # Time to wait between polling for task results.
                 pollingDelay = 0.5
                 def __init__(self, site):
                     self.client = Client()
                     self.view = self.client.load_balanced_view()
                     self.mux = self.client[:]
                     self.allLinks = []
                     self.linksWorking = {}
                     self.linksDone = {}
                     self.site = site
                 def visitLink(self, url):
                     if url not in self.allLinks:
                         self.allLinks.append(url)
                         if url.startswith(self.site):
                             print '    ', url
                             self.linksWorking[url] = self.view.apply(fetchAndParse, url)
                 def onVisitDone(self, links, url):
                     print url, ':'
                     self.linksDone[url] = None
                     del self.linksWorking[url]
                     for link in links:
                         self.visitLink(link)
                 def run(self):
                     self.visitLink(self.site)
                     while self.linksWorking:
                         print len(self.linksWorking), 'pending...'
                         self.synchronize()
                         time.sleep(self.pollingDelay)
                 def synchronize(self):
                     for url, ar in self.linksWorking.items():
                         # Calling get_task_result with block=False will return None if the

docs/examples/newparallel/multiengine1.py

0 +1 -1

             try:
                 ar.r
             except error.CompositeError:
                 print "Caught ZeroDivisionError OK."
             # push/pull

docs/examples/newparallel/options/mcpricer.py

0 +2 -2

             # <markdowncell>
             # A LoadBalancedView is an interface to the engines that provides dynamic load
             # balancing at the expense of not knowing which engine will execute the code.
             # <codecell>
             for i, price in enumerate(results):
                 prices[i] = tuple(price)
             prices.shape = (n_strikes, n_sigmas)
             strike_mesh, sigma_mesh = np.meshgrid(strike_vals, sigma_vals)

docs/examples/newparallel/pi/parallelpi.py

0 +2 -2

             The dataset we have been using for this is the 200 million digit one here:
             ftp://pi.super-computing.org/.2/pi200m/
             and the files used will be downloaded if they are not in the working directory
             of the IPython engines.
             """
             from IPython.parallel import Client
             from matplotlib import pyplot as plt

docs/examples/newparallel/pi/pidigits.py

0 +4 -4

             """Compute statistics on the digits of pi.
             This uses precomputed digits of pi from the website
             of Professor Yasumasa Kanada at the University of
             Tokoyo: http://www.super-computing.org/
             Currently, there are only functions to read the
                 return freqs
             # Read digits from a txt file
             def txt_file_to_digits(filename, the_type=str):
                 """
                 Yield the digits of pi read from a .txt file.
                             if c != '\n' and c!= ' ':
                                 yield the_type(c)
             # Actual counting functions
             def one_digit_freqs(digits, normalize=False):
                 """
                 if normalize:
                     freqs = freqs/freqs.sum()
                 return freqs
             def two_digit_freqs(digits, normalize=False):
                 """
                 Consume digits of pi and compute 2 digits freq. counts.

docs/examples/newparallel/plotting/plotting_backend.py

0 +3 -3

             The two files plotting_frontend.py and plotting_backend.py go together.
             This file (plotting_backend.py) performs the actual computation.  For this
             example, the computation just generates a set of random numbers that
             look like a distribution of particles with 2D position (x,y) and
             momentum (px,py).  In a real situation, this file would do some time
             consuming and complicated calculation, and could possibly make calls
             to MPI.
             One important feature is that this script can also be run standalone without
             IPython.  This is nice as it allows it to be run in more traditional
             settings where IPython isn't being used.
             When used with IPython.parallel, this code is run on the engines.  Because this

docs/examples/newparallel/rmt/rmt.py

0 +2 -2

             # <markdowncell>
             # The eigenvalues of random matrices obey certain statistical laws. Here we construct random matrices
             # from the Gaussian Orthogonal Ensemble (GOE), find their eigenvalues and then investigate the nearest
             # neighbor eigenvalue distribution $\rho(s)$.
             # The Wigner distribution gives the theoretical result for the nearest neighbor eigenvalue distribution
             # for the GOE:
+            #
             # $$\rho(s) = \frac{\pi s}{2} \exp(-\pi s^2/4)$$
             # <codecell>

docs/examples/newparallel/task_profiler.py

0 +8 -8

             This script submits a set of tasks via a LoadBalancedView.  The tasks
             are basically just a time.sleep(t), where t is a random number between
             two limits that can be configured at the command line.  To run
             the script there must first be an IPython controller and engines running::
                 ipclusterz start -n 16
                 python task_profiler.py -n 128 -t 0.01 -T 1.0
             This should show a speedup of 13-14x.  The limitation here is that the
             overhead of a single task is about 0.001-0.01 seconds.
             """
             import random, sys
                 parser.set_defaults(tmin=1e-3)
                 parser.set_defaults(tmax=1)
                 parser.set_defaults(profile='default')
                 parser.add_option("-n", type='int', dest='n',
                     help='the number of tasks to run')
                 parser.add_option("-t", type='float', dest='tmin',
                     help='the minimum task length in seconds')
                 parser.add_option("-T", type='float', dest='tmax',
                     help='the maximum task length in seconds')
                 parser.add_option("-p", '--profile', type='str', dest='profile',
                     help="the cluster profile [default: 'default']")
                 (opts, args) = parser.parse_args()
                 assert opts.tmax >= opts.tmin, "tmax must not be smaller than tmin"
                 rc = Client()
                 view = rc.load_balanced_view()
                 print view
                 # the jobs should take a random time within a range
                 times = [random.random()*(opts.tmax-opts.tmin)+opts.tmin for i in range(opts.n)]
                 stime = sum(times)
                 print "executing %i tasks, totalling %.1f secs on %i engines"%(opts.n, stime, nengines)
                 time.sleep(1)
                 start = time.time()
                 ptime = stop-start
                 scale = stime/ptime
                 print "executed %.1f secs in %.1f secs"%(stime, ptime)
                 print "%.3fx parallel performance on %i engines"%(scale, nengines)
                 print "%.1f%% of theoretical max"%(100*scale/nengines)

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

0 +22 -22

                $ ipclusterz start --profile mpi -n 8 # start 8 engines (assuming mpi profile has been configured)
                $ ./parallelwave-mpi.py --grid 400 100 --partition 4 2 --profile mpi
             See also parallelwave-mpi, which runs the same program, but uses MPI
             (via mpi4py) for the inter-engine communication.
             Authors
                 global t_hist
                 t_hist.append(t)
                 u_hist.append(1.0*u)
             # main program:
             if __name__ == '__main__':
                 parser = argparse.ArgumentParser()
                 paa = parser.add_argument
                 paa('--grid', '-g',
                 paa('-t', '--tstop',
                     type=float, default=1.,
                     help="Time units to run")
                 paa('--profile',
                     type=unicode, default=u'default',
                     help="Specify the ipcluster profile for the client to connect to.")
                 paa('--save',
                     action='store_true',
                     help="Add this flag to save the time/wave history during the run.")
                 paa('--scalar',
                     action='store_true',
                     help="Also run with scalar interior implementation, to see vector speedup.")
                 ns = parser.parse_args()
                 # set up arguments
                 grid = ns.grid
                     user_action = wave_saver
                 else:
                     user_action = None
                 num_cells = 1.0*(grid[0]-1)*(grid[1]-1)
                 final_test = True
                 # create the Client
                 rc = Client(profile=ns.profile)
                 num_procs = len(rc.ids)
                 if partition is None:
                     partition = [1,num_procs]
                 assert partition[0]*partition[1] == num_procs, "can't map partition %s to %i engines"%(partition, num_procs)
                 view = rc[:]
                 print "Running %s system on %s processes until %f"%(grid, partition, tstop)
                 # functions defining initial/boundary/source conditions
                 def I(x,y):
                     from numpy import exp
                     # return 10*exp(-(x - sin(100*t))**2)
                 def bc(x,y,t):
                     return 0.0
                 # initial imports, setup rank
                 view.execute('\n'.join([
                 "from mpi4py import MPI",
                 "import numpy",
                 "mpi = MPI.COMM_WORLD",
                 "my_id = MPI.COMM_WORLD.Get_rank()"]), block=True)
                 # initialize t_hist/u_hist for saving the state at each step (optional)
                 view['t_hist'] = []
                 view['u_hist'] = []
                 # set vector/scalar implementation details
                 impl = {}
                 impl['ic'] = 'vectorized'
                 impl['inner'] = 'scalar'
                 impl['bc'] = 'vectorized'
                 # execute some files so that the classes we need will be defined on the engines:
                 view.run('RectPartitioner.py')
                 view.run('wavesolver.py')
                 # setup remote partitioner
                 # note that Reference means that the argument passed to setup_partitioner will be the
                 # object named 'my_id' in the engine's namespace
                 # lambda for calling solver.solve:
                 _solve = lambda *args, **kwargs: solver.solve(*args, **kwargs)
                 if ns.scalar:
                     impl['inner'] = 'scalar'
                     # run first with element-wise Python operations for each cell
                         norm = -1
                     t1 = time.time()
                     print 'scalar inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
                 impl['inner'] = 'vectorized'
                 # setup new solvers
                 view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly,partitioner=Reference('partitioner'), dt=0,implementation=impl)
                 view.execute('mpi.barrier()')
                 # run again with numpy vectorized inner-implementation
                 t0 = time.time()
                 ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test)#, user_action=wave_saver)
                     norm = -1
                 t1 = time.time()
                 print 'vector inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
                 # if ns.save is True, then u_hist stores the history of u as a list
                 # If the partion scheme is Nx1, then u can be reconstructed via 'gather':
                 if ns.save and partition[-1] == 1:

docs/examples/newparallel/wave2D/parallelwave.py

0 +21 -21

                $ ipclusterz start -n 8 # start 8 engines
                $ ./parallelwave.py --grid 200 200 --partition 4 2
             See also parallelwave-mpi, which runs the same program, but uses MPI
             (via mpi4py) for the inter-engine communication.
             Authors
                 global t_hist
                 t_hist.append(t)
                 u_hist.append(1.0*u)
             # main program:
             if __name__ == '__main__':
                 parser = argparse.ArgumentParser()
                 paa = parser.add_argument
                 paa('--grid', '-g',
                 paa('-t', '--tstop',
                     type=float, default=1.,
                     help="Time units to run")
                 paa('--profile',
                     type=unicode, default=u'default',
                     help="Specify the ipcluster profile for the client to connect to.")
                 paa('--save',
                     action='store_true',
                     help="Add this flag to save the time/wave history during the run.")
                 paa('--scalar',
                     action='store_true',
                     help="Also run with scalar interior implementation, to see vector speedup.")
                 ns = parser.parse_args()
                 # set up arguments
                 grid = ns.grid
                     user_action = wave_saver
                 else:
                     user_action = None
                 num_cells = 1.0*(grid[0]-1)*(grid[1]-1)
                 final_test = True
                 # create the Client
                 rc = Client(profile=ns.profile)
                 num_procs = len(rc.ids)
                 if partition is None:
                     partition = [num_procs,1]
                 else:
                     num_procs = min(num_procs, partition[0]*partition[1])
                 assert partition[0]*partition[1] == num_procs, "can't map partition %s to %i engines"%(partition, num_procs)
                 # construct the View:
                 view = rc[:num_procs]
                 print "Running %s system on %s processes until %f"%(grid, partition, tstop)
                 # functions defining initial/boundary/source conditions
                 def I(x,y):
                     from numpy import exp
                     # return 10*exp(-(x - sin(100*t))**2)
                 def bc(x,y,t):
                     return 0.0
                 # initialize t_hist/u_hist for saving the state at each step (optional)
                 view['t_hist'] = []
                 view['u_hist'] = []
                 impl['ic'] = 'vectorized'
                 impl['inner'] = 'scalar'
                 impl['bc'] = 'vectorized'
                 # execute some files so that the classes we need will be defined on the engines:
                 view.execute('import numpy')
                 view.run('communicator.py')
                 view.run('RectPartitioner.py')
                 view.run('wavesolver.py')
                 # scatter engine IDs
                 view.scatter('my_id', range(num_procs), flatten=True)
                 # create the engine connectors
                 view.execute('com = EngineCommunicator()')
                 peers = ar.get_dict()
                 # print peers
                 # this is a dict, keyed by engine ID, of the connection info for the EngineCommunicators
                 # setup remote partitioner
                 # note that Reference means that the argument passed to setup_partitioner will be the
                 # object named 'com' in the engine's namespace
                         norm = -1
                     t1 = time.time()
                     print 'scalar inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
                 # run again with faster numpy-vectorized inner implementation:
                 impl['inner'] = 'vectorized'
                 # setup remote solvers
                 view.apply_sync(setup_solver, I,f,c,bc,Lx,Ly,partitioner=Reference('partitioner'), dt=0,implementation=impl)
                 t0 = time.time()
                 ar = view.apply_async(_solve, tstop, dt=0, verbose=True, final_test=final_test)#, user_action=wave_saver)
                 if final_test:
                     # this sum is performed element-wise as results finish
                     norm = -1
                 t1 = time.time()
                 print 'vector inner-version, Wtime=%g, norm=%g'%(t1-t0, norm)
                 # if ns.save is True, then u_hist stores the history of u as a list
                 # If the partion scheme is Nx1, then u can be reconstructed via 'gather':
                 if ns.save and partition[-1] == 1:

docs/examples/newparallel/wave2D/wavesolver.py

0 +9 -9

                 tstop is the stop time for the simulation.
                 I, f are functions: I(x,y), f(x,y,t)
                 user_action: function of (u, x, y, t) called at each time
                 level (x and y are one-dimensional coordinate vectors).
                 This function allows the calling code to plot the solution,
                 final_test: true means the discrete L2-norm of the final solution is
                 to be computed.
                 """
                 def __init__(self, I, f, c, bc, Lx, Ly, partitioner=None, dt=-1,
                             user_action=None,
                             implementation={'ic': 'vectorized',  # or 'scalar'
                                             'inner': 'vectorized',
                                             'bc': 'vectorized'}):
                     nx = partitioner.global_num_cells[0]  # number of global cells in x dir
                     ny = partitioner.global_num_cells[1]  # number of global cells in y dir
                     dx = Lx/float(nx)
                                 u_2[i,j] = u_1[i,j] + \
 .5*Cx2*(u_1[i-1,j] - 2*u_1[i,j] + u_1[i+1,j]) + \
 .5*Cy2*(u_1[i,j-1] - 2*u_1[i,j] + u_1[i,j+1]) + \
                                        dt2*f(x[i], y[j], 0.0)
                         # boundary values of u_2 (equals u(t=dt) due to du/dt=0)
                         i = 0
                         user_action(u_1, x, y, t)  # allow user to plot etc.
                     # print list(self.us[2][2])
                     self.us = (u,u_1,u_2)
                 def solve(self, tstop, dt=-1, user_action=None, verbose=False, final_test=False):
                     t0=time.time()
                     f=self.f
                     upper_y_neigh = partitioner.upper_neighbors[1]
                     u,u_1,u_2 = self.us
                     # u_1 = self.u_1
                     t = 0.0
                     while t <= tstop:
                         t_old = t;  t += dt
                            Cx2*(u_1[0:nx-1,1:ny] - 2*u_1[1:nx,1:ny] + u_1[2:nx+1,1:ny]) + \
                            Cy2*(u_1[1:nx,0:ny-1] - 2*u_1[1:nx,1:ny] + u_1[1:nx,2:ny+1]) + \
                            dt2*f(xv[1:nx,1:ny], yv[1:nx,1:ny], t_old)
                         # insert boundary conditions (if there's no neighbor):
                         if lower_x_neigh < 0:
                             if implementation['bc'] == 'scalar':

docs/examples/notebooks/text_analysis.py

0 +20 -20

                 >>> rescale_arr(a,3,6)
                 array([ 3.  ,  3.75,  4.5 ,  5.25,  6.  ])
                 """
                 # old bounds
                 m = arr.min()
                 M = arr.max()
                 # scale/offset
                 s = float(amax-amin)/(M-m)
                 d = amin - s*m
                 # Apply clip before returning to cut off possible overflows outside the
                 # intended range due to roundoff error, so that we can absolutely guarantee
                 # that on output, there are no values > amax or < amin.
                 """
                 return [w for w in text.lower().split()
                         if len(w)>=min_length and w not in remove]
             def print_vk(lst):
                 """Print a list of value/key pairs nicely formatted in key/value order."""
                 freqs = {}
                 for word in text:
                     freqs[word] = freqs.get(word, 0) + 1
                 return freqs
                 ----------
                 freqs : dict
                   A dict with string keys and integer values.
                 Return
                 ------
                 items : list
                 freqs : dict or list
                   Word frequencies, represented either as a dict of word->count, or as a
                   list of count->word pairs.
                 n : int
                   The number of least/most frequent words to print.
                 """
             def co_occurrences(lines, words):
                 """Return histogram of co-occurrences of words in a list of lines.
                 Parameters
                 ----------
                 lines : list
                   searched for co-occurrences.
                 """
                 wpairs = all_pairs(words)
                 # Now build histogram of co-occurrences
                 co_occur = {}
                 for w1, w2 in wpairs:
                     sizes.append(d['count'])
                     degrees.append(wgraph.degree(n))
                 sizes = rescale_arr(np.array(sizes, dtype=float), 100, 1000)
                 # Compute layout and label edges according to weight
                 pos = nx.spring_layout(wgraph) if pos is None else pos
                 labels = {}
                 # remap width to 1-10 range
                 width = rescale_arr(np.array(width, dtype=float), 1, 15)
                 # Create figure
                 fig = plt.figure()
                 ax = fig.add_subplot(111)
                     # interpret as a fraction
                     start = -int(round(show*len(freqs)))
                     show_f = sorted_f[start:]
                 # Now, extract words and counts, plot
                 n_words = len(show_f)
                 ind = np.arange(n_words)
                 # # Configure user variables here
                 #  # Specify the url (can be a local file path) of the text file to analyze.
                 #  # If not given, it's read from the command line as the first argument
+                #
                 #  # 11226 titles of recent articles in arxiv/math/prob
                 #  default_url  = "http://bibserver.berkeley.edu/tmp/titles.txt"
                 #  # Number of words to display in detailed histogram
                 #  n_words = 15
                 #  # Number of words to use as nodes for co-occurrence graph.
                 #  n_nodes = 15
+                #
                 #  # End of user configuration
+                #
                 #  # Actual code starts here
                 #  try:
                 #      url = sys.argv[1]
                 #  except IndexError:
                 #      url  = default_url
+                #
                 #  # Fetch text and do basic preprocessing
                 #  text = get_text_from_url(url).lower()
                 #  lines = text.splitlines()
                 #  words = text_cleanup(text)
+                #
                 #  # Compute frequency histogram
                 #  wf = word_freq(words)
                 #  sorted_wf = sort_freqs(wf)
+                #
                 #  # Build a graph from the n_nodes most frequent words
                 #  popular = sorted_wf[-n_nodes:]
                 #  pop_words = [wc[0] for wc in popular]
                 #  co_occur = co_occurrences(lines, pop_words)
                 #  wgraph = co_occurrences_graph(popular, co_occur, cutoff=1)
                 #  centrality = nx.eigenvector_centrality_numpy(wgraph)
+                #
                 #  # Print summaries of single-word frequencies and graph structure
                 #  summarize_freq_hist(sorted_wf)
                 #  summarize_centrality(centrality)
+                #
                 #  # Plot histogram and graph
                 #  plt.close('all')
                 #  plot_word_histogram(sorted_wf, n_words,
                 #                      "Frequencies for %s most frequent words" % n_words)
                 #  plot_word_histogram(sorted_wf, 1.0, "Frequencies for entire word list")
                 #  plot_graph(wgraph)
+                #
                 #  # Display figures
                 #  plt.show()

docs/source/conf.py

0 +1 -1

                 'sphinx.ext.autodoc',
                 'sphinx.ext.doctest',
                 'inheritance_diagram',
                 'ipython_console_highlighting',
                 'numpydoc',  # to preprocess docstrings
             ]

docs/sphinxext/apigen.py

0 +9 -9

                     functions, classes = self._parse_lines(f)
                     f.close()
                     return functions, classes
                 def _parse_lines(self, linesource):
                     ''' Parse lines of text for functions and classes '''
                     functions = []
                         return ''
                     # Make a shorter version of the uri that omits the package name for
                     # titles
                     uri_short = re.sub(r'^%s\.' % self.package_name,'',uri)
                     ad = '.. AUTO-GENERATED FILE -- DO NOT EDIT!\n\n'
                     chap_title = uri_short
                     elif match_type == 'package':
                         patterns = self.package_skip_patterns
                     else:
                         raise ValueError('Cannot interpret match type "%s"'
                                          % match_type)
                     # Match to URI without package name
                     L = len(self.package_name)
                     return True
                 def discover_modules(self):
                     ''' Return module sequence discovered from ``self.package_name``
                     Parameters
                     >>> dw.package_skip_patterns.append('\.util$')
                     >>> 'sphinx.util' in dw.discover_modules()
                     False
                     >>>
                     '''
                     modules = [self.package_name]
                     # raw directory parsing
                                 self._survives_exclude(module_uri, 'module')):
                                 modules.append(module_uri)
                     return sorted(modules)
                 def write_modules_api(self, modules,outdir):
                     # write the list
                     written_modules = []
                     outdir : string
                         Directory name in which to store files
                         We create automatic filenames for each module
                     Returns
                     -------
                     None
                     # compose list of modules
                     modules = self.discover_modules()
                     self.write_modules_api(modules,outdir)
                 def write_index(self, outdir, froot='gen', relative_to=None):
                     """Make a reST API index file from written files

docs/sphinxext/ipython_console_highlighting.py

0 +2 -2

             # Third party
             from pygments.lexer import Lexer, do_insertions
             from pygments.lexers.agile import (PythonConsoleLexer, PythonLexer,
                                                PythonTracebackLexer)
             from pygments.token import Comment, Generic
                   - It assumes the default IPython prompts, not customized ones.
                 """
                 name = 'IPython console session'
                 aliases = ['ipython']
                 mimetypes = ['text/x-ipython-console']

setup2.py

0 +10 -10

             # -*- coding: utf-8 -*-
             """Setup script for IPython.
             Under Posix environments it works like a typical setup.py script.
             Under Windows, the command sdist is not supported, since IPython
             requires utilities which are not available under Windows."""
             #-----------------------------------------------------------------------------
             from IPython.utils.path import target_update
             from setupbase import (
                 setup_args,
                 find_packages,
                 find_package_data,
                 find_scripts,
                 find_data_files,
                 check_for_dependencies,
                 # target_update()
                 to_update = [
                               # FIXME - Disabled for now: we need to redo an automatic way
                               # of generating the magic info inside the rst.
                               #('docs/magic.tex',
                               #['IPython/Magic.py'],
                               #"cd doc && ./update_magic.sh" ),
                          docdeps,
                          "cd docs && make dist")
                         )
                 [ target_update(*t) for t in to_update ]
             #---------------------------------------------------------------------------
             # Find all the packages, package data, and data_files
             #---------------------------------------------------------------------------
             if len(needs_setuptools.intersection(sys.argv)) > 0:
                 import setuptools
             # This dict is used for passing extra arguments that are setuptools
             # specific to setup
             setuptools_extra_args = {}
                     else:
                         pass
                         # do we want to install readline here?
                 # Script to be run by the windows binary installer after the default setup
                 # routine, to add shortcuts and similar windows-only things.  Windows
                 # post-install scripts MUST reside in the scripts/ dir, otherwise distutils

setupbase.py

0 +15 -15

             def oscmd(s):
                 print(">", s)
                 os.system(s)
             try:
                 execfile
             except NameError:
                 """
                 # This is not enough for these things to appear in an sdist.
                 # We need to muck with the MANIFEST to get this to work
                 # walk notebook resources:
                 cwd = os.getcwd()
                 os.chdir(os.path.join('IPython', 'frontend', 'html', 'notebook'))
                 for parent, dirs, files in static_walk:
                     for f in files:
                         static_data.append(os.path.join(parent, f))
                 package_data = {
                     'IPython.config.profile' : ['README', '*/*.py'],
                     'IPython.testing' : ['*.txt'],
                 XXX - this needs a proper docstring!
                 """
                 # we'll use these a lot below
                 lbase = len(base)
                 pathsep = os.path.sep
                 lpathsep = len(pathsep)
                 out = []
                 for (dirpath,dirnames,filenames) in os.walk(base):
                     # we need to strip out the dirpath from the base to map it to the
                     # output (installation) path.  This requires possibly stripping the
                     # path separator, because otherwise pjoin will not work correctly
                     # (pjoin('foo/','/bar') returns '/bar').
                     dp_eff = dirpath[lbase:]
                     if dp_eff.startswith(pathsep):
                         dp_eff = dp_eff[lpathsep:]
                     # The output path must be anchored at the out_base marker
                     out_path = pjoin(out_base,dp_eff)
                     # Now we can generate the final filenames. Since os.walk only produces
                     # filenames, we must join back with the dirpath to get full valid file
                     out.append((out_path, pfiles))
                 return out
             def find_data_files():
                 """
                 Most of these are docs.
                 """
                 docdirbase  = pjoin('share', 'doc', 'ipython')
                 manpagebase = pjoin('share', 'man', 'man1')
                 # Simple file lists can be made by hand
                 manpages  = filter(isfile, glob(pjoin('docs','man','*.1.gz')))
                 if not manpages:
                 gz_cmd = ( "cd %(man_dir)s && gzip -9c %(manpage)s > %(manpage_gz)s" %
                            locals() )
                 return (manpath_gz, [manpath], gz_cmd)
             #---------------------------------------------------------------------------
             # Find scripts
             #---------------------------------------------------------------------------
             def find_scripts(entry_points=False, suffix=''):
                 """Find IPython's scripts.
                 if entry_points is True:
                     return setuptools entry_point-style definitions
                 else:
                     return file paths of plain scripts [default]
                 suffix is appended to script names if entry_points is True, so that the
                 Python 3 scripts get named "ipython3" etc.
                 """
             def check_for_dependencies():
                 """Check for IPython's dependencies.
                 This function should NOT be called if running under setuptools!
                 """
                 from setupext.setupext import (
                 print_status('platform', sys.platform)
                 if sys.platform == 'win32':
                     print_status('Windows version', sys.getwindowsversion())
                 print_raw("")
                 print_raw("OPTIONAL DEPENDENCIES")

setupext/setupext.py

0 +2 -2

                     print_status('sphinx', "Not found (required for building documentation)")
                     return False
                 else:
                     print_status('sphinx', sphinx.__version__)
                     return True
             def check_for_pygments():
                     if zmq.__version__ < '2.1.4':
                         print_status('pyzmq', "no (have %s, but require >= 2.1.4 for"
                         " qtconsole and parallel computing capabilities)"%zmq.__version__)
                     else:
                         print_status("pyzmq", zmq.__version__)
                         return True

tools/run_ipy_in_profiler.py

0 +1 -1

                 print "Entering ipython for profiling. Type 'Exit' for profiler report"
                 IPython.ipapi.launch_new_instance()
             if len(sys.argv) == 1:
                 profile.run('main()', 'ipython_profiler_results')
             import pstats

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