code stringlengths 51 2.38k | docstring stringlengths 4 15.2k |
|---|---|
def find_frequencies(data, freq=44100, bits=16):
n = len(data)
p = _fft(data)
uniquePts = numpy.ceil((n + 1) / 2.0)
p = [(abs(x) / float(n)) ** 2 * 2 for x in p[0:uniquePts]]
p[0] = p[0] / 2
if n % 2 == 0:
p[-1] = p[-1] / 2
s = freq / float(n)
freqArray = numpy.arange(0, uniquePt... | Convert audio data into a frequency-amplitude table using fast fourier
transformation.
Return a list of tuples (frequency, amplitude).
Data should only contain one channel of audio. |
def get_lib_module_dict(self):
from importlib import import_module
if not self.ref:
return {}
u = parse_app_url(self.ref)
if u.scheme == 'file':
if not self.set_sys_path():
return {}
for module_name in self.lib_dir_names:
... | Load the 'lib' directory as a python module, so it can be used to provide functions
for rowpipe transforms. This only works filesystem packages |
def grounded_slot_range(self, slot: Optional[Union[SlotDefinition, Optional[str]]]) -> str:
if slot is not None and not isinstance(slot, str):
slot = slot.range
if slot is None:
return DEFAULT_BUILTIN_TYPE_NAME
elif slot in builtin_names:
return slot
e... | Chase the slot range to its final form
@param slot: slot to check
@return: name of resolved range |
def hydrate(self, database, recursive=True):
if isinstance(self, Document):
self.reload(database)
for field in self:
obj = getattr(self, field)
if isinstance(obj, Document):
obj.reload(database)
if recursive:
obj.hyd... | By default, recursively reloads all instances of Document
in the model. Recursion can be turned off.
:param database: the `Database` object source for rehydrating.
:return: an updated instance of `Document` / self. |
def domain_name(self, levels=1):
if levels < 1:
raise ValueError("levels must be greater than or equal to 1")
if levels == 1:
return self.domain_word() + '.' + self.tld()
else:
return self.domain_word() + '.' + self.domain_name(levels - 1) | Produce an Internet domain name with the specified number of
subdomain levels.
>>> domain_name()
nichols-phillips.com
>>> domain_name(2)
williamson-hopkins.jackson.com |
def closed(self, user):
decision = False
for record in self.history:
if record["when"] < self.options.since.date:
continue
if not decision and record["when"] < self.options.until.date:
for change in record["changes"]:
if (change... | Moved to CLOSED and not later moved to ASSIGNED |
def _reverse_call(self, related_method, *values):
related_fields = self._to_fields(*values)
for related_field in related_fields:
if callable(related_method):
related_method(related_field, self.instance._pk)
else:
getattr(related_field, related_meth... | Convert each value to a related field, then call the method on each
field, passing self.instance as argument.
If related_method is a string, it will be the method of the related field.
If it's a callable, it's a function which accept the related field and
self.instance. |
def get_all_users(self):
r = requests.get(api_url+'users/', headers=self.headers)
print(request_status(r))
r.raise_for_status()
output = r.json()
result = []
for x in output:
result.append(User(x))
return result | Returns all the users |
def nearest_interval(self, interval):
thresh_range = 25
if interval < self.intervals[0] - thresh_range or interval > self.intervals[-1] + thresh_range:
raise IndexError("The interval given is beyond " + str(thresh_range)
+ " cents over the range of intervals defi... | This function returns the nearest interval to any given interval. |
def is_valid(hal_id):
match = REGEX.match(hal_id)
return (match is not None) and (match.group(0) == hal_id) | Check that a given HAL id is a valid one.
:param hal_id: The HAL id to be checked.
:returns: Boolean indicating whether the HAL id is valid or not.
>>> is_valid("hal-01258754, version 1")
True
>>> is_valid("hal-01258754")
True
>>> is_valid("hal-01258754v2")
True
>>> is_valid("fo... |
def _termIsObsolete(oboTerm):
isObsolete = False
if u'is_obsolete' in oboTerm:
if oboTerm[u'is_obsolete'].lower() == u'true':
isObsolete = True
return isObsolete | Determine wheter an obo 'Term' entry is marked as obsolete.
:param oboTerm: a dictionary as return by
:func:`maspy.ontology._attributeLinesToDict()`
:return: bool |
def instance(host=None, port=None):
if not hasattr(WebServer, "_instance") or WebServer._instance is None:
assert host is not None
assert port is not None
WebServer._instance = WebServer(host, port)
return WebServer._instance | Singleton to return only one instance of Server.
:returns: instance of Server |
def _load_github_repo():
if 'TRAVIS' in os.environ:
raise RuntimeError('Detected that we are running in Travis. '
'Stopping to prevent infinite loops.')
try:
with open(os.path.join(config_dir, 'repo'), 'r') as f:
return f.read()
except (OSError, IOError... | Loads the GitHub repository from the users config. |
def _make_hlog_numeric(b, r, d):
hlog_obj = lambda y, x, b, r, d: hlog_inv(y, b, r, d) - x
find_inv = vectorize(lambda x: brentq(hlog_obj, -2 * r, 2 * r,
args=(x, b, r, d)))
return find_inv | Return a function that numerically computes the hlog transformation for given parameter values. |
def eval(self, data, name, feval=None):
if not isinstance(data, Dataset):
raise TypeError("Can only eval for Dataset instance")
data_idx = -1
if data is self.train_set:
data_idx = 0
else:
for i in range_(len(self.valid_sets)):
if data i... | Evaluate for data.
Parameters
----------
data : Dataset
Data for the evaluating.
name : string
Name of the data.
feval : callable or None, optional (default=None)
Customized evaluation function.
Should accept two parameters: preds,... |
def scores(factors):
temperaments = {
const.CHOLERIC: 0,
const.MELANCHOLIC: 0,
const.SANGUINE: 0,
const.PHLEGMATIC: 0
}
qualities = {
const.HOT: 0,
const.COLD: 0,
const.DRY: 0,
const.HUMID: 0
}
for factor in factors:
... | Computes the score of temperaments
and elements. |
def visit_subscript(self, node, parent):
context = self._get_context(node)
newnode = nodes.Subscript(
ctx=context, lineno=node.lineno, col_offset=node.col_offset, parent=parent
)
newnode.postinit(
self.visit(node.value, newnode), self.visit(node.slice, newnode)
... | visit a Subscript node by returning a fresh instance of it |
def gracefulShutdown(self):
if not self.bf.perspective:
log.msg("No active connection, shutting down NOW")
reactor.stop()
return
log.msg(
"Telling the master we want to shutdown after any running builds are finished")
d = self.bf.perspective.callRe... | Start shutting down |
def layer_covariance(layer1, layer2=None):
layer2 = layer2 or layer1
act1, act2 = layer1.activations, layer2.activations
num_datapoints = act1.shape[0]
return np.matmul(act1.T, act2) / float(num_datapoints) | Computes the covariance matrix between the neurons of two layers. If only one
layer is passed, computes the symmetric covariance matrix of that layer. |
def by_credentials(cls, session, login, password):
user = cls.by_login(session, login, local=True)
if not user:
return None
if crypt.check(user.password, password):
return user | Get a user from given credentials
:param session: SQLAlchemy session
:type session: :class:`sqlalchemy.Session`
:param login: username
:type login: unicode
:param password: user password
:type password: unicode
:return: associated user
:rtype: :class:`... |
def pv_count(self):
self.open()
count = lvm_vg_get_pv_count(self.handle)
self.close()
return count | Returns the physical volume count. |
def from_polar(degrees, magnitude):
vec = Vector2()
vec.X = math.cos(math.radians(degrees)) * magnitude
vec.Y = -math.sin(math.radians(degrees)) * magnitude
return vec | Convert polar coordinates to Carteasian Coordinates |
def url(self):
end_url = ("/accounts/{account_id}/alerts/{alert_id}/mentions/"
"{mention_id}/children?")
def without_keys(d, keys):
return {x: d[x] for x in d if x not in keys}
keys = {"access_token", "account_id", "alert_id"}
parameters = without_keys(self.... | The concatenation of the `base_url` and `end_url` that make up the
resultant url.
:return: the `base_url` and the `end_url`.
:rtype: str |
def check_version(chrome_exe):
cmd = [chrome_exe, '--version']
out = subprocess.check_output(cmd, timeout=60)
m = re.search(br'(Chromium|Google Chrome) ([\d.]+)', out)
if not m:
sys.exit(
'unable to parse browser version from output of '
'%r: %r' % (subprocess.lis... | Raises SystemExit if `chrome_exe` is not a supported browser version.
Must run in the main thread to have the desired effect. |
def merge(a, b):
"merges b into a recursively if a and b are dicts"
for key in b:
if isinstance(a.get(key), dict) and isinstance(b.get(key), dict):
merge(a[key], b[key])
else:
a[key] = b[key]
return a | merges b into a recursively if a and b are dicts |
def create_x10(plm, housecode, unitcode, feature):
from insteonplm.devices.ipdb import IPDB
ipdb = IPDB()
product = ipdb.x10(feature)
deviceclass = product.deviceclass
device = None
if deviceclass:
device = deviceclass(plm, housecode, unitcode)
return device | Create an X10 device from a feature definition. |
def text(el, strip=True):
if not el:
return ""
text = el.text
if strip:
text = text.strip()
return text | Return the text of a ``BeautifulSoup`` element |
def unused(self):
unused = self.definitions - self.used
used_nodes = set([u[1] for u in self.used])
unused = set([u for u in unused if u[1] not in used_nodes])
return unused | Calculate which AST nodes are unused.
Note that we have to take special care in the case of
x,y = f(z) where x is used later, but y is not. |
def _pick_selected_option(cls):
for option in cls.select_el:
if not hasattr(option, "selected"):
return None
if option.selected:
return option.value
return None | Select handler for authors. |
def _validate(self,val):
if isinstance(self.class_, tuple):
class_name = ('(%s)' % ', '.join(cl.__name__ for cl in self.class_))
else:
class_name = self.class_.__name__
if self.is_instance:
if not (isinstance(val,self.class_)) and not (val is None and self.all... | val must be None, an instance of self.class_ if self.is_instance=True or a subclass of self_class if self.is_instance=False |
def studio(self):
if self._studio is None:
from twilio.rest.studio import Studio
self._studio = Studio(self)
return self._studio | Access the Studio Twilio Domain
:returns: Studio Twilio Domain
:rtype: twilio.rest.studio.Studio |
def pause(env, identifier):
vsi = SoftLayer.VSManager(env.client)
vs_id = helpers.resolve_id(vsi.resolve_ids, identifier, 'VS')
if not (env.skip_confirmations or
formatting.confirm('This will pause the VS with id %s. Continue?'
% vs_id)):
raise exceptions.C... | Pauses an active virtual server. |
def order_duplicate_volume(self, origin_volume_id, origin_snapshot_id=None,
duplicate_size=None, duplicate_iops=None,
duplicate_tier_level=None,
duplicate_snapshot_size=None,
hourly_billing_flag=F... | Places an order for a duplicate file volume.
:param origin_volume_id: The ID of the origin volume to be duplicated
:param origin_snapshot_id: Origin snapshot ID to use for duplication
:param duplicate_size: Size/capacity for the duplicate volume
:param duplicate_iops: The IOPS per GB fo... |
def type_name(cls):
if cls.__type_name__:
type_name = cls.__type_name__.lower()
else:
camelcase = re.compile(r'([a-z])([A-Z])')
ccase = lambda s: camelcase.sub(lambda v: '{0}_{1}'.format(v.group(1), v.group(2)), s)
type_name = ccase(cls.__name__)
... | Returns the type name if it's been defined
otherwise, it creates it from the class name |
def _return_wrapper(fits, return_all, start, trace):
if not is_iterable(fits):
fits = [fits]
if trace:
print('Total fit time: %.3f seconds' % (time.time() - start))
if not return_all:
return fits[0]
return fits | If the user wants to get all of the models back, this will
return a list of the ARIMA models, otherwise it will just return
the model. If this is called from the end of the function, ``fits``
will already be a list.
We *know* that if a function call makes it here, ``fits`` is NOT None
or it would h... |
def indices(self, data):
duration = self.data_duration(data)
for start in range(0, duration - self.duration, self.stride):
yield start | Generate patch start indices
Parameters
----------
data : dict of np.ndarray
As produced by pumpp.transform
Yields
------
start : int >= 0
The start index of a sample patch |
def console_get_char(con: tcod.console.Console, x: int, y: int) -> int:
return lib.TCOD_console_get_char(_console(con), x, y) | Return the character at the x,y of this console.
.. deprecated:: 8.4
Array access performs significantly faster than using this function.
See :any:`Console.ch`. |
def iter_files(self, number=-1, etag=None):
url = self._build_url('files', base_url=self._api)
return self._iter(int(number), url, PullFile, etag=etag) | Iterate over the files associated with this pull request.
:param int number: (optional), number of files to return. Default:
-1 returns all available files.
:param str etag: (optional), ETag from a previous request to the same
endpoint
:returns: generator of :class:`Pull... |
def get_user_avatar(self, userid):
response, status_code = self.__pod__.User.get_v1_admin_user_uid_avatar(
sessionToken=self.__session,
uid=userid
).result()
self.logger.debug('%s: %s' % (status_code, response))
return status_code, response | get avatar by user id |
def undo(self, i=-1):
_history_enabled = self.history_enabled
param = self.get_history(i)
self.disable_history()
param.undo()
self.remove_parameter(uniqueid=param.uniqueid)
if _history_enabled:
self.enable_history() | Undo an item in the history logs
:parameter int i: integer for indexing (can be positive or
negative). Defaults to -1 if not provided (the latest
recorded history item)
:raises ValueError: if no history items have been recorded |
def get_parser(self, prog_name):
parser = argparse.ArgumentParser(description=self.get_description(),
prog=prog_name, add_help=False)
return parser | Override to add command options. |
def on_step_end(self, **kwargs:Any)->None:
"Update the params from master to model and zero grad."
self.learn.model.zero_grad()
master2model(self.model_params, self.master_params, self.flat_master) | Update the params from master to model and zero grad. |
def get_config(section, option, allow_empty_option=True, default=""):
try:
value = config.get(section, option)
if value is None or len(value) == 0:
if allow_empty_option:
return ""
else:
return default
else:
return value
... | Get data from configs |
def onEdge(self, canvas):
sides = []
if int(self.position[0]) <= 0:
sides.append(1)
if (int(self.position[0]) + self.image.width) >= canvas.width:
sides.append(3)
if int(self.position[1]) <= 0:
sides.append(2)
if (int(self.position[1]) + self.i... | Returns a list of the sides of the sprite
which are touching the edge of the canvas.
0 = Bottom
1 = Left
2 = Top
3 = Right |
def get_streams(self):
self._write_lock.acquire()
try:
return itervalues(self._stream_by_id)
finally:
self._write_lock.release() | Return a snapshot of all streams in existence at time of call. |
def finalize(self):
self.pause_session_logging()
self._disable_logging()
self._msg_callback = None
self._error_msg_callback = None
self._warning_msg_callback = None
self._info_msg_callback = None | Clean up the object.
After calling this method the object can't be used anymore.
This will be reworked when changing the logging model. |
def get_next_start_id(self):
link = self.rws_connection.last_result.links.get("next", None)
if link:
link = link['url']
p = urlparse(link)
start_id = int(parse_qs(p.query)['startid'][0])
return start_id
return None | If link for next result set has been passed, extract it and get the next set start id |
def get_current_target(module, module_parameter=None, action_parameter=None):
result = exec_action(module, 'show', module_parameter=module_parameter, action_parameter=action_parameter)[0]
if not result:
return None
if result == '(unset)':
return None
return result | Get the currently selected target for the given module.
module
name of the module to be queried for its current target
module_parameter
additional params passed to the defined module
action_parameter
additional params passed to the 'show' action
CLI Example (current target of... |
def get_plugins(sites=None):
plugins = []
for plugin in CMSPlugin.objects.all():
if plugin:
cl = plugin.get_plugin_class().model
if 'posts' in cl._meta.get_all_field_names():
instance = plugin.get_plugin_instance()[0]
plugins.append(instance)
i... | Returns all GoScale plugins
It ignored all other django-cms plugins |
def ensure_repo_exists(self):
if not os.path.isdir(self.cwd):
os.makedirs(self.cwd)
if not os.path.isdir(os.path.join(self.cwd, ".git")):
self.git.init()
self.git.config("user.email", "you@example.com")
self.git.config("user.name", "Your Name") | Create git repo if one does not exist yet |
def is_link_text_present(self, link_text):
soup = self.get_beautiful_soup()
html_links = soup.find_all('a')
for html_link in html_links:
if html_link.text.strip() == link_text.strip():
return True
return False | Returns True if the link text appears in the HTML of the page.
The element doesn't need to be visible,
such as elements hidden inside a dropdown selection. |
def json_as_html(self):
from cspreports import utils
formatted_json = utils.format_report(self.json)
return mark_safe("<pre>\n%s</pre>" % escape(formatted_json)) | Print out self.json in a nice way. |
def find_top_level_directory(start_directory):
top_level = start_directory
while os.path.isfile(os.path.join(top_level, '__init__.py')):
top_level = os.path.dirname(top_level)
if top_level == os.path.dirname(top_level):
raise ValueError("Can't find top level directory")
return os... | Finds the top-level directory of a project given a start directory
inside the project.
Parameters
----------
start_directory : str
The directory in which test discovery will start. |
def clone_source_dir(source_dir, dest_dir):
if os.path.isdir(dest_dir):
print('removing', dest_dir)
shutil.rmtree(dest_dir)
shutil.copytree(source_dir, dest_dir) | Copies the source Protobuf files into a build directory.
Args:
source_dir (str): source directory of the Protobuf files
dest_dir (str): destination directory of the Protobuf files |
def split_given_spans(self, spans, sep=' '):
N = len(spans)
results = [{TEXT: text} for text in self.texts_from_spans(spans, sep=sep)]
for elem in self:
if isinstance(self[elem], list):
splits = divide_by_spans(self[elem], spans, translate=True, sep=sep)
... | Split the text into several pieces.
Resulting texts have all the layers that are present in the text instance that is splitted.
The elements are copied to resulting pieces that are covered by their spans.
However, this can result in empty layers if no element of a splitted layer fits into
... |
def set_window_iconify_callback(window, cbfun):
window_addr = ctypes.cast(ctypes.pointer(window),
ctypes.POINTER(ctypes.c_long)).contents.value
if window_addr in _window_iconify_callback_repository:
previous_callback = _window_iconify_callback_repository[window_addr]
el... | Sets the iconify callback for the specified window.
Wrapper for:
GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun cbfun); |
def init(lib_name=None, bin_path=None, sdk_path=None):
if sum(bool(x) for x in [lib_name, bin_path, sdk_path]) > 1:
raise ValueError('expected zero or one arguments')
if sdk_path:
if sys.platform.startswith('win32'):
bin_path = os.path.join(sdk_path, 'bin')
elif sys.platform.startswith('darwin'):
... | Initialize the Myo SDK by loading the libmyo shared library. With no
arguments, libmyo must be on your `PATH` or `LD_LIBRARY_PATH`.
You can specify the exact path to libmyo with *lib_name*. Alternatively,
you can specify the binaries directory that contains libmyo with *bin_path*.
Finally, you can also pass th... |
def main(arguments):
global verbose
global veryVerbose
global iteration_num
global single_score
global pr_flag
global match_triple_dict
iteration_num = arguments.r + 1
if arguments.ms:
single_score = False
if arguments.v:
verbose = True
if arguments.vv:
ve... | Main function of smatch score calculation |
def get_template_path(filename):
if os.path.isfile(filename):
return os.path.abspath(filename)
for i in sys.path:
if os.path.isfile(os.path.join(i, filename)):
return os.path.abspath(os.path.join(i, filename))
return None | Find raw template in working directory or in sys.path.
template_path from config may refer to templates colocated with the Stacker
config, or files in remote package_sources. Here, we emulate python module
loading to find the path to the template.
Args:
filename (str): Template filename.
... |
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 from_urdf_file(cls, urdf_file, base_elements=None, last_link_vector=None, base_element_type="link", active_links_mask=None, name="chain"):
if base_elements is None:
base_elements = ["base_link"]
links = URDF_utils.get_urdf_parameters(urdf_file, base_elements=base_elements, last_link_vect... | Creates a chain from an URDF file
Parameters
----------
urdf_file: str
The path of the URDF file
base_elements: list of strings
List of the links beginning the chain
last_link_vector: numpy.array
Optional : The translation vector of the tip.
... |
def resolve_randconfig(self, args):
ttype = args.get('ttype')
if is_null(ttype):
sys.stderr.write('Target type must be specified')
return None
name_keys = dict(target_type=ttype,
fullpath=True)
randconfig = self.randconfig(**name_keys)
... | Get the name of the specturm file based on the job arguments |
def _openapi_json(self):
from pprint import pprint
pprint(self.to_dict())
return current_app.response_class(json.dumps(self.to_dict(), indent=4),
mimetype='application/json') | Serve JSON spec file |
def get_morph_files(directory):
lsdir = (os.path.join(directory, m) for m in os.listdir(directory))
return list(filter(_is_morphology_file, lsdir)) | Get a list of all morphology files in a directory
Returns:
list with all files with extensions '.swc' , 'h5' or '.asc' (case insensitive) |
def add_known_host(host, application_name, user=None):
cmd = ['ssh-keyscan', '-H', '-t', 'rsa', host]
try:
remote_key = subprocess.check_output(cmd).strip()
except Exception as e:
log('Could not obtain SSH host key from %s' % host, level=ERROR)
raise e
current_key = ssh_known_hos... | Add the given host key to the known hosts file.
:param host: host name
:type host: str
:param application_name: Name of application eg nova-compute-something
:type application_name: str
:param user: The user that the ssh asserts are for.
:type user: str |
def green(cls):
"Make the text foreground color green."
wAttributes = cls._get_text_attributes()
wAttributes &= ~win32.FOREGROUND_MASK
wAttributes |= win32.FOREGROUND_GREEN
cls._set_text_attributes(wAttributes) | Make the text foreground color green. |
def guest_resize_cpus(self, userid, cpu_cnt):
action = "resize guest '%s' to have '%i' virtual cpus" % (userid,
cpu_cnt)
LOG.info("Begin to %s" % action)
with zvmutils.log_and_reraise_sdkbase_error(action):
self._vmops... | Resize virtual cpus of guests.
:param userid: (str) the userid of the guest to be resized
:param cpu_cnt: (int) The number of virtual cpus that the guest should
have defined in user directory after resize. The value should
be an integer between 1 and 64. |
def get_error_info(self) -> Tuple[Optional[str], Optional[str]]:
etag = self.find1("error-app-tag")
emsg = self.find1("error-message")
return (etag.argument if etag else None, emsg.argument if emsg else None) | Return receiver's error tag and error message if present. |
def auto_param_specs(self):
for spec in self.study_class.parameter_specs():
if spec.name not in self._name_map:
yield spec | Parameter pecs in the sub-study class that are not explicitly provided
in the name map |
def handle_request(self):
timeout = self.socket.gettimeout()
if timeout is None:
timeout = self.timeout
elif self.timeout is not None:
timeout = min(timeout, self.timeout)
fd_sets = select.select([self], [], [], timeout)
if not fd_sets[0]:
self... | Handle one request, possibly blocking.
Respects self.timeout. |
def create_prototype(sample_dimension,
parameter_kind_base='user',
parameter_kind_options=[],
state_stay_probabilities=[0.6, 0.6, 0.7]):
parameter_kind = create_parameter_kind(base=parameter_kind_base,
options=... | Create a prototype HTK model file using a feature file. |
def has_value(key):
return salt.utils.data.traverse_dict_and_list(
__grains__,
key,
KeyError) is not KeyError | Determine whether a key exists in the grains dictionary.
Given a grains dictionary that contains the following structure::
{'pkg': {'apache': 'httpd'}}
One would determine if the apache key in the pkg dict exists by::
pkg:apache
CLI Example:
.. code-block:: bash
salt '*' g... |
def merkleroot(merkletree: 'MerkleTreeState') -> Locksroot:
assert merkletree.layers, 'the merkle tree layers are empty'
assert merkletree.layers[MERKLEROOT], 'the root layer is empty'
return Locksroot(merkletree.layers[MERKLEROOT][0]) | Return the root element of the merkle tree. |
def set_child_value(
self, sensor_id, child_id, value_type, value, **kwargs):
if not self.is_sensor(sensor_id, child_id):
return
if self.sensors[sensor_id].new_state:
self.sensors[sensor_id].set_child_value(
child_id, value_type, value,
... | Add a command to set a sensor value, to the queue.
A queued command will be sent to the sensor when the gateway
thread has sent all previously queued commands.
If the sensor attribute new_state returns True, the command will be
buffered in a queue on the sensor, and only the internal s... |
def peid_features(self, pefile_handle):
peid_match = self.peid_sigs.match(pefile_handle)
return peid_match if peid_match else [] | Get features from PEid signature database |
def kick_chat_member(self, user_id):
return self.bot.api_call("kickChatMember", chat_id=self.id, user_id=user_id) | Use this method to kick a user from a group or a supergroup.
The bot must be an administrator in the group for this to work.
:param int user_id: Unique identifier of the target user |
def match_country_name_to_its_code(country_name, city=''):
if country_name:
country_name = country_name.upper().replace('.', '').strip()
if country_to_iso_code.get(country_name):
return country_to_iso_code.get(country_name)
elif country_name == 'KOREA':
if city.upper(... | Try to match country name with its code.
Name of the city helps when country_name is "Korea". |
def list_items(self, url, container=None, last_obj=None, spr=False):
headers, container_uri = self._return_base_data(
url=url,
container=container
)
if container:
resp = self._header_getter(uri=container_uri, headers=headers)
if resp.status_code ==... | Builds a long list of objects found in a container.
NOTE: This could be millions of Objects.
:param url:
:param container:
:param last_obj:
:param spr: "single page return" Limit the returned data to one page
:type spr: ``bol``
:return None | list: |
def set_as_object(self, value):
self.clear()
map = MapConverter.to_map(value)
self.append(map) | Sets a new value to map element
:param value: a new element or map value. |
def set(self, key, value):
return uwsgi.cache_set(key, value, self.timeout, self.name) | Sets the specified key value.
:param str|unicode key:
:param int|str|unicode value:
:rtype: bool |
def format_configdictfield_nodes(field_name, field, field_id, state, lineno):
value_item = nodes.definition_list_item()
value_item += nodes.term(text="Value type")
value_item_def = nodes.definition()
value_item_def_para = nodes.paragraph()
name = '.'.join((field.itemtype.__module__, field.itemtype._... | Create a section node that documents a ConfigDictField config field.
Parameters
----------
field_name : `str`
Name of the configuration field (the attribute name of on the config
class).
field : ``lsst.pex.config.ConfigDictField``
A configuration field.
field_id : `str`
... |
def get_filenames(dirname, full_path=False, match_regex=None, extension=None):
if not os.path.exists(dirname):
raise OSError('directory "{}" does not exist'.format(dirname))
match_regex = re.compile(match_regex) if match_regex else None
for filename in sorted(os.listdir(dirname)):
if extensi... | Get all filenames under ``dirname`` that match ``match_regex`` or have file
extension equal to ``extension``, optionally prepending the full path.
Args:
dirname (str): /path/to/dir on disk where files to read are saved
full_path (bool): if False, return filenames without path; if True,
... |
def solution_to_array(solution, events, slots):
array = np.zeros((len(events), len(slots)), dtype=np.int8)
for item in solution:
array[item[0], item[1]] = 1
return array | Convert a schedule from solution to array form
Parameters
----------
solution : list or tuple
of tuples of event index and slot index for each scheduled item
events : list or tuple
of :py:class:`resources.Event` instances
slots : list or tuple
of :py:class:`resources.Slot` i... |
def is_group(self):
if self._broadcast is None and self.chat:
self._broadcast = getattr(self.chat, 'broadcast', None)
return (
isinstance(self._chat_peer, (types.PeerChat, types.PeerChannel))
and not self._broadcast
) | True if the message was sent on a group or megagroup. |
def omit(keys, from_, strict=False):
ensure_iterable(keys)
ensure_mapping(from_)
if strict:
remaining_keys = set(iterkeys(from_))
remove_subset(remaining_keys, keys)
else:
remaining_keys = set(iterkeys(from_)) - set(keys)
return from_.__class__((k, from_[k]) for k in remainin... | Returns a subset of given dictionary, omitting specified keys.
:param keys: Iterable of keys to exclude
:param strict: Whether ``keys`` are required to exist in the dictionary
:return: Dictionary filtered by omitting ``keys``
:raise KeyError: If ``strict`` is True and one of ``keys`` is not found
... |
def _debug_line(linenum: int, line: str, extramsg: str = "") -> None:
log.critical("{}Line {}: {!r}", extramsg, linenum, line) | Writes a debugging report on a line. |
def adjust_ether (self, ip=None, ether=None):
if ip != None and ip.haslayer(IP) and ether != None and ether.haslayer(Ether):
iplong = atol(ip.dst)
ether.dst = "01:00:5e:%02x:%02x:%02x" % ( (iplong>>16)&0x7F, (iplong>>8)&0xFF, (iplong)&0xFF )
return True
else:
return False | Called to explicitely fixup an associated Ethernet header
The function adjusts the ethernet header destination MAC address based on
the destination IP address. |
def set_itunes_author_name(self):
try:
self.itunes_author_name = self.soup.find('itunes:author').string
except AttributeError:
self.itunes_author_name = None | Parses author name from itunes tags and sets value |
def sample_zip(items_list, num_samples, allow_overflow=False, per_bin=1):
samples_list = [[] for _ in range(num_samples)]
samples_iter = zip_longest(*items_list)
sx = 0
for ix, samples_ in zip(range(num_samples), samples_iter):
samples = filter_Nones(samples_)
samples_list[sx].extend(sam... | Helper for sampling
Given a list of lists, samples one item for each list and bins them into
num_samples bins. If all sublists are of equal size this is equivilent to a
zip, but otherewise consecutive bins will have monotonically less
elemements
# Doctest doesn't work with assertionerror
#util... |
def cleanSystem(cls):
resourceRootDirPath = os.environ[cls.rootDirPathEnvName]
os.environ.pop(cls.rootDirPathEnvName)
shutil.rmtree(resourceRootDirPath)
for k, v in list(os.environ.items()):
if k.startswith(cls.resourceEnvNamePrefix):
os.environ.pop(k) | Removes all downloaded, localized resources |
def _init_file_logger(logger, level, log_path, log_size, log_count):
if level not in [logging.NOTSET, logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL]:
level = logging.DEBUG
for h in logger.handlers:
if isinstance(h, logging.handlers.RotatingFileHandler):
... | one logger only have one level RotatingFileHandler |
def from_flag(cls, flag):
value = _get_flag_value(flag)
if value is None:
return None
relation_name = value['relation']
conversations = Conversation.load(value['conversations'])
return cls.from_name(relation_name, conversations) | Find relation implementation in the current charm, based on the
name of an active flag.
You should not use this method directly.
Use :func:`endpoint_from_flag` instead. |
def load_limits(self, config):
self._limits['history_size'] = 28800
if not hasattr(config, 'has_section'):
return False
if config.has_section('global'):
self._limits['history_size'] = config.get_float_value('global', 'history_size', default=28800)
logger.debug... | Load limits from the configuration file, if it exists. |
def export_db(filename=None, remote=False):
local_machine()
if not filename:
filename = settings.DB_DUMP_FILENAME
if remote:
backup_dir = settings.FAB_SETTING('SERVER_DB_BACKUP_DIR')
else:
backup_dir = ''
local('pg_dump -c -Fc -O -U {0}{1} {2} -f {3}{4}'.format(
env.d... | Exports the database.
Make sure that you have this in your ``~/.pgpass`` file:
localhost:5433:*:<db_role>:<password>
Also make sure that the file has ``chmod 0600 .pgpass``.
Usage::
fab export_db
fab export_db:filename=foobar.dump |
def append_sample(self, **kwargs) -> 'Seeding':
data = {
'seed': random.randint(0, 1000000)
}
data.update(kwargs)
return self._append_seed(SEED_TYPE_SAMPLE, data) | Add seed induction methods.
Kwargs can have ``number_edges`` or ``number_seed_nodes``.
:returns: self for fluid API |
def create(self, name):
if not os.path.exists(self.directory):
os.makedirs(self.directory)
filename = self.get_new_filename(name)
with open(os.path.join(self.directory, filename), 'w') as fp:
fp.write("def up(db): pass\n\n\n")
fp.write("def down(db): pass\n")
... | Create a new empty migration. |
def checksum (data, start = 0, skip_word = None):
if len(data) % 2 != 0:
arr = array.array('H', data[:-1])
else:
arr = array.array('H', data)
if skip_word is not None:
for i in range(0, len(arr)):
if i == skip_word:
continue
start += arr[i]
else:
for i in range(0, len(arr)):... | Calculate standard internet checksum over data starting at start'th byte
skip_word: If specified, it's the word offset of a word in data to "skip"
(as if it were zero). The purpose is when data is received
data which contains a computed checksum that you are trying to
verify -... |
def __get_formulas(self):
array = self._get_target().getFormulaArray()
return tuple(itertools.chain.from_iterable(array)) | Gets formulas in this cell range as a tuple.
If cells contain actual formulas then the returned values start
with an equal sign but all values are returned. |
def make_template_name(self, model_type, sourcekey):
format_dict = self.__dict__.copy()
format_dict['sourcekey'] = sourcekey
if model_type == 'IsoSource':
return self._name_factory.spectral_template(**format_dict)
elif model_type in ['MapCubeSource', 'SpatialMap']:
... | Make the name of a template file for particular component
Parameters
----------
model_type : str
Type of model to use for this component
sourcekey : str
Key to identify this component
Returns filename or None if component does not require a template fil... |
def _make_ntgrid(grid):
hnames = [_nospace(n) for n in grid[0][1:]]
vnames = [_nospace(row[0]) for row in grid[1:]]
vnames_s = " ".join(vnames)
hnames_s = " ".join(hnames)
ntcol = collections.namedtuple('ntcol', vnames_s)
ntrow = collections.namedtuple('ntrow', hnames_s)
rdict = [dict(list(z... | make a named tuple grid
[["", "a b", "b c", "c d"],
["x y", 1, 2, 3 ],
["y z", 4, 5, 6 ],
["z z", 7, 8, 9 ],]
will return
ntcol(x_y=ntrow(a_b=1, b_c=2, c_d=3),
y_z=ntrow(a_b=4, b_c=5, c_d=6),
z_z=ntrow(a_b=7, b_c=8, c_d=9)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.