_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q279500 | for_type_by_name | test | def for_type_by_name(type_module, type_name, func):
"""
Add a pretty printer for a type specified by the module and name of a type
rather than the type object itself.
"""
key = (type_module, type_name)
oldfunc = _deferred_type_pprinters.get(key, None)
if func is not None:
# To suppor... | python | {
"resource": ""
} |
q279501 | PrettyPrinter.text | test | def text(self, obj):
"""Add literal text to the output."""
width = len(obj)
if self.buffer:
text = self.buffer[-1]
if not isinstance(text, Text):
text = Text()
self.buffer.append(text)
text.add(obj, width)
self.buffe... | python | {
"resource": ""
} |
q279502 | PrettyPrinter.breakable | test | def breakable(self, sep=' '):
"""
Add a breakable separator to the output. This does not mean that it
will automatically break here. If no breaking on this position takes
place the `sep` is inserted which default to one space.
"""
width = len(sep)
group = self.g... | python | {
"resource": ""
} |
q279503 | PrettyPrinter.end_group | test | def end_group(self, dedent=0, close=''):
"""End a group. See `begin_group` for more details."""
self.indentation -= dedent
group = self.group_stack.pop()
if not group.breakables:
self.group_queue.remove(group)
if close:
self.text(close) | python | {
"resource": ""
} |
q279504 | PrettyPrinter.flush | test | def flush(self):
"""Flush data that is left in the buffer."""
for data in self.buffer:
self.output_width += data.output(self.output, self.output_width)
self.buffer.clear()
self.buffer_width = 0 | python | {
"resource": ""
} |
q279505 | RepresentationPrinter.pretty | test | def pretty(self, obj):
"""Pretty print the given object."""
obj_id = id(obj)
cycle = obj_id in self.stack
self.stack.append(obj_id)
self.begin_group()
try:
obj_class = getattr(obj, '__class__', None) or type(obj)
# First try to find registered sing... | python | {
"resource": ""
} |
q279506 | exception_colors | test | def exception_colors():
"""Return a color table with fields for exception reporting.
The table is an instance of ColorSchemeTable with schemes added for
'Linux', 'LightBG' and 'NoColor' and fields for exception handling filled
in.
Examples:
>>> ec = exception_colors()
>>> ec.active_scheme... | python | {
"resource": ""
} |
q279507 | _write_row_into_ods | test | def _write_row_into_ods(ods, sheet_no, row_no, row):
"""
Write row with translations to ods file into specified sheet and row_no.
"""
ods.content.getSheet(sheet_no)
for j, col in enumerate(row):
cell = ods.content.getCell(j, row_no+1)
cell.stringValue(_escape_apostrophe(col))
... | python | {
"resource": ""
} |
q279508 | win32_clipboard_get | test | def win32_clipboard_get():
""" Get the current clipboard's text on Windows.
Requires Mark Hammond's pywin32 extensions.
"""
try:
import win32clipboard
except ImportError:
raise TryNext("Getting text from the clipboard requires the pywin32 "
"extensions: http://... | python | {
"resource": ""
} |
q279509 | osx_clipboard_get | test | def osx_clipboard_get():
""" Get the clipboard's text on OS X.
"""
p = subprocess.Popen(['pbpaste', '-Prefer', 'ascii'],
stdout=subprocess.PIPE)
text, stderr = p.communicate()
# Text comes in with old Mac \r line endings. Change them to \n.
text = text.replace('\r', '\n')
return text | python | {
"resource": ""
} |
q279510 | tkinter_clipboard_get | test | def tkinter_clipboard_get():
""" Get the clipboard's text using Tkinter.
This is the default on systems that are not Windows or OS X. It may
interfere with other UI toolkits and should be replaced with an
implementation that uses that toolkit.
"""
try:
import Tkinter
except ImportEr... | python | {
"resource": ""
} |
q279511 | _get_build_prefix | test | def _get_build_prefix():
""" Returns a safe build_prefix """
path = os.path.join(
tempfile.gettempdir(),
'pip_build_%s' % __get_username().replace(' ', '_')
)
if WINDOWS:
""" on windows(tested on 7) temp dirs are isolated """
return path
try:
os.mkdir(path)
... | python | {
"resource": ""
} |
q279512 | rekey | test | def rekey(dikt):
"""Rekey a dict that has been forced to use str keys where there should be
ints by json."""
for k in dikt.iterkeys():
if isinstance(k, basestring):
ik=fk=None
try:
ik = int(k)
except ValueError:
try:
... | python | {
"resource": ""
} |
q279513 | extract_dates | test | def extract_dates(obj):
"""extract ISO8601 dates from unpacked JSON"""
if isinstance(obj, dict):
obj = dict(obj) # don't clobber
for k,v in obj.iteritems():
obj[k] = extract_dates(v)
elif isinstance(obj, (list, tuple)):
obj = [ extract_dates(o) for o in obj ]
elif isi... | python | {
"resource": ""
} |
q279514 | squash_dates | test | def squash_dates(obj):
"""squash datetime objects into ISO8601 strings"""
if isinstance(obj, dict):
obj = dict(obj) # don't clobber
for k,v in obj.iteritems():
obj[k] = squash_dates(v)
elif isinstance(obj, (list, tuple)):
obj = [ squash_dates(o) for o in obj ]
elif is... | python | {
"resource": ""
} |
q279515 | date_default | test | def date_default(obj):
"""default function for packing datetime objects in JSON."""
if isinstance(obj, datetime):
return obj.strftime(ISO8601)
else:
raise TypeError("%r is not JSON serializable"%obj) | python | {
"resource": ""
} |
q279516 | json_clean | test | def json_clean(obj):
"""Clean an object to ensure it's safe to encode in JSON.
Atomic, immutable objects are returned unmodified. Sets and tuples are
converted to lists, lists are copied and dicts are also copied.
Note: dicts whose keys could cause collisions upon encoding (such as a dict
wit... | python | {
"resource": ""
} |
q279517 | easy_install.check_site_dir | test | def check_site_dir(self):
"""Verify that self.install_dir is .pth-capable dir, if needed"""
instdir = normalize_path(self.install_dir)
pth_file = os.path.join(instdir, 'easy-install.pth')
# Is it a configured, PYTHONPATH, implicit, or explicit site dir?
is_site_dir = instdir in... | python | {
"resource": ""
} |
q279518 | install_scripts.write_script | test | def write_script(self, script_name, contents, mode="t", *ignored):
"""Write an executable file to the scripts directory"""
from setuptools.command.easy_install import chmod, current_umask
log.info("Installing %s script to %s", script_name, self.install_dir)
target = os.path.join(self.ins... | python | {
"resource": ""
} |
q279519 | sleep_here | test | def sleep_here(count, t):
"""simple function that takes args, prints a short message, sleeps for a time, and returns the same args"""
import time,sys
print("hi from engine %i" % id)
sys.stdout.flush()
time.sleep(t)
return count,t | python | {
"resource": ""
} |
q279520 | BaseCommand.create_parser | test | def create_parser(self, prog_name, subcommand):
"""
Create and return the ``ArgumentParser`` which will be used to
parse the arguments to this command.
"""
parser = ArgumentParser(
description=self.description,
epilog=self.epilog,
add_... | python | {
"resource": ""
} |
q279521 | Extension._convert_pyx_sources_to_c | test | def _convert_pyx_sources_to_c(self):
"convert .pyx extensions to .c"
def pyx_to_c(source):
if source.endswith('.pyx'):
source = source[:-4] + '.c'
return source
self.sources = map(pyx_to_c, self.sources) | python | {
"resource": ""
} |
q279522 | main | test | def main(connection_file):
"""watch iopub channel, and print messages"""
ctx = zmq.Context.instance()
with open(connection_file) as f:
cfg = json.loads(f.read())
location = cfg['location']
reg_url = cfg['url']
session = Session(key=str_to_bytes(cfg['exec_key']))
q... | python | {
"resource": ""
} |
q279523 | InstallCommand._build_package_finder | test | def _build_package_finder(self, options, index_urls, session):
"""
Create a package finder appropriate to this install command.
This method is meant to be overridden by subclasses, not
called directly.
"""
return PackageFinder(
find_links=options.find_links,
... | python | {
"resource": ""
} |
q279524 | Application._log_level_changed | test | def _log_level_changed(self, name, old, new):
"""Adjust the log level when log_level is set."""
if isinstance(new, basestring):
new = getattr(logging, new)
self.log_level = new
self.log.setLevel(new) | python | {
"resource": ""
} |
q279525 | Application._log_default | test | def _log_default(self):
"""Start logging for this application.
The default is to log to stdout using a StreaHandler. The log level
starts at loggin.WARN, but this can be adjusted by setting the
``log_level`` attribute.
"""
log = logging.getLogger(self.__class__.__name__)... | python | {
"resource": ""
} |
q279526 | Application._flags_changed | test | def _flags_changed(self, name, old, new):
"""ensure flags dict is valid"""
for key,value in new.iteritems():
assert len(value) == 2, "Bad flag: %r:%s"%(key,value)
assert isinstance(value[0], (dict, Config)), "Bad flag: %r:%s"%(key,value)
assert isinstance(value[1], ba... | python | {
"resource": ""
} |
q279527 | Application.print_alias_help | test | def print_alias_help(self):
"""Print the alias part of the help."""
if not self.aliases:
return
lines = []
classdict = {}
for cls in self.classes:
# include all parents (up to, but excluding Configurable) in available names
for c in cls.mro()[... | python | {
"resource": ""
} |
q279528 | Application.print_flag_help | test | def print_flag_help(self):
"""Print the flag part of the help."""
if not self.flags:
return
lines = []
for m, (cfg,help) in self.flags.iteritems():
prefix = '--' if len(m) > 1 else '-'
lines.append(prefix+m)
lines.append(indent(dedent(help... | python | {
"resource": ""
} |
q279529 | Application.print_subcommands | test | def print_subcommands(self):
"""Print the subcommand part of the help."""
if not self.subcommands:
return
lines = ["Subcommands"]
lines.append('-'*len(lines[0]))
lines.append('')
for p in wrap_paragraphs(self.subcommand_description):
lines.append(... | python | {
"resource": ""
} |
q279530 | Application.print_help | test | def print_help(self, classes=False):
"""Print the help for each Configurable class in self.classes.
If classes=False (the default), only flags and aliases are printed.
"""
self.print_subcommands()
self.print_options()
if classes:
if self.classes:
... | python | {
"resource": ""
} |
q279531 | Application.print_examples | test | def print_examples(self):
"""Print usage and examples.
This usage string goes at the end of the command line help string
and should contain examples of the application's usage.
"""
if self.examples:
print "Examples"
print "--------"
print
... | python | {
"resource": ""
} |
q279532 | Application.update_config | test | def update_config(self, config):
"""Fire the traits events when the config is updated."""
# Save a copy of the current config.
newconfig = deepcopy(self.config)
# Merge the new config into the current one.
newconfig._merge(config)
# Save the combined config as self.config... | python | {
"resource": ""
} |
q279533 | Application.initialize_subcommand | test | def initialize_subcommand(self, subc, argv=None):
"""Initialize a subcommand with argv."""
subapp,help = self.subcommands.get(subc)
if isinstance(subapp, basestring):
subapp = import_item(subapp)
# clear existing instances
self.__class__.clear_instance()
# i... | python | {
"resource": ""
} |
q279534 | Application.flatten_flags | test | def flatten_flags(self):
"""flatten flags and aliases, so cl-args override as expected.
This prevents issues such as an alias pointing to InteractiveShell,
but a config file setting the same trait in TerminalInteraciveShell
getting inappropriate priority over the command-line ar... | python | {
"resource": ""
} |
q279535 | Application.parse_command_line | test | def parse_command_line(self, argv=None):
"""Parse the command line arguments."""
argv = sys.argv[1:] if argv is None else argv
if argv and argv[0] == 'help':
# turn `ipython help notebook` into `ipython notebook -h`
argv = argv[1:] + ['-h']
if self.subco... | python | {
"resource": ""
} |
q279536 | Application.load_config_file | test | def load_config_file(self, filename, path=None):
"""Load a .py based config file by filename and path."""
loader = PyFileConfigLoader(filename, path=path)
try:
config = loader.load_config()
except ConfigFileNotFound:
# problem finding the file, raise
r... | python | {
"resource": ""
} |
q279537 | Application.generate_config_file | test | def generate_config_file(self):
"""generate default config file from Configurables"""
lines = ["# Configuration file for %s."%self.name]
lines.append('')
lines.append('c = get_config()')
lines.append('')
for cls in self.classes:
lines.append(cls.class_config_s... | python | {
"resource": ""
} |
q279538 | downsample | test | def downsample(array, k):
"""Choose k random elements of array."""
length = array.shape[0]
indices = random.sample(xrange(length), k)
return array[indices] | python | {
"resource": ""
} |
q279539 | info_formatter | test | def info_formatter(info):
"""Produce a sequence of formatted lines from info.
`info` is a sequence of pairs (label, data). The produced lines are
nicely formatted, ready to print.
"""
label_len = max([len(l) for l, _d in info])
for label, data in info:
if data == []:
data ... | python | {
"resource": ""
} |
q279540 | DebugControl.write | test | def write(self, msg):
"""Write a line of debug output."""
if self.should('pid'):
msg = "pid %5d: %s" % (os.getpid(), msg)
self.output.write(msg+"\n")
self.output.flush() | python | {
"resource": ""
} |
q279541 | Configurable._config_changed | test | def _config_changed(self, name, old, new):
"""Update all the class traits having ``config=True`` as metadata.
For any class trait with a ``config`` metadata attribute that is
``True``, we update the trait with the value of the corresponding
config entry.
"""
# Get all tr... | python | {
"resource": ""
} |
q279542 | Configurable.class_get_help | test | def class_get_help(cls, inst=None):
"""Get the help string for this class in ReST format.
If `inst` is given, it's current trait values will be used in place of
class defaults.
"""
assert inst is None or isinstance(inst, cls)
cls_traits = cls.class_traits(config=... | python | {
"resource": ""
} |
q279543 | Configurable.class_get_trait_help | test | def class_get_trait_help(cls, trait, inst=None):
"""Get the help string for a single trait.
If `inst` is given, it's current trait values will be used in place of
the class default.
"""
assert inst is None or isinstance(inst, cls)
lines = []
header = "--%... | python | {
"resource": ""
} |
q279544 | Configurable.class_config_section | test | def class_config_section(cls):
"""Get the config class config section"""
def c(s):
"""return a commented, wrapped block."""
s = '\n\n'.join(wrap_paragraphs(s, 78))
return '# ' + s.replace('\n', '\n# ')
# section header
breaker = '#' + '-'*78
... | python | {
"resource": ""
} |
q279545 | SingletonConfigurable.clear_instance | test | def clear_instance(cls):
"""unset _instance for this class and singleton parents.
"""
if not cls.initialized():
return
for subclass in cls._walk_mro():
if isinstance(subclass._instance, cls):
# only clear instances that are instances
... | python | {
"resource": ""
} |
q279546 | SingletonConfigurable.instance | test | def instance(cls, *args, **kwargs):
"""Returns a global instance of this class.
This method create a new instance if none have previously been created
and returns a previously created instance is one already exists.
The arguments and keyword arguments passed to this method are passed
... | python | {
"resource": ""
} |
q279547 | FailureDetail.formatFailure | test | def formatFailure(self, test, err):
"""Add detail from traceback inspection to error message of a failure.
"""
ec, ev, tb = err
tbinfo = inspect_traceback(tb)
test.tbinfo = tbinfo
return (ec, '\n'.join([str(ev), tbinfo]), tb) | python | {
"resource": ""
} |
q279548 | crash_handler_lite | test | def crash_handler_lite(etype, evalue, tb):
"""a light excepthook, adding a small message to the usual traceback"""
traceback.print_exception(etype, evalue, tb)
from IPython.core.interactiveshell import InteractiveShell
if InteractiveShell.initialized():
# we are in a Shell environment, give... | python | {
"resource": ""
} |
q279549 | QtSubSocketChannel.flush | test | def flush(self):
""" Reimplemented to ensure that signals are dispatched immediately.
"""
super(QtSubSocketChannel, self).flush()
QtCore.QCoreApplication.instance().processEvents() | python | {
"resource": ""
} |
q279550 | QtKernelManager.start_channels | test | def start_channels(self, *args, **kw):
""" Reimplemented to emit signal.
"""
super(QtKernelManager, self).start_channels(*args, **kw)
self.started_channels.emit() | python | {
"resource": ""
} |
q279551 | NotebookReader.read | test | def read(self, fp, **kwargs):
"""Read a notebook from a file like object"""
nbs = fp.read()
if not py3compat.PY3 and not isinstance(nbs, unicode):
nbs = py3compat.str_to_unicode(nbs)
return self.reads(nbs, **kwargs) | python | {
"resource": ""
} |
q279552 | read_no_interrupt | test | def read_no_interrupt(p):
"""Read from a pipe ignoring EINTR errors.
This is necessary because when reading from pipes with GUI event loops
running in the background, often interrupts are raised that stop the
command from completing."""
import errno
try:
return p.read()
except IOEr... | python | {
"resource": ""
} |
q279553 | process_handler | test | def process_handler(cmd, callback, stderr=subprocess.PIPE):
"""Open a command in a shell subprocess and execute a callback.
This function provides common scaffolding for creating subprocess.Popen()
calls. It creates a Popen object and then calls the callback with it.
Parameters
----------
cmd... | python | {
"resource": ""
} |
q279554 | arg_split | test | def arg_split(s, posix=False, strict=True):
"""Split a command line's arguments in a shell-like manner.
This is a modified version of the standard library's shlex.split()
function, but with a default of posix=False for splitting, so that quotes
in inputs are respected.
if strict=False, then any er... | python | {
"resource": ""
} |
q279555 | compress_dhist | test | def compress_dhist(dh):
"""Compress a directory history into a new one with at most 20 entries.
Return a new list made from the first and last 10 elements of dhist after
removal of duplicates.
"""
head, tail = dh[:-10], dh[-10:]
newhead = []
done = set()
for h in head:
if h in ... | python | {
"resource": ""
} |
q279556 | magics_class | test | def magics_class(cls):
"""Class decorator for all subclasses of the main Magics class.
Any class that subclasses Magics *must* also apply this decorator, to
ensure that all the methods that have been decorated as line/cell magics
get correctly registered in the class instance. This is necessary becaus... | python | {
"resource": ""
} |
q279557 | record_magic | test | def record_magic(dct, magic_kind, magic_name, func):
"""Utility function to store a function as a magic of a specific kind.
Parameters
----------
dct : dict
A dictionary with 'line' and 'cell' subdicts.
magic_kind : str
Kind of magic to be stored.
magic_name : str
Key to sto... | python | {
"resource": ""
} |
q279558 | _method_magic_marker | test | def _method_magic_marker(magic_kind):
"""Decorator factory for methods in Magics subclasses.
"""
validate_type(magic_kind)
# This is a closure to capture the magic_kind. We could also use a class,
# but it's overkill for just that one bit of state.
def magic_deco(arg):
call = lambda f... | python | {
"resource": ""
} |
q279559 | _function_magic_marker | test | def _function_magic_marker(magic_kind):
"""Decorator factory for standalone functions.
"""
validate_type(magic_kind)
# This is a closure to capture the magic_kind. We could also use a class,
# but it's overkill for just that one bit of state.
def magic_deco(arg):
call = lambda f, *... | python | {
"resource": ""
} |
q279560 | MagicsManager.lsmagic_docs | test | def lsmagic_docs(self, brief=False, missing=''):
"""Return dict of documentation of magic functions.
The return dict has the keys 'line' and 'cell', corresponding to the
two types of magics we support. Each value is a dict keyed by magic
name whose value is the function docstring. If a ... | python | {
"resource": ""
} |
q279561 | MagicsManager.register | test | def register(self, *magic_objects):
"""Register one or more instances of Magics.
Take one or more classes or instances of classes that subclass the main
`core.Magic` class, and register them with IPython to use the magic
functions they provide. The registration process will then ensur... | python | {
"resource": ""
} |
q279562 | MagicsManager.register_function | test | def register_function(self, func, magic_kind='line', magic_name=None):
"""Expose a standalone function as magic function for IPython.
This will create an IPython magic (line, cell or both) from a
standalone function. The functions should have the following
signatures:
* For l... | python | {
"resource": ""
} |
q279563 | Magics.format_latex | test | def format_latex(self, strng):
"""Format a string for latex inclusion."""
# Characters that need to be escaped for latex:
escape_re = re.compile(r'(%|_|\$|#|&)',re.MULTILINE)
# Magic command names as headers:
cmd_name_re = re.compile(r'^(%s.*?):' % ESC_MAGIC,
... | python | {
"resource": ""
} |
q279564 | Magics.parse_options | test | def parse_options(self, arg_str, opt_str, *long_opts, **kw):
"""Parse options passed to an argument string.
The interface is similar to that of getopt(), but it returns back a
Struct with the options as keys and the stripped argument string still
as a string.
arg_str is quoted ... | python | {
"resource": ""
} |
q279565 | Magics.default_option | test | def default_option(self, fn, optstr):
"""Make an entry in the options_table for fn, with value optstr"""
if fn not in self.lsmagic():
error("%s is not a magic function" % fn)
self.options_table[fn] = optstr | python | {
"resource": ""
} |
q279566 | page_guiref | test | def page_guiref(arg_s=None):
"""Show a basic reference about the GUI Console."""
from IPython.core import page
page.page(gui_reference, auto_html=True) | python | {
"resource": ""
} |
q279567 | task_with_callable | test | def task_with_callable(the_callable, label=None, schedule=DEFAULT_SCHEDULE, userdata=None, pk_override=None):
"""Factory function to create a properly initialized task."""
task = Task()
if isinstance(the_callable, str):
if pk_override is not None:
components = the_callable.split('.')
... | python | {
"resource": ""
} |
q279568 | taskinfo_with_label | test | def taskinfo_with_label(label):
"""Return task info dictionary from task label. Internal function,
pretty much only used in migrations since the model methods aren't there."""
task = Task.objects.get(label=label)
info = json.loads(task._func_info)
return info | python | {
"resource": ""
} |
q279569 | Task.func_from_info | test | def func_from_info(self):
"""Find and return a callable object from a task info dictionary"""
info = self.funcinfo
functype = info['func_type']
if functype in ['instancemethod', 'classmethod', 'staticmethod']:
the_modelclass = get_module_member_by_dottedpath(info['class_path'... | python | {
"resource": ""
} |
q279570 | Task.calc_next_run | test | def calc_next_run(self):
"""Calculate next run time of this task"""
base_time = self.last_run
if self.last_run == HAS_NOT_RUN:
if self.wait_for_schedule is False:
self.next_run = timezone.now()
self.wait_for_schedule = False # reset so we don't run on ... | python | {
"resource": ""
} |
q279571 | Task.submit | test | def submit(self, timestamp):
"""Internal instance method to submit this task for running immediately.
Does not handle any iteration, end-date, etc., processing."""
Channel(RUN_TASK_CHANNEL).send({'id':self.pk, 'ts': timestamp.timestamp()}) | python | {
"resource": ""
} |
q279572 | Task.run | test | def run(self, message):
"""Internal instance method run by worker process to actually run the task callable."""
the_callable = self.func_from_info()
try:
task_message = dict(
task=self,
channel_message=message,
)
the_callable(ta... | python | {
"resource": ""
} |
q279573 | Task.run_asap | test | def run_asap(self):
"""Instance method to run this task immediately."""
now = timezone.now()
self.last_run = now
self.calc_next_run()
self.save()
self.submit(now) | python | {
"resource": ""
} |
q279574 | Task.run_iterations | test | def run_iterations(cls, the_callable, iterations=1, label=None, schedule='* * * * * *', userdata = None, run_immediately=False, delay_until=None):
"""Class method to run a callable with a specified number of iterations"""
task = task_with_callable(the_callable, label=label, schedule=schedule, userdata=u... | python | {
"resource": ""
} |
q279575 | Task.run_once | test | def run_once(cls, the_callable, userdata=None, delay_until=None):
"""Class method to run a one-shot task, immediately."""
cls.run_iterations(the_callable, userdata=userdata, run_immediately=True, delay_until=delay_until) | python | {
"resource": ""
} |
q279576 | IPEngineApp.find_url_file | test | def find_url_file(self):
"""Set the url file.
Here we don't try to actually see if it exists for is valid as that
is hadled by the connection logic.
"""
config = self.config
# Find the actual controller key file
if not self.url_file:
self.url_file = o... | python | {
"resource": ""
} |
q279577 | IPEngineApp.bind_kernel | test | def bind_kernel(self, **kwargs):
"""Promote engine to listening kernel, accessible to frontends."""
if self.kernel_app is not None:
return
self.log.info("Opening ports for direct connections as an IPython kernel")
kernel = self.kernel
kwargs... | python | {
"resource": ""
} |
q279578 | timid | test | def timid(ctxt, test, key=None, check=False, exts=None):
"""
Execute a test described by a YAML file.
:param ctxt: A ``timid.context.Context`` object.
:param test: The name of a YAML file containing the test
description. Note that the current working directory
set up ... | python | {
"resource": ""
} |
q279579 | ParentPollerWindows.create_interrupt_event | test | def create_interrupt_event():
""" Create an interrupt event handle.
The parent process should use this static method for creating the
interrupt event that is passed to the child process. It should store
this handle and use it with ``send_interrupt`` to interrupt the child
proces... | python | {
"resource": ""
} |
q279580 | ParentPollerWindows.run | test | def run(self):
""" Run the poll loop. This method never returns.
"""
try:
from _winapi import WAIT_OBJECT_0, INFINITE
except ImportError:
from _subprocess import WAIT_OBJECT_0, INFINITE
# Build the list of handle to listen on.
handles = []
... | python | {
"resource": ""
} |
q279581 | filter_ns | test | def filter_ns(ns, name_pattern="*", type_pattern="all", ignore_case=True,
show_all=True):
"""Filter a namespace dictionary by name pattern and item type."""
pattern = name_pattern.replace("*",".*").replace("?",".")
if ignore_case:
reg = re.compile(pattern+"$", re.I)
else:
reg... | python | {
"resource": ""
} |
q279582 | list_namespace | test | def list_namespace(namespace, type_pattern, filter, ignore_case=False, show_all=False):
"""Return dictionary of all objects in a namespace dictionary that match
type_pattern and filter."""
pattern_list=filter.split(".")
if len(pattern_list) == 1:
return filter_ns(namespace, name_pattern=pattern_l... | python | {
"resource": ""
} |
q279583 | mutex_opts | test | def mutex_opts(dict,ex_op):
"""Check for presence of mutually exclusive keys in a dict.
Call: mutex_opts(dict,[[op1a,op1b],[op2a,op2b]...]"""
for op1,op2 in ex_op:
if op1 in dict and op2 in dict:
raise ValueError,'\n*** ERROR in Arguments *** '\
'Options '+op1+' and '+... | python | {
"resource": ""
} |
q279584 | draw_if_interactive | test | def draw_if_interactive():
"""
Is called after every pylab drawing command
"""
# signal that the current active figure should be sent at the end of
# execution. Also sets the _draw_called flag, signaling that there will be
# something to send. At the end of the code execution, a separate call ... | python | {
"resource": ""
} |
q279585 | flush_figures | test | def flush_figures():
"""Send all figures that changed
This is meant to be called automatically and will call show() if, during
prior code execution, there had been any calls to draw_if_interactive.
This function is meant to be used as a post_execute callback in IPython,
so user-caused errors a... | python | {
"resource": ""
} |
q279586 | send_figure | test | def send_figure(fig):
"""Draw the given figure and send it as a PNG payload.
"""
fmt = InlineBackend.instance().figure_format
data = print_figure(fig, fmt)
# print_figure will return None if there's nothing to draw:
if data is None:
return
mimetypes = { 'png' : 'image/png', 'svg' : '... | python | {
"resource": ""
} |
q279587 | ExtensionManager.load_extension | test | def load_extension(self, module_str):
"""Load an IPython extension by its module name.
If :func:`load_ipython_extension` returns anything, this function
will return that object.
"""
from IPython.utils.syspathcontext import prepended_to_syspath
if module_str not in sys.m... | python | {
"resource": ""
} |
q279588 | ExtensionManager.unload_extension | test | def unload_extension(self, module_str):
"""Unload an IPython extension by its module name.
This function looks up the extension's name in ``sys.modules`` and
simply calls ``mod.unload_ipython_extension(self)``.
"""
if module_str in sys.modules:
mod = sys.modules[modu... | python | {
"resource": ""
} |
q279589 | random_ports | test | def random_ports(port, n):
"""Generate a list of n random ports near the given port.
The first 5 ports will be sequential, and the remaining n-5 will be
randomly selected in the range [port-2*n, port+2*n].
"""
for i in range(min(5, n)):
yield port + i
for i in range(n-5):
yield ... | python | {
"resource": ""
} |
q279590 | NotebookApp.init_webapp | test | def init_webapp(self):
"""initialize tornado webapp and httpserver"""
self.web_app = NotebookWebApplication(
self, self.kernel_manager, self.notebook_manager,
self.cluster_manager, self.log,
self.base_project_url, self.webapp_settings
)
if self.certfi... | python | {
"resource": ""
} |
q279591 | NotebookApp._handle_sigint | test | def _handle_sigint(self, sig, frame):
"""SIGINT handler spawns confirmation dialog"""
# register more forceful signal handler for ^C^C case
signal.signal(signal.SIGINT, self._signal_stop)
# request confirmation dialog in bg thread, to avoid
# blocking the App
thread = thr... | python | {
"resource": ""
} |
q279592 | NotebookApp._confirm_exit | test | def _confirm_exit(self):
"""confirm shutdown on ^C
A second ^C, or answering 'y' within 5s will cause shutdown,
otherwise original SIGINT handler will be restored.
This doesn't work on Windows.
"""
# FIXME: remove this delay when pyzmq dependency is >= 2... | python | {
"resource": ""
} |
q279593 | NotebookApp.cleanup_kernels | test | def cleanup_kernels(self):
"""shutdown all kernels
The kernels will shutdown themselves when this process no longer exists,
but explicit shutdown allows the KernelManagers to cleanup the connection files.
"""
self.log.info('Shutting down kernels')
km = self.kerne... | python | {
"resource": ""
} |
q279594 | price_options | test | def price_options(S=100.0, K=100.0, sigma=0.25, r=0.05, days=260, paths=10000):
"""
Price European and Asian options using a Monte Carlo method.
Parameters
----------
S : float
The initial price of the stock.
K : float
The strike price of the option.
sigma : float
Th... | python | {
"resource": ""
} |
q279595 | multiple_replace | test | def multiple_replace(dict, text):
""" Replace in 'text' all occurences of any key in the given
dictionary by its corresponding value. Returns the new string."""
# Function by Xavier Defrang, originally found at:
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
# Create a regular ex... | python | {
"resource": ""
} |
q279596 | PromptManager._render | test | def _render(self, name, color=True, **kwargs):
"""Render but don't justify, or update the width or txtwidth attributes.
"""
if name == 'rewrite':
return self._render_rewrite(color=color)
if color:
scheme = self.color_scheme_table.active_colors
... | python | {
"resource": ""
} |
q279597 | base_launch_kernel | test | def base_launch_kernel(code, fname, stdin=None, stdout=None, stderr=None,
executable=None, independent=False, extra_arguments=[],
cwd=None):
""" Launches a localhost kernel, binding to the specified ports.
Parameters
----------
code : str,
A strin... | python | {
"resource": ""
} |
q279598 | create_zipfile | test | def create_zipfile(context):
"""This is the actual zest.releaser entry point
Relevant items in the context dict:
name
Name of the project being released
tagdir
Directory where the tag checkout is placed (*if* a tag
checkout has been made)
version
Version we're rel... | python | {
"resource": ""
} |
q279599 | fix_version | test | def fix_version(context):
"""Fix the version in metadata.txt
Relevant context dict item for both prerelease and postrelease:
``new_version``.
"""
if not prerequisites_ok():
return
lines = codecs.open('metadata.txt', 'rU', 'utf-8').readlines()
for index, line in enumerate(lines):
... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.