INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Run code or file specified at the command - line | def _run_cmd_line_code(self):
"""Run code or file specified at the command-line"""
if self.code_to_run:
line = self.code_to_run
try:
self.log.info("Running code given at command line (c=): %s" %
line)
self.shell.run_ce... |
Run module specified at the command - line. | def _run_module(self):
"""Run module specified at the command-line."""
if self.module_to_run:
# Make sure that the module gets a proper sys.argv as if it were
# run using `python -m`.
save_argv = sys.argv
sys.argv = [sys.executable] + self.extra_args
... |
Create a simple generic function | def generic(func):
"""Create a simple generic function"""
_sentinel = object()
def _by_class(*args, **kw):
cls = args[0].__class__
for t in type(cls.__name__, (cls,object), {}).__mro__:
f = _gbt(t, _sentinel)
if f is not _sentinel:
return f(*args, **... |
Return the path to a data file of ours. | def data_filename(fname, pkgdir=""):
"""Return the path to a data file of ours.
The file is searched for on `STATIC_PATH`, and the first place it's found,
is returned.
Each directory in `STATIC_PATH` is searched as-is, and also, if `pkgdir`
is provided, at that subdirectory.
"""
for stati... |
Return the contents of a data file of ours. | def data(fname):
"""Return the contents of a data file of ours."""
data_file = open(data_filename(fname))
try:
return data_file.read()
finally:
data_file.close() |
HTML - escape the text in t. | def escape(t):
"""HTML-escape the text in `t`."""
return (t
# Convert HTML special chars into HTML entities.
.replace("&", "&").replace("<", "<").replace(">", ">")
.replace("'", "'").replace('"', """)
# Convert runs of spaces: "......" -> " ... |
Generate an HTML report for morfs. | def report(self, morfs):
"""Generate an HTML report for `morfs`.
`morfs` is a list of modules or filenames.
"""
assert self.config.html_dir, "must give a directory for html reporting"
# Read the status data.
self.status.read(self.config.html_dir)
# Check that ... |
Make local instances of static files for HTML report. | def make_local_static_report_files(self):
"""Make local instances of static files for HTML report."""
# The files we provide must always be copied.
for static, pkgdir in self.STATIC_FILES:
shutil.copyfile(
data_filename(static, pkgdir),
os.path.join(se... |
Write html to fname properly encoded. | def write_html(self, fname, html):
"""Write `html` to `fname`, properly encoded."""
fout = open(fname, "wb")
try:
fout.write(html.encode('ascii', 'xmlcharrefreplace'))
finally:
fout.close() |
Compute a hash that changes if the file needs to be re - reported. | def file_hash(self, source, cu):
"""Compute a hash that changes if the file needs to be re-reported."""
m = Hasher()
m.update(source)
self.coverage.data.add_to_hash(cu.filename, m)
return m.digest() |
Generate an HTML file for one source file. | def html_file(self, cu, analysis):
"""Generate an HTML file for one source file."""
source_file = cu.source_file()
try:
source = source_file.read()
finally:
source_file.close()
# Find out if the file on disk is already correct.
flat_rootname = cu.... |
Write the index. html file for this report. | def index_file(self):
"""Write the index.html file for this report."""
index_tmpl = Templite(
data("index.html"), self.template_globals
)
self.totals = sum([f['nums'] for f in self.files])
html = index_tmpl.render({
'arcs': self.arcs,
'ex... |
Read the last status in directory. | def read(self, directory):
"""Read the last status in `directory`."""
usable = False
try:
status_file = os.path.join(directory, self.STATUS_FILE)
fstatus = open(status_file, "rb")
try:
status = pickle.load(fstatus)
finally:
... |
Write the current status to directory. | def write(self, directory):
"""Write the current status to `directory`."""
status_file = os.path.join(directory, self.STATUS_FILE)
status = {
'format': self.STATUS_FORMAT,
'version': coverage.__version__,
'settings': self.settings,
'files': self.fi... |
uniq_stable ( elems ) - > list | def uniq_stable(elems):
"""uniq_stable(elems) -> list
Return from an iterable, a list of all the unique elements in the input,
but maintaining the order in which they first appear.
A naive solution to this problem which just makes a dictionary with the
elements as keys fails to respect the stabili... |
Sort and compare two lists. | def sort_compare(lst1, lst2, inplace=1):
"""Sort and compare two lists.
By default it does it in place, thus modifying the lists. Use inplace = 0
to avoid that (at the cost of temporary copy creation)."""
if not inplace:
lst1 = lst1[:]
lst2 = lst2[:]
lst1.sort(); lst2.sort()
ret... |
Takes a list of ( key value ) pairs and turns it into a dict. | def list2dict(lst):
"""Takes a list of (key,value) pairs and turns it into a dict."""
dic = {}
for k,v in lst: dic[k] = v
return dic |
Takes a list and turns it into a dict. Much slower than list2dict but more versatile. This version can take lists with sublists of arbitrary length ( including sclars ). | def list2dict2(lst, default=''):
"""Takes a list and turns it into a dict.
Much slower than list2dict, but more versatile. This version can take
lists with sublists of arbitrary length (including sclars)."""
dic = {}
for elem in lst:
if type(elem) in (types.ListType,types.TupleType):
... |
Get a slice of a sequence with variable step. Specify start stop step. | def get_slice(seq, start=0, stop=None, step=1):
"""Get a slice of a sequence with variable step. Specify start,stop,step."""
if stop == None:
stop = len(seq)
item = lambda i: seq[i]
return map(item,xrange(start,stop,step)) |
Chop a sequence into chunks of the given size. | def chop(seq, size):
"""Chop a sequence into chunks of the given size."""
chunk = lambda i: seq[i:i+size]
return map(chunk,xrange(0,len(seq),size)) |
Read configuration from setup. cfg. | def read_config():
"""Read configuration from setup.cfg."""
# XXX modifies global state, which is kind of evil
config = ConfigParser.ConfigParser()
config.read(['setup.cfg'])
if not config.has_section('check-manifest'):
return
if (config.has_option('check-manifest', 'ignore-default-rules... |
Read existing configuration from MANIFEST. in. | def read_manifest():
"""Read existing configuration from MANIFEST.in.
We use that to ignore anything the MANIFEST.in ignores.
"""
# XXX modifies global state, which is kind of evil
if not os.path.isfile('MANIFEST.in'):
return
with open('MANIFEST.in') as manifest:
contents = mani... |
Compile a glob pattern into a regexp. | def _glob_to_regexp(pat):
"""Compile a glob pattern into a regexp.
We need to do this because fnmatch allows * to match /, which we
don't want. E.g. an MANIFEST.in exclude of 'dirname/*css' should
match 'dirname/foo.css' but not 'dirname/subdir/bar.css'.
"""
pat = fnmatch.translate(pat)
# ... |
Does this filename match any of the patterns? | def file_matches(filename, patterns):
"""Does this filename match any of the patterns?"""
return any(fnmatch.fnmatch(filename, pat) for pat in patterns) |
List all files versioned by git in the current directory. | def get_versioned_files():
"""List all files versioned by git in the current directory."""
# Git for Windows uses UTF-8 instead of the locale encoding.
# Regular Git on sane POSIX systems uses the locale encoding
encoding = 'UTF-8' if sys.platform == 'win32' else None
output = ru... |
Start a new kernel. | def start_kernel(self, **kwargs):
"""Start a new kernel."""
kernel_id = unicode(uuid.uuid4())
# use base KernelManager for each Kernel
km = self.kernel_manager_factory(connection_file=os.path.join(
self.connection_dir, "kernel-%s.json" % kernel_id),
... |
Shutdown a kernel by its kernel uuid. | def shutdown_kernel(self, kernel_id):
"""Shutdown a kernel by its kernel uuid.
Parameters
==========
kernel_id : uuid
The id of the kernel to shutdown.
"""
self.get_kernel(kernel_id).shutdown_kernel()
del self._kernels[kernel_id] |
Kill a kernel by its kernel uuid. | def kill_kernel(self, kernel_id):
"""Kill a kernel by its kernel uuid.
Parameters
==========
kernel_id : uuid
The id of the kernel to kill.
"""
self.get_kernel(kernel_id).kill_kernel()
del self._kernels[kernel_id] |
Get the single KernelManager object for a kernel by its uuid. | def get_kernel(self, kernel_id):
"""Get the single KernelManager object for a kernel by its uuid.
Parameters
==========
kernel_id : uuid
The id of the kernel.
"""
km = self._kernels.get(kernel_id)
if km is not None:
return km
else:... |
Return a dictionary of ports for a kernel. | def get_kernel_ports(self, kernel_id):
"""Return a dictionary of ports for a kernel.
Parameters
==========
kernel_id : uuid
The id of the kernel.
Returns
=======
port_dict : dict
A dict of key, value pairs where the keys are the names
... |
Return the notebook_id for a kernel_id or None. | def notebook_for_kernel(self, kernel_id):
"""Return the notebook_id for a kernel_id or None."""
notebook_ids = [k for k, v in self._notebook_mapping.iteritems() if v == kernel_id]
if len(notebook_ids) == 1:
return notebook_ids[0]
else:
return None |
Remove the kernel/ notebook mapping for kernel_id. | def delete_mapping_for_kernel(self, kernel_id):
"""Remove the kernel/notebook mapping for kernel_id."""
notebook_id = self.notebook_for_kernel(kernel_id)
if notebook_id is not None:
del self._notebook_mapping[notebook_id] |
Start a kernel for a notebok an return its kernel_id. | def start_kernel(self, notebook_id=None, **kwargs):
"""Start a kernel for a notebok an return its kernel_id.
Parameters
----------
notebook_id : uuid
The uuid of the notebook to associate the new kernel with. If this
is not None, this kernel will be persistent wh... |
Shutdown a kernel and remove its notebook association. | def shutdown_kernel(self, kernel_id):
"""Shutdown a kernel and remove its notebook association."""
self._check_kernel_id(kernel_id)
super(MappingKernelManager, self).shutdown_kernel(kernel_id)
self.delete_mapping_for_kernel(kernel_id)
self.log.info("Kernel shutdown: %s" % kernel_... |
Interrupt a kernel. | def interrupt_kernel(self, kernel_id):
"""Interrupt a kernel."""
self._check_kernel_id(kernel_id)
super(MappingKernelManager, self).interrupt_kernel(kernel_id)
self.log.info("Kernel interrupted: %s" % kernel_id) |
Restart a kernel while keeping clients connected. | def restart_kernel(self, kernel_id):
"""Restart a kernel while keeping clients connected."""
self._check_kernel_id(kernel_id)
km = self.get_kernel(kernel_id)
km.restart_kernel()
self.log.info("Kernel restarted: %s" % kernel_id)
return kernel_id
# the foll... |
Create a new iopub stream. | def create_iopub_stream(self, kernel_id):
"""Create a new iopub stream."""
self._check_kernel_id(kernel_id)
return super(MappingKernelManager, self).create_iopub_stream(kernel_id) |
Create a new shell stream. | def create_shell_stream(self, kernel_id):
"""Create a new shell stream."""
self._check_kernel_id(kernel_id)
return super(MappingKernelManager, self).create_shell_stream(kernel_id) |
Create a new hb stream. | def create_hb_stream(self, kernel_id):
"""Create a new hb stream."""
self._check_kernel_id(kernel_id)
return super(MappingKernelManager, self).create_hb_stream(kernel_id) |
Configure plugin. | def configure(self, options, conf):
"""Configure plugin.
"""
if not self.can_configure:
return
self.conf = conf
disable = getattr(options, 'noDeprecated', False)
if disable:
self.enabled = False |
Reset all OneTimeProperty attributes that may have fired already. | def reset(self):
"""Reset all OneTimeProperty attributes that may have fired already."""
instdict = self.__dict__
classdict = self.__class__.__dict__
# To reset them, we simply remove them from the instance dict. At that
# point, it's as if they had never been computed. On the next acces... |
Generate integers from start to ( and including! ) stop with increment of inc. Alternative to range/ xrange. | def iseq(start=0, stop=None, inc=1):
"""
Generate integers from start to (and including!) stop,
with increment of inc. Alternative to range/xrange.
"""
if stop is None: # allow isequence(3) to be 0, 1, 2, 3
# take 1st arg as stop, start as 0, and inc=1
stop = start; start = 0; inc = ... |
Export the contents of the ConsoleWidget as HTML. | def export_html(html, filename, image_tag = None, inline = True):
""" Export the contents of the ConsoleWidget as HTML.
Parameters:
-----------
html : str,
A utf-8 encoded Python string containing the Qt HTML to export.
filename : str
The file to be saved.
image_tag : callable... |
Export the contents of the ConsoleWidget as XHTML with inline SVGs. | def export_xhtml(html, filename, image_tag=None):
""" Export the contents of the ConsoleWidget as XHTML with inline SVGs.
Parameters:
-----------
html : str,
A utf-8 encoded Python string containing the Qt HTML to export.
filename : str
The file to be saved.
image_tag : callab... |
wrapper for ensuring image_tag returns utf8 - encoded str on Python 2 | def ensure_utf8(image_tag):
"""wrapper for ensuring image_tag returns utf8-encoded str on Python 2"""
if py3compat.PY3:
# nothing to do on Python 3
return image_tag
def utf8_image_tag(*args, **kwargs):
s = image_tag(*args, **kwargs)
if isinstance(s, unicode):
... |
Transforms a Qt - generated HTML string into a standards - compliant one. | def fix_html(html):
""" Transforms a Qt-generated HTML string into a standards-compliant one.
Parameters:
-----------
html : str,
A utf-8 encoded Python string containing the Qt HTML.
"""
# A UTF-8 declaration is needed for proper rendering of some characters
# (e.g., indented comma... |
Displays a dialog for exporting HTML generated by Qt s rich text system. | def export(self):
""" Displays a dialog for exporting HTML generated by Qt's rich text
system.
Returns
-------
The name of the file that was saved, or None if no file was saved.
"""
parent = self.control.window()
dialog = QtGui.QFileDialog(parent, 'Save a... |
Returns a unique instance of klass or None | def get_unique_or_none(klass, *args, **kwargs):
""" Returns a unique instance of `klass` or None """
try:
return klass.objects.get(*args, **kwargs)
except klass.DoesNotExist:
return None
except klass.MultipleObjectsReturned:
return None
return None |
Returns a tuple of ( instance created ) where instance is the retrieved or created instance of klass and created is a boolean specifying whether a new object was created. The value for the unique fields must be present in the defaults dictionary. | def get_or_create_unique(klass, defaults, unique_fields):
"""
Returns a tuple of (instance, created), where `instance` is the retrieved
or created instance of `klass` and `created` is a boolean specifying whether
a new object was created. The value for the unique fields must be present in
the defaul... |
Tokenize the input string and return two lists exclude list is for words that start with a dash ( ex: - word ) and include list is for all other words | def get_text_tokenizer(query_string):
"""
Tokenize the input string and return two lists, exclude list is for words that
start with a dash (ex: -word) and include list is for all other words
"""
# Regex to split on double-quotes, single-quotes, and continuous non-whitespace characters.
split_pat... |
Builds a query for included terms in a text search. | def get_query_includes(tokenized_terms, search_fields):
"""
Builds a query for included terms in a text search.
"""
query = None
for term in tokenized_terms:
or_query = None
for field_name in search_fields:
q = Q(**{"%s__icontains" % field_name: term})
if or_q... |
Builds a query for both included & excluded terms in a text search. | def get_text_query(query_string, search_fields):
"""
Builds a query for both included & excluded terms in a text search.
"""
include_terms, exclude_terms = get_text_tokenizer(query_string)
include_q = get_query_includes(include_terms, search_fields)
exclude_q = get_query_excludes(exclude_terms, ... |
Query for if date_field is within number of days ago. | def get_date_greater_query(days, date_field):
"""
Query for if date_field is within number of "days" ago.
"""
query = None
days = get_integer(days)
if days:
past = get_days_ago(days)
query = Q(**{"%s__gte" % date_field: past.isoformat()})
return query |
Query for if date_field is within number of days from now. | def get_date_less_query(days, date_field):
"""
Query for if date_field is within number of "days" from now.
"""
query = None
days = get_integer(days)
if days:
future = get_days_from_now(days)
query = Q(**{"%s__lte" % date_field: future.isoformat()})
return query |
Query for null or blank field. | def get_null_or_blank_query(field=None):
"""
Query for null or blank field.
"""
if not field:
return field
null_q = get_null_query(field)
blank_q = get_blank_query(field)
return (null_q | blank_q) |
Converts queries to case insensitive for special fields. | def case_insensitive(self, fields_dict):
"""
Converts queries to case insensitive for special fields.
"""
if hasattr(self.model, 'CASE_INSENSITIVE_FIELDS'):
for field in self.model.CASE_INSENSITIVE_FIELDS:
if field in fields_dict:
fields_di... |
Decorator that adds attributes to classes or functions for use with the Attribute ( - a ) plugin. | def attr(*args, **kwargs):
"""Decorator that adds attributes to classes or functions
for use with the Attribute (-a) plugin.
"""
def wrap_ob(ob):
for name in args:
setattr(ob, name, True)
for name, value in kwargs.iteritems():
setattr(ob, name, value)
retu... |
Look up an attribute on a method/ function. If the attribute isn t found there looking it up in the method s class if any. | def get_method_attr(method, cls, attr_name, default = False):
"""Look up an attribute on a method/ function.
If the attribute isn't found there, looking it up in the
method's class, if any.
"""
Missing = object()
value = getattr(method, attr_name, Missing)
if value is Missing and cls is not... |
Register command line options | def options(self, parser, env):
"""Register command line options"""
parser.add_option("-a", "--attr",
dest="attr", action="append",
default=env.get('NOSE_ATTR'),
metavar="ATTR",
help="Run only tests t... |
Configure the plugin and system based on selected options. | def configure(self, options, config):
"""Configure the plugin and system, based on selected options.
attr and eval_attr may each be lists.
self.attribs will be a list of lists of tuples. In that list, each
list is a group of attributes, all of which must match for the rule to
m... |
Verify whether a method has the required attributes The method is considered a match if it matches all attributes for any attribute group.. | def validateAttrib(self, method, cls = None):
"""Verify whether a method has the required attributes
The method is considered a match if it matches all attributes
for any attribute group.
."""
# TODO: is there a need for case-sensitive value comparison?
any = False
... |
Accept the method if its attributes match. | def wantMethod(self, method):
"""Accept the method if its attributes match.
"""
try:
cls = method.im_class
except AttributeError:
return False
return self.validateAttrib(method, cls) |
Rotate the kill ring then yank back the new top. | def rotate(self):
""" Rotate the kill ring, then yank back the new top.
"""
if self._prev_yank:
text = self._ring.rotate()
if text:
self._skip_cursor = True
cursor = self._text_edit.textCursor()
cursor.movePosition(QtGui.QTe... |
backport a few patches from newer pyzmq These can be removed as we bump our minimum pyzmq version | def patch_pyzmq():
"""backport a few patches from newer pyzmq
These can be removed as we bump our minimum pyzmq version
"""
import zmq
# ioloop.install, introduced in pyzmq 2.1.7
from zmq.eventloop import ioloop
def install():
import tornado.ioloop
tornado... |
returns: API version number <str > raises: <VersionNotFound > | def version_from_schema(schema_el):
"""
returns: API version number <str>
raises: <VersionNotFound>
NOTE:
relies on presence of comment tags in the XSD, which are currently present
for both ebaySvc.xsd (TradingAPI) and ShoppingService.xsd (ShoppingAPI)
"""
vc_el = schema_el
while Tr... |
XML doc may have several prefix: namespace_url pairs can also specify a namespace_url as default tags in that namespace don t need a prefix NOTE: we rely on default namespace also present in prefixed form I m not sure if this is an XML certainty or a quirk of the eBay WSDLs | def _default_ns_prefix(nsmap):
"""
XML doc may have several prefix:namespace_url pairs, can also specify
a namespace_url as default, tags in that namespace don't need a prefix
NOTE:
we rely on default namespace also present in prefixed form, I'm not sure if
this is an XML certainty or a quirk of... |
returns: API version number <str > raises: <VersionNotFound > | def version_from_wsdl(wsdl_tree):
"""
returns: API version number <str>
raises: <VersionNotFound>
NOTE:
relies on presence of documentation node in the WSDLs:
<wsdl:documentation>
<Version>1.0.0</Version>
</wsdl:documentation>
"""
prefix = _default_ns_prefix(wsdl... |
Returns an XSD - schema - enabled lxml parser from a WSDL or XSD | def parser_from_schema(schema_url, require_version=True):
"""
Returns an XSD-schema-enabled lxml parser from a WSDL or XSD
`schema_url` can of course be local path via file:// url
"""
schema_tree = etree.parse(schema_url)
def get_version(element, getter):
try:
return getter... |
Ask a question to STDOUT and return answer from STDIN Args: question: A string question that will be printed to stdout Kwargs: required: True indicates the question must be answered answers: A sequence of dicts with key value pairs where the key will be a user - selectable choice menu item with the value as its related... | def askQuestion(question, required = True, answers = dict(), tries = 3):
"""Ask a question to STDOUT and return answer from STDIN
Args:
question: A string question that will be printed to stdout
Kwargs:
required: True indicates the question must be answered
answers: A seque... |
authenticate this page * unless * readonly view is active. In read - only mode the notebook list and print view should be accessible without authentication. | def authenticate_unless_readonly(f, self, *args, **kwargs):
"""authenticate this page *unless* readonly view is active.
In read-only mode, the notebook list and print view should
be accessible without authentication.
"""
@web.authenticated
def auth_f(self, *args, **kwargs):
ret... |
websocket url matching the current request | def ws_url(self):
"""websocket url matching the current request
turns http[s]://host[:port] into
ws[s]://host[:port]
"""
proto = self.request.protocol.replace('http', 'ws')
host = self.application.ipython_app.websocket_host # default to config value
if ho... |
Reserialize a reply message using JSON. | def _reserialize_reply(self, msg_list):
"""Reserialize a reply message using JSON.
This takes the msg list from the ZMQ socket, unserializes it using
self.session and then serializes the result using JSON. This method
should be used by self._on_zmq_reply to build messages that can
... |
Inject the first message which is the document cookie for authentication. | def _inject_cookie_message(self, msg):
"""Inject the first message, which is the document cookie,
for authentication."""
if isinstance(msg, unicode):
# Cookie can't constructor doesn't accept unicode strings for some reason
msg = msg.encode('utf8', 'replace')
try:... |
Start the heartbeating and call the callback if the kernel dies. | def start_hb(self, callback):
"""Start the heartbeating and call the callback if the kernel dies."""
if not self._beating:
self._kernel_alive = True
def ping_or_dead():
self.hb_stream.flush()
if self._kernel_alive:
self._kernel... |
callback for delayed heartbeat start Only start the hb loop if we haven t been closed during the wait. | def _really_start_hb(self):
"""callback for delayed heartbeat start
Only start the hb loop if we haven't been closed during the wait.
"""
if self._beating and not self.hb_stream.closed():
self._hb_periodic_callback.start() |
Stop the heartbeating and cancel all related callbacks. | def stop_hb(self):
"""Stop the heartbeating and cancel all related callbacks."""
if self._beating:
self._beating = False
self._hb_periodic_callback.stop()
if not self.hb_stream.closed():
self.hb_stream.on_recv(None) |
Load file object. | def fload(self):
"""Load file object."""
# read data and parse into blocks
if hasattr(self, 'fobj') and self.fobj is not None:
self.fobj.close()
if hasattr(self.src, "read"):
# It seems to be a file or a file-like object
self.fobj = self.src
el... |
Reload source from disk and initialize state. | def reload(self):
"""Reload source from disk and initialize state."""
self.fload()
self.src = self.fobj.read()
src_b = [b.strip() for b in self.re_stop.split(self.src) if b]
self._silent = [bool(self.re_silent.findall(b)) for b in src_b]
self._auto = [bool(s... |
Get the current block index validating and checking status. | def _get_index(self,index):
"""Get the current block index, validating and checking status.
Returns None if the demo is finished"""
if index is None:
if self.finished:
print >>io.stdout, 'Demo finished. Use <demo_name>.reset() if you want to rerun it.'
... |
Move the current seek pointer to the given block. | def seek(self,index):
"""Move the current seek pointer to the given block.
You can use negative indices to seek from the end, with identical
semantics to those of Python lists."""
if index<0:
index = self.nblocks + index
self._validate_index(index)
self.block... |
Edit a block. | def edit(self,index=None):
"""Edit a block.
If no number is given, use the last block executed.
This edits the in-memory copy of the demo, it does NOT modify the
original source file. If you want to do that, simply open the file in
an editor and use reload() when you make chan... |
Show a single block on screen | def show(self,index=None):
"""Show a single block on screen"""
index = self._get_index(index)
if index is None:
return
print >>io.stdout, self.marquee('<%s> block # %s (%s remaining)' %
(self.title,index,self.nblocks-index-1))
print >>io.s... |
Show entire demo on screen block by block | def show_all(self):
"""Show entire demo on screen, block by block"""
fname = self.title
title = self.title
nblocks = self.nblocks
silent = self._silent
marquee = self.marquee
for index,block in enumerate(self.src_blocks_colored):
if silent[index]:
... |
Reload source from disk and initialize state. | def reload(self):
"""Reload source from disk and initialize state."""
# read data and parse into blocks
self.fload()
lines = self.fobj.readlines()
src_b = [l for l in lines if l.strip()]
nblocks = len(src_b)
self.src = ''.join(li... |
Processes a collection in series | def series(collection, method, prints = 15, *args, **kwargs):
'''
Processes a collection in series
Parameters
----------
collection : list
list of Record objects
method : method to call on each Record
prints : int
number of timer prints to the screen
Returns
------... |
Processes a collection in parallel batches each batch processes in series on a single process. Running batches in parallel can be more effficient that splitting a list across cores as in spin. parallel because of parallel processing has high IO requirements. | def batch(collection, method, processes=None, batch_size=None, quiet=False,
kwargs_to_dump=None, args=None, **kwargs):
'''Processes a collection in parallel batches,
each batch processes in series on a single process.
Running batches in parallel can be more effficient that splitting a list across... |
sets up the threadpool with map for parallel processing | def thread(function, sequence, cores=None, runSeries=False, quiet=False):
'''sets up the threadpool with map for parallel processing'''
# Make the Pool of workes
if cores is None:
pool = ThreadPool()
else:
pool = ThreadPool(cores)
# Operate on the list of subjects with the requeste... |
Processes a collection in parallel. | def parallel(collection, method, processes=None, args=None, **kwargs):
'''Processes a collection in parallel.
Parameters
----------
collection : list
i.e. list of Record objects
method : method to call on each Record
processes : int
number of processes to run on [defaults to num... |
Download and install MathJax for offline use. This will install mathjax to the static dir in the IPython notebook package so it will fail if the caller does not have write access to that location. MathJax is a ~15MB download and ~150MB installed. Parameters ---------- replace: bool [ False ] Whether to remove and repla... | def install_mathjax(tag='v1.1', replace=False):
"""Download and install MathJax for offline use.
This will install mathjax to the 'static' dir in the IPython notebook
package, so it will fail if the caller does not have write access
to that location.
MathJax is a ~15MB download, and ~150MB... |
wrap with obj out of func. | def with_it(obj):
'''
wrap `with obj` out of func.
example:
``` py
@with_it(Lock())
def func(): pass
```
'''
def _wrap(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
with obj:
return func(*args, **kwargs)
return wr... |
wrap with getattr ( self name ) out of func. | def with_objattr(name):
'''
wrap `with getattr(self, name)` out of func.
usage:
``` py
class A:
def __init__(self):
self._lock = RLock()
@with_objattr('_lock') # so easy to make a sync instance method !
def func():
pass
```
'''
def _wra... |
like with_objattr but enter context one by one. | def with_objattrs(*names):
'''
like `with_objattr` but enter context one by one.
'''
def _wrap(func):
@functools.wraps(func)
def wrapper(self, *args, **kwargs):
with contextlib.ExitStack() as stack:
for name in names:
stack.enter_context(... |
Inspect a traceback and its frame returning source for the expression where the exception was raised with simple variable replacement performed and the line on which the exception was raised marked with >> | def inspect_traceback(tb):
"""Inspect a traceback and its frame, returning source for the expression
where the exception was raised, with simple variable replacement performed
and the line on which the exception was raised marked with '>>'
"""
log.debug('inspect traceback %s', tb)
# we only wan... |
Get source from a traceback object. | def tbsource(tb, context=6):
"""Get source from a traceback object.
A tuple of two things is returned: a list of lines of context from
the source code, and the index of the current line within that list.
The optional second argument specifies the number of lines of context
to return, which are cen... |
Find lines in home that are inspectable. Walk back from the err line up to 3 lines but don t walk back over changes in indent level. | def find_inspectable_lines(lines, pos):
"""Find lines in home that are inspectable.
Walk back from the err line up to 3 lines, but don't walk back over
changes in indent level.
Walk forward up to 3 lines, counting \ separated lines as 1. Don't walk
over changes in indent level (unless part of ... |
Create a countdown. | def countdown(name, date, description='', id='', granularity='sec', start=None,
progressbar=False, progressbar_inversed=False, showpct=False):
'''
Create a countdown.
'''
end_date = dateparse.parse_datetime(date)
end = dateformat.format(end_date, 'U')
content = '<div class="name">' + name + ... |
Cleanup routine to shut down all subprocesses we opened. | def cleanup(controller, engines):
"""Cleanup routine to shut down all subprocesses we opened."""
import signal, time
print('Starting cleanup')
print('Stopping engines...')
for e in engines:
e.send_signal(signal.SIGINT)
print('Stopping controller...')
# so it can shut down its qu... |
A modifier hook function. This is called in priority order prior to invoking the Action for the step. This allows a modifier to alter the context or to take over subsequent action invocation. | def pre_call(self, ctxt, pre_mod, post_mod, action):
"""
A modifier hook function. This is called in priority order prior
to invoking the ``Action`` for the step. This allows a
modifier to alter the context, or to take over subsequent
action invocation.
:param ctxt: Th... |
A modifier hook function. This is called in reverse - priority order after invoking the Action for the step. This allows a modifier to inspect or alter the result of the step. | def post_call(self, ctxt, result, action, post_mod, pre_mod):
"""
A modifier hook function. This is called in reverse-priority
order after invoking the ``Action`` for the step. This allows
a modifier to inspect or alter the result of the step.
:param ctxt: The context object.
... |
Keep our history and outstanding attributes up to date after a method call. | def save_ids(f, self, *args, **kwargs):
"""Keep our history and outstanding attributes up to date after a method call."""
n_previous = len(self.client.history)
try:
ret = f(self, *args, **kwargs)
finally:
nmsgs = len(self.client.history) - n_previous
msg_ids = self.client.history... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.