_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q279300 | ColorSchemeTable.add_scheme | test | def add_scheme(self,new_scheme):
"""Add a new color scheme to the table."""
if not isinstance(new_scheme,ColorScheme):
raise ValueError,'ColorSchemeTable only accepts ColorScheme instances'
self[new_scheme.name] = new_scheme | python | {
"resource": ""
} |
q279301 | ColorSchemeTable.set_active_scheme | test | def set_active_scheme(self,scheme,case_sensitive=0):
"""Set the currently active scheme.
Names are by default compared in a case-insensitive way, but this can
be changed by setting the parameter case_sensitive to true."""
scheme_names = self.keys()
if case_sensitive:
... | python | {
"resource": ""
} |
q279302 | home_lib | test | def home_lib(home):
"""Return the lib dir under the 'home' installation scheme"""
if hasattr(sys, 'pypy_version_info'):
lib = 'site-packages'
else:
lib = os.path.join('lib', 'python')
return os.path.join(home, lib) | python | {
"resource": ""
} |
q279303 | ZMQTerminalInteractiveShell.handle_iopub | test | def handle_iopub(self):
""" Method to procces subscribe channel's messages
This method reads a message and processes the content in different
outputs like stdout, stderr, pyout and status
Arguments:
sub_msg: message receive from kernel in the sub socket channel
... | python | {
"resource": ""
} |
q279304 | ZMQTerminalInteractiveShell.handle_stdin_request | test | def handle_stdin_request(self, timeout=0.1):
""" Method to capture raw_input
"""
msg_rep = self.km.stdin_channel.get_msg(timeout=timeout)
# in case any iopub came while we were waiting:
self.handle_iopub()
if self.session_id == msg_rep["parent_header"].get("session"):
... | python | {
"resource": ""
} |
q279305 | ZMQTerminalInteractiveShell.wait_for_kernel | test | def wait_for_kernel(self, timeout=None):
"""method to wait for a kernel to be ready"""
tic = time.time()
self.km.hb_channel.unpause()
while True:
self.run_cell('1', False)
if self.km.hb_channel.is_beating():
# heart failure was not the reason this ... | python | {
"resource": ""
} |
q279306 | PygmentsHighlighter.set_style | test | def set_style(self, style):
""" Sets the style to the specified Pygments style.
"""
if isinstance(style, basestring):
style = get_style_by_name(style)
self._style = style
self._clear_caches() | python | {
"resource": ""
} |
q279307 | PygmentsHighlighter._get_format | test | def _get_format(self, token):
""" Returns a QTextCharFormat for token or None.
"""
if token in self._formats:
return self._formats[token]
if self._style is None:
result = self._get_format_from_document(token, self._document)
else:
result = sel... | python | {
"resource": ""
} |
q279308 | PygmentsHighlighter._get_format_from_document | test | def _get_format_from_document(self, token, document):
""" Returns a QTextCharFormat for token by
"""
code, html = self._formatter._format_lines([(token, u'dummy')]).next()
self._document.setHtml(html)
return QtGui.QTextCursor(self._document).charFormat() | python | {
"resource": ""
} |
q279309 | PygmentsHighlighter._get_format_from_style | test | def _get_format_from_style(self, token, style):
""" Returns a QTextCharFormat for token by reading a Pygments style.
"""
result = QtGui.QTextCharFormat()
for key, value in style.style_for_token(token).items():
if value:
if key == 'color':
r... | python | {
"resource": ""
} |
q279310 | find_command | test | def find_command(cmd, paths=None, pathext=None):
"""Searches the PATH for the given command and returns its path"""
if paths is None:
paths = os.environ.get('PATH', '').split(os.pathsep)
if isinstance(paths, six.string_types):
paths = [paths]
# check if there are funny path extensions fo... | python | {
"resource": ""
} |
q279311 | normalize_path | test | def normalize_path(path):
"""
Convert a path to its canonical, case-normalized, absolute version.
"""
return os.path.normcase(os.path.realpath(os.path.expanduser(path))) | python | {
"resource": ""
} |
q279312 | check_nsp | test | def check_nsp(dist, attr, value):
"""Verify that namespace packages are valid"""
assert_string_list(dist,attr,value)
for nsp in value:
if not dist.has_contents_for(nsp):
raise DistutilsSetupError(
"Distribution contains no modules or packages for " +
"name... | python | {
"resource": ""
} |
q279313 | check_entry_points | test | def check_entry_points(dist, attr, value):
"""Verify that entry_points map is parseable"""
try:
pkg_resources.EntryPoint.parse_map(value)
except ValueError, e:
raise DistutilsSetupError(e) | python | {
"resource": ""
} |
q279314 | last_blank | test | def last_blank(src):
"""Determine if the input source ends in a blank.
A blank is either a newline or a line consisting of whitespace.
Parameters
----------
src : string
A single or multiline string.
"""
if not src: return False
ll = src.splitlines()[-1]
return (ll == '') or... | python | {
"resource": ""
} |
q279315 | last_two_blanks | test | def last_two_blanks(src):
"""Determine if the input source ends in two blanks.
A blank is either a newline or a line consisting of whitespace.
Parameters
----------
src : string
A single or multiline string.
"""
if not src: return False
# The logic here is tricky: I couldn't get ... | python | {
"resource": ""
} |
q279316 | transform_assign_system | test | def transform_assign_system(line):
"""Handle the `files = !ls` syntax."""
m = _assign_system_re.match(line)
if m is not None:
cmd = m.group('cmd')
lhs = m.group('lhs')
new_line = '%s = get_ipython().getoutput(%r)' % (lhs, cmd)
return new_line
return line | python | {
"resource": ""
} |
q279317 | transform_assign_magic | test | def transform_assign_magic(line):
"""Handle the `a = %who` syntax."""
m = _assign_magic_re.match(line)
if m is not None:
cmd = m.group('cmd')
lhs = m.group('lhs')
new_line = '%s = get_ipython().magic(%r)' % (lhs, cmd)
return new_line
return line | python | {
"resource": ""
} |
q279318 | transform_classic_prompt | test | def transform_classic_prompt(line):
"""Handle inputs that start with '>>> ' syntax."""
if not line or line.isspace():
return line
m = _classic_prompt_re.match(line)
if m:
return line[len(m.group(0)):]
else:
return line | python | {
"resource": ""
} |
q279319 | transform_ipy_prompt | test | def transform_ipy_prompt(line):
"""Handle inputs that start classic IPython prompt syntax."""
if not line or line.isspace():
return line
#print 'LINE: %r' % line # dbg
m = _ipy_prompt_re.match(line)
if m:
#print 'MATCH! %r -> %r' % (line, line[len(m.group(0)):]) # dbg
retur... | python | {
"resource": ""
} |
q279320 | InputSplitter.push | test | def push(self, lines):
"""Push one or more lines of input.
This stores the given lines and returns a status code indicating
whether the code forms a complete Python block or not.
Any exceptions generated in compilation are swallowed, but if an
exception was produced, the method... | python | {
"resource": ""
} |
q279321 | InputSplitter.push_accepts_more | test | def push_accepts_more(self):
"""Return whether a block of interactive input can accept more input.
This method is meant to be used by line-oriented frontends, who need to
guess whether a block is complete or not based solely on prior and
current input lines. The InputSplitter considers... | python | {
"resource": ""
} |
q279322 | InputSplitter._find_indent | test | def _find_indent(self, line):
"""Compute the new indentation level for a single line.
Parameters
----------
line : str
A single new line of non-whitespace, non-comment Python input.
Returns
-------
indent_spaces : int
New value for ... | python | {
"resource": ""
} |
q279323 | InputSplitter._store | test | def _store(self, lines, buffer=None, store='source'):
"""Store one or more lines of input.
If input lines are not newline-terminated, a newline is automatically
appended."""
if buffer is None:
buffer = self._buffer
if lines.endswith('\n'):
... | python | {
"resource": ""
} |
q279324 | IPythonInputSplitter.source_raw_reset | test | def source_raw_reset(self):
"""Return input and raw source and perform a full reset.
"""
out = self.source
out_r = self.source_raw
self.reset()
return out, out_r | python | {
"resource": ""
} |
q279325 | IPythonInputSplitter._handle_cell_magic | test | def _handle_cell_magic(self, lines):
"""Process lines when they start with %%, which marks cell magics.
"""
self.processing_cell_magic = True
first, _, body = lines.partition('\n')
magic_name, _, line = first.partition(' ')
magic_name = magic_name.lstrip(ESC_MAGIC)
... | python | {
"resource": ""
} |
q279326 | IPythonInputSplitter._line_mode_cell_append | test | def _line_mode_cell_append(self, lines):
"""Append new content for a cell magic in line mode.
"""
# Only store the raw input. Lines beyond the first one are only only
# stored for history purposes; for execution the caller will grab the
# magic pieces from cell_magic_parts and w... | python | {
"resource": ""
} |
q279327 | IPythonInputSplitter.transform_cell | test | def transform_cell(self, cell):
"""Process and translate a cell of input.
"""
self.reset()
self.push(cell)
return self.source_reset() | python | {
"resource": ""
} |
q279328 | IPythonInputSplitter.push | test | def push(self, lines):
"""Push one or more lines of IPython input.
This stores the given lines and returns a status code indicating
whether the code forms a complete Python block or not, after processing
all input lines for special IPython syntax.
Any exceptions generated in co... | python | {
"resource": ""
} |
q279329 | NotificationCenter._init_observers | test | def _init_observers(self):
"""Initialize observer storage"""
self.registered_types = set() #set of types that are observed
self.registered_senders = set() #set of senders that are observed
self.observers = {} | python | {
"resource": ""
} |
q279330 | NotificationCenter.post_notification | test | def post_notification(self, ntype, sender, *args, **kwargs):
"""Post notification to all registered observers.
The registered callback will be called as::
callback(ntype, sender, *args, **kwargs)
Parameters
----------
ntype : hashable
The notification t... | python | {
"resource": ""
} |
q279331 | NotificationCenter._observers_for_notification | test | def _observers_for_notification(self, ntype, sender):
"""Find all registered observers that should recieve notification"""
keys = (
(ntype,sender),
(ntype, None),
(None, sender),
(None,None)
)
obs = set(... | python | {
"resource": ""
} |
q279332 | NotificationCenter.add_observer | test | def add_observer(self, callback, ntype, sender):
"""Add an observer callback to this notification center.
The given callback will be called upon posting of notifications of
the given type/sender and will receive any additional arguments passed
to post_notification.
Parameters
... | python | {
"resource": ""
} |
q279333 | BackgroundJobManager.new | test | def new(self, func_or_exp, *args, **kwargs):
"""Add a new background job and start it in a separate thread.
There are two types of jobs which can be created:
1. Jobs based on expressions which can be passed to an eval() call.
The expression must be given as a string. For example:
... | python | {
"resource": ""
} |
q279334 | BackgroundJobManager._update_status | test | def _update_status(self):
"""Update the status of the job lists.
This method moves finished jobs to one of two lists:
- self.completed: jobs which completed successfully
- self.dead: jobs which finished but died.
It also copies those jobs to corresponding _report lists. Th... | python | {
"resource": ""
} |
q279335 | BackgroundJobManager._group_report | test | def _group_report(self,group,name):
"""Report summary for a given job group.
Return True if the group had any elements."""
if group:
print '%s jobs:' % name
for job in group:
print '%s : %s' % (job.num,job)
print
return True | python | {
"resource": ""
} |
q279336 | BackgroundJobManager._group_flush | test | def _group_flush(self,group,name):
"""Flush a given job group
Return True if the group had any elements."""
njobs = len(group)
if njobs:
plural = {1:''}.setdefault(njobs,'s')
print 'Flushing %s %s job%s.' % (njobs,name,plural)
group[:] = []
... | python | {
"resource": ""
} |
q279337 | BackgroundJobManager._status_new | test | def _status_new(self):
"""Print the status of newly finished jobs.
Return True if any new jobs are reported.
This call resets its own state every time, so it only reports jobs
which have finished since the last time it was called."""
self._update_status()
new_comp = se... | python | {
"resource": ""
} |
q279338 | BackgroundJobManager.status | test | def status(self,verbose=0):
"""Print a status of all jobs currently being managed."""
self._update_status()
self._group_report(self.running,'Running')
self._group_report(self.completed,'Completed')
self._group_report(self.dead,'Dead')
# Also flush the report queues
... | python | {
"resource": ""
} |
q279339 | BackgroundJobBase._init | test | def _init(self):
"""Common initialization for all BackgroundJob objects"""
for attr in ['call','strform']:
assert hasattr(self,attr), "Missing attribute <%s>" % attr
# The num tag can be set by an external job manager
self.num = None
self.stat... | python | {
"resource": ""
} |
q279340 | ListVariable.insert | test | def insert(self, idx, value):
"""
Inserts a value in the ``ListVariable`` at an appropriate index.
:param idx: The index before which to insert the new value.
:param value: The value to insert.
"""
self._value.insert(idx, value)
self._rebuild() | python | {
"resource": ""
} |
q279341 | Environment.copy | test | def copy(self):
"""
Retrieve a copy of the Environment. Note that this is a shallow
copy.
"""
return self.__class__(self._data.copy(), self._sensitive.copy(),
self._cwd) | python | {
"resource": ""
} |
q279342 | Environment._declare_special | test | def _declare_special(self, name, sep, klass):
"""
Declare an environment variable as a special variable. This can
be used even if the environment variable is not present.
:param name: The name of the environment variable that should
be considered special.
:... | python | {
"resource": ""
} |
q279343 | Environment.declare_list | test | def declare_list(self, name, sep=os.pathsep):
"""
Declare an environment variable as a list-like special variable.
This can be used even if the environment variable is not
present.
:param name: The name of the environment variable that should
be considered l... | python | {
"resource": ""
} |
q279344 | Environment.declare_set | test | def declare_set(self, name, sep=os.pathsep):
"""
Declare an environment variable as a set-like special variable.
This can be used even if the environment variable is not
present.
:param name: The name of the environment variable that should
be considered set... | python | {
"resource": ""
} |
q279345 | Environment.cwd | test | def cwd(self, value):
"""
Change the working directory that processes should be executed in.
:param value: The new path to change to. If relative, will be
interpreted relative to the current working
directory.
"""
self._cwd = utils.c... | python | {
"resource": ""
} |
q279346 | TSPProblem.move | test | def move(self, state=None):
"""Swaps two cities in the route.
:type state: TSPState
"""
state = self.state if state is None else state
route = state
a = random.randint(self.locked_range, len(route) - 1)
b = random.randint(self.locked_range, len(route) - 1)
... | python | {
"resource": ""
} |
q279347 | TSPProblem.energy | test | def energy(self, state=None):
"""Calculates the length of the route."""
state = self.state if state is None else state
route = state
e = 0
if self.distance_matrix:
for i in range(len(route)):
e += self.distance_matrix["{},{}".format(route[i-1], route[i... | python | {
"resource": ""
} |
q279348 | SQLiteDB._defaults | test | def _defaults(self, keys=None):
"""create an empty record"""
d = {}
keys = self._keys if keys is None else keys
for key in keys:
d[key] = None
return d | python | {
"resource": ""
} |
q279349 | SQLiteDB._check_table | test | def _check_table(self):
"""Ensure that an incorrect table doesn't exist
If a bad (old) table does exist, return False
"""
cursor = self._db.execute("PRAGMA table_info(%s)"%self.table)
lines = cursor.fetchall()
if not lines:
# table does not exist
... | python | {
"resource": ""
} |
q279350 | SQLiteDB._list_to_dict | test | def _list_to_dict(self, line, keys=None):
"""Inverse of dict_to_list"""
keys = self._keys if keys is None else keys
d = self._defaults(keys)
for key,value in zip(keys, line):
d[key] = value
return d | python | {
"resource": ""
} |
q279351 | SQLiteDB._render_expression | test | def _render_expression(self, check):
"""Turn a mongodb-style search dict into an SQL query."""
expressions = []
args = []
skeys = set(check.keys())
skeys.difference_update(set(self._keys))
skeys.difference_update(set(['buffers', 'result_buffers']))
if skeys:
... | python | {
"resource": ""
} |
q279352 | warn | test | def warn(msg,level=2,exit_val=1):
"""Standard warning printer. Gives formatting consistency.
Output is sent to io.stderr (sys.stderr by default).
Options:
-level(2): allows finer control:
0 -> Do nothing, dummy function.
1 -> Print message.
2 -> Print 'WARNING:' + message. (Default ... | python | {
"resource": ""
} |
q279353 | Reader.parse | test | def parse(self, config_file=None, specs=None, default_file=None):
"""Read a config_file, check the validity with a JSON Schema as specs
and get default values from default_file if asked.
All parameters are optionnal.
If there is no config_file defined, read the venv base
dir an... | python | {
"resource": ""
} |
q279354 | table | test | def table(rows):
'''
Output a simple table with several columns.
'''
output = '<table>'
for row in rows:
output += '<tr>'
for column in row:
output += '<td>{s}</td>'.format(s=column)
output += '</tr>'
output += '</table>'
return output | python | {
"resource": ""
} |
q279355 | link | test | def link(url, text='', classes='', target='', get="", **kwargs):
'''
Output a link tag.
'''
if not (url.startswith('http') or url.startswith('/')):
# Handle additional reverse args.
urlargs = {}
for arg, val in kwargs.items():
if arg[:4] == "url_":
u... | python | {
"resource": ""
} |
q279356 | jsfile | test | def jsfile(url):
'''
Output a script tag to a js file.
'''
if not url.startswith('http://') and not url[:1] == '/':
#add media_url for relative paths
url = settings.STATIC_URL + url
return '<script type="text/javascript" src="{src}"></script>'.format(
src=url) | python | {
"resource": ""
} |
q279357 | cssfile | test | def cssfile(url):
'''
Output a link tag to a css stylesheet.
'''
if not url.startswith('http://') and not url[:1] == '/':
#add media_url for relative paths
url = settings.STATIC_URL + url
return '<link href="{src}" rel="stylesheet">'.format(src=url) | python | {
"resource": ""
} |
q279358 | img | test | def img(url, alt='', classes='', style=''):
'''
Image tag helper.
'''
if not url.startswith('http://') and not url[:1] == '/':
#add media_url for relative paths
url = settings.STATIC_URL + url
attr = {
'class': classes,
'alt': alt,
'style': style,
's... | python | {
"resource": ""
} |
q279359 | sub | test | def sub(value, arg):
"""Subtract the arg from the value."""
try:
return valid_numeric(value) - valid_numeric(arg)
except (ValueError, TypeError):
try:
return value - arg
except Exception:
return '' | python | {
"resource": ""
} |
q279360 | mul | test | def mul(value, arg):
"""Multiply the arg with the value."""
try:
return valid_numeric(value) * valid_numeric(arg)
except (ValueError, TypeError):
try:
return value * arg
except Exception:
return '' | python | {
"resource": ""
} |
q279361 | div | test | def div(value, arg):
"""Divide the arg by the value."""
try:
return valid_numeric(value) / valid_numeric(arg)
except (ValueError, TypeError):
try:
return value / arg
except Exception:
return '' | python | {
"resource": ""
} |
q279362 | mod | test | def mod(value, arg):
"""Return the modulo value."""
try:
return valid_numeric(value) % valid_numeric(arg)
except (ValueError, TypeError):
try:
return value % arg
except Exception:
return '' | python | {
"resource": ""
} |
q279363 | model_verbose | test | def model_verbose(obj, capitalize=True):
"""
Return the verbose name of a model.
The obj argument can be either a Model instance, or a ModelForm instance.
This allows to retrieve the verbose name of the model of a ModelForm
easily, without adding extra context vars.
"""
if isinstance(obj, M... | python | {
"resource": ""
} |
q279364 | split_user_input | test | def split_user_input(line, pattern=None):
"""Split user input into initial whitespace, escape character, function part
and the rest.
"""
# We need to ensure that the rest of this routine deals only with unicode
encoding = get_stream_enc(sys.stdin, 'utf-8')
line = py3compat.cast_unicode(line, enc... | python | {
"resource": ""
} |
q279365 | MultiProcess.options | test | def options(self, parser, env):
"""
Register command-line options.
"""
parser.add_option("--processes", action="store",
default=env.get('NOSE_PROCESSES', 0),
dest="multiprocess_workers",
metavar="NUM",
... | python | {
"resource": ""
} |
q279366 | BuiltinTrap.add_builtin | test | def add_builtin(self, key, value):
"""Add a builtin and save the original."""
bdict = __builtin__.__dict__
orig = bdict.get(key, BuiltinUndefined)
if value is HideBuiltin:
if orig is not BuiltinUndefined: #same as 'key in bdict'
self._orig_builtins[key] = orig... | python | {
"resource": ""
} |
q279367 | BuiltinTrap.remove_builtin | test | def remove_builtin(self, key, orig):
"""Remove an added builtin and re-set the original."""
if orig is BuiltinUndefined:
del __builtin__.__dict__[key]
else:
__builtin__.__dict__[key] = orig | python | {
"resource": ""
} |
q279368 | BuiltinTrap.deactivate | test | def deactivate(self):
"""Remove any builtins which might have been added by add_builtins, or
restore overwritten ones to their previous values."""
remove_builtin = self.remove_builtin
for key, val in self._orig_builtins.iteritems():
remove_builtin(key, val)
self._orig... | python | {
"resource": ""
} |
q279369 | PackageFinder._find_url_name | test | def _find_url_name(self, index_url, url_name, req):
"""
Finds the true URL name of a package, when the given name isn't quite
correct.
This is usually used to implement case-insensitivity.
"""
if not index_url.url.endswith('/'):
# Vaguely part of the PyPI API.... | python | {
"resource": ""
} |
q279370 | HTMLPage.explicit_rel_links | test | def explicit_rel_links(self, rels=('homepage', 'download')):
"""Yields all links with the given relations"""
rels = set(rels)
for anchor in self.parsed.findall(".//a"):
if anchor.get("rel") and anchor.get("href"):
found_rels = set(anchor.get("rel").split())
... | python | {
"resource": ""
} |
q279371 | unshell_list | test | def unshell_list(s):
"""Turn a command-line argument into a list."""
if not s:
return None
if sys.platform == 'win32':
# When running coverage as coverage.exe, some of the behavior
# of the shell is emulated: wildcards are expanded into a list of
# filenames. So you have to ... | python | {
"resource": ""
} |
q279372 | main | test | def main(argv=None):
"""The main entry point to Coverage.
This is installed as the script entry point.
"""
if argv is None:
argv = sys.argv[1:]
try:
start = time.clock()
status = CoverageScript().command_line(argv)
end = time.clock()
if 0:
print(... | python | {
"resource": ""
} |
q279373 | ClassicOptionParser.add_action | test | def add_action(self, dash, dashdash, action_code):
"""Add a specialized option that is the action to execute."""
option = self.add_option(dash, dashdash, action='callback',
callback=self._append_action
)
option.action_code = action_code | python | {
"resource": ""
} |
q279374 | ClassicOptionParser._append_action | test | def _append_action(self, option, opt_unused, value_unused, parser):
"""Callback for an option that adds to the `actions` list."""
parser.values.actions.append(option.action_code) | python | {
"resource": ""
} |
q279375 | CoverageScript.command_line | test | def command_line(self, argv):
"""The bulk of the command line interface to Coverage.
`argv` is the argument list to process.
Returns 0 if all is well, 1 if something went wrong.
"""
# Collect the command-line options.
if not argv:
self.help_fn(topic='minimu... | python | {
"resource": ""
} |
q279376 | CoverageScript.help | test | def help(self, error=None, topic=None, parser=None):
"""Display an error message, or the named topic."""
assert error or topic or parser
if error:
print(error)
print("Use 'coverage help' for help.")
elif parser:
print(parser.format_help().strip())
... | python | {
"resource": ""
} |
q279377 | CoverageScript.do_help | test | def do_help(self, options, args, parser):
"""Deal with help requests.
Return True if it handled the request, False if not.
"""
# Handle help.
if options.help:
if self.classic:
self.help_fn(topic='help')
else:
self.help_fn(... | python | {
"resource": ""
} |
q279378 | CoverageScript.args_ok | test | def args_ok(self, options, args):
"""Check for conflicts and problems in the options.
Returns True if everything is ok, or False if not.
"""
for i in ['erase', 'execute']:
for j in ['annotate', 'html', 'report', 'combine']:
if (i in options.actions) and (j i... | python | {
"resource": ""
} |
q279379 | CoverageScript.do_execute | test | def do_execute(self, options, args):
"""Implementation of 'coverage run'."""
# Set the first path element properly.
old_path0 = sys.path[0]
# Run the script.
self.coverage.start()
code_ran = True
try:
try:
if options.module:
... | python | {
"resource": ""
} |
q279380 | CoverageScript.do_debug | test | def do_debug(self, args):
"""Implementation of 'coverage debug'."""
if not args:
self.help_fn("What information would you like: data, sys?")
return ERR
for info in args:
if info == 'sys':
print("-- sys ----------------------------------------"... | python | {
"resource": ""
} |
q279381 | unserialize_object | test | def unserialize_object(bufs):
"""reconstruct an object serialized by serialize_object from data buffers."""
bufs = list(bufs)
sobj = pickle.loads(bufs.pop(0))
if isinstance(sobj, (list, tuple)):
for s in sobj:
if s.data is None:
s.data = bufs.pop(0)
return unc... | python | {
"resource": ""
} |
q279382 | DisplayTrap.set | test | def set(self):
"""Set the hook."""
if sys.displayhook is not self.hook:
self.old_hook = sys.displayhook
sys.displayhook = self.hook | python | {
"resource": ""
} |
q279383 | log_errors | test | def log_errors(f, self, *args, **kwargs):
"""decorator to log unhandled exceptions raised in a method.
For use wrapping on_recv callbacks, so that exceptions
do not cause the stream to be closed.
"""
try:
return f(self, *args, **kwargs)
except Exception:
self.log.error("Unca... | python | {
"resource": ""
} |
q279384 | is_url | test | def is_url(url):
"""boolean check for whether a string is a zmq url"""
if '://' not in url:
return False
proto, addr = url.split('://', 1)
if proto.lower() not in ['tcp','pgm','epgm','ipc','inproc']:
return False
return True | python | {
"resource": ""
} |
q279385 | validate_url | test | def validate_url(url):
"""validate a url for zeromq"""
if not isinstance(url, basestring):
raise TypeError("url must be a string, not %r"%type(url))
url = url.lower()
proto_addr = url.split('://')
assert len(proto_addr) == 2, 'Invalid url: %r'%url
proto, addr = proto_addr
assert... | python | {
"resource": ""
} |
q279386 | validate_url_container | test | def validate_url_container(container):
"""validate a potentially nested collection of urls."""
if isinstance(container, basestring):
url = container
return validate_url(url)
elif isinstance(container, dict):
container = container.itervalues()
for element in container:
... | python | {
"resource": ""
} |
q279387 | _pull | test | def _pull(keys):
"""helper method for implementing `client.pull` via `client.apply`"""
user_ns = globals()
if isinstance(keys, (list,tuple, set)):
for key in keys:
if not user_ns.has_key(key):
raise NameError("name '%s' is not defined"%key)
return map(user_ns.get,... | python | {
"resource": ""
} |
q279388 | select_random_ports | test | def select_random_ports(n):
"""Selects and return n random ports that are available."""
ports = []
for i in xrange(n):
sock = socket.socket()
sock.bind(('', 0))
while sock.getsockname()[1] in _random_ports:
sock.close()
sock = socket.socket()
sock.... | python | {
"resource": ""
} |
q279389 | remote | test | def remote(view, block=None, **flags):
"""Turn a function into a remote function.
This method can be used for map:
In [1]: @remote(view,block=True)
...: def func(a):
...: pass
"""
def remote_function(f):
return RemoteFunction(view, f, block=block, **flags)
return remo... | python | {
"resource": ""
} |
q279390 | parallel | test | def parallel(view, dist='b', block=None, ordered=True, **flags):
"""Turn a function into a parallel remote function.
This method can be used for map:
In [1]: @parallel(view, block=True)
...: def func(a):
...: pass
"""
def parallel_function(f):
return ParallelFunction(view... | python | {
"resource": ""
} |
q279391 | ParallelFunction.map | test | def map(self, *sequences):
"""call a function on each element of a sequence remotely.
This should behave very much like the builtin map, but return an AsyncMapResult
if self.block is False.
"""
# set _map as a flag for use inside self.__call__
self._map = True
try... | python | {
"resource": ""
} |
q279392 | ReadlineNoRecord.get_readline_tail | test | def get_readline_tail(self, n=10):
"""Get the last n items in readline history."""
end = self.shell.readline.get_current_history_length() + 1
start = max(end-n, 1)
ghi = self.shell.readline.get_history_item
return [ghi(x) for x in range(start, end)] | python | {
"resource": ""
} |
q279393 | InteractiveShell.set_autoindent | test | def set_autoindent(self,value=None):
"""Set the autoindent flag, checking for readline support.
If called with no arguments, it acts as a toggle."""
if value != 0 and not self.has_readline:
if os.name == 'posix':
warn("The auto-indent feature requires the readline l... | python | {
"resource": ""
} |
q279394 | InteractiveShell.init_logstart | test | def init_logstart(self):
"""Initialize logging in case it was requested at the command line.
"""
if self.logappend:
self.magic('logstart %s append' % self.logappend)
elif self.logfile:
self.magic('logstart %s' % self.logfile)
elif self.logstart:
... | python | {
"resource": ""
} |
q279395 | InteractiveShell.save_sys_module_state | test | def save_sys_module_state(self):
"""Save the state of hooks in the sys module.
This has to be called after self.user_module is created.
"""
self._orig_sys_module_state = {}
self._orig_sys_module_state['stdin'] = sys.stdin
self._orig_sys_module_state['stdout'] = sys.stdou... | python | {
"resource": ""
} |
q279396 | InteractiveShell.restore_sys_module_state | test | def restore_sys_module_state(self):
"""Restore the state of the sys module."""
try:
for k, v in self._orig_sys_module_state.iteritems():
setattr(sys, k, v)
except AttributeError:
pass
# Reset what what done in self.init_sys_modules
if self.... | python | {
"resource": ""
} |
q279397 | InteractiveShell.register_post_execute | test | def register_post_execute(self, func):
"""Register a function for calling after code execution.
"""
if not callable(func):
raise ValueError('argument %s must be callable' % func)
self._post_execute[func] = True | python | {
"resource": ""
} |
q279398 | InteractiveShell.new_main_mod | test | def new_main_mod(self,ns=None):
"""Return a new 'main' module object for user code execution.
"""
main_mod = self._user_main_module
init_fakemod_dict(main_mod,ns)
return main_mod | python | {
"resource": ""
} |
q279399 | InteractiveShell.cache_main_mod | test | def cache_main_mod(self,ns,fname):
"""Cache a main module's namespace.
When scripts are executed via %run, we must keep a reference to the
namespace of their __main__ module (a FakeModule instance) around so
that Python doesn't clear it, rendering objects defined therein
useless... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.