code stringlengths 51 2.38k | docstring stringlengths 4 15.2k |
|---|---|
def subgraph(self, nodes):
adj_matrix = self.csgraph[np.ix_(nodes, nodes)]
weighted = True
if self.node_labels is not None:
node_labels = self.node_labels[nodes]
else:
node_labels = None
return DiGraph(adj_matrix, weighted=weighted, node_labels=node_labels... | Return the subgraph consisting of the given nodes and edges
between thses nodes.
Parameters
----------
nodes : array_like(int, ndim=1)
Array of node indices.
Returns
-------
DiGraph
A DiGraph representing the subgraph. |
def _index_key_for(self, att, value=None):
if value is None:
value = getattr(self, att)
if callable(value):
value = value()
if value is None:
return None
if att not in self.lists:
return self._get_index_key_for_non_list_attr(att, va... | Returns a key based on the attribute and its value.
The key is used for indexing. |
def cli(env):
mgr = SoftLayer.EventLogManager(env.client)
event_log_types = mgr.get_event_log_types()
table = formatting.Table(COLUMNS)
for event_log_type in event_log_types:
table.add_row([event_log_type])
env.fout(table) | Get Event Log Types |
def check_roundoff(self, rtol=0.25, atol=1e-6):
psdev = _gvar.sdev(self.p.flat)
paltsdev = _gvar.sdev(self.palt.flat)
if not numpy.allclose(psdev, paltsdev, rtol=rtol, atol=atol):
warnings.warn("Possible roundoff errors in fit.p; try svd cut.") | Check for roundoff errors in fit.p.
Compares standard deviations from fit.p and fit.palt to see if they
agree to within relative tolerance ``rtol`` and absolute tolerance
``atol``. Generates a warning if they do not (in which
case an SVD cut might be advisable). |
def _apply_to_data(data, func, unpack_dict=False):
apply_ = partial(_apply_to_data, func=func, unpack_dict=unpack_dict)
if isinstance(data, dict):
if unpack_dict:
return [apply_(v) for v in data.values()]
return {k: apply_(v) for k, v in data.items()}
if isinstance(data, (list, t... | Apply a function to data, trying to unpack different data
types. |
def publish_server_closed(self, server_address, topology_id):
event = ServerClosedEvent(server_address, topology_id)
for subscriber in self.__server_listeners:
try:
subscriber.closed(event)
except Exception:
_handle_exception() | Publish a ServerClosedEvent to all server listeners.
:Parameters:
- `server_address`: The address (host/port pair) of the server.
- `topology_id`: A unique identifier for the topology this server
is a part of. |
def fromDictionary(value):
if isinstance(value, dict):
pp = PortalParameters()
for k,v in value.items():
setattr(pp, "_%s" % k, v)
return pp
else:
raise AttributeError("Invalid input.") | creates the portal properties object from a dictionary |
def request_uplink_info(self, context, agent):
LOG.debug('request_uplink_info from %(agent)s', {'agent': agent})
event_type = 'agent.request.uplink'
payload = {'agent': agent}
timestamp = time.ctime()
data = (event_type, payload)
pri = self.obj.PRI_LOW_START + 1
s... | Process uplink message from an agent. |
def command(cmd):
status, out = commands.getstatusoutput(cmd)
if status is not 0:
logger.error("Something went wrong:")
logger.error(out)
raise SdistCreationError()
return out | Execute command and raise an exception upon an error.
>>> 'README' in command('ls')
True
>>> command('nonexistingcommand') #doctest: +ELLIPSIS
Traceback (most recent call last):
...
SdistCreationError |
def future(self,
request_iterator,
timeout=None,
metadata=None,
credentials=None):
return _utils.wrap_future_call(
self._inner.future(
_utils.WrappedAsyncIterator(request_iterator, self._loop),
... | Asynchronously invokes the underlying RPC on the client.
Args:
request_iterator: An ASYNC iterator that yields request values for the RPC.
timeout: An optional duration of time in seconds to allow for the RPC.
If None, the timeout is considered infinite.
metadata: Optional :term:`m... |
def unset(ctx, key):
file = ctx.obj['FILE']
quote = ctx.obj['QUOTE']
success, key = unset_key(file, key, quote)
if success:
click.echo("Successfully removed %s" % key)
else:
exit(1) | Removes the given key. |
def score_kmer(self, kmer):
if len(kmer) != len(self.pwm):
raise Exception("incorrect k-mer length")
score = 0.0
d = {"A":0, "C":1, "G":2, "T":3}
for nuc, row in zip(kmer.upper(), self.pwm):
score += log(row[d[nuc]] / 0.25 + 0.01)
return score | Calculate the log-odds score for a specific k-mer.
Parameters
----------
kmer : str
String representing a kmer. Should be the same length as the motif.
Returns
-------
score : float
Log-odd score. |
def decode_vlqs(s):
ints = []
i = 0
shift = 0
for c in s:
raw = B64_INT[c]
cont = VLQ_CONT & raw
i = ((VLQ_BASE_MASK & raw) << shift) | i
shift += VLQ_SHIFT
if not cont:
sign = -1 if 1 & i else 1
ints.append((i >> 1) * sign)
i =... | Decode str `s` into a list of integers. |
def _tweak_lane(lane_details, dname):
tweak_config_file = os.path.join(dname, "lane_config.yaml")
if os.path.exists(tweak_config_file):
with open(tweak_config_file) as in_handle:
tweak_config = yaml.safe_load(in_handle)
if tweak_config.get("uniquify_lanes"):
out = []
... | Potentially tweak lane information to handle custom processing, reading a lane_config.yaml file. |
def _recurse_find_trace(self, structure, item, trace=[]):
try:
i = structure.index(item)
except ValueError:
for j,substructure in enumerate(structure):
if isinstance(substructure, list):
return self._recurse_find_trace(substructure, item, trace... | given a nested structure from _parse_repr and find the trace route to get to item |
def _previewFile(self):
dataFrame = self._loadCSVDataFrame()
dataFrameModel = DataFrameModel(dataFrame, filePath=self._filename)
dataFrameModel.enableEditing(True)
self._previewTableView.setModel(dataFrameModel)
columnModel = dataFrameModel.columnDtypeModel()
columnModel.... | Updates the preview widgets with new models for both tab panes. |
def check_vtech(text):
err = "institution.vtech"
msg = "Incorrect name. Use '{}' instead of '{}'."
institution = [
["Virginia Polytechnic Institute and State University",
["Virginia Polytechnic and State University"]],
]
return preferred_forms_check(text, institution, err, msg) | Suggest the correct name.
source: Virginia Tech Division of Student Affairs
source_url: http://bit.ly/2en1zbv |
def update_collisions(self):
if not self.mode['items'] or len(self.mode['items']) == 0: return
self.collman.clear()
for z, node in self.children:
if hasattr(node, 'cshape') and type(node.cshape) == cm.CircleShape:
self.collman.add(node)
for other in self.collm... | Test player for collisions with items |
def list_nodes_full(**kwargs):
nodes = _query('server/list')
ret = {}
for node in nodes:
name = nodes[node]['label']
ret[name] = nodes[node].copy()
ret[name]['id'] = node
ret[name]['image'] = nodes[node]['os']
ret[name]['size'] = nodes[node]['VPSPLANID']
ret[n... | Return all data on nodes |
def unfreeze(name, path=None, use_vt=None):
_ensure_exists(name, path=path)
if state(name, path=path) == 'stopped':
raise CommandExecutionError(
'Container \'{0}\' is stopped'.format(name)
)
cmd = 'lxc-unfreeze'
if path:
cmd += ' -P {0}'.format(pipes.quote(path))
... | Unfreeze the named container.
path
path to the container parent directory
default: /var/lib/lxc (system)
.. versionadded:: 2015.8.0
use_vt
run the command through VT
.. versionadded:: 2015.8.0
CLI Example:
.. code-block:: bash
salt '*' lxc.unfreeze ... |
def find_method(self, decl):
name = decl.name
method = None
try:
method = getattr(self, u'do_{}'.format(
(name).replace('-', '_')))
except AttributeError:
if name.startswith('data-'):
method = getattr(self, 'do_data_any... | Find class method to call for declaration based on name. |
def aggregated_records(all_records, key_fields=KEY_FIELDS):
flow_table = defaultdict(_FlowStats)
for flow_record in all_records:
key = tuple(getattr(flow_record, attr) for attr in key_fields)
if any(x is None for x in key):
continue
flow_table[key].update(flow_record)
for... | Yield dicts that correspond to aggregates of the flow records given by
the sequence of FlowRecords in `all_records`. Skips incomplete records.
This will consume the `all_records` iterator, and requires enough memory to
be able to read it entirely.
`key_fields` optionally contains the fields over which t... |
def clone(self, source_id, backup_id, size,
volume_id=None, source_host=None):
volume_id = volume_id or str(uuid.uuid4())
return self.http_put('/volumes/%s' % volume_id,
params=self.unused({
'source_host': source_host,
... | create a volume then clone the contents of
the backup into the new volume |
def set_rule_name(self, rule_name):
if not self.aws.get('xray', None):
self.aws['xray'] = {}
self.aws['xray']['sampling_rule_name'] = rule_name | Add the matched centralized sampling rule name
if a segment is sampled because of that rule.
This method should be only used by the recorder. |
def i32(self, name, value=None, align=None):
self.int(4, name, value, align) | Add an 32 byte integer field to template.
This is an convenience method that simply calls `Int` keyword with predefined length. |
def limit_mem(limit=(4 * 1024**3)):
"Set soft memory limit"
rsrc = resource.RLIMIT_DATA
soft, hard = resource.getrlimit(rsrc)
resource.setrlimit(rsrc, (limit, hard))
softnew, _ = resource.getrlimit(rsrc)
assert softnew == limit
_log = logging.getLogger(__name__)
_log.debug('Set soft memo... | Set soft memory limit |
def read_config(ip, mac):
click.echo("Read configuration from %s" % ip)
request = requests.get(
'http://{}/{}/{}/'.format(ip, URI, mac), timeout=TIMEOUT)
print(request.json()) | Read the current configuration of a myStrom device. |
def prepare_function_symbol(self, symbol_name, basic_addr=None):
if basic_addr is None:
basic_addr = self.project.loader.extern_object.get_pseudo_addr(symbol_name)
return basic_addr, basic_addr | Prepare the address space with the data necessary to perform relocations pointing to the given symbol
Returns a 2-tuple. The first item is the address of the function code, the second is the address of the
relocation target. |
def main():
parser = build_parser()
Job.Runner.addToilOptions(parser)
args = parser.parse_args()
inputs = {'config': args.config,
'config_fastq': args.config_fastq,
'input': args.input,
'unc.bed': args.unc,
'hg19.transcripts.fa': args.fasta,
... | This is a Toil pipeline for the UNC best practice RNA-Seq analysis.
RNA-seq fastqs are combined, aligned, sorted, filtered, and quantified.
Please read the README.md located in the same directory. |
def dir2zip(in_dir, zip_fname):
z = zipfile.ZipFile(zip_fname, 'w',
compression=zipfile.ZIP_DEFLATED)
for root, dirs, files in os.walk(in_dir):
for file in files:
in_fname = pjoin(root, file)
in_stat = os.stat(in_fname)
info = zipfile.ZipInfo(i... | Make a zip file `zip_fname` with contents of directory `in_dir`
The recorded filenames are relative to `in_dir`, so doing a standard zip
unpack of the resulting `zip_fname` in an empty directory will result in
the original directory contents.
Parameters
----------
in_dir : str
Director... |
def __get_wbfmt_usrfld(self, data_nt):
if self.ntfld_wbfmt is not None:
if isinstance(self.ntfld_wbfmt, str):
ntval = getattr(data_nt, self.ntfld_wbfmt, None)
if ntval is not None:
return self.fmtname2wbfmtobj.get(ntval, None) | Return format for text cell from namedtuple field specified by 'ntfld_wbfmt |
def activate(self, ideSettings, ideGlobalData):
WizardInterface.activate(self, ideSettings, ideGlobalData)
self.__where = self.__getConfiguredWhere()
self.ide.editorsManager.sigTabClosed.connect(self.__collectGarbage)
self.ide.project.sigProjectChanged.connect(self.__collectGarbage) | Activates the plugin.
The plugin may override the method to do specific
plugin activation handling.
ideSettings - reference to the IDE Settings singleton
see codimension/src/utils/settings.py
ideGlobalData - reference to the IDE global settings
... |
def orphans_single(default_exec=False):
if not default_exec and executable.endswith('uwsgi'):
_executable = executable[:-5] + 'python'
else:
_executable = executable
p = subprocess.Popen([_executable, '-m', 'nikola', 'orphans'],
stdout=subprocess.PIPE)
p.wait()
... | Remove all orphans in the site, in the single user-mode. |
def _CreateImage(media_service, opener, url):
image_data = opener.open(url).read().decode('utf-8')
image = {
'type': 'IMAGE',
'data': image_data,
'xsi_type': 'Image'
}
return media_service.upload(image)[0] | Creates an image and uploads it to the server.
Args:
media_service: a SudsServiceProxy instance for AdWords's MediaService.
opener: an OpenerDirector instance.
url: a str URL used to load image data.
Returns:
The image that was successfully uploaded. |
def get_apps_tools():
tools_paths = {}
for app_config in apps.get_app_configs():
proc_path = os.path.join(app_config.path, 'tools')
if os.path.isdir(proc_path):
tools_paths[app_config.name] = proc_path
custom_tools_paths = getattr(settings, 'RESOLWE_CUSTOM_TOOLS_PATHS', [])
i... | Get applications' tools and their paths.
Return a dict with application names as keys and paths to tools'
directories as values. Applications without tools are omitted. |
def _postcheck(self, network, feedin):
curtailment = network.timeseries.curtailment
gen_repr = [repr(_) for _ in curtailment.columns]
feedin_repr = feedin.loc[:, gen_repr]
curtailment_repr = curtailment
curtailment_repr.columns = gen_repr
if not ((feedin_repr - curtailmen... | Raises an error if the curtailment of a generator exceeds the
feed-in of that generator at any time step.
Parameters
-----------
network : :class:`~.grid.network.Network`
feedin : :pandas:`pandas.DataFrame<dataframe>`
DataFrame with feed-in time series in kW. Columns... |
def accuracy(current, predicted):
acc = 0
if np.count_nonzero(predicted) > 0:
acc = float(np.dot(current, predicted))/float(np.count_nonzero(predicted))
return acc | Computes the accuracy of the TM at time-step t based on the prediction
at time-step t-1 and the current active columns at time-step t.
@param current (array) binary vector containing current active columns
@param predicted (array) binary vector containing predicted active columns
@return acc (float) predic... |
def preflightInfo(info):
missingRequired = set()
missingRecommended = set()
for attr in requiredAttributes:
if not hasattr(info, attr) or getattr(info, attr) is None:
missingRequired.add(attr)
for attr in recommendedAttributes:
if not hasattr(info, attr) or getattr(info, attr... | Returns a dict containing two items. The value for each
item will be a list of info attribute names.
================== ===
missingRequired Required data that is missing.
missingRecommended Recommended data that is missing.
================== === |
def cli(env, volume_id, reason, immediate):
file_storage_manager = SoftLayer.FileStorageManager(env.client)
if not (env.skip_confirmations or formatting.no_going_back(volume_id)):
raise exceptions.CLIAbort('Aborted')
cancelled = file_storage_manager.cancel_snapshot_space(
volume_id, reason, ... | Cancel existing snapshot space for a given volume. |
def wheel(self, direction, steps):
self._lock.acquire()
if direction == 1:
wheel_moved = steps
elif direction == 0:
wheel_moved = -1*steps
else:
raise ValueError("Expected direction to be 1 or 0")
self._lock.release()
return mouse.wheel... | Clicks the wheel the specified number of steps in the given direction.
Use Mouse.WHEEL_DOWN, Mouse.WHEEL_UP |
def update_user_info(self, **kwargs):
if kwargs:
self.config.update(kwargs)
method, url = get_URL('user_update')
res = getattr(self.session, method)(url, params=self.config)
if res.status_code == 200:
return True
hellraiser(res) | Update user info and settings.
:param \*\*kwargs: settings to be merged with
:func:`User.get_configfile` setings and sent to Filemail.
:rtype: ``bool`` |
def broadcast(self):
log.debug("Broadcasting M-SEARCH to %s:%s", self.mcast_ip, self.mcast_port)
request = '\r\n'.join(("M-SEARCH * HTTP/1.1",
"HOST:{mcast_ip}:{mcast_port}",
"ST:upnp:rootdevice",
"MX:2",
... | Send a multicast M-SEARCH request asking for devices to report in. |
def get_last_nonce(app, key, nonce):
uk = ses.query(um.UserKey).filter(um.UserKey.key==key)\
.filter(um.UserKey.last_nonce<nonce * 1000).first()
if not uk:
return None
lastnonce = copy.copy(uk.last_nonce)
uk.last_nonce = nonce * 1000
try:
ses.commit()
except Exception... | Get the last_nonce used by the given key from the SQLAlchemy database.
Update the last_nonce to nonce at the same time.
:param str key: the public key the nonce belongs to
:param int nonce: the last nonce used by this key |
def add_item(self, alias, item):
if not isinstance(alias, six.string_types):
raise TypeError('Item name must be a string, got a {!r}'.format(type(alias)))
item = copy.deepcopy(item)
if item.name is not_set:
item.name = alias
if self.settings.str_path_separator in ... | Add a config item to this section. |
def lexeme(self, verb, parse=True):
a = []
b = self.lemma(verb, parse=parse)
if b in self:
a = [x for x in self[b] if x != ""]
elif parse is True:
a = self.find_lexeme(b)
u = []; [u.append(x) for x in a if x not in u]
return u | Returns a list of all possible inflections of the given verb. |
def unwrap(self, value, session=None):
self.validate_unwrap(value)
return set([self.item_type.unwrap(v, session=session) for v in value]) | Unwraps the elements of ``value`` using ``SetField.item_type`` and
returns them in a set |
def get_subscriber_queue(self, event_types=None):
try:
self.started_queue.get(timeout=1)
raise RuntimeError('Cannot create a new subscriber queue while Exchange is running.')
except Empty:
pass
if event_types is None:
event_types = EventTypes.ALL
... | Create a new queue for a specific combination of event types
and return it.
Returns:
a :class:`multiprocessing.Queue`.
Raises:
RuntimeError if called after `run` |
def is_valid_schedule(schedule, events, slots):
if len(schedule) == 0:
return False
array = converter.schedule_to_array(schedule, events, slots)
return is_valid_array(array, events, slots) | Take a schedule and return whether it is a valid solution for the
given constraints
Parameters
----------
schedule : list or tuple
a schedule in schedule form
events : list or tuple
of resources.Event instances
slots : list or tuple
of resources.S... |
def upload_file(self, dataset_key, name, file_metadata={}, **kwargs):
owner_id, dataset_id = parse_dataset_key(dataset_key)
try:
self._uploads_api.upload_file(owner_id, dataset_id, name, **kwargs)
if file_metadata:
self.update_dataset(dataset_key, files=file_metad... | Upload one file to a dataset
:param dataset_key: Dataset identifier, in the form of owner/id
:type dataset_key: str
:param name: Name/path for files stored in the local filesystem
:type name: str
:param expand_archives: Boolean value to indicate files should be
expanded ... |
def render_description_meta_tag(context, is_og=False):
request = context['request']
content = ''
if context.get('object'):
try:
content = context['object'].get_meta_description()
except AttributeError:
pass
elif context.get('meta_tagger'):
content = contex... | Returns the description as meta or open graph tag. |
def getOntology(self, id_):
if id_ not in self._ontologyIdMap:
raise exceptions.OntologyNotFoundException(id_)
return self._ontologyIdMap[id_] | Returns the ontology with the specified ID. |
def repl_update(self, config):
cfg = config.copy()
cfg['version'] += 1
try:
result = self.run_command("replSetReconfig", cfg)
if int(result.get('ok', 0)) != 1:
return False
except pymongo.errors.AutoReconnect:
self.update_server_map(cfg... | Reconfig Replicaset with new config |
def reload(self, callback=None, errback=None):
return self.load(reload=True, callback=callback, errback=errback) | Reload record data from the API. |
def HandleAccounts(self, result):
self.logger.debug('Checking for changes to user accounts.')
configured_users = self.utils.GetConfiguredUsers()
enable_oslogin = self._GetEnableOsLoginValue(result)
enable_two_factor = self._GetEnableTwoFactorValue(result)
if enable_oslogin:
desired_users = {}
... | Called when there are changes to the contents of the metadata server.
Args:
result: json, the deserialized contents of the metadata server. |
def default(self, meth):
if self._default is not NOTHING:
raise DefaultAlreadySetError()
self._default = Factory(meth, takes_self=True)
return meth | Decorator that allows to set the default for an attribute.
Returns *meth* unchanged.
:raises DefaultAlreadySetError: If default has been set before.
.. versionadded:: 17.1.0 |
def put(self, content_bytes):
derived_path = self.context.request.url
over_max, content_size = self.content_size_exceeded_max(content_bytes)
logger.debug('[{log_prefix}] content size in bytes: {size}'
' | is over max? {over_max} | skip storage? {skip}'.format(
log_prefix=... | Save the `bytes` under a key derived from `path` in Memcache.
:return: A string representing the content path if it is stored.
:rettype: string or None |
def angle_to_name(angle, segments=8, abbr=False):
if segments == 4:
string = COMPASS_NAMES[int((angle + 45) / 90) % 4 * 2]
elif segments == 8:
string = COMPASS_NAMES[int((angle + 22.5) / 45) % 8 * 2]
elif segments == 16:
string = COMPASS_NAMES[int((angle + 11.25) / 22.5) % 16]
el... | Convert angle in to direction name.
Args:
angle (float): Angle in degrees to convert to direction name
segments (int): Number of segments to split compass in to
abbr (bool): Whether to return abbreviated direction string
Returns:
str: Direction name for ``angle`` |
def _eratosthenes():
d = {}
for q in count(2):
p = d.pop(q, None)
if p is None:
yield q
d[q * q] = q
else:
x = p + q
while x in d:
x += p
d[x] = p | Yields the sequence of prime numbers via the Sieve of Eratosthenes. |
def RetrievePluginAsset(self, plugin_name, asset_name):
return plugin_asset_util.RetrieveAsset(self.path, plugin_name, asset_name) | Return the contents of a given plugin asset.
Args:
plugin_name: The string name of a plugin.
asset_name: The string name of an asset.
Returns:
The string contents of the plugin asset.
Raises:
KeyError: If the asset is not available. |
def normalize(self):
for i, (_, amplitude, phase) in enumerate(self.model):
if amplitude < 0:
self.model['amplitude'][i] = -amplitude
self.model['phase'][i] = phase + 180.0
self.model['phase'][i] = np.mod(self.model['phase'][i], 360.0) | Adapt self.model so that amplitudes are positive and phases are in [0,360) as per convention |
def ack(self, msg):
message_id = msg['headers']['message-id']
subscription = msg['headers']['subscription']
transaction_id = None
if 'transaction-id' in msg['headers']:
transaction_id = msg['headers']['transaction-id']
return ack(message_id, subscription, transaction_... | Called when a MESSAGE has been received.
Override this method to handle received messages.
This function will generate an acknowledge message
for the given message and transaction (if present). |
def build_dependencies(self):
for m in self.modules:
m.build_dependencies()
for p in self.packages:
p.build_dependencies() | Recursively build the dependencies for sub-modules and sub-packages.
Iterate on node's modules then packages and call their
build_dependencies methods. |
def submit(self, spec):
spec = ApplicationSpec._from_any(spec)
resp = self._call('submit', spec.to_protobuf())
return resp.id | Submit a new skein application.
Parameters
----------
spec : ApplicationSpec, str, or dict
A description of the application to run. Can be an
``ApplicationSpec`` object, a path to a yaml/json file, or a
dictionary description of an application specification.
... |
def snapshot_list(self):
NO_SNAPSHOTS_TAKEN = 'No snapshots have been taken yet!'
output = self._run_vagrant_command(['snapshot', 'list'])
if NO_SNAPSHOTS_TAKEN in output:
return []
else:
return output.splitlines() | This command will list all the snapshots taken. |
def create_app_from_yml(path):
try:
with open(path, "rt", encoding="UTF-8") as f:
try:
interpolated = io.StringIO(f.read() % {
"here": os.path.abspath(os.path.dirname(path))})
interpolated.name = f.name
conf = yaml.safe_load(int... | Return an application instance created from YAML. |
def request_access_token(self, params):
return self.request(self.access_token_url, method="GET", params=params) | Foursquare does not accept POST requests to retrieve an access token,
so we'll be doing a GET request instead. |
def from_wif_or_ewif_hex(wif_hex: str, password: Optional[str] = None) -> SigningKeyType:
wif_bytes = Base58Encoder.decode(wif_hex)
fi = wif_bytes[0:1]
if fi == b"\x01":
return SigningKey.from_wif_hex(wif_hex)
elif fi == b"\x02" and password is not None:
return Si... | Return SigningKey instance from Duniter WIF or EWIF in hexadecimal format
:param wif_hex: WIF or EWIF string in hexadecimal format
:param password: Password of EWIF encrypted seed |
def tar_open(f):
if isinstance(f, six.string_types):
return tarfile.open(name=f)
else:
return tarfile.open(fileobj=f) | Open either a filename or a file-like object as a TarFile.
Parameters
----------
f : str or file-like object
The filename or file-like object from which to read.
Returns
-------
TarFile
A `TarFile` instance. |
def slice_target(self,chr,start,end):
trng = Bed(chr,start,end)
nrngs = []
for r in self._rngs:
i = r.intersect(trng)
if not i: continue
nrngs.append(i)
if len(nrngs) == 0: return None
return MappingGeneric(nrngs,self._options) | Slice the mapping by the target coordinate
First coordinate is 0-indexed start
Second coordinate is 1-indexed finish |
def status_charge():
data = status()
if 'BCHARGE' in data:
charge = data['BCHARGE'].split()
if charge[1].lower() == 'percent':
return float(charge[0])
return {'Error': 'Load not available.'} | Return battery charge
CLI Example:
.. code-block:: bash
salt '*' apcups.status_charge |
def cmd_posvel(self, args):
ignoremask = 511
latlon = None
try:
latlon = self.module('map').click_position
except Exception:
pass
if latlon is None:
print ("set latlon to zeros")
latlon = [0, 0]
else:
ignoremask ... | posvel mapclick vN vE vD |
def scale_joint_sfs(s):
i = np.arange(s.shape[0])[:, None]
j = np.arange(s.shape[1])[None, :]
out = (s * i) * j
return out | Scale a joint site frequency spectrum.
Parameters
----------
s : array_like, int, shape (n1, n2)
Joint site frequency spectrum.
Returns
-------
joint_sfs_scaled : ndarray, int, shape (n1, n2)
Scaled joint site frequency spectrum. |
def register_on_machine_registered(self, callback):
event_type = library.VBoxEventType.on_machine_registered
return self.event_source.register_callback(callback, event_type) | Set the callback function to consume on machine registered events.
Callback receives a IMachineRegisteredEvent object.
Returns the callback_id |
def get_all_launch_configurations(region=None, key=None, keyid=None,
profile=None):
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
retries = 30
while True:
try:
return conn.get_all_launch_configurations()
except boto.excep... | Fetch and return all Launch Configuration with details.
CLI example::
salt myminion boto_asg.get_all_launch_configurations |
def get_escalation_policies(profile='pagerduty', subdomain=None, api_key=None):
return _list_items(
'escalation_policies',
'id',
profile=profile,
subdomain=subdomain,
api_key=api_key,
) | List escalation_policies belonging to this account
CLI Example:
salt myminion pagerduty.get_escalation_policies |
def cache(self):
if not self._cache:
use_cache = getattr(settings, 'USE_DRF_INSTANCE_CACHE', True)
if use_cache:
from django.core.cache import cache
self._cache = cache
return self._cache | Get the Django cache interface.
This allows disabling the cache with
settings.USE_DRF_INSTANCE_CACHE=False. It also delays import so that
Django Debug Toolbar will record cache requests. |
def get_all_args(fn) -> list:
sig = inspect.signature(fn)
return list(sig.parameters) | Returns a list of all arguments for the function fn.
>>> def foo(x, y, z=100): return x + y + z
>>> get_all_args(foo)
['x', 'y', 'z'] |
def qs_for_ip(cls, ip_str):
ip = int(netaddr.IPAddress(ip_str))
if ip > 4294967295:
return cls.objects.none()
ip_range_query = {
'start__lte': ip,
'stop__gte': ip
}
return cls.objects.filter(**ip_range_query) | Returns a queryset with matching IPNetwork objects for the given IP. |
def UpdateClientsFromFleetspeak(clients):
if not fleetspeak_connector.CONN or not fleetspeak_connector.CONN.outgoing:
return
id_map = {}
for client in clients:
if client.fleetspeak_enabled:
id_map[fleetspeak_utils.GRRIDToFleetspeakID(client.client_id)] = client
if not id_map:
return
res = fl... | Updates ApiClient records to include info from Fleetspeak. |
def dtypes(self):
return [(str(f.name), f.dataType.simpleString()) for f in self.schema.fields] | Returns all column names and their data types as a list.
>>> df.dtypes
[('age', 'int'), ('name', 'string')] |
def add_row(self, row_data, resize_x=True):
if not resize_x:
self._check_row_size(row_data)
self.body(Tr()(Td()(cell) for cell in row_data))
return self | Adds a row at the end of the table |
def createManager(self, services, yadis_url=None):
key = self.getSessionKey()
if self.getManager():
raise KeyError('There is already a %r manager for %r' %
(key, self.url))
if not services:
return None
manager = YadisServiceManager(self.... | Create a new YadisService Manager for this starting URL and
suffix, and store it in the session.
@raises KeyError: When I already have a manager.
@return: A new YadisServiceManager or None |
def reind_proc(self, inputstring, **kwargs):
out = []
level = 0
for line in inputstring.splitlines():
line, comment = split_comment(line.strip())
indent, line = split_leading_indent(line)
level += ind_change(indent)
if line:
line = ... | Add back indentation. |
def validate_row_lengths(fields,
data
):
for i, row in enumerate(data):
if len(fields) != len(row):
msg = 'Row {} has {} entries when {} are expected.'.format(
i, len(row), len(fields))
raise FormatError(msg) | Validate the `data` row lengths according to the specification
in `fields`.
:param fields: The `FieldSpec` objects forming the
specification.
:param data: The rows to check.
:raises FormatError: When the number of entries in a row does
not match expectation. |
def get_resource_path(name, raise_exception=False):
if not RuntimeGlobals.resources_directories:
RuntimeGlobals.resources_directories.append(
os.path.normpath(os.path.join(umbra.__path__[0], Constants.resources_directory)))
for path in RuntimeGlobals.resources_directories:
path = os.... | Returns the resource file path matching the given name.
:param name: Resource name.
:type name: unicode
:param raise_exception: Raise the exception.
:type raise_exception: bool
:return: Resource path.
:rtype: unicode |
def b58check_encode(bin_s, version_byte=0):
bin_s = chr(int(version_byte)) + bin_s
num_leading_zeros = len(re.match(r'^\x00*', bin_s).group(0))
bin_s = bin_s + bin_checksum(bin_s)
hex_s = hexlify(bin_s)
b58_s = change_charset(hex_s, HEX_KEYSPACE, B58_KEYSPACE)
return B58_KEYSPACE[0] * num_leadin... | Takes in a binary string and converts it to a base 58 check string. |
def is_sub_plate(self, other):
if all(v in set(other.values) for v in self.values):
return True
if all(any(all(spv in m for spv in v) for m in map(set, other.values)) for v in self.values):
return True
if other in self.ancestor_plates:
return True
retu... | Determines if this plate is a sub-plate of another plate -
i.e. has the same meta data but a restricted set of values
:param other: The other plate
:return: True if this plate is a sub-plate of the other plate |
def _bsecurate_cli_view_graph(args):
curate.view_graph(args.basis, args.version, args.data_dir)
return '' | Handles the view-graph subcommand |
def get(self, request, hook_id):
try:
bot = caching.get_or_set(MessengerBot, hook_id)
except MessengerBot.DoesNotExist:
logger.warning("Hook id %s not associated to a bot" % hook_id)
return Response(status=status.HTTP_404_NOT_FOUND)
if request.query_params.get... | Verify token when configuring webhook from facebook dev.
MessengerBot.id is used for verification |
def path_is_known_executable(path):
return (
path_is_executable(path)
or os.access(str(path), os.R_OK)
and path.suffix in KNOWN_EXTS
) | Returns whether a given path is a known executable from known executable extensions
or has the executable bit toggled.
:param path: The path to the target executable.
:type path: :class:`~vistir.compat.Path`
:return: True if the path has chmod +x, or is a readable, known executable extension.
:rtyp... |
def get_readable_forums(self, forums, user):
if user.is_superuser:
return forums
readable_forums = self._get_forums_for_user(
user, ['can_read_forum', ], use_tree_hierarchy=True)
return forums.filter(id__in=[f.id for f in readable_forums]) \
if isinstance(foru... | Returns a queryset of forums that can be read by the considered user. |
def get_index(binstr, end_index=160):
res = -1
try:
res = binstr.index('1') + 1
except ValueError:
res = end_index
return res | Return the position of the first 1 bit
from the left in the word until end_index
:param binstr:
:param end_index:
:return: |
def get_trust(self):
if not bool(self._my_map['trustId']):
raise errors.IllegalState('this Authorization has no trust')
mgr = self._get_provider_manager('AUTHENTICATION.PROCESS')
if not mgr.supports_trust_lookup():
raise errors.OperationFailed('Authentication.Process does... | Gets the ``Trust`` for this authorization.
return: (osid.authentication.process.Trust) - the ``Trust``
raise: IllegalState - ``has_trust()`` is ``false``
raise: OperationFailed - unable to complete request
*compliance: mandatory -- This method must be implemented.* |
def get_acl_on(request):
acl_on = settings.ACL_ON
if settings.LOCKDOWN and hasattr(request, 'user'):
if request.user.is_superuser:
acl_on = False
return acl_on | Returns `True` if ACL should be honorated, returns otherwise `False`. |
def _precompile_substitution(self, kind, pattern):
if pattern not in self._regexc[kind]:
qm = re.escape(pattern)
self._regexc[kind][pattern] = {
"qm": qm,
"sub1": re.compile(r'^' + qm + r'$'),
"sub2": re.compile(r'^' + qm + r'(\W+)'),
... | Pre-compile the regexp for a substitution pattern.
This will speed up the substitutions that happen at the beginning of
the reply fetching process. With the default brain, this took the
time for _substitute down from 0.08s to 0.02s
:param str kind: One of ``sub``, ``person``.
:... |
def And(*args: Union[Bool, bool]) -> Bool:
union = []
args_list = [arg if isinstance(arg, Bool) else Bool(arg) for arg in args]
for arg in args_list:
union.append(arg.annotations)
return Bool(z3.And([a.raw for a in args_list]), union) | Create an And expression. |
def weight_decay(decay_rate, var_list, skip_biases=True):
if not decay_rate:
return 0.
tf.logging.info("Applying weight decay, decay_rate: %0.5f", decay_rate)
weight_decays = []
for v in var_list:
is_bias = len(v.shape.as_list()) == 1 and v.name.endswith("bias:0")
if not (skip_biases and is_bias):
... | Apply weight decay to vars in var_list. |
def get_option_choices(opt_name, opt_value, default_value, all_choices):
choices = []
if isinstance(opt_value, six.string_types):
choices = [opt_value]
elif isinstance(opt_value, (list, tuple)):
choices = list(opt_value)
elif opt_value is None:
choices = default_value
else:
... | Generate possible choices for the option `opt_name`
limited to `opt_value` value with default value
as `default_value` |
def _parse_version(self, line):
version_string = line.split(' ')[1]
version_list = version_string.split('.')
major_version = ''.join([version_list[0], version_list[1]])
release_num = ''.join([version_list[2].rstrip(), "-03"])
return (major_version, release_num) | There's a magic suffix to the release version, currently it's -03, but
it increments seemingly randomly. |
async def get_checkpoint_async(self, partition_id):
lease = await self.get_lease_async(partition_id)
checkpoint = None
if lease:
if lease.offset:
checkpoint = Checkpoint(partition_id, lease.offset,
lease.sequence_number)
... | Get the checkpoint data associated with the given partition.
Could return null if no checkpoint has been created for that partition.
:param partition_id: The partition ID.
:type partition_id: str
:return: Given partition checkpoint info, or `None` if none has been previously stored.
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.