def _topic(self, topic):
        """prefixed topic for IOPub messages"""
        if self.int_id >= 0:
            base = "engine.%i" % self.int_id
        else:
            base = "kernel.%s" % self.ident

        return py3compat.cast_bytes("%s.%s" % (base, topic))

def _topic ( self , topic ) : if self . int_id >= 0 : base = "engine.%i" % self . int_id else : base = "kernel.%s" % self . ident return py3compat . cast_bytes ( "%s.%s" % ( base , topic ) )


def _at_shutdown(self):
        """Actions taken at shutdown by the kernel, called by python's atexit.
        """
        # io.rprint("Kernel at_shutdown") # dbg
        if self._shutdown_message is not None:
            self.session.send(self.iopub_socket, self._shutdown_message, ident=self._topic('shutdown'))
            self.log.debug("%s", self._shutdown_message)
        [ s.flush(zmq.POLLOUT) for s in self.shell_streams ]

def
_at_shutdown
(
self
)
:
# io.rprint("Kernel at_shutdown") # dbg
if
self
.
_shutdown_message
is
not
:
self
.
session
.
send
(
self
.
iopub_socket
,
self
.
_shutdown_message
,
ident
=
self
.
_topic
(
'shutdown'
)
)
self
.
log
.
debug
(
"%s"
,
self
.
_shutdown_message
)
[
s
.
flush
(
zmq
.
POLLOUT
)
for
s
in
self
.
shell_streams
]

Actions taken at shutdown by the kernel called by python s atexit .


def beforeContext(self):
        """Copy sys.modules onto my mod stack
        """
        mods = sys.modules.copy()
        self._mod_stack.append(mods)

def beforeContext ( self ) : mods = sys . modules . copy ( ) self . _mod_stack . append ( mods )


def afterContext(self):
        """Pop my mod stack and restore sys.modules to the state
        it was in when mod stack was pushed.
        """
        mods = self._mod_stack.pop()
        to_del = [ m for m in sys.modules.keys() if m not in mods ]
        if to_del:
            log.debug('removing sys modules entries: %s', to_del)
            for mod in to_del:
                del sys.modules[mod]
        sys.modules.update(mods)

def
afterContext
(
self
)
:
mods
=
self
.
_mod_stack
.
pop
(
)
to_del
=
[
m
for
m
in
sys
.
modules
.
keys
(
)
if
m
not
in
mods
]
if
to_del
:
log
.
debug
(
'removing sys modules entries: %s'
,
to_del
)
for
mod
in
to_del
:
del
sys
.
modules
[
mod
]
sys
.
modules
.
update
(
mods
)

Pop my mod stack and restore sys . modules to the state it was in when mod stack was pushed .


def absdir(path):
    """Return absolute, normalized path to directory, if it exists; None
    otherwise.
    """
    if not os.path.isabs(path):
        path = os.path.normpath(os.path.abspath(os.path.join(os.getcwd(),
                                                             path)))
    if path is None or not os.path.isdir(path):
        return None
    return path

def absdir ( path ) : if not os . path . isabs ( path ) : path = os . path . normpath ( os . path . abspath ( os . path . join ( os . getcwd ( ) , path ) ) ) if path is None or not os . path . isdir ( path ) : return None return path

Return absolute normalized path to directory if it exists ; None otherwise .


def file_like(name):
    """A name is file-like if it is a path that exists, or it has a
    directory part, or it ends in .py, or it isn't a legal python
    identifier.
    """
    return (os.path.exists(name)
            or os.path.dirname(name)
            or name.endswith('.py')
            or not ident_re.match(os.path.splitext(name)[0]))

def file_like ( name ) : return ( os . path . exists ( name ) or os . path . dirname ( name ) or name . endswith ( '.py' ) or not ident_re . match ( os . path . splitext ( name ) [ 0 ] ) )

A name is file - like if it is a path that exists or it has a directory part or it ends in . py or it isn t a legal python identifier .


def isclass(obj):
    """Is obj a class? Inspect's isclass is too liberal and returns True
    for objects that can't be subclasses of anything.
    """
    obj_type = type(obj)
    return obj_type in class_types or issubclass(obj_type, type)

def isclass ( obj ) : obj_type = type ( obj ) return obj_type in class_types or issubclass ( obj_type , type )

Is obj a class? Inspect s isclass is too liberal and returns True for objects that can t be subclasses of anything .


def ispackage(path):
    """
    Is this path a package directory?

    >>> ispackage('nose')
    True
    >>> ispackage('unit_tests')
    False
    >>> ispackage('nose/plugins')
    True
    >>> ispackage('nose/loader.py')
    False
    """
    if os.path.isdir(path):
        # at least the end of the path must be a legal python identifier
        # and __init__.py[co] must exist
        end = os.path.basename(path)
        if ident_re.match(end):
            for init in ('__init__.py', '__init__.pyc', '__init__.pyo'):
                if os.path.isfile(os.path.join(path, init)):
                    return True
            if sys.platform.startswith('java') and \
                    os.path.isfile(os.path.join(path, '__init__$py.class')):
                return True
    return False


def getpackage(filename):
    """
    Find the full dotted package name for a given python source file
    name. Returns None if the file is not a python source file.

    >>> getpackage('foo.py')
    'foo'
    >>> getpackage('biff/baf.py')
    'baf'
    >>> getpackage('nose/util.py')
    'nose.util'

    Works for directories too.

    >>> getpackage('nose')
    'nose'
    >>> getpackage('nose/plugins')
    'nose.plugins'

    And __init__ files stuck onto directories

    >>> getpackage('nose/plugins/__init__.py')
    'nose.plugins'

    Absolute paths also work.

    >>> path = os.path.abspath(os.path.join('nose', 'plugins'))
    >>> getpackage(path)
    'nose.plugins'
    """
    src_file = src(filename)
    if not src_file.endswith('.py') and not ispackage(src_file):
        return None
    base, ext = os.path.splitext(os.path.basename(src_file))
    if base == '__init__':
        mod_parts = []
    else:
        mod_parts = [base]
    path, part = os.path.split(os.path.split(src_file)[0])
    while part:
        if ispackage(os.path.join(path, part)):
            mod_parts.append(part)
        else:
            break
        path, part = os.path.split(path)
    mod_parts.reverse()
    return '.'.join(mod_parts)

def getpackage ( filename ) : src_file = src ( filename ) if not src_file . endswith ( '.py' ) and not ispackage ( src_file ) : return None base , ext = os . path . splitext ( os . path . basename ( src_file ) ) if base == '__init__' : mod_parts = [ ] else : mod_parts = [ base ] path , part = os . path . split ( os . path . split ( src_file ) [ 0 ] ) while part : if ispackage ( os . path . join ( path , part ) ) : mod_parts . append ( part ) else : break path , part = os . path . split ( path ) mod_parts . reverse ( ) return '.' . join ( mod_parts )

Find the full dotted package name for a given python source file name . Returns None if the file is not a python source file .


def ln(label):
    """Draw a 70-char-wide divider, with label in the middle.

    >>> ln('hello there')
    '---------------------------- hello there -----------------------------'
    """
    label_len = len(label) + 2
    chunk = (70 - label_len) // 2
    out = '%s %s %s' % ('-' * chunk, label, '-' * chunk)
    pad = 70 - len(out)
    if pad > 0:
        out = out + ('-' * pad)
    return out

def
ln
(
label
)
:
label_len
=
len
(
label
)
+
2
chunk
=
(
70
label_len
)
//
2
out
=
'%s %s %s'
%
(
'-'
*
chunk
,
label
,
'-'
*
chunk
)
pad
=
70
len
(
out
)
if
pad
>
0
:
out
=
out
+
(
'-'
*
pad
)
return
out

Draw a 70 - char - wide divider with label in the middle .


def regex_last_key(regex):
    """Sort key function factory that puts items that match a
    regular expression last.

    >>> from nose.config import Config
    >>> from nose.pyversion import sort_list
    >>> c = Config()
    >>> regex = c.testMatch
    >>> entries = ['.', '..', 'a_test', 'src', 'lib', 'test', 'foo.py']
    >>> sort_list(entries, regex_last_key(regex))
    >>> entries
    ['.', '..', 'foo.py', 'lib', 'src', 'a_test', 'test']
    """
    def k(obj):
        if regex.search(obj):
            return (1, obj)
        return (0, obj)
    return k

def regex_last_key ( regex ) : def k ( obj ) : if regex . search ( obj ) : return ( 1 , obj ) return ( 0 , obj ) return k

Sort key function factory that puts items that match a regular expression last .


def transplant_func(func, module):
    """
    Make a function imported from module A appear as if it is located
    in module B.

    >>> from pprint import pprint
    >>> pprint.__module__
    'pprint'
    >>> pp = transplant_func(pprint, __name__)
    >>> pp.__module__
    'nose.util'

    The original function is not modified.

    >>> pprint.__module__
    'pprint'

    Calling the transplanted function calls the original.

    >>> pp([1, 2])
    [1, 2]
    >>> pprint([1,2])
    [1, 2]

    """
    from nose.tools import make_decorator
    def newfunc(*arg, **kw):
        return func(*arg, **kw)

    newfunc = make_decorator(func)(newfunc)
    newfunc.__module__ = module
    return newfunc

def transplant_func ( func , module ) : from nose . tools import make_decorator def newfunc ( * arg , * * kw ) : return func ( * arg , * * kw ) newfunc = make_decorator ( func ) ( newfunc ) newfunc . __module__ = module return newfunc

Make a function imported from module A appear as if it is located in module B .


def transplant_class(cls, module):
    """
    Make a class appear to reside in `module`, rather than the module in which
    it is actually defined.

    >>> from nose.failure import Failure
    >>> Failure.__module__
    'nose.failure'
    >>> Nf = transplant_class(Failure, __name__)
    >>> Nf.__module__
    'nose.util'
    >>> Nf.__name__
    'Failure'

    """
    class C(cls):
        pass
    C.__module__ = module
    C.__name__ = cls.__name__
    return C

def transplant_class ( cls , module ) : class C ( cls ) : pass C . __module__ = module C . __name__ = cls . __name__ return C

Make a class appear to reside in module rather than the module in which it is actually defined .


def get_system_cpu_times():
    """Return system CPU times as a namedtuple."""
    user, nice, system, idle = _psutil_osx.get_system_cpu_times()
    return _cputimes_ntuple(user, nice, system, idle)

def get_system_cpu_times ( ) : user , nice , system , idle = _psutil_osx . get_system_cpu_times ( ) return _cputimes_ntuple ( user , nice , system , idle )

Return system CPU times as a namedtuple .


def get_process_cmdline(self):
        """Return process cmdline as a list of arguments."""
        if not pid_exists(self.pid):
            raise NoSuchProcess(self.pid, self._process_name)
        return _psutil_osx.get_process_cmdline(self.pid)

def get_process_cmdline ( self ) : if not pid_exists ( self . pid ) : raise NoSuchProcess ( self . pid , self . _process_name ) return _psutil_osx . get_process_cmdline ( self . pid )

Return process cmdline as a list of arguments .


def get_open_files(self):
        """Return files opened by process."""
        if self.pid == 0:
            return []
        files = []
        rawlist = _psutil_osx.get_process_open_files(self.pid)
        for path, fd in rawlist:
            if isfile_strict(path):
                ntuple = nt_openfile(path, fd)
                files.append(ntuple)
        return files

def get_open_files ( self ) : if self . pid == 0 : return [ ] files = [ ] rawlist = _psutil_osx . get_process_open_files ( self . pid ) for path , fd in rawlist : if isfile_strict ( path ) : ntuple = nt_openfile ( path , fd ) files . append ( ntuple ) return files


def get_connections(self, kind='inet'):
        """Return etwork connections opened by a process as a list of
        namedtuples.
        """
        if kind not in conn_tmap:
            raise ValueError("invalid %r kind argument; choose between %s"
                             % (kind, ', '.join([repr(x) for x in conn_tmap])))
        families, types = conn_tmap[kind]
        ret = _psutil_osx.get_process_connections(self.pid, families, types)
        return [nt_connection(*conn) for conn in ret]

Return etwork connections opened by a process as a list of namedtuples .


def user_has_group(user, group, superuser_skip=True):
    """
    Check if a user is in a certaing group.
    By default, the check is skipped for superusers.
    """

    if user.is_superuser and superuser_skip:
        return True

    return user.groups.filter(name=group).exists()

def user_has_group ( user , group , superuser_skip = True ) : if user . is_superuser and superuser_skip : return True return user . groups . filter ( name = group ) . exists ( )

Check if a user is in a certaing group . By default the check is skipped for superusers .


def resolve_class(class_path):
    """
    Load a class by a fully qualified class_path,
    eg. myapp.models.ModelName
    """

    modulepath, classname = class_path.rsplit('.', 1)
    module = __import__(modulepath, fromlist=[classname])
    return getattr(module, classname)

def resolve_class ( class_path ) : modulepath , classname = class_path . rsplit ( '.' , 1 ) module = __import__ ( modulepath , fromlist = [ classname ] ) return getattr ( module , classname )

Load a class by a fully qualified class_path eg . myapp . models . ModelName


def usage_percent(used, total, _round=None):
    """Calculate percentage usage of 'used' against 'total'."""
    try:
        ret = (used / total) * 100
    except ZeroDivisionError:
        ret = 0
    if _round is not None:
        return round(ret, _round)
    else:
        return ret

def usage_percent ( used , total , _round = None ) : try : ret = ( used / total ) * 100 except ZeroDivisionError : ret = 0 if _round is not None : return round ( ret , _round ) else : return ret

Calculate percentage usage of used against total .


def memoize(f):
    """A simple memoize decorator for functions."""
    cache= {}
    def memf(*x):
        if x not in cache:
            cache[x] = f(*x)
        return cache[x]
    return memf

def memoize ( f ) : cache = { } def memf ( * x ) : if x not in cache : cache [ x ] = f ( * x ) return cache [ x ] return memf

A simple memoize decorator for functions .


def deprecated(replacement=None):
    """A decorator which can be used to mark functions as deprecated."""
    def outer(fun):
        msg = "psutil.%s is deprecated" % fun.__name__
        if replacement is not None:
            msg += "; use %s instead" % replacement
        if fun.__doc__ is None:
            fun.__doc__ = msg

        @wraps(fun)
        def inner(*args, **kwargs):
            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
            return fun(*args, **kwargs)

        return inner
    return outer

def
deprecated
(
replacement
=
)
:
def
outer
(
fun
)
:
msg
=
"psutil.%s is deprecated"
%
fun
.
__name__
if
replacement
is
not
:
msg
+=
"; use %s instead"
%
replacement
if
fun
.
__doc__
is
:
fun
.
__doc__
=
msg
@
wraps
(
fun
)
def
inner
(
*
args
,
*
*
kwargs
)
:
warnings
.
warn
(
msg
,
category
=
DeprecationWarning
,
stacklevel
=
2
)
return
fun
(
*
args
,
*
*
kwargs
)
return
inner
return
outer

A decorator which can be used to mark functions as deprecated .


def _login(self):
        """
        Login into Google Docs with user authentication info.
        """
        try:
            self.gd_client = gdata.docs.client.DocsClient()
            self.gd_client.ClientLogin(self.email, self.password, self.source)
        except RequestError as e:
            raise PODocsError(e)

def _login ( self ) : try : self . gd_client = gdata . docs . client . DocsClient ( ) self . gd_client . ClientLogin ( self . email , self . password , self . source ) except RequestError as e : raise PODocsError ( e )

Login into Google Docs with user authentication info .


def _get_gdocs_key(self):
        """
        Parse GDocs key from Spreadsheet url.
        """
        try:
            args = urlparse.parse_qs(urlparse.urlparse(self.url).query)
            self.key = args['key'][0]
        except KeyError as e:
            raise PODocsError(e)

def _get_gdocs_key ( self ) : try : args = urlparse . parse_qs ( urlparse . urlparse ( self . url ) . query ) self . key = args [ 'key' ] [ 0 ] except KeyError as e : raise PODocsError ( e )


def _ensure_temp_path_exists(self):
        """
        Make sure temp directory exists and create one if it does not.
        """
        try:
            if not os.path.exists(self.temp_path):
                os.mkdir(self.temp_path)
        except OSError as e:
            raise PODocsError(e)

def _ensure_temp_path_exists ( self ) : try : if not os . path . exists ( self . temp_path ) : os . mkdir ( self . temp_path ) except OSError as e : raise PODocsError ( e )

Make sure temp directory exists and create one if it does not .


def _clear_temp(self):
        """
        Clear temp directory from created csv and ods files during
        communicator operations.
        """
        temp_files = [LOCAL_ODS, GDOCS_TRANS_CSV, GDOCS_META_CSV,
                      LOCAL_TRANS_CSV, LOCAL_META_CSV]
        for temp_file in temp_files:
            file_path = os.path.join(self.temp_path, temp_file)
            if os.path.exists(file_path):
                os.remove(file_path)

def _clear_temp ( self ) : temp_files = [ LOCAL_ODS , GDOCS_TRANS_CSV , GDOCS_META_CSV , LOCAL_TRANS_CSV , LOCAL_META_CSV ] for temp_file in temp_files : file_path = os . path . join ( self . temp_path , temp_file ) if os . path . exists ( file_path ) : os . remove ( file_path )

Clear temp directory from created csv and ods files during communicator operations .


def _upload_file_to_gdoc(
            self, file_path,
            content_type='application/x-vnd.oasis.opendocument.spreadsheet'):
        """
        Uploads file to GDocs spreadsheet.
        Content type can be provided as argument, default is ods.
        """
        try:
            entry = self.gd_client.GetResourceById(self.key)
            media = gdata.data.MediaSource(
                file_path=file_path, content_type=content_type)
            self.gd_client.UpdateResource(
                entry, media=media, update_metadata=True)
        except (RequestError, IOError) as e:
            raise PODocsError(e)

Uploads file to GDocs spreadsheet . Content type can be provided as argument default is ods .


def synchronize(self):
        """
        Synchronize local po files with translations on GDocs Spreadsheet.
        Downloads two csv files, merges them and converts into po files
        structure. If new msgids appeared in po files, this method creates
        new ods with appended content and sends it to GDocs.
        """
        gdocs_trans_csv = os.path.join(self.temp_path, GDOCS_TRANS_CSV)
        gdocs_meta_csv = os.path.join(self.temp_path, GDOCS_META_CSV)
        local_trans_csv = os.path.join(self.temp_path, LOCAL_TRANS_CSV)
        local_meta_csv = os.path.join(self.temp_path, LOCAL_META_CSV)

        try:
            entry = self._download_csv_from_gdocs(gdocs_trans_csv,
                                                  gdocs_meta_csv)
        except PODocsError as e:
            if 'Sheet 1 not found' in str(e) \
                    or 'Conversion failed unexpectedly' in str(e):
                self.upload()
            else:
                raise PODocsError(e)
        else:
            self._merge_local_and_gdoc(entry, local_trans_csv, local_meta_csv,
                                       gdocs_trans_csv, gdocs_meta_csv)

            try:
                csv_to_po(local_trans_csv, local_meta_csv,
                          self.locale_root, self.po_files_path, self.header)
            except IOError as e:
                raise PODocsError(e)

        self._clear_temp()

def
synchronize
(
self
)
:
gdocs_trans_csv
=
os
.
path
.
join
(
self
.
temp_path
,
GDOCS_TRANS_CSV
)
gdocs_meta_csv
=
os
.
path
.
join
(
self
.
temp_path
,
GDOCS_META_CSV
)
local_trans_csv
=
os
.
path
.
join
(
self
.
temp_path
,
LOCAL_TRANS_CSV
)
local_meta_csv
=
os
.
path
.
join
(
self
.
temp_path
,
LOCAL_META_CSV
)
try
:
entry
=
self
.
_download_csv_from_gdocs
(
gdocs_trans_csv
,
gdocs_meta_csv
)
except
PODocsError
as
e
:
if
'Sheet 1 not found'
in
str
(
e
)
or
'Conversion failed unexpectedly'
in
str
(
e
)
:
self
.
upload
(
)
else
:
raise
PODocsError
(
e
)
else
:
self
.
_merge_local_and_gdoc
(
entry
,
local_trans_csv
,
local_meta_csv
,
gdocs_trans_csv
,
gdocs_meta_csv
)
try
:
csv_to_po
(
local_trans_csv
,
local_meta_csv
,
self
.
locale_root
,
self
.
po_files_path
,
self
.
header
)
except
IOError
as
e
:
raise
PODocsError
(
e
)
self
.
_clear_temp
(
)

Synchronize local po files with translations on GDocs Spreadsheet . Downloads two csv files merges them and converts into po files structure . If new msgids appeared in po files this method creates new ods with appended content and sends it to GDocs .


def download(self):
        """
        Download csv files from GDocs and convert them into po files structure.
        """
        trans_csv_path = os.path.realpath(
            os.path.join(self.temp_path, GDOCS_TRANS_CSV))
        meta_csv_path = os.path.realpath(
            os.path.join(self.temp_path, GDOCS_META_CSV))

        self._download_csv_from_gdocs(trans_csv_path, meta_csv_path)

        try:
            csv_to_po(trans_csv_path, meta_csv_path,
                      self.locale_root, self.po_files_path, header=self.header)
        except IOError as e:
            raise PODocsError(e)

        self._clear_temp()

def download ( self ) : trans_csv_path = os . path . realpath ( os . path . join ( self . temp_path , GDOCS_TRANS_CSV ) ) meta_csv_path = os . path . realpath ( os . path . join ( self . temp_path , GDOCS_META_CSV ) ) self . _download_csv_from_gdocs ( trans_csv_path , meta_csv_path ) try : csv_to_po ( trans_csv_path , meta_csv_path , self . locale_root , self . po_files_path , header = self . header ) except IOError as e : raise PODocsError ( e ) self . _clear_temp ( )

Download csv files from GDocs and convert them into po files structure .


def upload(self):
        """
        Upload all po files to GDocs ignoring conflicts.
        This method looks for all msgids in po_files and sends them
        as ods to GDocs Spreadsheet.
        """
        local_ods_path = os.path.join(self.temp_path, LOCAL_ODS)
        try:
            po_to_ods(self.languages, self.locale_root,
                      self.po_files_path, local_ods_path)
        except (IOError, OSError) as e:
            raise PODocsError(e)

        self._upload_file_to_gdoc(local_ods_path)

        self._clear_temp()

def upload ( self ) : local_ods_path = os . path . join ( self . temp_path , LOCAL_ODS ) try : po_to_ods ( self . languages , self . locale_root , self . po_files_path , local_ods_path ) except ( IOError , OSError ) as e : raise PODocsError ( e ) self . _upload_file_to_gdoc ( local_ods_path ) self . _clear_temp ( )

Upload all po files to GDocs ignoring conflicts . This method looks for all msgids in po_files and sends them as ods to GDocs Spreadsheet .


def clear(self):
        """
        Clear GDoc Spreadsheet by sending empty csv file.
        """
        empty_file_path = os.path.join(self.temp_path, 'empty.csv')
        try:
            empty_file = open(empty_file_path, 'w')
            empty_file.write(',')
            empty_file.close()
        except IOError as e:
            raise PODocsError(e)

        self._upload_file_to_gdoc(empty_file_path, content_type='text/csv')

        os.remove(empty_file_path)

def clear ( self ) : empty_file_path = os . path . join ( self . temp_path , 'empty.csv' ) try : empty_file = open ( empty_file_path , 'w' ) empty_file . write ( ',' ) empty_file . close ( ) except IOError as e : raise PODocsError ( e ) self . _upload_file_to_gdoc ( empty_file_path , content_type = 'text/csv' ) os . remove ( empty_file_path )

Clear GDoc Spreadsheet by sending empty csv file .


def new_qt_console(self, evt=None):
        """start a new qtconsole connected to our kernel"""
        return connect_qtconsole(self.ipkernel.connection_file, profile=self.ipkernel.profile)

def new_qt_console ( self , evt = None ) : return connect_qtconsole ( self . ipkernel . connection_file , profile = self . ipkernel . profile )


def check_url_accessibility(url, timeout=10):
    '''
    Check whether the URL accessible and returns HTTP 200 OK or not
    if not raises ValidationError
    '''
    if(url=='localhost'):
        url = 'http://127.0.0.1'
    try:
        req = urllib2.urlopen(url, timeout=timeout)
        if (req.getcode()==200):
            return True
    except Exception:
        pass
    fail("URL '%s' is not accessible from this machine" % url)


def url_has_contents(url, contents, case_sensitive=False, timeout=10):
    '''
    Check whether the HTML page contains the content or not and return boolean
    '''
    try:
        req = urllib2.urlopen(url, timeout=timeout)
    except Exception, _:
        False
    else:
        rep = req.read()
        if (not case_sensitive and rep.lower().find(contents.lower()) >= 0) or (case_sensitive and rep.find(contents) >= 0):
            return True
        else:
            return False

def url_has_contents ( url , contents , case_sensitive = False , timeout = 10 ) : try : req = urllib2 . urlopen ( url , timeout = timeout ) except Exception , _ : False else : rep = req . read ( ) if ( not case_sensitive and rep . lower ( ) . find ( contents . lower ( ) ) >= 0 ) or ( case_sensitive and rep . find ( contents ) >= 0 ) : return True else : return False


def get_response_code(url, timeout=10):
    '''
    Visit the URL and return the HTTP response code in 'int'
    '''
    try:
        req = urllib2.urlopen(url, timeout=timeout)
    except HTTPError, e:
        return e.getcode()
    except Exception, _:
        fail("Couldn't reach the URL '%s'" % url)
    else:
        return req.getcode()

def
get_response_code
(
url
,
timeout
=
10
)
:
try
:
req
=
urllib2
.
urlopen
(
url
,
timeout
=
timeout
)
except
HTTPError
,
e
:
return
e
.
getcode
(
)
except
Exception
,
_
:
fail
(
"Couldn't reach the URL '%s'"
%
url
)
else
:
return
req
.
getcode
(
)

Visit the URL and return the HTTP response code in int


def compare_content_type(url, content_type):
    '''
    Compare the content type header of url param with content_type param and returns boolean
    @param url -> string e.g. http://127.0.0.1/index
    @param content_type -> string e.g. text/html
    '''
    try:
        response = urllib2.urlopen(url)
    except:
        return False

    return response.headers.type == content_type

def compare_content_type ( url , content_type ) : try : response = urllib2 . urlopen ( url ) except : return False return response . headers . type == content_type


def compare_response_code(url, code):
    '''
    Compare the response code of url param with code param and returns boolean
    @param url -> string e.g. http://127.0.0.1/index
    @param content_type -> int e.g. 404, 500, 400 ..etc
    '''
    try:
        response = urllib2.urlopen(url)

    except HTTPError as e:
        return e.code == code

    except:
        return False

    return response.code == code

def compare_response_code ( url , code ) : try : response = urllib2 . urlopen ( url ) except HTTPError as e : return e . code == code except : return False return response . code == code


def _validate_data(self, source, data, metadata=None):
        """Validate the display data.

        Parameters
        ----------
        source : str
            The fully dotted name of the callable that created the data, like
            :func:`foo.bar.my_formatter`.
        data : dict
            The formata data dictionary.
        metadata : dict
            Any metadata for the data.
        """

        if not isinstance(source, basestring):
            raise TypeError('source must be a str, got: %r' % source)
        if not isinstance(data, dict):
            raise TypeError('data must be a dict, got: %r' % data)
        if metadata is not None:
            if not isinstance(metadata, dict):
                raise TypeError('metadata must be a dict, got: %r' % data)

def
_validate_data
(
self
,
source
,
data
,
metadata
=
)
:
if
not
isinstance
(
source
,
basestring
)
:
raise
TypeError
(
'source must be a str, got: %r'
%
source
)
if
not
isinstance
(
data
,
dict
)
:
raise
TypeError
(
'data must be a dict, got: %r'
%
data
)
if
metadata
is
not
:
if
not
isinstance
(
metadata
,
dict
)
:
raise
TypeError
(
'metadata must be a dict, got: %r'
%
data
)


def clear_output(self, stdout=True, stderr=True, other=True):
        """Clear the output of the cell receiving output."""
        if stdout:
            print('\033[2K\r', file=io.stdout, end='')
            io.stdout.flush()
        if stderr:
            print('\033[2K\r', file=io.stderr, end='')
            io.stderr.flush()

def clear_output ( self , stdout = True , stderr = True , other = True ) : if stdout : print ( '\033[2K\r' , file = io . stdout , end = '' ) io . stdout . flush ( ) if stderr : print ( '\033[2K\r' , file = io . stderr , end = '' ) io . stderr . flush ( )

Clear the output of the cell receiving output .


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
    cmd is `python` return `sys.executable`.

    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'))

    Parameters
    ----------
    cmd : str
        The command line program to look for.
    """
    if cmd == 'python':
        return os.path.abspath(sys.executable)
    try:
        path = _find_cmd(cmd).rstrip()
    except OSError:
        raise FindCmdError('command could not be found: %s' % cmd)
    # which returns empty if not found
    if path == '':
        raise FindCmdError('command could not be found: %s' % cmd)
    return os.path.abspath(path)

def
find_cmd
(
cmd
)
:
if
cmd
==
'python'
:
return
os
.
path
.
abspath
(
sys
.
executable
)
try
:
path
=
_find_cmd
(
cmd
)
.
rstrip
(
)
except
OSError
:
raise
FindCmdError
(
'command could not be found: %s'
%
cmd
)
# which returns empty if not found
if
path
==
''
:
raise
FindCmdError
(
'command could not be found: %s'
%
cmd
)
return
os
.
path
.
abspath
(
path
)

Find absolute path to executable cmd in a cross platform manner .


def code_unit_factory(morfs, file_locator):
    """Construct a list of CodeUnits from polymorphic inputs.

    `morfs` is a module or a filename, or a list of same.

    `file_locator` is a FileLocator that can help resolve filenames.

    Returns a list of CodeUnit objects.

    """
    # Be sure we have a list.
    if not isinstance(morfs, (list, tuple)):
        morfs = [morfs]

    # On Windows, the shell doesn't expand wildcards.  Do it here.
    globbed = []
    for morf in morfs:
        if isinstance(morf, string_class) and ('?' in morf or '*' in morf):
            globbed.extend(glob.glob(morf))
        else:
            globbed.append(morf)
    morfs = globbed

    code_units = [CodeUnit(morf, file_locator) for morf in morfs]

    return code_units

Construct a list of CodeUnits from polymorphic inputs .


def flat_rootname(self):
        """A base for a flat filename to correspond to this code unit.

        Useful for writing files about the code where you want all the files in
        the same directory, but need to differentiate same-named files from
        different directories.

        For example, the file a/b/c.py might return 'a_b_c'

        """
        if self.modname:
            return self.modname.replace('.', '_')
        else:
            root = os.path.splitdrive(self.name)[1]
            return root.replace('\\', '_').replace('/', '_').replace('.', '_')

def flat_rootname ( self ) : if self . modname : return self . modname . replace ( '.' , '_' ) else : root = os . path . splitdrive ( self . name ) [ 1 ] return root . replace ( '\\' , '_' ) . replace ( '/' , '_' ) . replace ( '.' , '_' )

A base for a flat filename to correspond to this code unit .


def source_file(self):
        """Return an open file for reading the source of the code unit."""
        if os.path.exists(self.filename):
            # A regular text file: open it.
            return open_source(self.filename)

        # Maybe it's in a zip file?
        source = self.file_locator.get_zip_data(self.filename)
        if source is not None:
            return StringIO(source)

        # Couldn't find source.
        raise CoverageException(
            "No source for code '%s'." % self.filename
            )

def
source_file
(
self
)
:
if
os
.
path
.
exists
(
self
.
filename
)
:
# A regular text file: open it.
return
open_source
(
self
.
filename
)
# Maybe it's in a zip file?
source
=
self
.
file_locator
.
get_zip_data
(
self
.
filename
)
if
source
is
not
:
return
StringIO
(
source
)
# Couldn't find source.
raise
CoverageException
(
"No source for code '%s'."
%
self
.
filename
)

Return an open file for reading the source of the code unit .


def should_be_python(self):
        """Does it seem like this file should contain Python?

        This is used to decide if a file reported as part of the exection of
        a program was really likely to have contained Python in the first
        place.

        """
        # Get the file extension.
        _, ext = os.path.splitext(self.filename)

        # Anything named *.py* should be Python.
        if ext.startswith('.py'):
            return True
        # A file with no extension should be Python.
        if not ext:
            return True
        # Everything else is probably not Python.
        return False


def _total_seconds(td):
    """timedelta.total_seconds was added in 2.7"""
    try:
        # Python >= 2.7
        return td.total_seconds()
    except AttributeError:
        # Python 2.6
        return 1e-6 * (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6)

def
_total_seconds
(
td
)
:
try
:
# Python >= 2.7
return
td
.
total_seconds
(
)
except
AttributeError
:
# Python 2.6
return
1e-6
*
(
td
.
microseconds
+
(
td
.
seconds
+
td
.
days
*
24
*
3600
)
*
10
**
6
)

timedelta . total_seconds was added in 2 . 7


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
        by get() inside a `RemoteError`.
        """
        if not self.ready():
            self.wait(timeout)

        if self._ready:
            if self._success:
                return self._result
            else:
                raise self._exception
        else:
            raise error.TimeoutError("Result not ready.")

def
get
(
self
,
timeout
=
1
)
:
if
not
self
.
ready
(
)
:
self
.
wait
(
timeout
)
if
self
.
_ready
:
if
self
.
_success
:
return
self
.
_result
else
:
raise
self
.
_exception
else
:
raise
error
.
TimeoutError
(
"Result not 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:
            return
        self._ready = self._client.wait(self.msg_ids, timeout)
        if self._ready:
            try:
                results = map(self._client.results.get, self.msg_ids)
                self._result = results
                if self._single_result:
                    r = results[0]
                    if isinstance(r, Exception):
                        raise r
                else:
                    results = error.collect_exceptions(results, self._fname)
                self._result = self._reconstruct_result(results)
            except Exception, e:
                self._exception = e
                self._success = False
            else:
                self._success = True
            finally:
                self._metadata = map(self._client.metadata.get, self.msg_ids)
                self._wait_for_outputs(10)

def wait ( self , timeout = - 1 ) : if self . _ready : return self . _ready = self . _client . wait ( self . msg_ids , timeout ) if self . _ready : try : results = map ( self . _client . results . get , self . msg_ids ) self . _result = results if self . _single_result : r = results [ 0 ] if isinstance ( r , Exception ) : raise r else : results = error . collect_exceptions ( results , self . _fname ) self . _result = self . _reconstruct_result ( results ) except Exception , e : self . _exception = e self . _success = False else : self . _success = True finally : self . _metadata = map ( self . _client . metadata . get , self . msg_ids ) self . _wait_for_outputs ( 10 )

Wait until the result is available or until timeout seconds pass .


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))
        maxcount = bycount.count(bycount[-1])
        if maxcount > 1:
            raise ValueError("Cannot build dict, %i jobs ran on engine #%i"%(
                    maxcount, bycount[-1]))

        return dict(zip(engine_ids,results))

Get the results as a dict keyed by engine_id .


def abort(self):
        """abort my tasks."""
        assert not self.ready(), "Can't abort, I am already done!"
        return self._client.abort(self.msg_ids, targets=self._targets, block=True)

def
abort
(
self
)
:
assert
not
self
.
ready
(
)
,
"Can't abort, I am already done!"
return
self
.
_client
.
abort
(
self
.
msg_ids
,
targets
=
self
.
_targets
,
block
=
True
)


def elapsed(self):
        """elapsed time since initial submission"""
        if self.ready():
            return self.wall_time

        now = submitted = datetime.now()
        for msg_id in self.msg_ids:
            if msg_id in self._client.metadata:
                stamp = self._client.metadata[msg_id]['submitted']
                if stamp and stamp < submitted:
                    submitted = stamp
        return _total_seconds(now-submitted)

def elapsed ( self ) : if self . ready ( ) : return self . wall_time now = submitted = datetime . now ( ) for msg_id in self . msg_ids : if msg_id in self . _client . metadata : stamp = self . _client . metadata [ msg_id ] [ 'submitted' ] if stamp and stamp < submitted : submitted = stamp return _total_seconds ( now - submitted )


def wait_interactive(self, interval=1., timeout=None):
        """interactive wait, printing progress at regular intervals"""
        N = len(self)
        tic = time.time()
        while not self.ready() and (timeout is None or time.time() - tic <= timeout):
            self.wait(interval)
            clear_output()
            print("%4i/%i tasks finished after %4i s" % (self.progress, N, self.elapsed), end="")
            sys.stdout.flush()
        print()
        print("done")

def
wait_interactive
(
self
,
interval
=
1.
,
timeout
=
)
:
N
=
len
(
self
)
tic
=
time
.
time
(
)
while
not
self
.
ready
(
)
and
(
timeout
is
or
time
.
time
(
)
tic
<=
timeout
)
:
self
.
wait
(
interval
)
clear_output
(
)
print
(
"%4i/%i tasks finished after %4i s"
%
(
self
.
progress
,
N
,
self
.
elapsed
)
,
end
=
""
)
sys
.
stdout
.
flush
(
)
print
(
)
print
(
"done"
)

interactive wait printing progress at regular intervals


def _republish_displaypub(self, content, eid):
        """republish individual displaypub content dicts"""
        try:
            ip = get_ipython()
        except NameError:
            # displaypub is meaningless outside IPython
            return
        md = content['metadata'] or {}
        md['engine'] = eid
        ip.display_pub.publish(content['source'], content['data'], md)


def _wait_for_outputs(self, timeout=-1):
        """wait for the 'status=idle' message that indicates we have all outputs
        """
        if not self._success:
            # don't wait on errors
            return
        tic = time.time()
        while not all(md['outputs_ready'] for md in self._metadata):
            time.sleep(0.01)
            self._client._flush_iopub(self._client._iopub_socket)
            if timeout >= 0 and time.time() > tic + timeout:
                break

def
_wait_for_outputs
(
self
,
timeout
=
1
)
:
if
not
self
.
_success
:
# don't wait on errors
return
tic
=
time
.
time
(
)
while
not
all
(
md
[
'outputs_ready'
]
for
md
in
self
.
_metadata
)
:
time
.
sleep
(
0.01
)
self
.
_client
.
_flush_iopub
(
self
.
_client
.
_iopub_socket
)
if
timeout
>=
0
and
time
.
time
(
)
>
tic
+
timeout
:
break

wait for the status = idle message that indicates we have all outputs


def wait(self, timeout=-1):
        """wait for result to complete."""
        start = time.time()
        if self._ready:
            return
        local_ids = filter(lambda msg_id: msg_id in self._client.outstanding, self.msg_ids)
        local_ready = self._client.wait(local_ids, timeout)
        if local_ready:
            remote_ids = filter(lambda msg_id: msg_id not in self._client.results, self.msg_ids)
            if not remote_ids:
                self._ready = True
            else:
                rdict = self._client.result_status(remote_ids, status_only=False)
                pending = rdict['pending']
                while pending and (timeout < 0 or time.time() < start+timeout):
                    rdict = self._client.result_status(remote_ids, status_only=False)
                    pending = rdict['pending']
                    if pending:
                        time.sleep(0.1)
                if not pending:
                    self._ready = True
        if self._ready:
            try:
                results = map(self._client.results.get, self.msg_ids)
                self._result = results
                if self._single_result:
                    r = results[0]
                    if isinstance(r, Exception):
                        raise r
                else:
                    results = error.collect_exceptions(results, self._fname)
                self._result = self._reconstruct_result(results)
            except Exception, e:
                self._exception = e
                self._success = False
            else:
                self._success = True
            finally:
                self._metadata = map(self._client.metadata.get, self.msg_ids)

def wait ( self , timeout = - 1 ) : start = time . time ( ) if self . _ready : return local_ids = filter ( lambda msg_id : msg_id in self . _client . outstanding , self . msg_ids ) local_ready = self . _client . wait ( local_ids , timeout ) if local_ready : remote_ids = filter ( lambda msg_id : msg_id not in self . _client . results , self . msg_ids ) if not remote_ids : self . _ready = True else : rdict = self . _client . result_status ( remote_ids , status_only = False ) pending = rdict [ 'pending' ] while pending and ( timeout < 0 or time . time ( ) < start + timeout ) : rdict = self . _client . result_status ( remote_ids , status_only = False ) pending = rdict [ 'pending' ] if pending : time . sleep ( 0.1 ) if not pending : self . _ready = True if self . _ready : try : results = map ( self . _client . results . get , self . msg_ids ) self . _result = results if self . _single_result : r = results [ 0 ] if isinstance ( r , Exception ) : raise r else : results = error . collect_exceptions ( results , self . _fname ) self . _result = self . _reconstruct_result ( results ) except Exception , e : self . _exception = e self . _success = False else : self . _success = True finally : self . _metadata = map ( self . _client . metadata . get , self . msg_ids )


def abs_file(filename):
    """Return the absolute normalized form of `filename`."""
    path = os.path.expandvars(os.path.expanduser(filename))
    path = os.path.abspath(os.path.realpath(path))
    path = actual_path(path)
    return path

def abs_file ( filename ) : path = os . path . expandvars ( os . path . expanduser ( filename ) ) path = os . path . abspath ( os . path . realpath ( path ) ) path = actual_path ( path ) return path

Return the absolute normalized form of filename .


def prep_patterns(patterns):
    """Prepare the file patterns for use in a `FnmatchMatcher`.

    If a pattern starts with a wildcard, it is used as a pattern
    as-is.  If it does not start with a wildcard, then it is made
    absolute with the current directory.

    If `patterns` is None, an empty list is returned.

    """
    prepped = []
    for p in patterns or []:
        if p.startswith("*") or p.startswith("?"):
            prepped.append(p)
        else:
            prepped.append(abs_file(p))
    return prepped

def prep_patterns ( patterns ) : prepped = [ ] for p in patterns or [ ] : if p . startswith ( "*" ) or p . startswith ( "?" ) : prepped . append ( p ) else : prepped . append ( abs_file ( p ) ) return prepped

Prepare the file patterns for use in a FnmatchMatcher .


def sep(s):
    """Find the path separator used in this string, or os.sep if none."""
    sep_match = re.search(r"[\\/]", s)
    if sep_match:
        the_sep = sep_match.group(0)
    else:
        the_sep = os.sep
    return the_sep

def sep ( s ) : sep_match = re . search ( r"[\\/]" , s ) if sep_match : the_sep = sep_match . group ( 0 ) else : the_sep = os . sep return the_sep

Find the path separator used in this string or os . sep if none .


def find_python_files(dirname):
    """Yield all of the importable Python files in `dirname`, recursively.

    To be importable, the files have to be in a directory with a __init__.py,
    except for `dirname` itself, which isn't required to have one.  The
    assumption is that `dirname` was specified directly, so the user knows
    best, but subdirectories are checked for a __init__.py to be sure we only
    find the importable files.

    """
    for i, (dirpath, dirnames, filenames) in enumerate(os.walk(dirname)):
        if i > 0 and '__init__.py' not in filenames:
            # If a directory doesn't have __init__.py, then it isn't
            # importable and neither are its files
            del dirnames[:]
            continue
        for filename in filenames:
            # We're only interested in files that look like reasonable Python
            # files: Must end with .py or .pyw, and must not have certain funny
            # characters that probably mean they are editor junk.
            if re.match(r"^[^.#~!$@%^&*()+=,]+\.pyw?$", filename):
                yield os.path.join(dirpath, filename)

Yield all of the importable Python files in dirname recursively .


def relative_filename(self, filename):
        """Return the relative form of `filename`.

        The filename will be relative to the current directory when the
        `FileLocator` was constructed.

        """
        fnorm = os.path.normcase(filename)
        if fnorm.startswith(self.relative_dir):
            filename = filename[len(self.relative_dir):]
        return filename

def relative_filename ( self , filename ) : fnorm = os . path . normcase ( filename ) if fnorm . startswith ( self . relative_dir ) : filename = filename [ len ( self . relative_dir ) : ] return filename


def canonical_filename(self, filename):
        """Return a canonical filename for `filename`.

        An absolute path with no redundant components and normalized case.

        """
        if filename not in self.canonical_filename_cache:
            if not os.path.isabs(filename):
                for path in [os.curdir] + sys.path:
                    if path is None:
                        continue
                    f = os.path.join(path, filename)
                    if os.path.exists(f):
                        filename = f
                        break
            cf = abs_file(filename)
            self.canonical_filename_cache[filename] = cf
        return self.canonical_filename_cache[filename]

def canonical_filename ( self , filename ) : if filename not in self . canonical_filename_cache : if not os . path . isabs ( filename ) : for path in [ os . curdir ] + sys . path : if path is None : continue f = os . path . join ( path , filename ) if os . path . exists ( f ) : filename = f break cf = abs_file ( filename ) self . canonical_filename_cache [ filename ] = cf return self . canonical_filename_cache [ filename ]

Return a canonical filename for filename .


def get_zip_data(self, filename):
        """Get data from `filename` if it is a zip file path.

        Returns the string data read from the zip file, or None if no zip file
        could be found or `filename` isn't in it.  The data returned will be
        an empty string if the file is empty.

        """
        import zipimport
        markers = ['.zip'+os.sep, '.egg'+os.sep]
        for marker in markers:
            if marker in filename:
                parts = filename.split(marker)
                try:
                    zi = zipimport.zipimporter(parts[0]+marker[:-1])
                except zipimport.ZipImportError:
                    continue
                try:
                    data = zi.get_data(parts[1])
                except IOError:
                    continue
                return to_string(data)
        return None

def get_zip_data ( self , filename ) : import zipimport markers = [ '.zip' + os . sep , '.egg' + os . sep ] for marker in markers : if marker in filename : parts = filename . split ( marker ) try : zi = zipimport . zipimporter ( parts [ 0 ] + marker [ : - 1 ] ) except zipimport . ZipImportError : continue try : data = zi . get_data ( parts [ 1 ] ) except IOError : continue return to_string ( data ) return None

Get data from filename if it is a zip file path .


def match(self, fpath):
        """Does `fpath` indicate a file in one of our trees?"""
        for d in self.dirs:
            if fpath.startswith(d):
                if fpath == d:
                    # This is the same file!
                    return True
                if fpath[len(d)] == os.sep:
                    # This is a file in the directory
                    return True
        return False

def
match
(
self
,
fpath
)
:
for
d
in
self
.
dirs
:
if
fpath
.
startswith
(
d
)
:
if
fpath
==
d
:
# This is the same file!
return
True
if
fpath
[
len
(
d
)
]
==
os
.
sep
:
# This is a file in the directory
return
True
return
False

Does fpath indicate a file in one of our trees?


def match(self, fpath):
        """Does `fpath` match one of our filename patterns?"""
        for pat in self.pats:
            if fnmatch.fnmatch(fpath, pat):
                return True
        return False

def match ( self , fpath ) : for pat in self . pats : if fnmatch . fnmatch ( fpath , pat ) : return True return False

Does fpath match one of our filename patterns?


def map(self, path):
        """Map `path` through the aliases.

        `path` is checked against all of the patterns.  The first pattern to
        match is used to replace the root of the path with the result root.
        Only one pattern is ever used.  If no patterns match, `path` is
        returned unchanged.

        The separator style in the result is made to match that of the result
        in the alias.

        """
        for regex, result, pattern_sep, result_sep in self.aliases:
            m = regex.match(path)
            if m:
                new = path.replace(m.group(0), result)
                if pattern_sep != result_sep:
                    new = new.replace(pattern_sep, result_sep)
                if self.locator:
                    new = self.locator.canonical_filename(new)
                return new
        return path

def map ( self , path ) : for regex , result , pattern_sep , result_sep in self . aliases : m = regex . match ( path ) if m : new = path . replace ( m . group ( 0 ) , result ) if pattern_sep != result_sep : new = new . replace ( pattern_sep , result_sep ) if self . locator : new = self . locator . canonical_filename ( new ) return new return path


def loop_qt4(kernel):
    """Start a kernel with PyQt4 event loop integration."""

    from IPython.external.qt_for_kernel import QtCore
    from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4

    kernel.app = get_app_qt4([" "])
    kernel.app.setQuitOnLastWindowClosed(False)
    kernel.timer = QtCore.QTimer()
    kernel.timer.timeout.connect(kernel.do_one_iteration)
    # Units for the timer are in milliseconds
    kernel.timer.start(1000*kernel._poll_interval)
    start_event_loop_qt4(kernel.app)

Start a kernel with PyQt4 event loop integration .


def loop_wx(kernel):
    """Start a kernel with wx event loop support."""

    import wx
    from IPython.lib.guisupport import start_event_loop_wx

    doi = kernel.do_one_iteration
     # Wx uses milliseconds
    poll_interval = int(1000*kernel._poll_interval)

    # We have to put the wx.Timer in a wx.Frame for it to fire properly.
    # We make the Frame hidden when we create it in the main app below.
    class TimerFrame(wx.Frame):
        def __init__(self, func):
            wx.Frame.__init__(self, None, -1)
            self.timer = wx.Timer(self)
            # Units for the timer are in milliseconds
            self.timer.Start(poll_interval)
            self.Bind(wx.EVT_TIMER, self.on_timer)
            self.func = func

        def on_timer(self, event):
            self.func()

    # We need a custom wx.App to create our Frame subclass that has the
    # wx.Timer to drive the ZMQ event loop.
    class IPWxApp(wx.App):
        def OnInit(self):
            self.frame = TimerFrame(doi)
            self.frame.Show(False)
            return True

    # The redirect=False here makes sure that wx doesn't replace
    # sys.stdout/stderr with its own classes.
    kernel.app = IPWxApp(redirect=False)

    # The import of wx on Linux sets the handler for signal.SIGINT
    # to 0.  This is a bug in wx or gtk.  We fix by just setting it
    # back to the Python default.
    import signal
    if not callable(signal.getsignal(signal.SIGINT)):
        signal.signal(signal.SIGINT, signal.default_int_handler)

    start_event_loop_wx(kernel.app)

Start a kernel with wx event loop support .


def loop_tk(kernel):
    """Start a kernel with the Tk event loop."""

    import Tkinter
    doi = kernel.do_one_iteration
    # Tk uses milliseconds
    poll_interval = int(1000*kernel._poll_interval)
    # For Tkinter, we create a Tk object and call its withdraw method.
    class Timer(object):
        def __init__(self, func):
            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()

    kernel.timer = Timer(doi)
    kernel.timer.start()


def loop_gtk(kernel):
    """Start the kernel, coordinating with the GTK event loop"""
    from .gui.gtkembed import GTKEmbed

    gtk_kernel = GTKEmbed(kernel)
    gtk_kernel.start()

def loop_gtk ( kernel ) : from . gui . gtkembed import GTKEmbed gtk_kernel = GTKEmbed ( kernel ) gtk_kernel . start ( )

Start the kernel coordinating with the GTK event loop


def loop_cocoa(kernel):
    """Start the kernel, coordinating with the Cocoa CFRunLoop event loop
    via the matplotlib MacOSX backend.
    """
    import matplotlib
    if matplotlib.__version__ < '1.1.0':
        kernel.log.warn(
        "MacOSX backend in matplotlib %s doesn't have a Timer, "
        "falling back on Tk for CFRunLoop integration.  Note that "
        "even this won't work if Tk is linked against X11 instead of "
        "Cocoa (e.g. EPD).  To use the MacOSX backend in the kernel, "
        "you must use matplotlib >= 1.1.0, or a native libtk."
        )
        return loop_tk(kernel)

    from matplotlib.backends.backend_macosx import TimerMac, show

    # scale interval for sec->ms
    poll_interval = int(1000*kernel._poll_interval)

    real_excepthook = sys.excepthook
    def handle_int(etype, value, tb):
        """don't let KeyboardInterrupts look like crashes"""
        if etype is KeyboardInterrupt:
            io.raw_print("KeyboardInterrupt caught in CFRunLoop")
        else:
            real_excepthook(etype, value, tb)

    # add doi() as a Timer to the CFRunLoop
    def doi():
        # restore excepthook during IPython code
        sys.excepthook = real_excepthook
        kernel.do_one_iteration()
        # and back:
        sys.excepthook = handle_int

    t = TimerMac(poll_interval)
    t.add_callback(doi)
    t.start()

    # but still need a Poller for when there are no active windows,
    # during which time mainloop() returns immediately
    poller = zmq.Poller()
    if kernel.control_stream:
        poller.register(kernel.control_stream.socket, zmq.POLLIN)
    for stream in kernel.shell_streams:
        poller.register(stream.socket, zmq.POLLIN)

    while True:
        try:
            # double nested try/except, to properly catch KeyboardInterrupt
            # due to pyzmq Issue #130
            try:
                # don't let interrupts during mainloop invoke crash_handler:
                sys.excepthook = handle_int
                show.mainloop()
                sys.excepthook = real_excepthook
                # use poller if mainloop returned (no windows)
                # scale by extra factor of 10, since it's a real poll
                poller.poll(10*poll_interval)
                kernel.do_one_iteration()
            except:
                raise
        except KeyboardInterrupt:
            # Ctrl-C shouldn't crash the kernel
            io.raw_print("KeyboardInterrupt caught in kernel")
        finally:
            # ensure excepthook is restored
            sys.excepthook = real_excepthook

Start the kernel coordinating with the Cocoa CFRunLoop event loop via the matplotlib MacOSX backend .


def enable_gui(gui, kernel=None):
    """Enable integration with a given GUI"""
    if gui not in loop_map:
        raise ValueError("GUI %r not supported" % gui)
    if kernel is None:
        if Application.initialized():
            kernel = getattr(Application.instance(), 'kernel', None)
        if kernel is None:
            raise RuntimeError("You didn't specify a kernel,"
                " and no IPython Application with a kernel appears to be running."
            )
    loop = loop_map[gui]
    if kernel.eventloop is not None and kernel.eventloop is not loop:
        raise RuntimeError("Cannot activate multiple GUI eventloops")
    kernel.eventloop = loop


def GOE(N):
    """Creates an NxN element of the Gaussian Orthogonal Ensemble"""
    m = ra.standard_normal((N,N))
    m += m.T
    return m/2

def GOE ( N ) : m = ra . standard_normal ( ( N , N ) ) m += m . T return m / 2


def center_eigenvalue_diff(mat):
    """Compute the eigvals of mat and then find the center eigval difference."""
    N = len(mat)
    evals = np.sort(la.eigvals(mat))
    diff = np.abs(evals[N/2] - evals[N/2-1])
    return diff

def center_eigenvalue_diff ( mat ) : N = len ( mat ) evals = np . sort ( la . eigvals ( mat ) ) diff = np . abs ( evals [ N / 2 ] - evals [ N / 2 - 1 ] ) return diff

Compute the eigvals of mat and then find the center eigval difference .


def ensemble_diffs(num, N):
    """Return num eigenvalue diffs for the NxN GOE ensemble."""
    diffs = np.empty(num)
    for i in xrange(num):
        mat = GOE(N)
        diffs[i] = center_eigenvalue_diff(mat)
    return diffs

def ensemble_diffs ( num , N ) : diffs = np . empty ( num ) for i in xrange ( num ) : mat = GOE ( N ) diffs [ i ] = center_eigenvalue_diff ( mat ) return diffs

Return num eigenvalue diffs for the NxN GOE ensemble .


def init(self, ctxt, step_addr):
        """
        Initialize the item.  This calls the class constructor with the
        appropriate arguments and returns the initialized object.

        :param ctxt: The context object.
        :param step_addr: The address of the step in the test
                          configuration.
        """

        return self.cls(ctxt, self.name, self.conf, step_addr)

def init ( self , ctxt , step_addr ) : return self . cls ( ctxt , self . name , self . conf , step_addr )

Initialize the item . This calls the class constructor with the appropriate arguments and returns the initialized object .


def parse_file(cls, ctxt, fname, key=None, step_addr=None):
        """
        Parse a YAML file containing test steps.

        :param ctxt: The context object.
        :param fname: The name of the file to parse.
        :param key: An optional dictionary key.  If specified, the
                    file must be a YAML dictionary, and the referenced
                    value will be interpreted as a list of steps.  If
                    not provided, the file must be a YAML list, which
                    will be interpreted as the list of steps.
        :param step_addr: The address of the step in the test
                          configuration.  This may be used in the case
                          of includes, for instance.

        :returns: A list of ``Step`` objects.
        """

        # Load the YAML file
        try:
            with open(fname) as f:
                step_data = yaml.load(f)
        except Exception as exc:
            raise ConfigError(
                'Failed to read file "%s": %s' % (fname, exc),
                step_addr,
            )

        # Do we have a key?
        if key is not None:
            if (not isinstance(step_data, collections.Mapping) or
                    key not in step_data):
                raise ConfigError(
                    'Bad step configuration file "%s": expecting dictionary '
                    'with key "%s"' % (fname, key),
                    step_addr,
                )

            # Extract just the step data
            step_data = step_data[key]

        # Validate that it's a sequence
        if not isinstance(step_data, collections.Sequence):
            addr = ('%s[%s]' % (fname, key)) if key is not None else fname
            raise ConfigError(
                'Bad step configuration sequence at %s: expecting list, '
                'not "%s"' % (addr, step_data.__class__.__name__),
                step_addr,
            )

        # OK, assemble the step list and return it
        steps = []
        for idx, step_conf in enumerate(step_data):
            steps.extend(cls.parse_step(
                ctxt, StepAddress(fname, idx, key), step_conf))

        return steps

Parse a YAML file containing test steps .


def parse_step(cls, ctxt, step_addr, step_conf):
        """
        Parse a step dictionary.

        :param ctxt: The context object.
        :param step_addr: The address of the step in the test
                          configuration.
        :param step_conf: The description of the step.  This may be a
                          scalar string or a dictionary.

        :returns: A list of steps.
        """

        # Make sure the step makes sense
        if isinstance(step_conf, six.string_types):
            # Convert string to a dict for uniformity of processing
            step_conf = {step_conf: None}
        elif not isinstance(step_conf, collections.Mapping):
            raise ConfigError(
                'Unable to parse step configuration: expecting string or '
                'dictionary, not "%s"' % step_conf.__class__.__name__,
                step_addr,
            )

        # Parse the configuration into the action and modifier classes
        # and the configuration to apply to each
        action_item = None
        mod_items = {}
        kwargs = {}  # extra args for Step.__init__()
        for key, key_conf in step_conf.items():
            # Handle special keys first
            if key in cls.schemas:
                # Validate the key
                utils.schema_validate(key_conf, cls.schemas[key], ConfigError,
                                      key, step_addr=step_addr)

                # Save the value
                kwargs[key] = key_conf

            # Is it an action?
            elif key in entry.points[NAMESPACE_ACTION]:
                if action_item is not None:
                    raise ConfigError(
                        'Bad step configuration: action "%s" specified, '
                        'but action "%s" already processed' %
                        (key, action_item.name),
                        step_addr,
                    )

                action_item = StepItem(
                    entry.points[NAMESPACE_ACTION][key], key, key_conf)

            # OK, is it a modifier?
            elif key in entry.points[NAMESPACE_MODIFIER]:
                mod_class = entry.points[NAMESPACE_MODIFIER][key]

                # Store it in priority order
                mod_items.setdefault(mod_class.priority, [])
                mod_items[mod_class.priority].append(StepItem(
                    mod_class, key, key_conf))

            # Couldn't resolve it
            else:
                raise ConfigError(
                    'Bad step configuration: unable to resolve action '
                    '"%s"' % key,
                    step_addr,
                )

        # Make sure we have an action
        if action_item is None:
            raise ConfigError(
                'Bad step configuration: no action specified',
                step_addr,
            )

        # What is the action type?
        action_type = (Modifier.STEP if action_item.cls.step_action
                       else Modifier.NORMAL)

        # OK, build our modifiers list and preprocess the action
        # configuration
        modifiers = []
        for mod_item in utils.iter_prio_dict(mod_items):
            # Verify that the modifier is compatible with the
            # action
            if mod_item.cls.restriction & action_type == 0:
                raise ConfigError(
                    'Bad step configuration: modifier "%s" is '
                    'incompatible with the action "%s"' %
                    (mod_item.name, action_item.name),
                    step_addr,
                )

            # Initialize the modifier
            modifier = mod_item.init(ctxt, step_addr)

            # Add it to the list of modifiers
            modifiers.append(modifier)

            # Apply the modifier's configuration processing
            action_item.conf = modifier.action_conf(
                ctxt, action_item.cls, action_item.name, action_item.conf,
                step_addr)

        # Now we can initialize the action
        action = action_item.init(ctxt, step_addr)

        # Create the step
        step = cls(step_addr, action, modifiers, **kwargs)

        # If the final_action is a StepAction, invoke it now and
        # return the list of steps.  We do this after creating the
        # Step object so that we can take advantage of its handling of
        # modifiers.
        if action_item.cls.step_action:
            return step(ctxt)

        # Not a step action, return the step as a list of one element
        return [step]


def init_crash_handler(self):
        """Create a crash handler, typically setting sys.excepthook to it."""
        self.crash_handler = self.crash_handler_class(self)
        sys.excepthook = self.excepthook
        def unset_crashhandler():
            sys.excepthook = sys.__excepthook__
        atexit.register(unset_crashhandler)

def init_crash_handler ( self ) : self . crash_handler = self . crash_handler_class ( self ) sys . excepthook = self . excepthook def unset_crashhandler ( ) : sys . excepthook = sys . __excepthook__ atexit . register ( unset_crashhandler )

Create a crash handler typically setting sys . excepthook to it .


def load_config_file(self, suppress_errors=True):
        """Load the config file.

        By default, errors in loading config are handled, and a warning
        printed on screen. For testing, the suppress_errors option is set
        to False, so errors will make tests fail.
        """
        self.log.debug("Searching path %s for config files", self.config_file_paths)
        base_config = 'ipython_config.py'
        self.log.debug("Attempting to load config file: %s" %
                       base_config)
        try:
            Application.load_config_file(
                self,
                base_config,
                path=self.config_file_paths
            )
        except ConfigFileNotFound:
            # ignore errors loading parent
            self.log.debug("Config file %s not found", base_config)
            pass
        if self.config_file_name == base_config:
            # don't load secondary config
            return
        self.log.debug("Attempting to load config file: %s" %
                       self.config_file_name)
        try:
            Application.load_config_file(
                self,
                self.config_file_name,
                path=self.config_file_paths
            )
        except ConfigFileNotFound:
            # Only warn if the default config file was NOT being used.
            if self.config_file_specified:
                msg = self.log.warn
            else:
                msg = self.log.debug
            msg("Config file not found, skipping: %s", self.config_file_name)
        except:
            # For testing purposes.
            if not suppress_errors:
                raise
            self.log.warn("Error loading config file: %s" %
                          self.config_file_name, exc_info=True)


def init_profile_dir(self):
        """initialize the profile dir"""
        try:
            # location explicitly specified:
            location = self.config.ProfileDir.location
        except AttributeError:
            # location not specified, find by profile name
            try:
                p = ProfileDir.find_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
            except ProfileDirError:
                # not found, maybe create it (always create default profile)
                if self.auto_create or self.profile=='default':
                    try:
                        p = ProfileDir.create_profile_dir_by_name(self.ipython_dir, self.profile, self.config)
                    except ProfileDirError:
                        self.log.fatal("Could not create profile: %r"%self.profile)
                        self.exit(1)
                    else:
                        self.log.info("Created profile dir: %r"%p.location)
                else:
                    self.log.fatal("Profile %r not found."%self.profile)
                    self.exit(1)
            else:
                self.log.info("Using existing profile dir: %r"%p.location)
        else:
            # location is fully specified
            try:
                p = ProfileDir.find_profile_dir(location, self.config)
            except ProfileDirError:
                # not found, maybe create it
                if self.auto_create:
                    try:
                        p = ProfileDir.create_profile_dir(location, self.config)
                    except ProfileDirError:
                        self.log.fatal("Could not create profile directory: %r"%location)
                        self.exit(1)
                    else:
                        self.log.info("Creating new profile dir: %r"%location)
                else:
                    self.log.fatal("Profile directory %r not found."%location)
                    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 stage_default_config_file(self):
        """auto generate default config file, and stage it into the profile."""
        s = self.generate_config_file()
        fname = os.path.join(self.profile_dir.location, self.config_file_name)
        if self.overwrite or not os.path.exists(fname):
            self.log.warn("Generating default config file: %r"%(fname))
            with open(fname, 'w') as f:
                f.write(s)

def
stage_default_config_file
(
self
)
:
s
=
self
.
generate_config_file
(
)
fname
=
os
.
path
.
join
(
self
.
profile_dir
.
location
,
self
.
config_file_name
)
if
self
.
overwrite
or
not
os
.
path
.
exists
(
fname
)
:
self
.
log
.
warn
(
"Generating default config file: %r"
%
(
fname
)
)
with
open
(
fname
,
'w'
)
as
f
:
f
.
write
(
s
)

auto generate default config file and stage it into the profile .


def write(self, suffix=None):
        """Write the collected coverage data to a file.

        `suffix` is a suffix to append to the base file name. This can be used
        for multiple or parallel execution, so that many coverage data files
        can exist simultaneously.  A dot will be used to join the base name and
        the suffix.

        """
        if self.use_file:
            filename = self.filename
            if suffix:
                filename += "." + suffix
            self.write_file(filename)

def write ( self , suffix = None ) : if self . use_file : filename = self . filename if suffix : filename += "." + suffix self . write_file ( filename )

Write the collected coverage data to a file .


def erase(self):
        """Erase the data, both in this object, and from its file storage."""
        if self.use_file:
            if self.filename:
                file_be_gone(self.filename)
        self.lines = {}
        self.arcs = {}

def erase ( self ) : if self . use_file : if self . filename : file_be_gone ( self . filename ) self . lines = { } self . arcs = { }

Erase the data both in this object and from its file storage .


def line_data(self):
        """Return the map from filenames to lists of line numbers executed."""
        return dict(
            [(f, sorted(lmap.keys())) for f, lmap in iitems(self.lines)]
            )

def line_data ( self ) : return dict ( [ ( f , sorted ( lmap . keys ( ) ) ) for f , lmap in iitems ( self . lines ) ] )

Return the map from filenames to lists of line numbers executed .


def arc_data(self):
        """Return the map from filenames to lists of line number pairs."""
        return dict(
            [(f, sorted(amap.keys())) for f, amap in iitems(self.arcs)]
            )

def arc_data ( self ) : return dict ( [ ( f , sorted ( amap . keys ( ) ) ) for f , amap in iitems ( self . arcs ) ] )

Return the map from filenames to lists of line number pairs .


def write_file(self, filename):
        """Write the coverage data to `filename`."""

        # Create the file data.
        data = {}

        data['lines'] = self.line_data()
        arcs = self.arc_data()
        if arcs:
            data['arcs'] = arcs

        if self.collector:
            data['collector'] = self.collector

        if self.debug and self.debug.should('dataio'):
            self.debug.write("Writing data to %r" % (filename,))

        # Write the pickle to the file.
        fdata = open(filename, 'wb')
        try:
            pickle.dump(data, fdata, 2)
        finally:
            fdata.close()

def
write_file
(
self
,
filename
)
:
# Create the file data.
data
=
{
}
data
[
'lines'
]
=
self
.
line_data
(
)
arcs
=
self
.
arc_data
(
)
if
arcs
:
data
[
'arcs'
]
=
arcs
if
self
.
collector
:
data
[
'collector'
]
=
self
.
collector
if
self
.
debug
and
self
.
debug
.
should
(
'dataio'
)
:
self
.
debug
.
write
(
"Writing data to %r"
%
(
filename
,
)
)
# Write the pickle to the file.
fdata
=
open
(
filename
,
'wb'
)
try
:
pickle
.
dump
(
data
,
fdata
,
2
)
finally
:
fdata
.
close
(
)


def read_file(self, filename):
        """Read the coverage data from `filename`."""
        self.lines, self.arcs = self._read_file(filename)

def read_file ( self , filename ) : self . lines , self . arcs = self . _read_file ( filename )


def raw_data(self, filename):
        """Return the raw pickled data from `filename`."""
        if self.debug and self.debug.should('dataio'):
            self.debug.write("Reading data from %r" % (filename,))
        fdata = open(filename, 'rb')
        try:
            data = pickle.load(fdata)
        finally:
            fdata.close()
        return data

def
raw_data
(
self
,
filename
)
:
if
self
.
debug
and
self
.
debug
.
should
(
'dataio'
)
:
self
.
debug
.
write
(
"Reading data from %r"
%
(
filename
,
)
)
fdata
=
open
(
filename
,
'rb'
)
try
:
data
=
pickle
.
load
(
fdata
)
finally
:
fdata
.
close
(
)
return
data

Return the raw pickled data from filename .


def _read_file(self, filename):
        """Return the stored coverage data from the given file.

        Returns two values, suitable for assigning to `self.lines` and
        `self.arcs`.

        """
        lines = {}
        arcs = {}
        try:
            data = self.raw_data(filename)
            if isinstance(data, dict):
                # Unpack the 'lines' item.
                lines = dict([
                    (f, dict.fromkeys(linenos, None))
                        for f, linenos in iitems(data.get('lines', {}))
                    ])
                # Unpack the 'arcs' item.
                arcs = dict([
                    (f, dict.fromkeys(arcpairs, None))
                        for f, arcpairs in iitems(data.get('arcs', {}))
                    ])
        except Exception:
            pass
        return lines, arcs

def
_read_file
(
self
,
filename
)
:
lines
=
{
}
arcs
=
{
}
try
:
data
=
self
.
raw_data
(
filename
)
if
isinstance
(
data
,
dict
)
:
# Unpack the 'lines' item.
lines
=
dict
(
[
(
f
,
dict
.
fromkeys
(
linenos
,
)
)
for
f
,
linenos
in
iitems
(
data
.
get
(
'lines'
,
{
}
)
)
]
)
# Unpack the 'arcs' item.
arcs
=
dict
(
[
(
f
,
dict
.
fromkeys
(
arcpairs
,
)
)
for
f
,
arcpairs
in
iitems
(
data
.
get
(
'arcs'
,
{
}
)
)
]
)
except
Exception
:
pass
return
lines
,
arcs

Return the stored coverage data from the given file .


def combine_parallel_data(self, aliases=None):
        """Combine a number of data files together.

        Treat `self.filename` as a file prefix, and combine the data from all
        of the data files starting with that prefix plus a dot.

        If `aliases` is provided, it's a `PathAliases` object that is used to
        re-map paths to match the local machine's.

        """
        aliases = aliases or PathAliases()
        data_dir, local = os.path.split(self.filename)
        localdot = local + '.'
        for f in os.listdir(data_dir or '.'):
            if f.startswith(localdot):
                full_path = os.path.join(data_dir, f)
                new_lines, new_arcs = self._read_file(full_path)
                for filename, file_data in iitems(new_lines):
                    filename = aliases.map(filename)
                    self.lines.setdefault(filename, {}).update(file_data)
                for filename, file_data in iitems(new_arcs):
                    filename = aliases.map(filename)
                    self.arcs.setdefault(filename, {}).update(file_data)
                if f != local:
                    os.remove(full_path)

def combine_parallel_data ( self , aliases = None ) : aliases = aliases or PathAliases ( ) data_dir , local = os . path . split ( self . filename ) localdot = local + '.' for f in os . listdir ( data_dir or '.' ) : if f . startswith ( localdot ) : full_path = os . path . join ( data_dir , f ) new_lines , new_arcs = self . _read_file ( full_path ) for filename , file_data in iitems ( new_lines ) : filename = aliases . map ( filename ) self . lines . setdefault ( filename , { } ) . update ( file_data ) for filename , file_data in iitems ( new_arcs ) : filename = aliases . map ( filename ) self . arcs . setdefault ( filename , { } ) . update ( file_data ) if f != local : os . remove ( full_path )

Combine a number of data files together .


def add_line_data(self, line_data):
        """Add executed line data.

        `line_data` is { filename: { lineno: None, ... }, ...}

        """
        for filename, linenos in iitems(line_data):
            self.lines.setdefault(filename, {}).update(linenos)

def add_line_data ( self , line_data ) : for filename , linenos in iitems ( line_data ) : self . lines . setdefault ( filename , { } ) . update ( linenos )


def add_arc_data(self, arc_data):
        """Add measured arc data.

        `arc_data` is { filename: { (l1,l2): None, ... }, ...}

        """
        for filename, arcs in iitems(arc_data):
            self.arcs.setdefault(filename, {}).update(arcs)

def add_arc_data ( self , arc_data ) : for filename , arcs in iitems ( arc_data ) : self . arcs . setdefault ( filename , { } ) . update ( arcs )


def add_to_hash(self, filename, hasher):
        """Contribute `filename`'s data to the Md5Hash `hasher`."""
        hasher.update(self.executed_lines(filename))
        hasher.update(self.executed_arcs(filename))

def add_to_hash ( self , filename , hasher ) : hasher . update ( self . executed_lines ( filename ) ) hasher . update ( self . executed_arcs ( filename ) )

Contribute filename s data to the Md5Hash hasher .


def summary(self, fullpath=False):
        """Return a dict summarizing the coverage data.

        Keys are based on the filenames, and values are the number of executed
        lines.  If `fullpath` is true, then the keys are the full pathnames of
        the files, otherwise they are the basenames of the files.

        """
        summ = {}
        if fullpath:
            filename_fn = lambda f: f
        else:
            filename_fn = os.path.basename
        for filename, lines in iitems(self.lines):
            summ[filename_fn(filename)] = len(lines)
        return summ

def summary ( self , fullpath = False ) : summ = { } if fullpath : filename_fn = lambda f : f else : filename_fn = os . path . basename for filename , lines in iitems ( self . lines ) : summ [ filename_fn ( filename ) ] = len ( lines ) return summ

Return a dict summarizing the coverage data .


def get_pasted_lines(sentinel, l_input=py3compat.input):
    """ Yield pasted lines until the user enters the given sentinel value.
    """
    print "Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." \
          % sentinel
    while True:
        try:
            l = l_input(':')
            if l == sentinel:
                return
            else:
                yield l
        except EOFError:
            print '<EOF>'
            return

Yield pasted lines until the user enters the given sentinel value .


def mainloop(self, display_banner=None):
        """Start the mainloop.

        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
                except KeyboardInterrupt:
                    # this should not be necessary, but KeyboardInterrupt
                    # handling seems rather unpredictable...
                    self.write("\nKeyboardInterrupt in interact()\n")


def _replace_rlhist_multiline(self, source_raw, hlen_before_cell):
        """Store multiple lines as a single entry in history"""

        # do nothing without readline or disabled multiline
        if not self.has_readline or not self.multiline_history:
            return hlen_before_cell

        # windows rl has no remove_history_item
        if not hasattr(self.readline, "remove_history_item"):
            return hlen_before_cell

        # skip empty cells
        if not source_raw.rstrip():
            return hlen_before_cell

        # nothing changed do nothing, e.g. when rl removes consecutive dups
        hlen = self.readline.get_current_history_length()
        if hlen == hlen_before_cell:
            return hlen_before_cell

        for i in range(hlen - hlen_before_cell):
            self.readline.remove_history_item(hlen - i - 1)
        stdin_encoding = get_stream_enc(sys.stdin, 'utf-8')
        self.readline.add_history(py3compat.unicode_to_str(source_raw.rstrip(),
                                    stdin_encoding))
        return self.readline.get_current_history_length()


def raw_input(self, prompt=''):
        """Write a prompt and read a line.

        The returned line does not include the trailing newline.
        When the user enters the EOF key sequence, EOFError is raised.

        Optional inputs:

          - prompt(''): a string to be printed to prompt the user.

          - continue_prompt(False): whether this line is the first one or a
          continuation in a sequence of inputs.
        """
        # Code run by the user may have modified the readline completer state.
        # We must ensure that our completer is back in place.

        if self.has_readline:
            self.set_readline_completer()

        # raw_input expects str, but we pass it unicode sometimes
        prompt = py3compat.cast_bytes_py2(prompt)

        try:
            line = py3compat.str_to_unicode(self.raw_input_original(prompt))
        except ValueError:
            warn("\n********\nYou or a %run:ed script called sys.stdin.close()"
                 " or sys.stdout.close()!\nExiting IPython!\n")
            self.ask_exit()
            return ""

        # Try to be reasonably smart about not re-indenting pasted input more
        # than necessary.  We do this by trimming out the auto-indent initial
        # spaces, if the user's actual input started itself with whitespace.
        if self.autoindent:
            if num_ini_spaces(line) > self.indent_current_nsp:
                line = line[self.indent_current_nsp:]
                self.indent_current_nsp = 0

        return line


def edit_syntax_error(self):
        """The bottom half of the syntax error handler called in the main loop.

        Loop until syntax error is fixed or user cancels.
        """

        while self.SyntaxTB.last_syntax_error:
            # copy and clear last_syntax_error
            err = self.SyntaxTB.clear_err_state()
            if not self._should_recompile(err):
                return
            try:
                # may set last_syntax_error again if a SyntaxError is raised
                self.safe_execfile(err.filename,self.user_ns)
            except:
                self.showtraceback()
            else:
                try:
                    f = open(err.filename)
                    try:
                        # This should be inside a display_trap block and I
                        # think it is.
                        sys.displayhook(f.read())
                    finally:
                        f.close()
                except:
                    self.showtraceback()

The bottom half of the syntax error handler called in the main loop .


def _should_recompile(self,e):
        """Utility routine for edit_syntax_error"""

        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
        except EOFError:
            return False

        def int0(x):
            try:
                return int(x)
            except TypeError:
                return 0
        # always pass integer line and offset values to editor hook
        try:
            self.hooks.fix_error_editor(e.filename,
                int0(e.lineno),int0(e.offset),e.msg)
        except TryNext:
            warn('Could not open editor')
            return False
        return True


def exit(self):
        """Handle interactive exit.

        This method calls the ask_exit callback."""
        if self.confirm_exit:
            if self.ask_yes_no('Do you really want to exit ([y]/n)?','y'):
                self.ask_exit()
        else:
            self.ask_exit()

def
exit
(
self
)
:
if
self
.
confirm_exit
:
if
self
.
ask_yes_no
(
'Do you really want to exit ([y]/n)?'
,
'y'
)
:
self
.
ask_exit
(
)
else
:
self
.
ask_exit
(
)


def get_url_rev(self):
        """
        Returns the correct repository URL and revision by parsing the given
        repository URL
        """
        error_message= (
           "Sorry, '%s' is a malformed VCS url. "
           "Ihe format is <vcs>+<protocol>://<url>, "
           "e.g. svn+http://myrepo/svn/MyApp#egg=MyApp")
        assert '+' in self.url, error_message % self.url
        url = self.url.split('+', 1)[1]
        scheme, netloc, path, query, frag = urlparse.urlsplit(url)
        rev = None
        if '@' in path:
            path, rev = path.rsplit('@', 1)
        url = urlparse.urlunsplit((scheme, netloc, path, query, ''))
        return url, rev


def new_frontend_master(self):
        """ Create and return new frontend attached to new kernel, launched on localhost.
        """
        ip = self.ip if self.ip in LOCAL_IPS else LOCALHOST
        kernel_manager = self.kernel_manager_class(
                                ip=ip,
                                connection_file=self._new_connection_file(),
                                config=self.config,
        )
        # start the kernel
        kwargs = dict()
        kwargs['extra_arguments'] = self.kernel_argv
        kernel_manager.start_kernel(**kwargs)
        kernel_manager.start_channels()
        widget = self.widget_factory(config=self.config,
                                   local_kernel=True)
        self.init_colors(widget)
        widget.kernel_manager = kernel_manager
        widget._existing = False
        widget._may_close = True
        widget._confirm_exit = self.confirm_exit
        return widget

def
new_frontend_master
(
self
)
:
ip
=
self
.
ip
if
self
.
ip
in
LOCAL_IPS
else
LOCALHOST
kernel_manager
=
self
.
kernel_manager_class
(
ip
=
ip
,
connection_file
=
self
.
_new_connection_file
(
)
,
config
=
self
.
config
,
)
# start the kernel
kwargs
=
dict
(
)
kwargs
[
'extra_arguments'
]
=
self
.
kernel_argv
kernel_manager
.
start_kernel
(
*
*
kwargs
)
kernel_manager
.
start_channels
(
)
widget
=
self
.
widget_factory
(
config
=
self
.
config
,
local_kernel
=
True
)
self
.
init_colors
(
widget
)
widget
.
kernel_manager
=
kernel_manager
widget
.
_existing
=
False
widget
.
_may_close
=
True
widget
.
_confirm_exit
=
self
.
confirm_exit
return
widget

Create and return new frontend attached to new kernel launched on localhost .


def init_colors(self, widget):
        """Configure the coloring of the widget"""
        # Note: This will be dramatically simplified when colors
        # are removed from the backend.

        # parse the colors arg down to current known labels
        try:
            colors = self.config.ZMQInteractiveShell.colors
        except AttributeError:
            colors = None
        try:
            style = self.config.IPythonWidget.syntax_style
        except AttributeError:
            style = None
        try:
            sheet = self.config.IPythonWidget.style_sheet
        except AttributeError:
            sheet = None

        # find the value for colors:
        if colors:
            colors=colors.lower()
            if colors in ('lightbg', 'light'):
                colors='lightbg'
            elif colors in ('dark', 'linux'):
                colors='linux'
            else:
                colors='nocolor'
        elif style:
            if style=='bw':
                colors='nocolor'
            elif styles.dark_style(style):
                colors='linux'
            else:
                colors='lightbg'
        else:
            colors=None

        # Configure the style
        if style:
            widget.style_sheet = styles.sheet_from_template(style, colors)
            widget.syntax_style = style
            widget._syntax_style_changed()
            widget._style_sheet_changed()
        elif colors:
            # use a default dark/light/bw style
            widget.set_default_style(colors=colors)

        if self.stylesheet:
            # we got an explicit stylesheet
            if os.path.isfile(self.stylesheet):
                with open(self.stylesheet) as f:
                    sheet = f.read()
            else:
                raise IOError("Stylesheet %r not found." % self.stylesheet)
        if sheet:
            widget.style_sheet = sheet
            widget._style_sheet_changed()


def info(self):
        """return the connection info for this object's sockets."""
        return (self.identity, self.url, self.pub_url, self.location)

def info ( self ) : return ( self . identity , self . url , self . pub_url , self . location )

return the connection info for this object s sockets .


def Rconverter(Robj, dataframe=False):
    """
    Convert an object in R's namespace to one suitable
    for ipython's namespace.

    For a data.frame, it tries to return a structured array.
    It first checks for colnames, then names.
    If all are NULL, it returns np.asarray(Robj), else
    it tries to construct a recarray

    Parameters
    ----------

    Robj: an R object returned from rpy2
    """
    is_data_frame = ro.r('is.data.frame')
    colnames = ro.r('colnames')
    rownames = ro.r('rownames') # with pandas, these could be used for the index
    names = ro.r('names')

    if dataframe:
        as_data_frame = ro.r('as.data.frame')
        cols = colnames(Robj)
        _names = names(Robj)
        if cols != ri.NULL:
            Robj = as_data_frame(Robj)
            names = tuple(np.array(cols))
        elif _names != ri.NULL:
            names = tuple(np.array(_names))
        else: # failed to find names
            return np.asarray(Robj)
        Robj = np.rec.fromarrays(Robj, names = names)
    return np.asarray(Robj)

Convert an object in R s namespace to one suitable for ipython s namespace .


def findsource(object):
    """Return the entire source file and starting line number for an object.

    The argument may be a module, class, method, function, traceback, frame,
    or code object.  The source code is returned as a list of all the lines
    in the file and the line number indexes a line in that list.  An IOError
    is raised if the source code cannot be retrieved.

    FIXED version with which we monkeypatch the stdlib to work around a bug."""

    file = getsourcefile(object) or getfile(object)
    # If the object is a frame, then trying to get the globals dict from its
    # module won't work. Instead, the frame object itself has the globals
    # dictionary.
    globals_dict = None
    if inspect.isframe(object):
        # XXX: can this ever be false?
        globals_dict = object.f_globals
    else:
        module = getmodule(object, file)
        if module:
            globals_dict = module.__dict__
    lines = linecache.getlines(file, globals_dict)
    if not lines:
        raise IOError('could not get source code')

    if ismodule(object):
        return lines, 0

    if isclass(object):
        name = object.__name__
        pat = re.compile(r'^(\s*)class\s*' + name + r'\b')
        # make some effort to find the best matching class definition:
        # use the one with the least indentation, which is the one
        # that's most probably not inside a function definition.
        candidates = []
        for i in range(len(lines)):
            match = pat.match(lines[i])
            if match:
                # if it's at toplevel, it's already the best one
                if lines[i][0] == 'c':
                    return lines, i
                # else add whitespace to candidate list
                candidates.append((match.group(1), i))
        if candidates:
            # this will sort by whitespace, and by line number,
            # less whitespace first
            candidates.sort()
            return lines, candidates[0][1]
        else:
            raise IOError('could not find class definition')

    if ismethod(object):
        object = object.im_func
    if isfunction(object):
        object = object.func_code
    if istraceback(object):
        object = object.tb_frame
    if isframe(object):
        object = object.f_code
    if iscode(object):
        if not hasattr(object, 'co_firstlineno'):
            raise IOError('could not find function definition')
        pat = re.compile(r'^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)')
        pmatch = pat.match
        # fperez - fix: sometimes, co_firstlineno can give a number larger than
        # the length of lines, which causes an error.  Safeguard against that.
        lnum = min(object.co_firstlineno,len(lines))-1
        while lnum > 0:
            if pmatch(lines[lnum]): break
            lnum -= 1

        return lines, lnum
    raise IOError('could not find code object')

Return the entire source file and starting line number for an object .


def set_colors(self,*args,**kw):
        """Shorthand access to the color table scheme selector method."""

        # Set own color table
        self.color_scheme_table.set_active_scheme(*args,**kw)
        # for convenience, set Colors to the active scheme
        self.Colors = self.color_scheme_table.active_colors
        # Also set colors of debugger
        if hasattr(self,'pdb') and self.pdb is not None:
            self.pdb.set_colors(*args,**kw)

Shorthand access to the color table scheme selector method .


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
        else:
            self.old_scheme = self.color_scheme_table.active_scheme_name
            self.color_scheme_table.set_active_scheme('NoColor')
            self.Colors = self.color_scheme_table.active_colors

def color_toggle ( self ) : 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 else : self . old_scheme = self . color_scheme_table . active_scheme_name self . color_scheme_table . set_active_scheme ( 'NoColor' ) self . Colors = self . color_scheme_table . active_colors

Toggle between the currently active color scheme and NoColor .