code stringlengths 51 2.38k | docstring stringlengths 4 15.2k |
|---|---|
def rnd_date_list_high_performance(size, start=date(1970, 1, 1), end=None, **kwargs):
if end is None:
end = date.today()
start_days = to_ordinal(parser.parse_datetime(start))
end_days = to_ordinal(parser.parse_datetime(end))
_assert_correct_start_end(start_days, end_days)
if has_np:
... | Generate mass random date.
:param size: int, number of
:param start: date similar object, int / str / date / datetime
:param end: date similar object, int / str / date / datetime, default today's date
:param kwargs: args placeholder
:return: list of datetime.date |
def start_event_stream(self):
if not self._stream:
self._stream = GerritStream(self, ssh_client=self._ssh_client)
self._stream.start() | Start streaming events from `gerrit stream-events`. |
def add_probe(self, probe):
if self.probes:
probe_last = self.probes[-1]
if not probe.ip:
probe.ip = probe_last.ip
probe.name = probe_last.name
self.probes.append(probe) | Adds a Probe instance to this hop's results. |
def compare_dicts(d1, d2):
a = json.dumps(d1, indent=4, sort_keys=True)
b = json.dumps(d2, indent=4, sort_keys=True)
diff = ('\n' + '\n'.join(difflib.ndiff(
a.splitlines(),
b.splitlines())))
return diff | Returns a diff string of the two dicts. |
def qpinfo():
parser = qpinfo_parser()
args = parser.parse_args()
path = pathlib.Path(args.path).resolve()
try:
ds = load_data(path)
except UnknownFileFormatError:
print("Unknown file format: {}".format(path))
return
print("{} ({})".format(ds.__class__.__doc__, ds.__class... | Print information of a quantitative phase imaging dataset |
def get_uuid(type=4):
import uuid
name = 'uuid'+str(type)
u = getattr(uuid, name)
return u().hex | Get uuid value |
def write_to(self, f, version = None):
if not version:
version = self.version
if version == 1:
header = "%(url)s %(ip_address)s %(date)s %(content_type)s %(length)s"
elif version == 2:
header = "%(url)s %(ip_address)s %(date)s %(content_type)s %(result_code)s ... | Writes out the arc header to the file like object `f`.
If the version field is 1, it writes out an arc v1 header,
otherwise (and this is default), it outputs a v2 header. |
def unique_file_name(base_name, extension=''):
idcount = 0
if extension and not extension.startswith('.'):
extension = '.%s' % extension
fname = base_name + extension
while os.path.exists(fname):
fname = "%s-%d%s" % (base_name, idcount, extension)
idcount += 1
return fname | Creates a unique file name based on the specified base name.
@base_name - The base name to use for the unique file name.
@extension - The file extension to use for the unique file name.
Returns a unique file string. |
def _log_every_n_to_logger(n, logger, level, message, *args):
logger = logger or logging.getLogger()
def _gen():
while True:
for _ in range(n):
yield False
logger.log(level, message, *args)
yield True
gen = _gen()
return lambda: six.next(gen) | Logs the given message every n calls to a logger.
Args:
n: Number of calls before logging.
logger: The logger to which to log.
level: The logging level (e.g. logging.INFO).
message: A message to log
*args: Any format args for the message.
Returns:
A method that logs and returns True every n... |
def _opening_bracket_index(self, text, bpair=('(', ')')):
level = 1
for i, char in enumerate(reversed(text[:-1])):
if char == bpair[1]:
level += 1
elif char == bpair[0]:
level -= 1
if level == 0:
return len(text) - i - 2 | Return the index of the opening bracket that matches the closing bracket at the end of the text. |
def create_zone(zone, private=False, vpc_id=None, vpc_region=None, region=None,
key=None, keyid=None, profile=None):
if region is None:
region = 'universal'
if private:
if not vpc_id or not vpc_region:
msg = 'vpc_id and vpc_region must be specified for a private zone'... | Create a Route53 hosted zone.
.. versionadded:: 2015.8.0
zone
DNS zone to create
private
True/False if the zone will be a private zone
vpc_id
VPC ID to associate the zone to (required if private is True)
vpc_region
VPC Region (required if private is True)
re... |
def word(cap=False):
syllables = []
for x in range(random.randint(2,3)):
syllables.append(_syllable())
word = "".join(syllables)
if cap: word = word[0].upper() + word[1:]
return word | This function generates a fake word by creating between two and three
random syllables and then joining them together. |
def pipe_exchangerate(context=None, _INPUT=None, conf=None, **kwargs):
offline = conf.get('offline', {}).get('value')
rate_data = get_offline_rate_data(err=False) if offline else get_rate_data()
rates = parse_request(rate_data)
splits = get_splits(_INPUT, conf, **cdicts(opts, kwargs))
parsed = utils... | A string module that retrieves the current exchange rate for a given
currency pair. Loopable.
Parameters
----------
context : pipe2py.Context object
_INPUT : iterable of items or strings (base currency)
conf : {
'quote': {'value': <'USD'>},
'default': {'value': <'USD'>},
... |
def to_cfn_resource_name(name):
if not name:
raise ValueError("Invalid name: %r" % name)
word_separators = ['-', '_']
for word_separator in word_separators:
word_parts = [p for p in name.split(word_separator) if p]
name = ''.join([w[0].upper() + w[1:] for w in word_parts])
return... | Transform a name to a valid cfn name.
This will convert the provided name to a CamelCase name.
It's possible that the conversion to a CFN resource name
can result in name collisions. It's up to the caller
to handle name collisions appropriately. |
def xmoe_2d():
hparams = xmoe_top_2()
hparams.decoder_layers = ["att", "hmoe"] * 4
hparams.mesh_shape = "b0:2;b1:4"
hparams.outer_batch_size = 4
hparams.layout = "outer_batch:b0;inner_batch:b1,expert_x:b1,expert_y:b0"
hparams.moe_num_experts = [4, 4]
return hparams | Two-dimensional hierarchical mixture of 16 experts. |
def get_experiment_from_id(self, experiment_id):
experiment = self.experiment_id_map.get(experiment_id)
if experiment:
return experiment
self.logger.error('Experiment ID "%s" is not in datafile.' % experiment_id)
self.error_handler.handle_error(exceptions.InvalidExperimentException(enums.Errors.IN... | Get experiment for the provided experiment ID.
Args:
experiment_id: Experiment ID for which experiment is to be determined.
Returns:
Experiment corresponding to the provided experiment ID. |
def _send_ack(self, transaction):
ack = Message()
ack.type = defines.Types['ACK']
if not transaction.request.acknowledged and transaction.request.type == defines.Types["CON"]:
ack = self._messageLayer.send_empty(transaction, transaction.request, ack)
self.send_datagram(ac... | Sends an ACK message for the request.
:param transaction: the transaction that owns the request |
def are_equal(self, sp1, sp2):
set1 = set(sp1.elements)
set2 = set(sp2.elements)
return set1.issubset(set2) or set2.issubset(set1) | True if there is some overlap in composition between the species
Args:
sp1: First species. A dict of {specie/element: amt} as per the
definition in Site and PeriodicSite.
sp2: Second species. A dict of {specie/element: amt} as per the
definition in Site a... |
def _check_repos(self, repos):
self._checking_repos = []
self._valid_repos = []
for repo in repos:
worker = self.download_is_valid_url(repo)
worker.sig_finished.connect(self._repos_checked)
worker.repo = repo
self._checking_repos.append(repo) | Check if repodata urls are valid. |
def _resolve_dtype(data_type):
if isinstance(data_type, _FIXED_ATOMIC):
out = _get_atomic_dtype(data_type)
elif isinstance(data_type, _FLEXIBLE_ATOMIC):
out = (_get_atomic_dtype(data_type), data_type.length)
elif isinstance(data_type, Array):
shape = data_type.shape
if isinst... | Retrieve the corresponding NumPy's `dtype` for a given data type. |
def find_key_by_subkey(self, subkey):
for key in self.list_keys():
for sub in key['subkeys']:
if sub[0] == subkey:
return key
raise LookupError(
"GnuPG public key for subkey %s not found!" % subkey) | Find a key by a fingerprint of one of its subkeys.
:param str subkey: The fingerprint of the subkey to search for. |
def registry_key(self, key_name, value_name, value_type, **kwargs):
indicator_obj = RegistryKey(key_name, value_name, value_type, **kwargs)
return self._indicator(indicator_obj) | Add Registry Key data to Batch object.
Args:
key_name (str): The key_name value for this Indicator.
value_name (str): The value_name value for this Indicator.
value_type (str): The value_type value for this Indicator.
confidence (str, kwargs): The threat confiden... |
def load_module(module_name, module_path):
if sys.version_info >= (3,0):
import pyximport
pyximport.install()
sys.path.append(module_path)
return __import__(module_name)
else:
import imp
module_info = imp.find_module(module_name, [module_path])
return imp.... | Load the module named `module_name` from `module_path`
independently of the Python version. |
def current(self):
top = super(Transaction, self).current()
if isinstance(top, Transaction):
return top | Return the topmost transaction.
.. note::
If the topmost element on the stack is not a transaction,
returns None.
:rtype: :class:`google.cloud.datastore.transaction.Transaction` or None
:returns: The current transaction (if any are active). |
def _get_digit_list(alist: [str], from_index: int) -> ([str], [str]):
ret = []
alist.pop(from_index)
while len(alist) > from_index and alist[from_index].isdigit():
ret.append(alist.pop(from_index))
return alist, ret | Returns a list of items removed from a given list of strings
that are all digits from 'from_index' until hitting a non-digit item |
def add_root_family(self, family_id):
if self._catalog_session is not None:
return self._catalog_session.add_root_catalog(catalog_id=family_id)
return self._hierarchy_session.add_root(id_=family_id) | Adds a root family.
arg: family_id (osid.id.Id): the ``Id`` of a family
raise: AlreadyExists - ``family_id`` is already in hierarchy
raise: NotFound - ``family_id`` not found
raise: NullArgument - ``family_id`` is ``null``
raise: OperationFailed - unable to complete reque... |
def dim_reduce_data(data, d):
genes, cells = data.shape
distances = np.zeros((cells, cells))
for i in range(cells):
for j in range(cells):
distances[i,j] = poisson_dist(data[:,i], data[:,j])
proximity = distances**2
J = np.eye(cells) - 1./cells
B = -0.5*np.dot(J, np.dot(proxi... | Does a MDS on the data directly, not on the means.
Args:
data (array): genes x cells
d (int): desired dimensionality
Returns:
X, a cells x d matrix |
def expand(directory: str) -> str:
temp1 = os.path.expanduser(directory)
return os.path.expandvars(temp1) | Apply expanduser and expandvars to directory to expand '~' and env vars. |
def iter(self, columnnames, order='', sort=True):
from .tableiter import tableiter
return tableiter(self, columnnames, order, sort) | Return a tableiter object.
:class:`tableiter` lets one iterate over a table by returning in each
iteration step a reference table containing equal values for the given
columns.
By default a sort is done on the given columns to get the correct
iteration order.
`order`
... |
def _get_log_format(self, request):
user = getattr(request, 'user', None)
if not user:
return
if not request.user.is_authenticated:
return
method = request.method.upper()
if not (method in self.target_methods):
return
request_url = urlp... | Return operation log format. |
def list_():
ret = {}
cmd = 'cpan -l'
out = __salt__['cmd.run'](cmd).splitlines()
for line in out:
comps = line.split()
ret[comps[0]] = comps[1]
return ret | List installed Perl modules, and the version installed
CLI Example:
.. code-block:: bash
salt '*' cpan.list |
def _request(self, http_method, relative_url='', **kwargs):
relative_url = self._remove_leading_slash(relative_url)
new_kwargs = self.default_kwargs().copy()
custom_kwargs = self.before_request(
http_method,
relative_url,
kwargs.copy()
)
new_kw... | Does actual HTTP request using requests library. |
def registerExitCall():
r
if state.isExitHooked:
return
state.isExitHooked = True
from atexit import register
register(core.start) | r"""Registers an exit call to start the core.
The core would be started after the main module is loaded. Ec would be exited from the core. |
def trim(self):
if 0 < self.cutoff <= 0.5:
pscore = self.raw_data['pscore']
keep = (pscore >= self.cutoff) & (pscore <= 1-self.cutoff)
Y_trimmed = self.raw_data['Y'][keep]
D_trimmed = self.raw_data['D'][keep]
X_trimmed = self.raw_data['X'][keep]
self.raw_data = Data(Y_trimmed, D_trimmed, X_trimmed)
... | Trims data based on propensity score to create a subsample with
better covariate balance.
The default cutoff value is set to 0.1. To set a custom cutoff
value, modify the object attribute named cutoff directly.
This method should only be executed after the propensity score
has been estimated. |
def generate_tensor_filename(self, field_name, file_num, compressed=True):
file_ext = TENSOR_EXT
if compressed:
file_ext = COMPRESSED_TENSOR_EXT
filename = os.path.join(self.filename, 'tensors', '%s_%05d%s' %(field_name, file_num, file_ext))
return filename | Generate a filename for a tensor. |
def deconstruct(self):
name, path, args, kwargs = super(CountryField, self).deconstruct()
kwargs.pop("choices")
if self.multiple:
kwargs["multiple"] = self.multiple
if self.countries is not countries:
kwargs["countries"] = self.countries.__class__
return n... | Remove choices from deconstructed field, as this is the country list
and not user editable.
Not including the ``blank_label`` property, as this isn't database
related. |
def from_string(cls, string):
if string in units.UNITS_BY_ALL:
return cls(description=string, unit=units.Unit(string))
else:
return cls(description=string) | Convert a string into a Dimension |
def _build_field_choices(self, fields):
return tuple(sorted(
[(fquery, capfirst(fname)) for fquery, fname in fields.items()],
key=lambda f: f[1].lower())
) + self.FIELD_CHOICES | Iterate over passed model fields tuple and update initial choices. |
def longest_one_seg_prefix(self, word):
for i in range(self.longest_seg, 0, -1):
if word[:i] in self.seg_dict:
return word[:i]
return '' | Return longest Unicode IPA prefix of a word
Args:
word (unicode): input word as Unicode IPA string
Returns:
unicode: longest single-segment prefix of `word` in database |
def check_password_confirm(self, form, trigger_action_group=None):
pwcol = self.options['password_column']
pwconfirmfield = pwcol + "_confirm"
if pwcol in form and pwconfirmfield in form and form[pwconfirmfield].data != form[pwcol].data:
if self.options["password_confirm_failed_messa... | Checks that the password and the confirm password match in
the provided form. Won't do anything if any of the password fields
are not in the form. |
def _setup_buffer(self):
if not self._buffer_cfg or not isinstance(self._buffer_cfg, dict):
return
buffer_name = list(self._buffer_cfg.keys())[0]
buffer_class = napalm_logs.buffer.get_interface(buffer_name)
log.debug('Setting up buffer interface "%s"', buffer_name)
if... | Setup the buffer subsystem. |
def _connect(self):
"Create a Unix domain socket connection"
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
sock.settimeout(self.socket_timeout)
sock.connect(self.path)
return sock | Create a Unix domain socket connection |
def truncate_rationale(rationale, max_length=MAX_RATIONALE_SIZE_IN_EVENT):
if isinstance(rationale, basestring) and max_length is not None and len(rationale) > max_length:
return rationale[0:max_length], True
else:
return rationale, False | Truncates the rationale for analytics event emission if necessary
Args:
rationale (string): the string value of the rationale
max_length (int): the max length for truncation
Returns:
truncated_value (string): the possibly truncated version of the rationale
was_truncated (bool):... |
def _get_module(self, line):
for sline in self._source:
if len(sline) > 0 and sline[0] != "!":
rmatch = self.RE_MODULE.match(sline)
if rmatch is not None:
self.modulename = rmatch.group("name")
break
else:
re... | Finds the name of the module and retrieves it from the parser cache. |
def nth_value(expr, nth, skip_nulls=False, sort=None, ascending=True):
return _cumulative_op(expr, NthValue, data_type=expr._data_type, sort=sort,
ascending=ascending, _nth=nth, _skip_nulls=skip_nulls) | Get nth value of a grouped and sorted expression.
:param expr: expression for calculation
:param nth: integer position
:param skip_nulls: whether to skip null values, False by default
:param sort: name of the sort column
:param ascending: whether to sort in ascending order
:return: calculated c... |
def crypto_pwhash_str_alg(passwd, opslimit, memlimit, alg):
ensure(isinstance(opslimit, integer_types),
raising=TypeError)
ensure(isinstance(memlimit, integer_types),
raising=TypeError)
ensure(isinstance(passwd, bytes),
raising=TypeError)
_check_argon2_limits_alg(opslimi... | Derive a cryptographic key using the ``passwd`` given as input
and a random ``salt``, returning a string representation which
includes the salt, the tuning parameters and the used algorithm.
:param passwd: The input password
:type passwd: bytes
:param opslimit: computational cost
:type opslimit... |
def WritePythonFile(file_descriptor, package, version, printer):
_WriteFile(file_descriptor, package, version,
_ProtoRpcPrinter(printer)) | Write the given extended file descriptor to out. |
def init_config(self):
input_fpath = os.path.join(self.work_path, 'input.nml')
input_nml = f90nml.read(input_fpath)
if self.expt.counter == 0 or self.expt.repeat_run:
input_type = 'n'
else:
input_type = 'r'
input_nml['MOM_input_nml']['input_filename'] = in... | Patch input.nml as a new or restart run. |
def _compute_radii(self):
radii = self._get_user_components('radii')
if (radii is None):
centers = self.components_['centers']
n_centers = centers.shape[0]
max_dist = np.max(pairwise_distances(centers))
radii = np.ones(n_centers) * max_dist/sqrt(2.0 * n_ce... | Generate RBF radii |
def assert_visible(self, selector, testid=None, **kwargs):
self.info_log(
"Assert visible selector(%s) testid(%s)" % (selector, testid)
)
highlight = kwargs.get(
'highlight',
BROME_CONFIG['highlight']['highlight_on_assertion_success']
)
self.de... | Assert that the element is visible in the dom
Args:
selector (str): the selector used to find the element
testid (str): the test_id or a str
Kwargs:
wait_until_visible (bool)
highlight (bool)
Returns:
bool: True is the assertion succ... |
def toggle_value(request, name):
obj = service.system.namespace.get(name, None)
if not obj or service.read_only:
raise Http404
new_status = obj.status = not obj.status
if service.redirect_from_setters:
return HttpResponseRedirect(reverse('set_ready', args=(name, new_status)))
else:
... | For manual shortcut links to perform toggle actions |
def set_subnet_name(name):
cmd = 'systemsetup -setlocalsubnetname "{0}"'.format(name)
__utils__['mac_utils.execute_return_success'](cmd)
return __utils__['mac_utils.confirm_updated'](
name,
get_subnet_name,
) | Set the local subnet name
:param str name: The new local subnet name
.. note::
Spaces are changed to dashes. Other special characters are removed.
:return: True if successful, False if not
:rtype: bool
CLI Example:
.. code-block:: bash
The following will be set as 'Mikes-Mac... |
def save(self):
kwargs = {}
if self.id3v23:
id3 = self.mgfile
if hasattr(id3, 'tags'):
id3 = id3.tags
id3.update_to_v23()
kwargs['v2_version'] = 3
mutagen_call('save', self.path, self.mgfile.save, **kwargs) | Write the object's tags back to the file. May
throw `UnreadableFileError`. |
def get(self, robj, r=None, pr=None, timeout=None, basic_quorum=None,
notfound_ok=None, head_only=False):
msg_code = riak.pb.messages.MSG_CODE_GET_REQ
codec = self._get_codec(msg_code)
msg = codec.encode_get(robj, r, pr,
timeout, basic_quorum,
... | Serialize get request and deserialize response |
def get_books(self):
if self.retrieved:
raise errors.IllegalState('List has already been retrieved.')
self.retrieved = True
return objects.BookList(self._results, runtime=self._runtime) | Gets the book list resulting from a search.
return: (osid.commenting.BookList) - the book list
raise: IllegalState - list has already been retrieved
*compliance: mandatory -- This method must be implemented.* |
def markdown(text, html=False, valid_tags=GFM_TAGS):
if text is None:
return None
if html:
return Markup(sanitize_html(markdown_convert_html(gfm(text)), valid_tags=valid_tags))
else:
return Markup(markdown_convert_text(gfm(text))) | Return Markdown rendered text using GitHub Flavoured Markdown,
with HTML escaped and syntax-highlighting enabled. |
def validate(self, value):
try:
if value:
v = float(value)
if (v != 0 and v < self.fmin) or v > self.fmax:
return None
if abs(round(100000*v)-100000*v) > 1.e-12:
return None
return value
excep... | This prevents setting any value more precise than 0.00001 |
def get(self, *args, **kwargs):
self.before_get(args, kwargs)
qs = QSManager(request.args, self.schema)
objects_count, objects = self.get_collection(qs, kwargs)
schema_kwargs = getattr(self, 'get_schema_kwargs', dict())
schema_kwargs.update({'many': True})
self.before_mar... | Retrieve a collection of objects |
def latch_file_info(self, args):
self.file_dict.clear()
for key, val in self.file_args.items():
try:
file_path = args[key]
if file_path is None:
continue
if key[0:4] == 'args':
if isinstance(file_path, li... | Extract the file paths from a set of arguments |
def conversations(self):
body = {
"conversation_type": self.conversation_type,
"audience_definition": self.audience_definition,
"targeting_inputs": self.targeting_inputs
}
return self.__get(account=self.account, client=self.account.client, params=json.dumps(bo... | Get the conversation topics for an input targeting criteria |
def OnCellBorderWidth(self, event):
with undo.group(_("Border width")):
self.grid.actions.set_border_attr("borderwidth",
event.width, event.borders)
self.grid.ForceRefresh()
self.grid.update_attribute_toolbar()
event.Skip() | Cell border width event handler |
def account_xdr_object(self):
return Xdr.types.PublicKey(Xdr.const.KEY_TYPE_ED25519,
self.verifying_key.to_bytes()) | Create PublicKey XDR object via public key bytes.
:return: Serialized XDR of PublicKey type. |
def dar_nombre_campo_dbf(clave, claves):
"Reducir nombre de campo a 10 caracteres, sin espacios ni _, sin repetir"
nombre = clave.replace("_","")[:10]
i = 0
while nombre in claves:
i += 1
nombre = nombre[:9] + str(i)
return nombre.lower() | Reducir nombre de campo a 10 caracteres, sin espacios ni _, sin repetir |
def get_all_trials(self):
response = requests.get(urljoin(self._path, "trials"))
return self._deserialize(response) | Returns a list of all trials' information. |
def check_config_options(_class, required_options, optional_options, options):
for opt in required_options:
if opt not in options:
msg = "Required option missing: {0}"
raise ConfigurationError(msg.format(opt))
for opt in options:
if opt not in (required_options + optional... | Helper method to check options.
Arguments:
_class -- the original class that takes received the options.
required_options -- the options that are required. If they are not
present, a ConfigurationError is raised. Given as a
tuple.
optional_optio... |
def get_fieldset_index(fieldsets, index_or_name):
if isinstance(index_or_name, six.integer_types):
return index_or_name
for key, value in enumerate(fieldsets):
if value[0] == index_or_name:
return key
raise KeyError("Key not found: '{}'.".format(index_or_name)) | Return the index of a fieldset in the ``fieldsets`` list.
Args:
fieldsets (list): The original ``fieldsets`` list.
index_or_name (int or str): The value of the reference element, or directly its numeric index.
Returns:
(int) The index of the fieldset in the ``fieldsets`` list. |
def commandify(use_argcomplete=False, exit=True, *args, **kwargs):
parser = CommandifyArgumentParser(*args, **kwargs)
parser.setup_arguments()
if use_argcomplete:
try:
import argcomplete
except ImportError:
print('argcomplete not installed, please install it.')
... | Turns decorated functions into command line args
Finds the main_command and all commands and generates command line args
from these. |
def progress_task(name=None, t=INFO, max_value=100, *args, **kwargs):
return task(name=name, t=t, init_progress=True, max_value=max_value,
*args, **kwargs) | This decorator extends the basic @task decorator by allowing users to
display some form of progress on the console. The module can receive
an increment in the progress through "tick_progress". |
def _write_index_file(data_dir):
cached_words = [
w
for w in _get_words(data_dir)
if data_dir.joinpath("translations/{}.html".format(w)).is_file()
]
content_str = _create_index_content(cached_words)
html_string = HTML_TEMPLATE.replace("{% word %}", "Index")
html_string = html... | Create index file of cached translations.
Parameters
----------
data_dir : pathlib.Path
Cache directory location. |
def _parseImageNtHeaders(self, data, imageDosHeader):
inth = self._classes.IMAGE_NT_HEADERS.from_buffer(data, imageDosHeader.header.e_lfanew)
if inth.Signature != b'PE':
raise BinaryError('No valid PE/COFF file')
return ImageNtHeaderData(header=inth) | Returns the ImageNtHeaders |
def print_settings(settings, depth=0):
if isinstance(settings, Setting):
settings = [settings]
for setting in settings:
cur = setting.currentValue
print(
"%s* %s (%s, value: %s, type: %s)"
% (
" " * depth,
setting.title,
... | Print all available settings of the device. |
def add_screenshot(self, screenshot):
if screenshot in self.screenshots:
return
self.screenshots.append(screenshot) | Add a screenshot object if it does not already exist |
def get_python_path(venv_path):
bin_path = get_bin_path(venv_path)
program_path = os.path.join(bin_path, 'python')
if sys.platform.startswith('win'):
program_path = program_path + '.exe'
return program_path | Get given virtual environment's `python` program path.
:param venv_path: Virtual environment directory path.
:return: `python` program path. |
def execute_sql(self, query):
c = self.con.cursor()
c.execute(query)
result = []
if c.rowcount > 0:
try:
result = c.fetchall()
except psycopg2.ProgrammingError:
pass
return result | Executes a given query string on an open postgres database. |
def minimise_tables(routing_tables, target_lengths,
methods=(remove_default_entries, ordered_covering)):
if not isinstance(target_lengths, dict):
lengths = collections.defaultdict(lambda: target_lengths)
else:
lengths = target_lengths
new_tables = dict()
for chip, tab... | Utility function which attempts to minimises routing tables for multiple
chips.
For each routing table supplied, this function will attempt to use the
minimisation algorithms given (or some sensible default algorithms), trying
each sequentially until a target number of routing entries has been
reac... |
def AddFXrefRead(self, method, classobj, field):
if field not in self._fields:
self._fields[field] = FieldClassAnalysis(field)
self._fields[field].AddXrefRead(classobj, method) | Add a Field Read to this class
:param method:
:param classobj:
:param field:
:return: |
def rescale_taps(taps):
taps = np.array(taps)
cs = sum(taps)
for (i, x) in enumerate(taps):
taps[i] = x / cs
return taps.tolist() | Rescale taps in that way that their sum equals 1 |
def handle_simulation_end(self, data_portal):
log.info(
'Simulated {} trading days\n'
'first open: {}\n'
'last close: {}',
self._session_count,
self._trading_calendar.session_open(self._first_session),
self._trading_calendar.session_close(s... | When the simulation is complete, run the full period risk report
and send it out on the results socket. |
def recarray_to_hdf5_group(ra, parent, name, **kwargs):
import h5py
h5f = None
if isinstance(parent, str):
h5f = h5py.File(parent, mode='a')
parent = h5f
try:
h5g = parent.require_group(name)
for n in ra.dtype.names:
array_to_hdf5(ra[n], h5g, n, **kwargs)
... | Write each column in a recarray to a dataset in an HDF5 group.
Parameters
----------
ra : recarray
Numpy recarray to store.
parent : string or h5py group
Parent HDF5 file or group. If a string, will be treated as HDF5 file
name.
name : string
Name or path of group to... |
def get_subject_without_validation(jwt_bu64):
try:
jwt_dict = get_jwt_dict(jwt_bu64)
except JwtException as e:
return log_jwt_bu64_info(logging.error, str(e), jwt_bu64)
try:
return jwt_dict['sub']
except LookupError:
log_jwt_dict_info(logging.error, 'Missing "sub" key', j... | Extract subject from the JWT without validating the JWT.
- The extracted subject cannot be trusted for authn or authz.
Args:
jwt_bu64: bytes
JWT, encoded using a a URL safe flavor of Base64.
Returns:
str: The subject contained in the JWT. |
def update_total(self, n=1):
with self._lock:
self._pbar.total += n
self.refresh() | Increment total pbar value. |
def find_and_refine_peaks(self, threshold, min_separation=1.0,
use_cumul=False):
if use_cumul:
theMap = self._ts_cumul
else:
theMap = self._tsmap
peaks = find_peaks(theMap, threshold, min_separation)
for peak in peaks:
o, ... | Run a simple peak-finding algorithm, and fit the peaks to
paraboloids to extract their positions and error ellipses.
Parameters
----------
threshold : float
Peak threshold in TS.
min_separation : float
Radius of region size in degrees. Sets the minimum ... |
def style_print(*values, **kwargs):
style = kwargs.pop("style", None)
values = [style_format(value, style) for value in values]
print(*values, **kwargs) | A convenience function that applies style_format to text before printing |
def convertstatsmethod(method_str):
if StringClass.string_match(method_str, 'Average'):
return 'ave'
elif StringClass.string_match(method_str, 'Maximum'):
return 'max'
elif StringClass.string_match(method_str, 'Minimum'):
return 'min'
elif method_str.l... | Convert statistics method to ave, min, and max. |
def template(self):
if self._template:
return self._template
template_json = self.read_template(self.args.tmplname)
self._template = loads(template_json)
return self._template | Returns the template in JSON form |
def enum_choice_list(data):
if not data:
return {}
try:
choices = [x.value for x in data]
except AttributeError:
choices = data
def _type(value):
return next((x for x in choices if x.lower() == value.lower()), value) if value else value
params = {
'choices': C... | Creates the argparse choices and type kwargs for a supplied enum type or list of strings |
def _register_update(self, method='isel', replot=False, dims={}, fmt={},
force=False, todefault=False):
ArrayList._register_update(self, method=method, dims=dims)
InteractiveBase._register_update(self, fmt=fmt, todefault=todefault,
replot... | Register new dimensions and formatoptions for updating
Parameters
----------
%(InteractiveArray._register_update.parameters)s |
async def turn_on(self, switch=None):
if switch is not None:
switch = codecs.decode(switch.rjust(2, '0'), 'hex')
packet = self.protocol.format_packet(b"\x10" + switch + b"\x01")
else:
packet = self.protocol.format_packet(b"\x0a")
states = await self._send(pack... | Turn on relay. |
def valid_conkey(self, conkey):
for prefix in _COND_PREFIXES:
trailing = conkey.lstrip(prefix)
if trailing == '' and conkey:
return True
try:
int(trailing)
return True
except ValueError:
pass
... | Check that the conkey is a valid one. Return True if valid. A
condition key is valid if it is one in the _COND_PREFIXES
list. With the prefix removed, the remaining string must be
either a number or the empty string. |
def Expand(self, macro_ref_str):
match = _MACRO_RE.match(macro_ref_str)
if match is None or match.group(0) != macro_ref_str:
raise PDDMError('Failed to parse macro reference: "%s"' % macro_ref_str)
if match.group('name') not in self._macros:
raise PDDMError('No macro named "%s".' % match.group('... | Expands the macro reference.
Args:
macro_ref_str: String of a macro reference (i.e. foo(a, b)).
Returns:
The text from the expansion.
Raises:
PDDMError if there are any issues. |
def _print_registers(self, registers):
for reg, value in registers.items():
print(" %s : 0x%08x (%d)" % (reg, value, value)) | Print registers. |
def ctime(self, timezone=None):
if timezone is None:
timezone = self.timezone
return time.ctime(self.__timestamp__ - timezone) | Returns a ctime string.
:param timezone = self.timezone
The timezone (in seconds west of UTC) to return the value in. By
default, the timezone used when constructing the class is used
(local one by default). To use UTC, use timezone = 0. To use the
local tz, use ... |
def param(self, name, default=None):
if not name in self.params:
return default
return self.params[name] | convenient function for returning an arbitrary MAVLink
parameter with a default |
async def add(self, setname, ip, timeout=0):
args = ['add', '-exist', setname, ip, 'timeout', timeout]
return await self.start(__class__.CMD, *args) | Adds the given IP address to the given ipset.
If a timeout is given, the IP will stay in the ipset for
the given duration. Else it's added forever.
The resulting command looks like this:
``ipset add -exist ellis_blacklist4 192.0.2.10 timeout 14400`` |
def _pre_train(self,
stop_param_updates,
num_epochs,
updates_epoch):
updates = {k: stop_param_updates.get(k, num_epochs) * updates_epoch
for k, v in self.params.items()}
single_steps = {k: np.exp(-((1.0 - (1.0 / v)))
... | Set parameters and constants before training. |
def index_all_layers(self):
from hypermap.aggregator.models import Layer
if not settings.REGISTRY_SKIP_CELERY:
layers_cache = set(Layer.objects.filter(is_valid=True).values_list('id', flat=True))
deleted_layers_cache = set(Layer.objects.filter(is_valid=False).values_list('id', flat=True))
... | Index all layers in search engine. |
def load_from_file(cls, file_path):
data = None
if os.path.exists(file_path):
metadata_file = open(file_path)
data = json.loads(metadata_file.read())
return cls(initial=data) | Load the meta data given a file_path or empty meta data |
def data_to_unicode(self, data):
if isinstance(data, dict):
return {self.to_unicode(k): self.to_unicode(v) for k, v in data.iteritems()}
if isinstance(data, list):
return [self.to_unicode(l) for l in data]
else:
return self.to_unicode(data) | Recursively convert a list or dictionary to unicode.
Args:
data: The data to be unicoded.
Returns:
Unicoded data. |
def get_fields(self):
columns = self.columns
model = self.model
fields = []
for col in columns:
if isinstance(col, (str, unicode)):
v = col.split('.')
if len(v) > 1:
field = get_model(v[0], engine_name=self.model.get_engine_... | get property instance according self.columns |
def _convert_args(handler, args):
args = list(args)
params = inspect.signature(handler).parameters
for i, (arg, name) in enumerate(zip(args, params)):
default = params[name].default
annotation = params[name].annotation
if annotation != inspect.Parameter.empty:
if isinstan... | Convert a list of command arguments to types specified by the handler.
Args:
handler: a command handler function.
args: the list of string arguments to pass to handler.
Returns:
A new list containing `args` that have been converted to the expected type
for `handler`. For each function ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.