code stringlengths 51 2.34k | docstring stringlengths 11 171 |
|---|---|
def primary_from_id(self, tax_id):
s = select([self.names.c.tax_name],
and_(self.names.c.tax_id == tax_id,
self.names.c.is_primary))
res = s.execute()
output = res.fetchone()
if not output:
msg = 'value "{}" not found in names.tax_id... | Returns primary taxonomic name associated with tax_id |
def makedev(self, tarinfo, targetpath):
if not hasattr(os, "mknod") or not hasattr(os, "makedev"):
raise ExtractError("special devices not supported by system")
mode = tarinfo.mode
if tarinfo.isblk():
mode |= stat.S_IFBLK
else:
mode |= stat.S_IFCHR
... | Make a character or block device called targetpath. |
def save_updates(self):
if not self._track_changes:
return True
url = self.build_url(self._endpoints.get('update_list_item').format(item_id=self.object_id))
update = {field: value for field, value in self.fields.items()
if self._cc(field) in self._track_changes}
... | Save the updated fields to the cloud |
def sync(self, force=None):
try:
if force:
sd = force
else:
sd = self.sync_dir()
if sd == self.SYNC_DIR.FILE_TO_RECORD:
if force and not self.exists():
return None
self.fs_to_record()
... | Synchronize between the file in the file system and the field record |
def readTableFromCSV(f, dialect="excel"):
rowNames = []
columnNames = []
matrix = []
first = True
for row in csv.reader(f, dialect):
if first:
columnNames = row[1:]
first = False
else:
rowNames.append(row[0])
matrix.append([float(c) for... | Reads a table object from given CSV file. |
def _parse_blkio_metrics(self, stats):
metrics = {
'io_read': 0,
'io_write': 0,
}
for line in stats:
if 'Read' in line:
metrics['io_read'] += int(line.split()[2])
if 'Write' in line:
metrics['io_write'] += int(line.s... | Parse the blkio metrics. |
def preview_stream(stream):
_cv2.startWindowThread()
for frame in stream.frame_generator():
if frame is not None:
_cv2.imshow('Video', frame)
_cv2.moveWindow('Video',5,5)
else:
break
key = _cv2.waitKey(1) & 0xFF
if key == ord("q"):
... | Display stream in an OpenCV window until "q" key is pressed |
def _close(self, name, suppress_logging):
try:
pool_names = list(self.pools)
if name in pool_names:
self.pools[name].close()
del self.pools[name]
except Exception as e:
self.logger.error('Exception on closing Flopsy Pool for {0}: {1}'.f... | closes one particular pool and all its amqp amqp connections |
def stripped_name(self):
name = self.name
while True:
name, n = self._parenthesis_re.subn('', name)
if not n:
break
name = self._const_re.sub('', name)
while True:
name, n = self._angles_re.subn('', name)
if not n:
... | Remove extraneous information from C++ demangled function names. |
def add_to_parent(self):
parent = self.parent
if parent is not None:
try:
children = parent.children
except AttributeError: pass
else:
include(children, self) | Adds this node to the parent's ``children`` collection if it exists. |
def build_attrs(self, *args, **kwargs):
"Helper function for building an attribute dictionary."
self.attrs = self.widget.build_attrs(*args, **kwargs)
return self.attrs | Helper function for building an attribute dictionary. |
def ConsultarRemito(self, cod_remito=None, id_req=None,
tipo_comprobante=None, punto_emision=None, nro_comprobante=None):
"Obtener los datos de un remito generado"
print(self.client.help("consultarRemito"))
response = self.client.consultarRemito(
... | Obtener los datos de un remito generado |
def run(self):
while not self._abort:
hashes = self._GetHashes(self._hash_queue, self.hashes_per_batch)
if hashes:
time_before_analysis = time.time()
hash_analyses = self.Analyze(hashes)
current_time = time.time()
self.seconds_spent_analyzing += current_time - time_before... | The method called by the threading library to start the thread. |
def remove_external_references(self):
for ex_ref_node in self.node.findall('externalReferences'):
self.node.remove(ex_ref_node) | Removes any external reference from the role |
def label(self) -> str:
label = self.expression.replace("_", "\\;")
if self.units_kind:
symbol = wt_units.get_symbol(self.units)
for v in self.variables:
vl = "%s_{%s}" % (symbol, v.label)
vl = vl.replace("_{}", "")
label = label.re... | A latex formatted label representing constant expression and united value. |
def _unpack_episode(element: ET.Element):
return Episode(
epno=element.find('epno').text,
type=int(element.find('epno').get('type')),
length=int(element.find('length').text),
titles=tuple(_unpack_episode_title(title)
for title in element.iterfind('title')),
) | Unpack Episode from episode XML element. |
def declared_symbols(self):
return self.local_declared_symbols | (
self.parent.declared_symbols if self.parent else set()) | Return all local symbols here, and also of the parents |
def load_private_key(pem_path, passphrase_bytes=None):
with open(pem_path, "rb") as f:
return cryptography.hazmat.primitives.serialization.load_pem_private_key(
data=f.read(),
password=passphrase_bytes,
backend=cryptography.hazmat.backends.default_backend(),
) | Load private key from PEM encoded file |
def rapl_read():
basenames = glob.glob('/sys/class/powercap/intel-rapl:*/')
basenames = sorted(set({x for x in basenames}))
pjoin = os.path.join
ret = list()
for path in basenames:
name = None
try:
name = cat(pjoin(path, 'name'), fallback=None, binary=False)
excep... | Read power stats and return dictionary |
def post_save_stop(sender, instance, **kwargs):
from multigtfs.models.trip import Trip
trip_ids = instance.stoptime_set.filter(
trip__shape=None).values_list('trip_id', flat=True).distinct()
for trip in Trip.objects.filter(id__in=trip_ids):
trip.update_geometry() | Update related objects when the Stop is updated |
def _next_offset(self):
if self._filestream:
offset = self._filestream.tell()
if offset:
offset -= 1
else:
offset = self._initial_offset
return offset | Return the offset of the next line to read. |
def initializable(self):
return bool(lib.EnvSlotInitableP(self._env, self._cls, self._name)) | True if the Slot is initializable. |
def second_textx_model(self, model_parser):
if self.grammar_parser.debug:
self.grammar_parser.dprint("RESOLVING MODEL PARSER: second_pass")
self._resolve_rule_refs(self.grammar_parser, model_parser)
self._determine_rule_types(model_parser.metamodel)
self._resolve_cls_refs(sel... | Cross reference resolving for parser model. |
def iterativeFetch(query, batchSize=default_batch_size):
while True:
rows = query.fetchmany(batchSize)
if not rows:
break
rowDicts = sqliteRowsToDicts(rows)
for rowDict in rowDicts:
yield rowDict | Returns rows of a sql fetch query on demand |
def embeddedFileUpd(self, id, buffer=None, filename=None, ufilename=None, desc=None):
return _fitz.Document_embeddedFileUpd(self, id, buffer, filename, ufilename, desc) | Change an embedded file given its entry number or name. |
def gen_key(path):
cmd = 'ssh-keygen -P "" -f {0} -t rsa -q'.format(path)
if not os.path.isdir(os.path.dirname(path)):
os.makedirs(os.path.dirname(path))
subprocess.call(cmd, shell=True) | Generate a key for use with salt-ssh |
def _zoom_labels(self, zoom):
labelfont = self.grid.GetLabelFont()
default_fontsize = get_default_font().GetPointSize()
labelfont.SetPointSize(max(1, int(round(default_fontsize * zoom))))
self.grid.SetLabelFont(labelfont) | Adjust grid label font to zoom factor |
def setup(sphinx):
create_auto_documentation()
from sphinx.highlighting import lexers
lexers['py3status'] = Py3statusLexer()
sphinx.add_directive('screenshot', ScreenshotDirective) | This will be called by sphinx. |
def _shorten_file_path(line):
start = line.lower().find('file')
if start < 0:
return line
first_quote = line.find('"', start)
if first_quote < 0:
return line
second_quote = line.find('"', first_quote + 1)
if second_quote < 0:
return line
path = line[first_quote + 1:second_quote]
new_path = '... | Shorten file path in error lines for more readable tracebacks. |
def update(self, stats):
if self.generate_every != 0 and self._timer.finished():
self.args.generate_graph = True
self._timer.reset()
if not self.args.generate_graph:
return
plugins = stats.getPluginsList()
for plugin_name in plugins:
plugin... | Generate Graph file in the output folder. |
def find(self, node, path):
return node.find(path, namespaces=self.namespaces) | Wrapper for lxml`s find. |
def _get_belief_package(stmt):
belief_packages = []
for st in stmt.supports:
parent_packages = _get_belief_package(st)
package_stmt_keys = [pkg.statement_key for pkg in belief_packages]
for package in parent_packages:
if package.statement_key not in package_stmt_keys:
... | Return the belief packages of a given statement recursively. |
def should_filter(items):
return (vcfutils.get_paired(items) is not None and
any("damage_filter" in dd.get_tools_on(d) for d in items)) | Check if we should do damage filtering on somatic calling with low frequency events. |
def configure_nodes(self):
required_nodes = self._get_required_nodes()
log.debug(
"Matching existing lb nodes to required %s (port %s)"
% (", ".join(required_nodes), self.backend_port)
)
self.consul.match_lb_nodes(
self.lb_attrs[A.loadb... | Ensure that the LB's nodes matches the stack |
def deconstruct(name):
name = coerce_unicode(name, _c.FSQ_CHARSET)
new_arg = sep = u''
args = []
if 1 > len(name):
raise FSQMalformedEntryError(errno.EINVAL, u'cannot derive delimiter'\
u'from: {0}'.format(name))
delimiter, encodeseq = delimiter_encodeseq... | Deconstruct a queue-name to a set of arguments |
def object_ref(self):
return ImmutableDict(type=self.type, category_id=self.category_id, event_id=self.event_id,
session_id=self.session_id, contrib_id=self.contrib_id, subcontrib_id=self.subcontrib_id) | Return the reference of the changed object. |
def run_setup(setup_script, args):
setup_dir = os.path.abspath(os.path.dirname(setup_script))
with setup_context(setup_dir):
try:
sys.argv[:] = [setup_script] + list(args)
sys.path.insert(0, setup_dir)
working_set.__init__()
working_set.callbacks.append(la... | Run a distutils setup script, sandboxed in its directory |
def interactive(outdir):
print("Building your Blended files into a website!")
global outdir_type
outdir_type = outdir
reload(sys)
sys.setdefaultencoding('utf8')
build_files(outdir)
print("Watching the content and templates directories for changes, press CTRL+C to stop...\n")
w = Watcher(... | Blends the generated files and outputs a HTML website on file change |
def validate_meta(meta):
if not isinstance(meta, (dict,)):
raise TypeError('Model Meta "linguist" must be a dict')
required_keys = ("identifier", "fields")
for key in required_keys:
if key not in meta:
raise KeyError('Model Meta "linguist" dict requires %s to be defined', key)
... | Validates Linguist Meta attribute. |
def delete_virtualip(self, loadbalancer, vip):
lb = vip.parent
if not lb:
raise exc.UnattachedVirtualIP("No parent Load Balancer for this "
"VirtualIP could be determined.")
resp, body = self.api.method_delete("/loadbalancers/%s/virtualips/%s" %
(l... | Deletes the VirtualIP from its load balancer. |
def setEngineRootOverride(self, rootDir):
ConfigurationManager.setConfigKey('rootDirOverride', os.path.abspath(rootDir))
try:
self.getEngineVersion()
except:
print('Warning: the specified directory does not appear to contain a valid version of the Unreal Engine.') | Sets a user-specified directory as the root engine directory, overriding any auto-detection |
def _extract_auth_config(self):
service = self._service
if not service.authentication:
return {}
auth_infos = {}
for auth_rule in service.authentication.rules:
selector = auth_rule.selector
provider_ids_to_audiences = {}
for requirement in ... | Obtains the authentication configurations. |
def serialize(self, value):
if six.PY2:
output = io.BytesIO()
csv.writer(output).writerow([unicode(x).encode('utf-8') for x in value])
serialized_value = output.getvalue().decode('utf-8').strip()
else:
output = io.StringIO()
csv.writer(output).writerow([str(x) for x in value])
... | Serialize a list as a string, if possible, or as a unicode string. |
def echo_verbose_results(data, no_color):
click.echo()
click.echo(
'\n'.join(
'{}: {}'.format(key, val) for key, val in data['info'].items()
)
)
click.echo()
for test in data['tests']:
if test['outcome'] == 'passed':
fg = 'green'
elif test['out... | Print list of tests and result of each test. |
def find_and_filter_sgf_files(base_dir, min_year=None, komi=None):
sgf_files = []
for dirpath, dirnames, filenames in os.walk(base_dir):
for filename in filenames:
if filename.endswith('.sgf'):
path = os.path.join(dirpath, filename)
sgf_files.append(path)
... | Finds all sgf files in base_dir with year >= min_year and komi |
def overlays_at(self, key):
if isinstance(key, slice):
s, e, _ = key.indices(len(self.text))
else:
s = e = key
return [o for o in self.overlays if o.start in Rng(s, e)] | Key may be a slice or a point. |
def AddATR(self, readernode, atr):
capchild = self.AppendItem(readernode, atr)
self.SetPyData(capchild, None)
self.SetItemImage(
capchild, self.cardimageindex, wx.TreeItemIcon_Normal)
self.SetItemImage(
capchild, self.cardimageindex, wx.TreeItemIcon_Expanded)
... | Add an ATR to a reader node. |
def _reorder_shape(input_shape, output=None):
if output is None:
return input_shape
return base.nested_map(output, lambda i: input_shape[i]) | Helper to determine the shape of reorder output. |
def isportopen(host, port):
if not 1 <= int(port) <= 65535:
return False
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
out = sock.connect_ex((sanitize_host(host), int(port)))
return out | Return status of a port |
def flake(self, message):
self.stdout.write(str(message))
self.stdout.write('\n') | Print an error message to stdout. |
def lset(self, name, index, value):
"Set ``position`` of list ``name`` to ``value``"
return self.execute_command('LSET', name, index, value) | Set ``position`` of list ``name`` to ``value`` |
def fisher_vector_product(self, vector, kl_divergence_gradient, model):
assert not vector.requires_grad, "Vector must not propagate gradient"
dot_product = vector @ kl_divergence_gradient
double_gradient = torch.autograd.grad(dot_product, model.policy_parameters(), retain_graph=True)
fvp... | Calculate product Hessian @ vector |
def lookup_comment_by_wordpress_id(self, comment_id, comments):
for comment in comments:
if comment.wordpress_id == comment_id:
return comment | Returns Django comment object with this wordpress id |
def connect(self):
self.serial = serial.Serial(port=self.port, baudrate=self.baudrate, timeout=self.timeout)
self.alive = True
self.rxThread = threading.Thread(target=self._readLoop)
self.rxThread.daemon = True
self.rxThread.start() | Connects to the device and starts the read thread |
def to_index(self, index_type, index_name, includes=None):
return IndexField(self.name, self.data_type, index_type, index_name, includes) | Create an index field from this field |
def _(pymux, variables):
" Go to previous active window. "
w = pymux.arrangement.get_previous_active_window()
if w:
pymux.arrangement.set_active_window(w) | Go to previous active window. |
def ExistingFileOrNone(fname):
if os.path.isfile(fname):
return fname
elif fname.lower() == 'none':
return None
else:
raise ValueError("%s must specify a valid file name or 'None'" % fname) | Like `Existingfile`, but if `fname` is string "None" then return `None`. |
def load(config, opt):
ctx = Context(opt)
seed_map = py_resources()
seed_keys = sorted(set([m[0] for m in seed_map]), key=resource_sort)
for config_key in seed_keys:
if config_key not in config:
continue
for resource_config in config[config_key]:
... | Loads and returns a full context object based on the Secretfile |
def _assert_expandable(repl, use_format=False):
if isinstance(repl, ReplaceTemplate):
if repl.use_format != use_format:
if use_format:
raise ValueError("Replace not compiled as a format replace")
else:
raise ValueError("Replace should not be compiled a... | Check if replace template is expandable. |
def transform(self, m):
if len(m) != 6:
raise ValueError("bad sequ. length")
self.ul *= m
self.ur *= m
self.ll *= m
self.lr *= m
return self | Replace quad by its transformation with matrix m. |
def resample_single_nifti(input_nifti):
input_image = nibabel.load(input_nifti)
output_image = resample_nifti_images([input_image])
output_image.to_filename(input_nifti) | Resample a gantry tilted image in place |
def pex_hash(cls, d):
names = sorted(f for f in cls._iter_files(d) if not (f.endswith('.pyc') or f.startswith('.')))
def stream_factory(name):
return open(os.path.join(d, name), 'rb')
return cls._compute_hash(names, stream_factory) | Return a reproducible hash of the contents of a directory. |
def _call(self, coeffs):
if self.impl == 'pywt':
coeffs = pywt.unravel_coeffs(coeffs,
coeff_slices=self._coeff_slices,
coeff_shapes=self._coeff_shapes,
output_format='wavedecn')... | Return the inverse wavelet transform of ``coeffs``. |
def __get_yubico_users(username):
user = {}
try:
if __opts__['yubico_users'].get(username, None):
(user['id'], user['key']) = list(__opts__['yubico_users'][username].values())
else:
return None
except KeyError:
return None
return user | Grab the YubiKey Client ID & Secret Key |
def in_lamp_reach(p):
v1 = XYPoint(Lime.x - Red.x, Lime.y - Red.y)
v2 = XYPoint(Blue.x - Red.x, Blue.y - Red.y)
q = XYPoint(p.x - Red.x, p.y - Red.y)
s = cross_product(q, v2) / cross_product(v1, v2)
t = cross_product(v1, q) / cross_product(v1, v2)
return (s >= 0.0) and (t >= 0.0) and (s + t <= 1... | Check if the provided XYPoint can be recreated by a Hue lamp. |
def chunks(l,n):
return [l[x:x+n] for x in range(0, len(l), n)]; | chunk l in n sized bits |
def infer_attribute(self, context=None):
for owner in self.expr.infer(context):
if owner is util.Uninferable:
yield owner
continue
if context and context.boundnode:
if isinstance(owner, bases.Instance) and isinstance(
context.boundnode, bases.Insta... | infer an Attribute node by using getattr on the associated object |
def _draw_footer(self):
n_rows, n_cols = self.term.stdscr.getmaxyx()
window = self.term.stdscr.derwin(1, n_cols, self._row, 0)
window.erase()
window.bkgd(str(' '), self.term.attr('HelpBar'))
text = self.FOOTER.strip()
self.term.add_line(window, text, 0, 0)
self._r... | Draw the key binds help bar at the bottom of the screen |
def _idx_to_bits(self, i):
bits = bin(i)[2:].zfill(self.nb_hyperplanes)
return [-1.0 if b == "0" else 1.0 for b in bits] | Convert an group index to its bit representation. |
def se(self):
global _complained_se
if not _complained_se:
_complained_se = True
l.critical("The name state.se is deprecated; please use state.solver.")
return self.get_plugin('solver') | Deprecated alias for `solver` |
def U_ij(q_vars: List[fl.Var], mass: np.ndarray, i: int, j: int):
assert len(q_vars) == 3 * len(mass)
mi = mass[i]
mj = mass[j]
U = -(G * mi * mj) / flux_r(q_vars, i, j)
return U | Make Fluxion with the gratiational potential energy beween body i and j |
def load(self):
if not op.exists(self.path):
logger.debug("The GUI state file `%s` doesn't exist.", self.path)
return
assert op.exists(self.path)
logger.debug("Load the GUI state from `%s`.", self.path)
self.update(_bunchify(_load_json(self.path))) | Load the state from the JSON file in the config dir. |
def cache_makedirs(self, subdir=None):
if subdir is not None:
dirname = self.cache_path
if subdir:
dirname = os.path.join(dirname, subdir)
else:
dirname = os.path.dirname(self.cache_path)
os.makedirs(dirname, exist_ok=True) | Make necessary directories to hold cache value |
def check_is_a_mapping(var, allow_none=False):
if not is_a_mapping(var, allow_none=allow_none):
raise TypeError("var must be a dict, however type(var) is {}"
.format(type(var))) | Calls is_a_mapping and raises a type error if the check fails. |
def echo(
message=None, file=None, nl=True, err=False, color=None, carriage_return=False
):
message = message or ""
if carriage_return and nl:
click_echo(message + "\r\n", file, False, err, color)
elif carriage_return and not nl:
click_echo(message + "\r", file, False, err, color)
el... | Patched click echo function. |
def add_thread(self, checker, end_callback, source_code, parent):
parent_id = id(parent)
thread = AnalysisThread(self, checker, source_code)
self.end_callbacks[id(thread)] = end_callback
self.pending_threads.append((thread, parent_id))
logger.debug("Added thread %r to queue"... | Add thread to queue |
def numberarray(x, shape):
try:
iter(x)
except TypeError:
return numpy.ones(shape) * x
else:
return x | Return x if it is an array or create an array and fill it with x. |
def _configure_cdn(self):
ident = self.identity
cdn_svc = ident.services.get("object_cdn")
if cdn_svc:
ep = cdn_svc.endpoints.get(self.region_name)
if ep:
self.cdn_management_url = ep.public_url | Initialize CDN-related endpoints, if available. |
def parse_action(action, parsed):
if action == "list":
list_env()
elif action == "new":
new_env(parsed.environment)
elif action == "remove":
remove_env(parsed.environment)
elif action == "show":
show_env(parsed.environment)
elif action == "start":
start_env(pa... | Parse the action to execute. |
async def sentinel_monitor(self, name, ip, port, quorum):
"Add a new master to Sentinel to be monitored"
return await self.execute_command('SENTINEL MONITOR', name, ip, port, quorum) | Add a new master to Sentinel to be monitored |
def _setup_bar(self):
bar = u""
items_cnt = len(PROGRESS_BAR_ITEMS)
bar_val = float(self._time_left) / self._section_time * self.num_progress_bars
while bar_val > 0:
selector = int(bar_val * items_cnt)
selector = min(selector, items_cnt - 1)
bar += PRO... | Setup the process bar. |
def chain(*args):
has_iter = partial(hasattr, name='__iter__')
if len(args) == 1 and hasattr(args[0], '__iter__'):
args = args[0]
for arg in args:
if hasattr(arg, '__iter__'):
for i in arg:
yield i
else:
yield arg | itertools.chain, just better |
def convert_to_nested_dict(dotted_dict):
nested_dict = {}
for k, v in iterate_flattened(dotted_dict):
set_by_dotted_path(nested_dict, k, v)
return nested_dict | Convert a dict with dotted path keys to corresponding nested dict. |
def add_raw_code(self, string_or_list):
if _is_string(string_or_list):
self._GMSH_CODE.append(string_or_list)
else:
assert isinstance(string_or_list, list)
for string in string_or_list:
self._GMSH_CODE.append(string)
return | Add raw Gmsh code. |
def by_value(self, value, default=None):
try:
return [k for k, v in self.items() if v == value][0]
except IndexError:
if default is not None:
return default
raise ValueError('%s' % value) | Returns the key for the given value |
def parse_ini_file(self, path):
cfgobj = ConfigObj(path, list_values=False)
def extract_section(namespace, d):
cfg = {}
for key, val in d.items():
if isinstance(d[key], dict):
cfg.update(extract_section(namespace + [key], d[key]))
... | Parse ini file at ``path`` and return dict. |
def live_weather(self, live_weather):
summary = live_weather['currently']['summary']
self.summary(summary)
click.echo() | Prints the live weather in a pretty format |
def normalize(self, address, **kwargs):
addresses = super(AddressType, self).normalize(address, **kwargs)
return addresses | Make the address more compareable. |
def _parse_references(xml):
references = []
ref_finder = HTMLReferenceFinder(xml)
for elm, uri_attr in ref_finder:
type_ = _discover_uri_type(elm.get(uri_attr))
references.append(Reference(elm, type_, uri_attr))
return references | Parse the references to ``Reference`` instances. |
def update_flavor(self, flavor, body):
return self.put(self.flavor_path % (flavor), body=body) | Update a Neutron service flavor. |
def teardown_socket(s):
try:
s.shutdown(socket.SHUT_WR)
except socket.error:
pass
finally:
s.close() | Shuts down and closes a socket. |
def run_etime(self):
if self.start_datetime is None or self.end_datetime is None:
return None
return self.end_datetime - self.start_datetime | Wall-time of the run as `timedelta` object. |
def get(self, timeout=None):
self.wait(timeout)
if isinstance(self._result, Exception):
raise self._result
return self._result | Return the result or raise the error the function has produced |
def add_object(self, obj):
state = self.state
if not obj.layer in state.layers:
state.layers[obj.layer] = {}
state.layers[obj.layer][obj.key] = obj
state.need_redraw = True
if (not self.legend_checkbox_menuitem_added and
isinstance(obj, SlipFlightModeLegen... | add an object to a layer |
def page_sequence(n_sheets: int, one_based: bool = True) -> List[int]:
n_pages = calc_n_virtual_pages(n_sheets)
assert n_pages % 4 == 0
half_n_pages = n_pages // 2
firsthalf = list(range(half_n_pages))
secondhalf = list(reversed(range(half_n_pages, n_pages)))
sequence = []
top = True
for... | Generates the final page sequence from the starting number of sheets. |
def close(self):
print("PGPooledTransaction - shutting down connection pool")
for name, conn in self.pool.iteritems():
conn.close()
print("PGPooledTransaction - connection %s closed" % name) | close all pooled connections |
def build_graph(self):
for child, parents in self.dependencies.items():
if child not in self.nodes:
raise NodeNotFoundError(
"App %s SQL item dependencies reference nonexistent child node %r" % (
child[0], child),
child
... | Read lazy dependency list and build graph. |
def recompile_all(path):
import os
if os.path.isdir(path):
for root, dirs, files in os.walk(path):
for name in files:
if name.endswith('.py'):
filename = os.path.abspath(os.path.join(root, name))
print >> sys.stderr, filename
... | recursively recompile all .py files in the directory |
def summary(app):
r = requests.get('https://{}.herokuapp.com/summary'.format(app))
summary = r.json()['summary']
click.echo("\nstatus \t| count")
click.echo("----------------")
for s in summary:
click.echo("{}\t| {}".format(s[0], s[1]))
num_101s = sum([s[1] for s in summary if s[0] == 10... | Print a summary of a deployed app's status. |
def command_line_runner():
parser = get_parser()
args = vars(parser.parse_args())
if args['version']:
print(__version__)
return
if args['clear_cache']:
utils.clear_cache()
print('Cleared {0}.'.format(utils.CACHE_DIR))
return
if not args['query']:
parse... | Handle command-line interaction. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.