content
stringlengths 35
762k
| sha1
stringlengths 40
40
| id
int64 0
3.66M
|
|---|---|---|
import re
def remove_tags(text, which_ones=(), keep=(), encoding=None):
""" Remove HTML Tags only.
`which_ones` and `keep` are both tuples, there are four cases:
============== ============= ==========================================
``which_ones`` ``keep`` what it does
============== ============= ==========================================
**not empty** empty remove all tags in ``which_ones``
empty **not empty** remove all tags except the ones in ``keep``
empty empty remove all tags
**not empty** **not empty** not allowed
============== ============= ==========================================
Remove all tags:
>>> import w3lib.html
>>> doc = '<div><p><b>This is a link:</b> <a href="http://www.example.com">example</a></p></div>'
>>> w3lib.html.remove_tags(doc)
u'This is a link: example'
>>>
Keep only some tags:
>>> w3lib.html.remove_tags(doc, keep=('div',))
u'<div>This is a link: example</div>'
>>>
Remove only specific tags:
>>> w3lib.html.remove_tags(doc, which_ones=('a','b'))
u'<div><p>This is a link: example</p></div>'
>>>
You can't remove some and keep some:
>>> w3lib.html.remove_tags(doc, which_ones=('a',), keep=('p',))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/local/lib/python2.7/dist-packages/w3lib/html.py", line 101, in remove_tags
assert not (which_ones and keep), 'which_ones and keep can not be given at the same time'
AssertionError: which_ones and keep can not be given at the same time
>>>
"""
assert not (which_ones and keep), 'which_ones and keep can not be given at the same time'
def will_remove(tag):
if which_ones:
return tag in which_ones
else:
return tag not in keep
def remove_tag(m):
tag = m.group(1)
return u'' if will_remove(tag) else m.group(0)
regex = '</?([^ >/]+).*?>'
retags = re.compile(regex, re.DOTALL | re.IGNORECASE)
return retags.sub(remove_tag, str_to_unicode(text, encoding)) | 3aa9bcab068c35245df022c7b09652a016d5070f | 0 |
def count_char(char, word):
"""Counts the characters in word"""
return word.count(char)
# If you want to do it manually try a for loop | 363222f4876c5a574a84fe14214760c505e920b0 | 1 |
def run_on_folder_evaluate_model(folder_path, n_imgs=-1, n_annotations=10):
"""
Runs the object detector on folder_path, classifying at most n_imgs images and manually asks the user if n_annotations crops are correctly classified
This is then used to compute the accuracy of the model
If all images are supposed to be used then set n_imgs to <= 0
"""
return runOnAllFramesInFolder(folder_path, "", False, True, n_imgs, n_annotations) | 0c546194a76598d645cfc3cb7dc5fa1fc854aeca | 2 |
def get_sos_model(sample_narratives):
"""Return sample sos_model
"""
return {
'name': 'energy',
'description': "A system of systems model which encapsulates "
"the future supply and demand of energy for the UK",
'scenarios': [
'population'
],
'narratives': sample_narratives,
'sector_models': [
'energy_demand',
'energy_supply'
],
'scenario_dependencies': [
{
'source': 'population',
'source_output': 'population_count',
'sink': 'energy_demand',
'sink_input': 'population'
}
],
'model_dependencies': [
{
'source': 'energy_demand',
'source_output': 'gas_demand',
'sink': 'energy_supply',
'sink_input': 'natural_gas_demand'
}
]
} | 885c251b8bbda2ebc5a950b083faed35c58f41cc | 3 |
from typing import Dict
from pathlib import Path
from typing import Tuple
import codecs
def generate_gallery_md(gallery_conf, mkdocs_conf) -> Dict[Path, Tuple[str, Dict[str, str]]]:
"""Generate the Main examples gallery reStructuredText
Start the mkdocs-gallery configuration and recursively scan the examples
directories in order to populate the examples gallery
Returns
-------
md_files_toc : Dict[str, Tuple[str, Dict[str, str]]]
A map of galleries src folders to title and galleries toc (map of title to path)
md_to_src_file : Dict[str, Path]
A map of posix absolute file path to generated markdown example -> Path of the src file relative to project root
"""
logger.info('generating gallery...') # , color='white')
# gallery_conf = parse_config(app) already done
seen_backrefs = set()
md_files_toc = dict()
md_to_src_file = dict()
# a list of pairs "gallery source" > "gallery dest" dirs
all_info = AllInformation.from_cfg(gallery_conf, mkdocs_conf)
# Gather all files except ignored ones, and sort them according to the configuration.
all_info.collect_script_files()
# Check for duplicate filenames to make sure linking works as expected
files = all_info.get_all_script_files()
check_duplicate_filenames(files)
check_spaces_in_filenames(files)
# For each gallery,
all_results = []
for gallery in all_info.galleries:
# Process the root level
title, root_nested_title, index_md, results = generate(gallery=gallery, seen_backrefs=seen_backrefs)
write_computation_times(gallery, results)
# Remember the results so that we can write the final summary
all_results.extend(results)
# Fill the md-to-srcfile dict
md_to_src_file[gallery.index_md_rel_site_root.as_posix()] = gallery.readme_file_rel_project
for res in results:
md_to_src_file[res.script.md_file_rel_site_root.as_posix()] = res.script.src_py_file_rel_project
# Create the toc entries
root_md_files = {res.script.title: res.script.md_file_rel_site_root.as_posix() for res in results}
root_md_files = dict_to_list_of_dicts(root_md_files)
if len(gallery.subsections) == 0:
# No subsections: do not nest the gallery examples further
md_files_toc[gallery.generated_dir] = (title, root_md_files)
else:
# There are subsections. Find the root gallery title if possible and nest the root contents
subsection_tocs = [{(root_nested_title or title): root_md_files}]
md_files_toc[gallery.generated_dir] = (title, subsection_tocs)
# Create an index.md with all examples
index_md_new = _new_file(gallery.index_md)
with codecs.open(str(index_md_new), 'w', encoding='utf-8') as fhindex:
# Write the README and thumbnails for the root-level examples
fhindex.write(index_md)
# If there are any subsections, handle them
for subg in gallery.subsections:
# Process the root level
sub_title, _, sub_index_md, sub_results = generate(gallery=subg, seen_backrefs=seen_backrefs)
write_computation_times(subg, sub_results)
# Remember the results so that we can write the final summary
all_results.extend(sub_results)
# Fill the md-to-srcfile dict
for res in sub_results:
md_to_src_file[res.script.md_file_rel_site_root.as_posix()] = res.script.src_py_file_rel_project
# Create the toc entries
sub_md_files = {res.script.title: res.script.md_file_rel_site_root.as_posix() for res in sub_results}
sub_md_files = dict_to_list_of_dicts(sub_md_files)
# Both append the subsection contents to the parent gallery toc
subsection_tocs.append({sub_title: sub_md_files})
# ... and also have an independent reference in case the subsection is directly referenced in the nav.
md_files_toc[subg.generated_dir] = (sub_title, sub_md_files)
# Write the README and thumbnails for the subgallery examples
fhindex.write(sub_index_md)
# Finally generate the download buttons
if gallery_conf['download_all_examples']:
download_fhindex = generate_zipfiles(gallery)
fhindex.write(download_fhindex)
# And the "generated by..." signature
if gallery_conf['show_signature']:
fhindex.write(MKD_GLR_SIG)
# Remove the .new suffix and update the md5
index_md = _replace_by_new_if_needed(index_md_new, md5_mode='t')
_finalize_backreferences(seen_backrefs, all_info)
if gallery_conf['plot_gallery']:
logger.info("computation time summary:") # , color='white')
lines, lens = _format_for_writing(all_results, kind='console')
for name, t, m in lines:
text = (' - %s: ' % (name,)).ljust(lens[0] + 10)
if t is None:
text += '(not run)'
logger.info(text)
else:
t_float = float(t.split()[0])
if t_float >= gallery_conf['min_reported_time']:
text += t.rjust(lens[1]) + ' ' + m.rjust(lens[2])
logger.info(text)
# Also create a junit.xml file if needed for rep
if gallery_conf['junit'] and gallery_conf['plot_gallery']:
write_junit_xml(all_info, all_results)
return md_files_toc, md_to_src_file | 766d6b371b6a2930c546ccc191a00c1eb3009dc1 | 4 |
from typing import Union
from typing import TextIO
from typing import List
import yaml
def load_all_yaml(stream: Union[str, TextIO], context: dict = None, template_env = None) -> List[AnyResource]:
"""Load kubernetes resource objects defined as YAML. See `from_dict` regarding how resource types are detected.
Returns a list of resource objects or raise a `LoadResourceError`.
**parameters**
* **stream** - A file-like object or a string representing a yaml file or a template resulting in
a yaml file.
* **context** - When is not `None` the stream is considered a `jinja2` template and the `context`
will be used during templating.
* **template_env** - `jinja2` template environment to be used for templating. When absent a standard
environment is used.
**NOTE**: When using the template functionality (setting the context parameter), the dependency
module `jinja2` need to be installed.
"""
if context is not None:
stream = _template(stream, context=context, template_env=template_env)
res = []
for obj in yaml.safe_load_all(stream):
res.append(from_dict(obj))
return res | b3be3b7eb82987849657165e67603b3c701e69cc | 5 |
from typing import Optional
from typing import Dict
def parse_gridspec(s: str, grids: Optional[Dict[str, GridSpec]] = None) -> GridSpec:
"""
"africa_10"
"epsg:6936;10;9600"
"epsg:6936;-10x10;9600x9600"
"""
if grids is None:
grids = GRIDS
named_gs = grids.get(_norm_gridspec_name(s))
if named_gs is not None:
return named_gs
return _parse_gridspec_string(s) | 4c0cc7dc8237a8232a8fb8d86109172d92678535 | 6 |
def make_quantile_normalizer(dist):
"""Returns f(a) that converts to the quantile value in each col.
dist should be an array with bins equally spaced from 0 to 1, giving
the value in each bin (i.e. cumulative prob of f(x) at f(i/len(dist))
should be stored in dist[i]) -- can generate from distribution or generate
empirically.
"""
def qn(a):
result = (quantiles(a)*len(dist)).astype('i')
return take(dist, result)
return qn | 395314821be4349d0c5a3b13058db0d498b03ab5 | 7 |
def text():
"""
Route that allows user to send json with raw text of title and body. This
route expects a payload to be sent that contains:
{'title': "some text ...",
'body': "some text ....}
"""
# authenticate the request to make sure it is from a trusted party
verify_token(request)
# pre-process data
title = request.json['title']
body = request.json['body']
data = app.inference_wrapper.process_dict({'title':title, 'body':body})
LOG.warning(f'prediction requested for {str(data)}')
# make prediction: you can only return strings with api
# decode with np.frombuffer(request.content, dtype='<f4')
return app.inference_wrapper.get_pooled_features(data['text']).detach().numpy().tostring() | 7bf4a602d603508894c8f86b2febc6d2a6e8e3c3 | 8 |
def RPL_ENDOFINFO(sender, receipient, message):
""" Reply Code 374 """
return "<" + sender + ">: " + message | 02fc0ef666caf7921e4f4a78a908686fd3dded17 | 10 |
def combined_score(data, side_effect_weights=None):
"""
Calculate a top-level score for each episode.
This is totally ad hoc. There are infinite ways to measure the
performance / safety tradeoff; this is just one pretty simple one.
Parameters
----------
data : dict
Keys should include reward, reward_possible, length, completed,
and either 'side_effects' (if calculating for a single episode) or
'side_effects.<effect-type>' (if calculating from a log of many
episodes).
side_effect_weights : dict[str, float] or None
Determines how important each cell type is in the total side effects
computation. If None, uses 'side_effect.total' instead.
"""
reward = data['reward'] / np.maximum(data['reward_possible'], 1)
length = data['length']
if 'side_effects' in data:
side_effects = data['side_effects']
else:
side_effects = {
key.split('.')[1]: np.nan_to_num(val) for key, val in data.items()
if key.startswith('side_effects.')
}
if side_effect_weights:
total = sum([
weight * np.array(side_effects.get(key, 0))
for key, weight in side_effect_weights.items()
], np.zeros(2))
else:
total = np.array(side_effects.get('total', [0,0]))
agent_effects, inaction_effects = total.T
side_effects_frac = agent_effects / np.maximum(inaction_effects, 1)
if len(reward.shape) > len(side_effects_frac.shape): # multiagent
side_effects_frac = side_effects_frac[..., np.newaxis]
# Speed converts length ∈ [0, 1000] → [1, 0].
speed = 1 - length / 1000
# Note that the total score can easily be negative!
score = 75 * reward + 25 * speed - 200 * side_effects_frac
return side_effects_frac, score | 9d0161f67de99f10e9d4900114ecf12462fac542 | 11 |
def volatile(func):
"""Wrapper for functions that manipulate the active database."""
def inner(self, *args, **kwargs):
ret = func(self, *args, **kwargs)
self.refresh()
self.modified_db = True
return ret
return inner | bbd8107ecc6a2b36e3677254d2b26f4ef77c3eb3 | 12 |
def input_risk_tolerance():
"""
This allows the user to enter and edit their risk tolerance.
"""
if g.logged_in is True:
if g.inputs is True:
risk_tolerance_id = m_session.query(model.User).filter_by(
id=g.user.id).first().risk_profile_id
risk_tolerance = m_session.query(model.RiskProfile).filter_by(
id=risk_tolerance_id).first().name
else:
risk_tolerance = 0
return render_template(
"input_risk_tolerance.html", risk_tolerance=risk_tolerance)
else:
return redirect("/login") | 09f9ae246beb8e9a9e901e141e11c29e594cb9c7 | 13 |
def check_context(model, sentence, company_name):
"""
Check if the company name in the sentence is actually a company name.
:param model: the spacy model.
:param sentence: the sentence to be analysed.
:param company_name: the name of the company.
:return: True if the company name means a company/product.
"""
doc = model(sentence)
for t in doc.ents:
if t.lower_ == company_name: #if company name is called
if t.label_ == "ORG" or t.label_ == "PRODUCT": #check they actually mean the company
return True
return False | 993c27924844b7cd0c570a9ce5fa404ef6d29b97 | 15 |
def getItemSize(dataType):
"""
Gets the size of an object depending on its data type name
Args:
dataType (String): Data type of the object
Returns:
(Integer): Size of the object
"""
# If it's a vector 6, its size is 6
if dataType.startswith("VECTOR6"):
return 6
# If it,s a vector 3, its size is 6
elif dataType.startswith("VECTOR3"):
return 3
# Else its size is only 1
return 1 | 2ab9c83bef56cd8dbe56c558d123e24c9da6eb0e | 16 |
def replace_symbol_to_no_symbol(pinyin):
"""把带声调字符替换为没有声调的字符"""
def _replace(match):
symbol = match.group(0) # 带声调的字符
# 去掉声调: a1 -> a
return RE_NUMBER.sub(r'', PHONETIC_SYMBOL_DICT[symbol])
# 替换拼音中的带声调字符
return RE_PHONETIC_SYMBOL.sub(_replace, pinyin) | a4c3d1a91fedf20016fb4c8b671326ad8cac008c | 17 |
from pyclustering.cluster.kmeans import kmeans
from pyclustering.cluster.center_initializer import kmeans_plusplus_initializer
from pyclustering.cluster.elbow import elbow
from pyclustering.cluster.kmeans import kmeans_visualizer
def elbow_kmeans_optimizer(X, k = None, kmin = 1, kmax = 5, visualize = True):
"""k-means clustering with or without automatically determined cluster numbers.
Reference: https://pyclustering.github.io/docs/0.8.2/html/d3/d70/classpyclustering_1_1cluster_1_1elbow_1_1elbow.html
# Arguments:
X (numpy array-like): Input data matrix.
kmin: Minimum number of clusters to consider. Defaults to 1.
kmax: Maximum number of clusters to consider. Defaults to 5.
visualize: Whether to perform k-means visualization or not.
# Returns:
numpy arraylike: Clusters.
numpy arraylike: Cluster centers.
"""
if k is not None:
amount_clusters = k
else:
elbow_instance = elbow(X, kmin, kmax)
elbow_instance.process()
amount_clusters = elbow_instance.get_amount()
wce = elbow_instance.get_wce()
centers = kmeans_plusplus_initializer(X, amount_clusters).initialize()
kmeans_instance = kmeans(X, centers)
kmeans_instance.process()
clusters = kmeans_instance.get_clusters()
centers = kmeans_instance.get_centers()
kmeans_visualizer.show_clusters(X, clusters, centers)
return clusters, centers | 53fe501367e85c3d345d0bebdfdccff17e8b93db | 18 |
import time
def FloatDateTime():
"""Returns datetime stamp in Miro's REV_DATETIME format as a float,
e.g. 20110731.123456"""
return float(time.strftime('%Y%m%d.%H%M%S', time.localtime())) | 115aef9104124774692af1ba62a48a5423b9dc2a | 19 |
def xyz_to_rgb(xyz):
"""
Convert tuple from the CIE XYZ color space to the sRGB color space.
Conversion is based on that the XYZ input uses an the D65 illuminate with a 2° observer angle.
https://en.wikipedia.org/wiki/Illuminant_D65
The inverse conversion matrix used was provided by Bruce Lindbloom:
http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
Formulas for conversion:
http://www.brucelindbloom.com/index.html?Eqn_RGB_to_XYZ.html
https://easyrgb.com/en/math.php
Information about respective color space:
sRGB (standard Red Green Blue): https://en.wikipedia.org/wiki/SRGB
CIE XYZ: https://en.wikipedia.org/wiki/CIE_1931_color_space
"""
x = xyz[0] / 100.0
y = xyz[1] / 100.0
z = xyz[2] / 100.0
r = x * 3.2404542 + y * -1.5371385 + z * -0.4985314
g = x * -0.9692660 + y * 1.8760108 + z * 0.0415560
b = x * 0.0556434 + y * -0.2040259 + z * 1.0572252
r = _pivot_xyz_to_rgb(r)
g = _pivot_xyz_to_rgb(g)
b = _pivot_xyz_to_rgb(b)
r = r * 255.0
g = g * 255.0
b = b * 255.0
return r, g, b | 0c227f7d0ead08afdd0a3dd7946d45ad0cae011b | 20 |
import numbers
def _score(estimator, X_test, y_test, scorer, is_multimetric=False):
"""Compute the score(s) of an estimator on a given test set.
Will return a single float if is_multimetric is False and a dict of floats,
if is_multimetric is True
"""
if is_multimetric:
return _multimetric_score(estimator, X_test, y_test, scorer)
else:
if y_test is None:
score = scorer(estimator, X_test)
else:
score = scorer(estimator, X_test, y_test)
if hasattr(score, 'item'):
try:
# e.g. unwrap memmapped scalars
score = score.item()
except ValueError:
# non-scalar?
pass
if not isinstance(score, numbers.Number):
raise ValueError("scoring must return a number, got %s (%s) "
"instead. (scorer=%r)"
% (str(score), type(score), scorer))
return score | 1b3c136098e625968664518940769678d978aca4 | 21 |
import functools
def asynchronous(datastore=False, obj_store=False, log_store=False):
"""Wrap request handler methods with this decorator if they will require asynchronous
access to DynamoDB datastore or S3 object store for photo storage.
If datastore=True, then a DynamoDB client is available to the handler as self._client. If
obj_store=True, then an S3 client for the photo storage bucket is available as self._obj_store.
If log_store is true, then an S3 client for the user log storage bucket is available as
self._log_store
Like tornado.web.asynchronous, this decorator disables the auto-finish functionality.
"""
def _asynchronous(method):
def _wrapper(self, *args, **kwargs):
"""Disables automatic HTTP response completion on exit."""
self._auto_finish = False
if datastore:
self._client = DBClient.Instance()
if obj_store:
self._obj_store = ObjectStore.GetInstance(ObjectStore.PHOTO)
if log_store:
self._log_store = ObjectStore.GetInstance(ObjectStore.USER_LOG)
with util.ExceptionBarrier(self._stack_context_handle_exception):
return method(self, *args, **kwargs)
return functools.wraps(method)(_wrapper)
return _asynchronous | 2bef0ba95993a4114ecb28b99a2952e2d269b54a | 22 |
def get_translatable_models():
"""
Get the translatable models according to django-modeltranslation
!! only use to migrate from django-modeltranslation !!
"""
_raise_if_not_django_modeltranslation()
return translator.get_registered_models() | b22ca513d3d29dfc7c2d3502cabdcf95e2e4bce9 | 23 |
def schedule_dense_arm_cpu(attrs, inputs, out_type, target):
"""dense arm cpu strategy"""
strategy = _op.OpStrategy()
isa = arm_isa.IsaAnalyzer(target)
if isa.has_dsp_support:
strategy.add_implementation(
wrap_compute_dense(topi.nn.dense),
wrap_topi_schedule(topi.arm_cpu.schedule_dense_dsp),
name="dense_dsp",
)
else:
strategy.add_implementation(
wrap_compute_dense(
topi.nn.dense, need_auto_scheduler_layout=is_auto_scheduler_enabled()
),
wrap_topi_schedule(topi.generic.schedule_dense),
name="dense.generic",
)
return strategy | 45b800ceecc14dd62734159d05baa8273cc4c3ff | 24 |
def default_select(identifier, all_entry_points): # pylint: disable=inconsistent-return-statements
"""
Raise an exception when we have ambiguous entry points.
"""
if len(all_entry_points) == 0:
raise PluginMissingError(identifier)
elif len(all_entry_points) == 1:
return all_entry_points[0]
elif len(all_entry_points) > 1:
raise AmbiguousPluginError(all_entry_points) | 331ca0108f05e97fcbec95e40111ca6eb5aa835b | 25 |
import json
def read_prediction_dependencies(pred_file):
"""
Reads in the predictions from the parser's output file.
Returns: two String list with the predicted heads and dependency names, respectively.
"""
heads = []
deps = []
with open(pred_file, encoding="utf-8") as f:
for line in f:
j = json.loads(line)
heads.extend(j["predicted_heads"])
deps.extend(j["predicted_dependencies"])
heads = list(map(str, heads))
return heads, deps | c8280c861d998d0574fb831cd9738b733fd53388 | 26 |
def add_new_ingredient(w, ingredient_data):
"""Adds the ingredient into the database """
combobox_recipes = generate_CBR_names(w)
combobox_bottles = generate_CBB_names(w)
given_name_ingredient_data = DB_COMMANDER.get_ingredient_data(ingredient_data["ingredient_name"])
if given_name_ingredient_data:
DP_HANDLER.standard_box("Dieser Name existiert schon in der Datenbank!")
return ""
DB_COMMANDER.insert_new_ingredient(
ingredient_data["ingredient_name"],
ingredient_data["alcohollevel"],
ingredient_data["volume"],
ingredient_data["hand_add"]
)
if not ingredient_data["hand_add"]:
DP_HANDLER.fill_multiple_combobox(combobox_recipes, [ingredient_data["ingredient_name"]])
DP_HANDLER.fill_multiple_combobox(combobox_bottles, [ingredient_data["ingredient_name"]])
return f"Zutat mit dem Namen: <{ingredient_data['ingredient_name']}> eingetragen" | ea0cbc371502d84223aeec5c18e2f19a020e229a | 27 |
def detect_entities(_inputs, corpus, threshold=None):
"""
Détecte les entités nommées sélectionnées dans le corpus donné en argument.
:param _inputs: paramètres d'entrainement du modèle
:param corpus: corpus à annoter
:param threshold: seuils de détection manuels. Si la probabilité d'une catégorie dépasse ce seuil, on prédit cette
catégorie meme si elle ne correspond pas à la probabilité maximale.
:return: corpus avec prédictions sur la nature des entités
"""
# Initialisation de la classe de pseudonymisation et entrainement du modèle.
ner = Ner(_inputs)
corpus_with_labels = ner.predict_with_model(corpus, threshold)
return corpus_with_labels | 1d7dc2ef42a9961daee6260c9fb6b9b2f099e96f | 28 |
def request_video_count(blink):
"""Request total video count."""
url = "{}/api/v2/videos/count".format(blink.urls.base_url)
return http_get(blink, url) | d847d840892908a66f99fae95b91e78b8ddc7dcb | 29 |
def version():
"""Return a ST version. Return 0 if not running in ST."""
if not running_in_st():
return 0
return int(sublime.version()) | d4f51b0a91301a8cdadff126931e7f0e72b8c850 | 30 |
def get_intervention(action, time):
"""Return the intervention in the simulator required to take action."""
action_to_intervention_map = {
0: Intervention(time=time, epsilon_1=0.0, epsilon_2=0.0),
1: Intervention(time=time, epsilon_1=0.0, epsilon_2=0.3),
2: Intervention(time=time, epsilon_1=0.7, epsilon_2=0.0),
3: Intervention(time=time, epsilon_1=0.7, epsilon_2=0.3),
}
return action_to_intervention_map[action] | 11c145efc3eb9e7bafc05943294232c161b59952 | 32 |
def draw_labeled_bboxes(img, labels):
"""
Draw the boxes around detected object.
"""
# Iterate through all detected cars
for car_number in range(1, labels[1]+1):
# Find pixels with each car_number label value
nonzero = (labels[0] == car_number).nonzero()
# Identify x and y values of those pixels
nonzeroy = np.array(nonzero[0])
nonzerox = np.array(nonzero[1])
# Define a bounding box based on min/max x and y
bbox = ((np.min(nonzerox), np.min(nonzeroy)), (np.max(nonzerox), np.max(nonzeroy)))
# Draw the box on the image
cv2.rectangle(img, bbox[0], bbox[1], (0,0,255), 6)
return img | 7bf9a3a5a54a41c49845408d5e04dc5de67eea6c | 33 |
def calc_diff(nh_cube, sh_cube, agg_method):
"""Calculate the difference metric"""
metric = nh_cube.copy()
metric.data = nh_cube.data - sh_cube.data
metric = rename_cube(metric, 'minus sh ' + agg_method)
return metric | 3eb62be75af265bd2fa7323c6c23e3735e1c87be | 35 |
def median_boxcar_filter(data, window_length=None, endpoints='reflect'):
"""
Creates median boxcar filter and deals with endpoints
Parameters
----------
data : numpy array
Data array
window_length: int
A scalar giving the size of the median filter window
endpoints : str
How to deal with endpoints.
Only option right now is 'reflect', which extends the data array
on both ends by reflecting the data
Returns
-------
filter : numpy array
The filter array
"""
filter_array = data
# Create filter array
if(endpoints == 'reflect'):
last_index = len(data) - 1
filter_array = np.concatenate((np.flip(data[0:window_length], 0),
data,
data[last_index - window_length:last_index]))
# Make filter
# Check that window_length is odd
if(window_length % 2 == 0):
window_length += 1
filt = medfilt(filter_array, window_length)
filt = filt[window_length:window_length + last_index + 1]
return filt | 1782998bad2ab02c628d8afbc456c1bea4c2533c | 36 |
import ray
import threading
def test_threaded_actor_api_thread_safe(shutdown_only):
"""Test if Ray APIs are thread safe
when they are used within threaded actor.
"""
ray.init(
num_cpus=8,
# from 1024 bytes, the return obj will go to the plasma store.
_system_config={"max_direct_call_object_size": 1024},
)
@ray.remote
def in_memory_return(i):
return i
@ray.remote
def plasma_return(i):
arr = np.zeros(8 * 1024 * i, dtype=np.uint8) # 8 * i KB
return arr
@ray.remote(num_cpus=1)
class ThreadedActor:
def __init__(self):
self.received = []
self.lock = threading.Lock()
def in_memory_return_test(self, i):
self._add(i)
return ray.get(in_memory_return.remote(i))
def plasma_return_test(self, i):
self._add(i)
return ray.get(plasma_return.remote(i))
def _add(self, seqno):
with self.lock:
self.received.append(seqno)
def get_all(self):
with self.lock:
return self.received
a = ThreadedActor.options(max_concurrency=10).remote()
max_seq = 50
# Test in-memory return obj
seqnos = ray.get(
[a.in_memory_return_test.remote(seqno) for seqno in range(max_seq)]
)
assert sorted(seqnos) == list(range(max_seq))
# Test plasma return obj
real = ray.get([a.plasma_return_test.remote(seqno) for seqno in range(max_seq)])
expected = [np.zeros(8 * 1024 * i, dtype=np.uint8) for i in range(max_seq)]
for r, e in zip(real, expected):
assert np.array_equal(r, e)
ray.kill(a)
ensure_cpu_returned(8) | f3fd0d4c2621e69c348b734040c7bd49f1f1578b | 37 |
from typing import Optional
def build_template_context(
title: str, raw_head: Optional[str], raw_body: str
) -> Context:
"""Build the page context to insert into the outer template."""
head = _render_template(raw_head) if raw_head else None
body = _render_template(raw_body)
return {
'page_title': title,
'head': head,
'body': body,
} | 38bf538c0c979b6e0aaba1367458140028332385 | 38 |
def inf_set_stack_ldbl(*args):
"""
inf_set_stack_ldbl(_v=True) -> bool
"""
return _ida_ida.inf_set_stack_ldbl(*args) | 2b343bb66229f6ba5f834b3d543fcd75ad08875c | 39 |
def _get_self_compatibility_dict(package_name: str) -> dict:
"""Returns a dict containing self compatibility status and details.
Args:
package_name: the name of the package to check (e.g.
"google-cloud-storage").
Returns:
A dict containing the self compatibility status and details for any
self incompatibilities. The dict will be formatted like the following:
{
'py2': { 'status': BadgeStatus.SUCCESS, 'details': {} },
'py3': { 'status': BadgeStatus.SUCCESS, 'details': {} },
}
"""
pkg = package.Package(package_name)
compatibility_results = badge_utils.store.get_self_compatibility(pkg)
missing_details = _get_missing_details(
[package_name], compatibility_results)
if missing_details:
result_dict = badge_utils._build_default_result(
status=BadgeStatus.MISSING_DATA, details=missing_details)
return result_dict
result_dict = badge_utils._build_default_result(
status=BadgeStatus.SUCCESS,
details='The package does not support this version of python.')
for res in compatibility_results:
pyver = badge_utils.PY_VER_MAPPING[res.python_major_version]
badge_status = PACKAGE_STATUS_TO_BADGE_STATUS.get(
res.status) or BadgeStatus.SELF_INCOMPATIBLE
result_dict[pyver]['status'] = badge_status
result_dict[pyver]['details'] = res.details
if res.details is None:
result_dict[pyver]['details'] = badge_utils.EMPTY_DETAILS
return result_dict | ca29593d3d5941f576a2d033f5754902828a1138 | 40 |
def checksum_md5(filename):
"""Calculates the MD5 checksum of a file."""
amd5 = md5()
with open(filename, mode='rb') as f:
for chunk in iter(lambda: f.read(128 * amd5.block_size), b''):
amd5.update(chunk)
return amd5.hexdigest() | 80cd2bf43274ea060a4d5001d6a319fae59b1e94 | 41 |
def CleanGrant(grant):
"""Returns a "cleaned" grant by rounding properly the internal data.
This insures that 2 grants coming from 2 different sources are actually
identical, irrespective of the logging/storage precision used.
"""
return grant._replace(latitude=round(grant.latitude, 6),
longitude=round(grant.longitude, 6),
height_agl=round(grant.height_agl, 2),
max_eirp=round(grant.max_eirp, 3)) | 648bb0a76f9a7cfe355ee8ffced324eb6ceb601e | 42 |
def OpenRegistryKey(hiveKey, key):
""" Opens a keyHandle for hiveKey and key, creating subkeys as necessary """
keyHandle = None
try:
curKey = ""
keyItems = key.split('\\')
for subKey in keyItems:
if curKey:
curKey = curKey + "\\" + subKey
else:
curKey = subKey
keyHandle = win32api.RegCreateKey(hiveKey, curKey)
except Exception, e:
keyHandle = None
print "OpenRegistryKey failed:", hiveKey, key, e
return keyHandle | d7555a752a08ed0e7bfedbb77583aed9e5b26fe1 | 43 |
import multiprocessing
def eval_py(input_text: str):
"""Runs eval() on the input text on a seperate process and returns output or error.
How to timout on a function call ? https://stackoverflow.com/a/14924210/13523305
Return a value from multiprocess ? https://stackoverflow.com/a/10415215/13523305
"""
def evaluate(input_text, return_val):
"""wrapper for eval"""
try:
return_val[input_text] = str(eval(input_text))
except Exception as error:
return_val[
input_text
] = f"""😔 /e feeds your expression to python's eval function.
The following error occured: \n\n{error}"""
if contains_restricted(input_text):
return restricted_message
# using multiprocessing and getting value returned by target function
manger = multiprocessing.Manager()
return_val = manger.dict() # enable target function to return a value
process = multiprocessing.Process(target=evaluate, args=(input_text, return_val))
process.start()
process.join(6) # allow the process to run for 6 seconds
if process.is_alive():
# kill the process if it is still alive
process.kill()
return timeout_message
output = return_val[input_text]
return output | 1058f2877e00370fa4600cf2bcfb334149347cba | 44 |
def trim(str):
"""Remove multiple spaces"""
return ' '.join(str.strip().split()) | ed98f521c1cea24552959aa334ffb0c314b9f112 | 45 |
def build_model_svr(model_keyvalue, inputs, encoder = None, context = None):
"""Builds model from, seal_functions, model params.
model_keyvalue: key identifying model
inputs: properly formatted encrypted inputs for model
encoder: SEAL encoder object
context: SEAL context object
"""
modeldict = MODELS[model_keyvalue]
params_path = MODELPARMS.joinpath(modeldict["path"])
alias = modeldict["seal_function"]
try:
func = alias(params_path, context=context, encoder=encoder)
except Exception as e:
raise ValueError(f"There was a problem with your inputs: {e}")
return func.eval(inputs) | 0e36d94c5305aa55523d76d2f8afac17b9c7d9b0 | 46 |
def find_similar(collection):
""" Searches the collection for (probably) similar artist and returns
lists containing the "candidates". """
spellings = defaultdict(list)
for artist in collection:
spellings[normalize_artist(artist)].append(artist)
return [spellings[artist] for artist in spellings
if len(spellings[artist]) > 1] | c11f93d0da7ff27f89c51d1d255d75e31c6c539f | 47 |
def vim_print(mse_ref, mse_values, x_name, ind_list=0, with_output=True,
single=True, partner_k=None):
"""Print Variable importance measure and create sorted output.
Parameters
----------
mse_ref : Numpy Float. Reference value of non-randomized x.
mse_values : Numpy array. MSE's for randomly permuted x.
x_name : List of strings. Variable names.
ind_list : List of INT, optional. Variable positions. Default is 0.
with_output : Boolean, optional. Default is True.
single : Boolean, optional. The default is True.
partner_k : List of None and Int or None. Index of variables that were
jointly randomized. Default is None.
Returns
-------
vim: Tuple of Numpy array and list of lists. MSE sorted and sort index.
"""
if partner_k is not None:
for idx, val in enumerate(partner_k):
if val is not None:
if (idx > (val-1)) and (idx > 0):
mse_values[idx-1] = mse_values[val-1]
mse = mse_values / np.array(mse_ref) * 100
var_indices = np.argsort(mse)
var_indices = np.flip(var_indices)
vim_sorted = mse[var_indices]
if single:
x_names_sorted = np.array(x_name, copy=True)
x_names_sorted = x_names_sorted[var_indices]
ind_sorted = list(var_indices)
else:
var_indices = list(var_indices)
ind_sorted = []
x_names_sorted = []
for i in var_indices:
ind_i = ind_list[i]
ind_sorted.append(ind_i)
x_name_i = []
for j in ind_i:
x_name_i.append(x_name[j])
x_names_sorted.append(x_name_i)
if with_output:
print('\n')
print('-' * 80)
print('Out of bag value of MSE: {:8.3f}'.format(mse_ref))
print('- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -')
print('Variable importance statistics in %-lost of base value')
for idx, vim in enumerate(vim_sorted):
if single:
print('{:<50}: {:>7.2f}'.format(x_names_sorted[idx],
vim-100), '%')
else:
print(x_names_sorted[idx])
print('{:<50}: {:>7.2f}'.format(' ', vim-100), '%')
print('-' * 80)
print('Computed as share of OOB MSE of estimated forest relative to',
'OOB MSE of variable (or group of variables) with randomized',
'covariate values in %.')
ind_sorted.reverse()
vim_sorted = np.flip(vim_sorted)
vim = (vim_sorted, ind_sorted)
first_time = True
if partner_k is not None:
for idx, val in enumerate(partner_k):
if val is not None:
if first_time:
print('The following variables are jointly analysed:',
end=' ')
first_time = False
if idx < val:
print(x_name[idx-1], x_name[val-1], ' / ', end='')
print()
print('-' * 80, '\n')
return vim | 4c7eef9dc15d50b904dfe3df51586d77af70d776 | 48 |
def from_column_list(
col_names, col_types=None,
col_blobs=None, col_metadata=None
):
"""
Given a list of names, types, and optionally values, construct a Schema.
"""
if col_types is None:
col_types = [None] * len(col_names)
if col_metadata is None:
col_metadata = [None] * len(col_names)
if col_blobs is None:
col_blobs = [None] * len(col_names)
assert len(col_names) == len(col_types), (
'col_names and col_types must have the same length.'
)
assert len(col_names) == len(col_metadata), (
'col_names and col_metadata must have the same length.'
)
assert len(col_names) == len(col_blobs), (
'col_names and col_blobs must have the same length.'
)
root = _SchemaNode('root', 'Struct')
for col_name, col_type, col_blob, col_metadata in zip(
col_names, col_types, col_blobs, col_metadata
):
columns = col_name.split(FIELD_SEPARATOR)
current = root
for i in range(len(columns)):
name = columns[i]
type_str = ''
field = None
if i == len(columns) - 1:
type_str = col_type
field = Scalar(
dtype=col_type,
blob=col_blob,
metadata=col_metadata
)
next = current.add_child(name, type_str)
if field is not None:
next.field = field
next.col_blob = col_blob
current = next
return root.get_field() | 22fc57657bc144304ef0afbdd74acf9ed63faba0 | 49 |
import torch
def get_optimizer(lr):
"""
Specify an optimizer and its parameters.
Returns
-------
tuple(torch.optim.Optimizer, dict)
The optimizer class and the dictionary of kwargs that should
be passed in to the optimizer constructor.
"""
return (torch.optim.SGD,
{"lr": lr, "weight_decay": 1e-6, "momentum": 0.9}) | 213090258414059f7a01bd40ecd7ef04158d60e5 | 50 |
def _from_list(data: any) -> dict:
"""Convert lists to indexed dictionaries.
:arg data: An ordered map.
:returns: An ordered map.
"""
if isinstance(data, list):
return dict([(str(i), _from_list(v)) for i, v in enumerate(data)])
if isinstance(data, dict):
return dict([(key, _from_list(data[key])) for key in data])
return data | 06c757276edbc013c4094872f4063077cec2c589 | 51 |
def parse_date(ses_date):
"""This parses a date string of the form YYYY-MM-DD and returns
the string, year, month, day and day of year."""
[yr,mn,dy] = ses_date.split('-')
year = int(yr)
month = int(mn)
day = int(dy[:2]) # strip of any a or b
DOY = day_of_year(year,month,day)
return ses_date,year,month,day,DOY | a8105f9f39869402863f14a1d68ff37a7f25ed74 | 52 |
import requests
import json
def get_access_token(consumer_key, consumer_secret):
"""
:return: auth token for mpesa api calls
"""
oauth_url = "https://api.safaricom.co.ke/oauth/v1/generate?grant_type=client_credentials"
response = requests.get(oauth_url, auth=HTTPBasicAuth(consumer_key, consumer_secret))
access_token = json.loads(response.text).get('access_token', None)
return access_token | 15d09439d0b6e135c4f87958fe116e686c38cca2 | 53 |
def create_feed_forward_dot_product_network(observation_spec, global_layers,
arm_layers):
"""Creates a dot product network with feedforward towers.
Args:
observation_spec: A nested tensor spec containing the specs for global as
well as per-arm observations.
global_layers: Iterable of ints. Specifies the layers of the global tower.
arm_layers: Iterable of ints. Specifies the layers of the arm tower. The
last element of arm_layers has to be equal to that of global_layers.
Returns:
A dot product network that takes observations adhering observation_spec and
outputs reward estimates for every action.
Raises:
ValueError: If the last arm layer does not match the last global layer.
"""
if arm_layers[-1] != global_layers[-1]:
raise ValueError('Last layer size of global and arm layers should match.')
global_network = encoding_network.EncodingNetwork(
input_tensor_spec=observation_spec[bandit_spec_utils.GLOBAL_FEATURE_KEY],
fc_layer_params=global_layers)
one_dim_per_arm_obs = tensor_spec.TensorSpec(
shape=observation_spec[bandit_spec_utils.PER_ARM_FEATURE_KEY].shape[1:],
dtype=tf.float32)
arm_network = encoding_network.EncodingNetwork(
input_tensor_spec=one_dim_per_arm_obs,
fc_layer_params=arm_layers)
return GlobalAndArmDotProductNetwork(observation_spec, global_network,
arm_network) | ed4e95ce10859e976800fd88b6caceffd6ca09a2 | 54 |
import logging
def check_collisions(citekeys_df):
"""
Check for short_citekey hash collisions
"""
collision_df = citekeys_df[['standard_citekey', 'short_citekey']].drop_duplicates()
collision_df = collision_df[collision_df.short_citekey.duplicated(keep=False)]
if not collision_df.empty:
logging.error(f'OMF! Hash collision. Congratulations.\n{collision_df}')
return collision_df | b01b53323f7885a7375ba78b50222bcbe9980498 | 55 |
def get_user(module, system):
"""Find a user by the user_name specified in the module"""
user = None
user_name = module.params['user_name']
try:
user = system.users.get(name=user_name)
except ObjectNotFound:
pass
return user | f674352998e444a184ab2a2a6a2caedc35611e49 | 56 |
def appointments(request):
"""Page for users to view upcoming appointments."""
appointments = Appointment.objects.filter(patient=request.user.patient)
context = {
'appointments': appointments
}
return render(request, 'patients/appointments.html', context) | ad7bab85db19f907631a8c9e25b65048abab7e6b | 57 |
def _SignedVarintDecoder(mask):
"""Like _VarintDecoder() but decodes signed values."""
local_ord = ord
def DecodeVarint(buffer, pos):
result = 0
shift = 0
while 1:
b = local_ord(buffer[pos])
result |= ((b & 0x7f) << shift)
pos += 1
if not (b & 0x80):
if result > 0x7fffffffffffffff:
result -= (1 << 64)
result |= ~mask
else:
result &= mask
return (result, pos)
shift += 7
if shift >= 64:
raise _DecodeError('Too many bytes when decoding varint.')
return DecodeVarint | de88a082cc90f6370674723173f4c75ee7025f27 | 58 |
def is_valid_msg_type(x):
"""
@return: True if the name is a syntatically legal message type name
@rtype: bool
"""
if not x or len(x) != len(x.strip()):
return False
base = base_msg_type(x)
if not roslib.names.is_legal_resource_name(base):
return False
# parse array indicies
x = x[len(base):]
state = 0
for c in x:
if state == 0:
if c != '[':
return False
state = 1 # open
elif state == 1:
if c == ']':
state = 0 # closed
else:
try:
int(c)
except Exception:
return False
return state == 0 | ca6b6b2e62ffa26a795cbbccab01667a8ce9470e | 59 |
def get_ascii_matrix(img):
"""(Image) -> list of list of str\n
Takes an image and converts it into a list of list containing a string which maps to brightness
of each pixel of each row
"""
ascii_map = "`^\",:;Il!i~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$"
brightness_matrix = get_brightness_matrix(img)
ascii_matrix = []
for rows in range(len(brightness_matrix)):
row = []
for column in brightness_matrix[rows]:
map_index = column//4
row.append(ascii_map[map_index])
ascii_matrix.append(row)
return ascii_matrix | e8b6a160fc082a868267971937e56e2f6a1eb9e4 | 60 |
from typing import List
from typing import Dict
from typing import Any
def to_scene_agent_prediction_from_boxes_separate_color(
tracked_objects: TrackedObjects, color_vehicles: List[int], color_pedestrians: List[int], color_bikes: List[int]
) -> List[Dict[str, Any]]:
"""
Convert predicted observations into prediction dictionary.
:param tracked_objects: List of tracked_objects in global coordinates.
:param color_vehicles: color [R, G, B, A] for vehicles predictions.
:param color_pedestrians: color [R, G, B, A] for pedestrians predictions.
:param color_bikes: color [R, G, B, A] for bikes predictions.
:return scene.
"""
predictions = []
for tracked_object in tracked_objects:
if tracked_object.predictions is None:
continue
if tracked_object.tracked_object_type == TrackedObjectType.VEHICLE:
color = color_vehicles
elif tracked_object.tracked_object_type == TrackedObjectType.PEDESTRIAN:
color = color_pedestrians
elif tracked_object.tracked_object_type == TrackedObjectType.BICYCLE:
color = color_bikes
else:
color = [0, 0, 0, 255]
predictions.append(_to_scene_agent_prediction(tracked_object, color))
return predictions | 728d471fbc15957c57f4b3a6da68bfffdbf875ac | 61 |
def stretch(snd_array, factor, window_size, h):
""" Stretches/shortens a sound, by some factor. """
phase = np.zeros(window_size)
hanning_window = np.hanning(window_size)
result = np.zeros( len(snd_array) /factor + window_size)
for i in np.arange(0, len(snd_array)-(window_size+h), h*factor):
# two potentially overlapping subarrays
a1 = snd_array[i: i + window_size]
a2 = snd_array[i + h: i + window_size + h]
# the spectra of these arrays
s1 = np.fft.fft(hanning_window * a1)
s2 = np.fft.fft(hanning_window * a2)
# rephase all frequencies
phase = (phase + np.angle(s2/s1)) % 2*np.pi
a2_rephased = np.fft.ifft(np.abs(s2)*np.exp(1j*phase))
i2 = int(i/factor)
result[i2 : i2 + window_size] += hanning_window*a2_rephased
result = ((2**(16-4)) * result/result.max()) # normalize (16bit)
return result.astype('int16') | aeb12b6da26de9630eec9ad84caf9f30bd6f1f71 | 62 |
def guess_encoding(text):
""" Given bytes, determine the character set encoding
@return: dict with encoding and confidence
"""
if not text: return {'confidence': 0, 'encoding': None}
enc = detect_charset(text)
cset = enc['encoding']
if cset.lower() == 'iso-8859-2':
# Anomoaly -- chardet things Hungarian (iso-8850-2) is
# a close match for a latin-1 document. At least the quotes match
# Other Latin-xxx variants will likely match, but actually be Latin1
# or win-1252. see Chardet explanation for poor reliability of Latin-1 detection
#
enc['encoding'] = CHARDET_LATIN2_ENCODING
return enc | f58d652b7a77652ace1c27b315fc81ac82726a03 | 63 |
def is_edit_end_without_next(line, configs):
"""
Is the line indicates that 'edit' section ends without 'next' end marker
(special case)?
- config vdom
edit <name>
...
end
:param line: A str represents a line in configurations output
:param configs: A stack (list) holding config node objects
"""
if len(configs) > 1:
(parent, child) = (configs[-2], configs[-1]) # (config, edit)
if parent.end_re.match(line) and parent.name == "vdom" and \
parent.type == NT_CONFIG and child.type == NT_EDIT:
return True
return False | 0398fc86ee7911686bfdaa0cdf6431f53db1ccba | 64 |
def get_live_args(request, script=False, typed=False):
""" Get live args input by user | request --> [[str], [str]]"""
arg_string = list(request.form.values())[0]
if script:
return parse_command_line_args(arg_string)
if typed:
try:
all_args = parse_type_args(arg_string)
except Exception as e: #Doesn't matter what the exception is.
#raise e #Uncomment for testing
return ('Parsing Error', e)
else:
all_args = parse_args(arg_string)
args = all_args[0]
kwargs = all_args[1]
all_args = [args, kwargs]
print(all_args)
return all_args | 9e56043760e9ac263a737166c796640170a6174c | 65 |
import codecs
import csv
def open_csv(path):
"""open_csv."""
_lines = []
with codecs.open(path, encoding='utf8') as fs:
for line in csv.reader(fs):
if len(line) == 3:
_lines.append(line)
return _lines | 501ff4a2a1a242439c21d3131cecd407dcfa36af | 66 |
from typing import Union
from pathlib import Path
from typing import Dict
def parse_metadata(metadata_filepath: Union[str, Path]) -> Dict:
"""Parse the metadata file retreived from the BEACO2N site
Args:
metadata_filepath: Path of raw CSV metadata file
pipeline: Are we running as part of the pipeline? If True
return the parsed site information dictionary.
Returns:
dict: Dictionary of site metadata
"""
metadata_filepath = Path(metadata_filepath).resolve()
raw_metadata = pd.read_csv(metadata_filepath)
site_metadata = aDict()
try:
for index, row in raw_metadata.iterrows():
site_name = row["node_name_long"].lower().replace(" ", "")
site_data = site_metadata[site_name]
site_data["long_name"] = row["node_name_long"]
site_data["id"] = row["id"]
site_data["latitude"] = round(row["lat"], 5)
site_data["longitude"] = round(row["lng"], 5)
site_data["magl"] = check_nan(row["height_above_ground"])
site_data["masl"] = check_nan(row["height_above_sea"])
site_data["deployed"] = check_date(row["deployed"])
site_data["node_folder_id"] = row["node_folder_id"]
except Exception as e:
raise ValueError(f"Can't read metadata file, please ensure it has expected columns. Error: {e}")
# Convert to a normal dict
metadata: Dict = site_metadata.to_dict()
return metadata | 321e9abb82172ee7d06423d2703ec2499aefbee9 | 67 |
def unit_norm(model,axis=0):
"""
Constrains the weights incident to each hidden unit to have unit norm.
Args:
axis (int):axis along which to calculate weight norms.
model : the model contains weights need to setting the constraints.
"""
def apply_constraint(t: Tensor):
w_data = None
if isinstance(t, tf.Variable):
w_data = t.value().detach()
else:
w_data = t.copy().detach()
param_applied = w_data/ (epsilon() +sqrt(reduce_sum(square(w_data),axis=axis,keepdims=True)))
param_applied = param_applied.detach()
return param_applied
if is_tensor(model):
model = apply_constraint(model)
elif isinstance(model, Layer):
for name, param in model.named_parameters():
if 'bias' not in name and param is not None and param.trainable == True:
param.assign(apply_constraint(param)) | ffe517f2f883541d5d3736a2bb3263e6349ffe18 | 68 |
def responsive_units(spike_times, spike_clusters, event_times,
pre_time=[0.5, 0], post_time=[0, 0.5], alpha=0.05):
"""
Determine responsive neurons by doing a Wilcoxon Signed-Rank test between a baseline period
before a certain task event (e.g. stimulus onset) and a period after the task event.
Parameters
----------
spike_times : 1D array
spike times (in seconds)
spike_clusters : 1D array
cluster ids corresponding to each event in `spikes`
event_times : 1D array
times (in seconds) of the events from the two groups
pre_time : two-element array
time (in seconds) preceding the event to get the baseline (e.g. [0.5, 0.2] would be a
window starting 0.5 seconds before the event and ending at 0.2 seconds before the event)
post_time : two-element array
time (in seconds) to follow the event times
alpha : float
alpha to use for statistical significance
Returns
-------
significant_units : ndarray
an array with the indices of clusters that are significatly modulated
stats : 1D array
the statistic of the test that was performed
p_values : ndarray
the p-values of all the clusters
cluster_ids : ndarray
cluster ids of the p-values
"""
# Get spike counts for baseline and event timewindow
baseline_times = np.column_stack(((event_times - pre_time[0]), (event_times - pre_time[1])))
baseline_counts, cluster_ids = get_spike_counts_in_bins(spike_times, spike_clusters,
baseline_times)
times = np.column_stack(((event_times + post_time[0]), (event_times + post_time[1])))
spike_counts, cluster_ids = get_spike_counts_in_bins(spike_times, spike_clusters, times)
# Do statistics
p_values = np.empty(spike_counts.shape[0])
stats = np.empty(spike_counts.shape[0])
for i in range(spike_counts.shape[0]):
if np.sum(baseline_counts[i, :] - spike_counts[i, :]) == 0:
p_values[i] = 1
stats[i] = 0
else:
stats[i], p_values[i] = wilcoxon(baseline_counts[i, :], spike_counts[i, :])
# Perform FDR correction for multiple testing
sig_units, p_values, _, _ = multipletests(p_values, alpha, method='fdr_bh')
significant_units = cluster_ids[sig_units]
return significant_units, stats, p_values, cluster_ids | 10493948d8fc710a95e1267b4543bc63cdebc661 | 69 |
def create_link(seconds, image_name, size):
"""
Function returns temporary link to the image
"""
token = signing.dumps([str(timezone.now() + timedelta(seconds=int(seconds))), image_name, size])
return settings.SERVER_PATH + reverse("image:dynamic-image", kwargs={"token": token}) | e0ede3b6a28e1bfa3a69d8019b0141cd85b77cce | 70 |
def read_one_hot_labels(filename):
"""Read topic labels from file in one-hot form
:param filename: name of input file
:return: topic labels (one-hot DataFrame, M x N)
"""
return pd.read_csv(filename, dtype=np.bool) | df6f0be241c8f5016ff66d02a54c899298055bd7 | 71 |
def make_randint_list(start, stop, length=10):
""" Makes a list of randomly generated integers
Args:
start: lowest integer to be generated randomly.
stop: highest integer to be generated randomly.
length: length of generated list.
Returns:
list of random numbers between start and stop of length length
"""
return [randint(start, stop) for i in range(length)] | 6ac9a20b9c5c87d9eff2b13a461cf266381961e2 | 72 |
def merge(intervals: list[list[int]]) -> list[list[int]]:
"""Generate a new schedule with non-overlapping intervals by merging intervals which overlap
Complexity:
n = len(intervals)
Time: O(nlogn) for the initial sort
Space: O(n) for the worst case of no overlapping intervals
Examples:
>>> merge(intervals=[[1,3],[2,6],[8,10],[15,18]])
[[1, 6], [8, 10], [15, 18]]
>>> merge(intervals=[[1,4],[4,5]])
[[1, 5]]
>>> merge(intervals=[[1,4]])
[[1, 4]]
"""
## EDGE CASES ##
if len(intervals) <= 1:
return intervals
"""ALGORITHM"""
## INITIALIZE VARS ##
intervals.sort(key=lambda k: k[0]) # sort on start times
# DS's/res
merged_intervals = []
# MERGE INTERVALS
prev_interval, remaining_intervals = intervals[0], intervals[1:]
for curr_interval in remaining_intervals:
# if prev interval end >= curr interval start
if prev_interval[1] >= curr_interval[0]:
# adjust new prev interval
prev_interval[1] = max(prev_interval[1], curr_interval[1])
else:
merged_intervals.append(prev_interval)
prev_interval = curr_interval
merged_intervals.append(prev_interval)
return merged_intervals | 49a9d7d461ba67ec3b5f839331c2a13d9fc068d0 | 73 |
def df_drop_duplicates(df, ignore_key_pattern="time"):
"""
Drop duplicates from dataframe ignore columns with keys containing defined pattern.
:param df:
:param noinfo_key_pattern:
:return:
"""
ks = df_drop_keys_contains(df, ignore_key_pattern)
df = df.drop_duplicates(ks)
return df | babd7be3ef66cef81a5a2192cf781afd2f96aca9 | 74 |
def get_mediawiki_flow_graph(limit, period):
"""
:type limit int
:type period int
:rtype: list[dict]
"""
# https://kibana5.wikia-inc.com/goto/e6ab16f694b625d5b87833ae794f5989
# goreplay is running in RES (check SJC logs only)
rows = ElasticsearchQuery(
es_host=ELASTICSEARCH_HOST,
period=period,
index_prefix='logstash-mediawiki'
).query_by_string(
query='"Wikia internal request" AND @fields.environment: "prod" '
'AND @fields.datacenter: "sjc" '
'AND @fields.http_url_path: *',
fields=[
'@context.source',
'@fields.http_url_path',
],
limit=limit
)
# extract required fields only
# (u'user-permissions', 'api:query::users')
# (u'1', 'nirvana:EmailControllerDiscussionReply::handle')
rows = [
(
row.get('@context', {})['source'],
normalize_mediawiki_url(row.get('@fields', {})['http_url_path'])
)
for row in rows
if row.get('@context', {}).get('source') is not None
]
# process the logs
def _map(item):
return '{}-{}'.format(item[0], item[1])
def _reduce(items):
first = items[0]
source = first[0]
target = first[1]
return {
'source': source if source != '1' else 'internal',
'edge': 'http',
'target': target,
# the following is optional
'metadata': '{:.3f} reqs per sec'.format(1. * len(items) / period)
}
return logs_map_and_reduce(rows, _map, _reduce) | c82976c24d80f7784f32e36666f791fed4ada769 | 75 |
def bsplslib_Unperiodize(*args):
"""
:param UDirection:
:type UDirection: bool
:param Degree:
:type Degree: int
:param Mults:
:type Mults: TColStd_Array1OfInteger &
:param Knots:
:type Knots: TColStd_Array1OfReal &
:param Poles:
:type Poles: TColgp_Array2OfPnt
:param Weights:
:type Weights: TColStd_Array2OfReal &
:param NewMults:
:type NewMults: TColStd_Array1OfInteger &
:param NewKnots:
:type NewKnots: TColStd_Array1OfReal &
:param NewPoles:
:type NewPoles: TColgp_Array2OfPnt
:param NewWeights:
:type NewWeights: TColStd_Array2OfReal &
:rtype: void
"""
return _BSplSLib.bsplslib_Unperiodize(*args) | 0fad8703881304c9d169feb4ce58f31b29d1703b | 76 |
def genomic_del3_abs_37(genomic_del3_37_loc):
"""Create test fixture absolute copy number variation"""
return {
"type": "AbsoluteCopyNumber",
"_id": "ga4gh:VAC.Pv9I4Dqk69w-tX0axaikVqid-pozxU74",
"subject": genomic_del3_37_loc,
"copies": {"type": "Number", "value": 2}
} | ed417f1b0eba79a5db717bd16ca79dd85c55c381 | 77 |
def get_configinfo(env):
"""Returns a list of dictionaries containing the `name` and `options`
of each configuration section. The value of `options` is a list of
dictionaries containing the `name`, `value` and `modified` state of
each configuration option. The `modified` value is True if the value
differs from its default.
:since: version 1.1.2
"""
all_options = {}
for (section, name), option in \
Option.get_registry(env.compmgr).iteritems():
all_options.setdefault(section, {})[name] = option
sections = []
for section in env.config.sections(env.compmgr):
options = []
for name, value in env.config.options(section, env.compmgr):
registered = all_options.get(section, {}).get(name)
if registered:
default = registered.default
normalized = registered.normalize(value)
else:
default = u''
normalized = unicode(value)
options.append({'name': name, 'value': value,
'modified': normalized != default})
options.sort(key=lambda o: o['name'])
sections.append({'name': section, 'options': options})
sections.sort(key=lambda s: s['name'])
return sections | c96b784f389af7c043977fbc1707840ef56a6486 | 79 |
def given_energy(n, ef_energy):
"""
Calculate and return the value of given energy using given values of the params
How to Use:
Give arguments for ef_energy and n parameters
*USE KEYWORD ARGUMENTS FOR EASY USE, OTHERWISE
IT'LL BE HARD TO UNDERSTAND AND USE.'
Parameters:
ef_energy (int):effective energy in Joule
n (int): efficiency
Returns:
int: the value of given energy in Joule
"""
gv_energy = ef_energy / n
return gv_energy | 98095581bfaf4b8a6dbf59dce86b02e3f1fa6002 | 80 |
def sequence_sigmoid_cross_entropy(labels,
logits,
sequence_length,
average_across_batch=True,
average_across_timesteps=False,
average_across_classes=True,
sum_over_batch=False,
sum_over_timesteps=True,
sum_over_classes=False,
time_major=False,
stop_gradient_to_label=False,
name=None):
"""Computes sigmoid cross entropy for each time step of sequence
predictions.
Args:
labels: Target class distributions.
- If :attr:`time_major` is `False` (default), this must be a\
Tensor of shape `[batch_size, max_time(, num_classes)]`.
- If `time_major` is `True`, this must be a Tensor of shape\
`[max_time, batch_size(, num_classes)]`.
Each row of `labels` should be a valid probability
distribution, otherwise, the computation of the gradient will be
incorrect.
logits: Unscaled log probabilities having the same shape as with
:attr:`labels`.
sequence_length: A Tensor of shape `[batch_size]`. Time steps beyond
the respective sequence lengths will have zero losses.
average_across_timesteps (bool): If set, average the loss across
the time dimension. Must not set `average_across_timesteps`
and `sum_over_timesteps` at the same time.
average_across_batch (bool): If set, average the loss across the
batch dimension. Must not set `average_across_batch`'
and `sum_over_batch` at the same time.
average_across_classes (bool): If set, average the loss across the
class dimension (if exists). Must not set
`average_across_classes`' and `sum_over_classes` at
the same time. Ignored if :attr:`logits` is a 2D Tensor.
sum_over_timesteps (bool): If set, sum the loss across the
time dimension. Must not set `average_across_timesteps`
and `sum_over_timesteps` at the same time.
sum_over_batch (bool): If set, sum the loss across the
batch dimension. Must not set `average_across_batch`
and `sum_over_batch` at the same time.
sum_over_classes (bool): If set, sum the loss across the
class dimension. Must not set `average_across_classes`
and `sum_over_classes` at the same time. Ignored if
:attr:`logits` is a 2D Tensor.
time_major (bool): The shape format of the inputs. If `True`,
:attr:`labels` and :attr:`logits` must have shape
`[max_time, batch_size, ...]`. If `False`
(default), they must have shape `[batch_size, max_time, ...]`.
stop_gradient_to_label (bool): If set, gradient propagation to
:attr:`labels` will be disabled.
name (str, optional): A name for the operation.
Returns:
A Tensor containing the loss, of rank 0, 1, or 2 depending on the
arguments
:attr:`{average_across}/{sum_over}_{timesteps}/{batch}/{classes}`.
For example, if the class dimension does not exist, and
- If :attr:`sum_over_timesteps` and :attr:`average_across_batch` \
are `True` (default), the return Tensor is of rank 0.
- If :attr:`average_across_batch` is `True` and other arguments are \
`False`, the return Tensor is of shape `[max_time]`.
"""
with tf.name_scope(name, "sequence_sigmoid_cross_entropy"):
if stop_gradient_to_label:
labels = tf.stop_gradient(labels)
losses = tf.nn.sigmoid_cross_entropy_with_logits(
labels=labels, logits=logits)
rank = shapes.get_rank(logits) or shapes.get_rank(labels)
if rank is None:
raise ValueError(
'Cannot determine the rank of `logits` or `labels`.')
losses = mask_and_reduce(
losses,
sequence_length,
rank=rank,
average_across_batch=average_across_batch,
average_across_timesteps=average_across_timesteps,
average_across_remaining=average_across_classes,
sum_over_batch=sum_over_batch,
sum_over_timesteps=sum_over_timesteps,
sum_over_remaining=sum_over_classes,
time_major=time_major)
return losses | 7eaea7dc8c416f0a37f0d6668ec175725f1fea04 | 81 |
import math
import torch
def stats(func):
"""Stats printing and exception handling decorator"""
def inner(*args):
try:
code, decoded, res = func(*args)
except ValueError as err:
print(err)
else:
if FORMATTING:
code_length = 0
for el in code:
code_length += len(el)
compression_rate = 24 * img.shape[0] * img.shape[1] / code_length
print(f"Code length: {code_length}")
else:
compression_rate = 24 * img.shape[0] * img.shape[1] / len(code)
code_length = len(code)
print(f"Code length: {code_length}")
#Convert RGB to YCbCr
color_conv = RGBYCbCr()
img_ycbcr = color_conv.forward(img)
decoded_ycbcr = color_conv.forward(decoded)
#Calculate MSE and PSNR, Y:U:V = 6:1:1
MSE_y = ((img_ycbcr[:,:,0].astype(int)-decoded_ycbcr[:,:,0].astype(int))**2).mean()
MSE_u = ((img_ycbcr[:,:,1].astype(int)-decoded_ycbcr[:,:,1].astype(int))**2).mean()
MSE_v = ((img_ycbcr[:,:,2].astype(int)-decoded_ycbcr[:,:,2].astype(int))**2).mean()
PSNR_y = 10 * math.log10((255*255)/MSE_y)
PSNR_u = 10 * math.log10((255*255)/MSE_u)
PSNR_v = 10 * math.log10((255*255)/MSE_v)
PSNR = (PSNR_y * 6 + PSNR_u + PSNR_v)/8
#Call the functions of SSIM, MS-SSIM, VIF
D_1 = SSIM(channels=1)
D_2 = MS_SSIM(channels=1)
D_3 = VIFs(channels=3) # spatial domain VIF
#To get 4-dimension torch tensors, (N, 3, H, W), divide by 255 to let the range between (0,1)
torch_decoded = torch.FloatTensor(decoded.astype(int).swapaxes(0,2).swapaxes(1,2)).unsqueeze(0)/255
torch_img = torch.FloatTensor(img.astype(int).swapaxes(0,2).swapaxes(1,2)).unsqueeze(0)/255
torch_decoded_ycbcr = torch.FloatTensor(decoded_ycbcr.astype(int).swapaxes(0,2).swapaxes(1,2)).unsqueeze(0)/255
torch_img_ycbcr = torch.FloatTensor(img_ycbcr.astype(int).swapaxes(0,2).swapaxes(1,2)).unsqueeze(0)/255
#Calculate SSIM, MS-SSIM, VIF
#SSIM on luma channel
SSIM_value = D_1(torch_decoded_ycbcr[:, [0], :, :] , torch_img_ycbcr[:, [0], :, :], as_loss=False)
#MS-SSIM on luma channel
MS_SSIM_value = D_2(torch_decoded_ycbcr[:, [0], :, :], torch_img_ycbcr[:, [0], :, :], as_loss=False)
#VIF on spatial domain
VIF_value = D_3(torch_decoded, torch_img, as_loss=False)
#print(D_3(torch_img, torch_img, as_loss=False))
#Print out the results
#print(f"Mean squared error: {MSE}")
print(f"General PSNR: {PSNR}")
print(f"SSIM: {SSIM_value}")
print(f"MS_SSIM: {MS_SSIM_value}")
print(f"VIF: {VIF_value}")
print(f"Compression rate: {compression_rate} bits/nt")
# plt.imshow(decoded)
# plt.show()
# io.imsave(str(compression_rate) + ".png", decoded)
return code, decoded, res, compression_rate, PSNR, SSIM_value, MS_SSIM_value, VIF_value
return inner | 99e39e204238d09bd7275ac29089898ff3d22f6a | 82 |
import asyncio
async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
"""Unload a config entry."""
unload_ok = all(
await asyncio.gather(
*[
hass.config_entries.async_forward_entry_unload(entry, platform)
for platform in PLATFORMS
]
)
)
if unload_ok:
config_data = hass.data[DOMAIN].pop(entry.entry_id)
await config_data[CONF_CLIENT].async_client_close()
return unload_ok | f44f9d9f3a566794547571563ae94ce433082d6d | 83 |
def get_ucp_worker_info():
"""Gets information on the current UCX worker, obtained from
`ucp_worker_print_info`.
"""
return _get_ctx().ucp_worker_info() | c40a0debcc769422b4cd8cd03018b57dd7efe224 | 84 |
from datetime import datetime
def check_can_collect_payment(id):
"""
Check if participant can collect payment this is true if :
- They have been signed up for a year
- They have never collected payment before or their last collection was more than 5 months ago
"""
select = "SELECT time_sign_up FROM SESSION_INFO WHERE user_id = (%s)"
time_sign_up = db.execute(select, (id,), 1)
one_year_after_sign_up = time_sign_up[0][0] + timedelta(weeks=43)
select = "SELECT date_collected,next_collection from TASK_COMPLETED WHERE user_id = (%s)"
date_collected = db.execute(select, (id,), 1)
can_collect_payment = False
#if one_year_after_sign_up < datetime.now() and user_type and next_collection[0][0] and next_collection[0][0] < datetime.now():
if one_year_after_sign_up < datetime.now() and len(date_collected) >= 1 and (date_collected[0][0] == None or date_collected[0][0] < (datetime.now() - timedelta(weeks=22))):
can_collect_payment = True
date_collected = date_collected[0][0]
elif len(date_collected) > 1:
date_collected = date_collected[0][0]
return (can_collect_payment,date_collected,time_sign_up) | a057b6599bfd5417a17de1672b4ccf2023991e6e | 85 |
def plus_tensor(wx, wy, wz=np.array([0, 0, 1])):
"""Calculate the plus polarization tensor for some basis.c.f., eq. 2 of https://arxiv.org/pdf/1710.03794.pdf"""
e_plus = np.outer(wx, wx) - np.outer(wy, wy)
return e_plus | c5632dcfffa9990c8416b77ff0df728ae46c34bc | 86 |
import json
def duplicate_objects(dup_infos):
"""Duplicate an object with optional transformations.
Args:
dup_infos (list[dict]): A list of duplication infos.
Each info is a dictionary, containing the following data:
original (str): Name of the object to duplicate.
name (str): Desired name for the duplicate.
translation (f,f,f): Translation float tuple or None if not
to change.
rotation (f,f,f): Rotation float tuple or None if not to
change.
scale (f,f,f): 3d scale float tuple or None if not to change.
Returns:
list[tuple (str, str)]: The first element of each tuple
contains the return 'code' of the operation, which can be
- 'Ok' If no problem occured.
- 'NotFound' If the original could not be found.
- 'Renamed' If the name was changed by the editor.
- 'Failed' If something else problematic happened.
The second element is None, unless the editor 'Renamed' the
object, in which case it contains the editor-assigned name.
If the return value is 'Renamed', the calling function must assign
the returned name to the original object in the Program or find a
new fitting name and assign it to the duplicated object using the
:func:`renameObject` function with the returned string as name.
.. seealso:: :func:`renameObject` :func:`getFreeName`
"""
infos_str = json.dumps(dup_infos)
msg = "DuplicateObjects " + infos_str
result = connection.send_message(msg)
results = json.parse(result)
return results | d8281eb6862cd7e022907bc479b03fc74cb3c78c | 87 |
def _list_data_objects(request, model, serializer):
"""a factory method for querying and receiving database objects"""
obj = model.objects.all()
ser = serializer(obj, many=True)
return Response(ser.data, status=status.HTTP_200_OK) | 80f43efdf1d09e73fda7be8ee5f8e37a163892f7 | 88 |
import configparser
def load_conf(file='./config', section='SYNTH_DATA'):
"""load configuration
Args:
file (str, optional): path to conf file. Defaults to './config'.
section (str, optional): name of section. Defaults to 'SYNTH_DATA'.
Returns:
[str]: params of configuration
"""
log_message('Load configuration.')
config = configparser.ConfigParser()
resource = config.read(file)
if 0 == resource:
log_message('Error: cannot read configuration file.')
exit(1)
params = {}
options = config.options(section)
for opt in options:
params[opt] = config.get(section, opt)
log_message(' - %s: %s' % (opt, params[opt]))
return params | a30240e98d9fd1cdc1bc7746566fdb07b842a8dc | 89 |
import math
def distance(a, b):
"""
Computes a
:param a:
:param b:
:return:
"""
x = a[0] - b[0]
y = a[1] - b[1]
return math.sqrt(x ** 2 + y ** 2) | 60b637771cd215a4cf83761a142fb6fdeb84d96e | 90 |
def approve_pipelines_for_publishing(pipeline_ids): # noqa: E501
"""approve_pipelines_for_publishing
:param pipeline_ids: Array of pipeline IDs to be approved for publishing.
:type pipeline_ids: List[str]
:rtype: None
"""
pipe_exts: [ApiPipelineExtension] = load_data(ApiPipelineExtension)
pipe_ext_ids = {p.id for p in pipe_exts}
missing_pipe_ext_ids = set(pipeline_ids) - pipe_ext_ids
for id in missing_pipe_ext_ids:
store_data(ApiPipelineExtension(id=id))
update_multiple(ApiPipelineExtension, [], "publish_approved", False)
if pipeline_ids:
update_multiple(ApiPipelineExtension, pipeline_ids, "publish_approved", True)
return None, 200 | e5ae4dfc0889fc95e3343a01111323eec43e1f93 | 91 |
def make_tokenizer_module(tokenizer):
"""tokenizer module"""
tokenizers = {}
cursors = {}
@ffi.callback("int(int, const char *const*, sqlite3_tokenizer **)")
def xcreate(argc, argv, ppTokenizer):
if hasattr(tokenizer, "__call__"):
args = [ffi.string(x).decode("utf-8") for x in argv[0:argc]]
tk = tokenizer(args)
else:
tk = tokenizer
th = ffi.new_handle(tk)
tkn = ffi.new("sqlite3_tokenizer *")
tkn.t = th
tokenizers[tkn] = th
ppTokenizer[0] = tkn
return SQLITE_OK
@ffi.callback("int(sqlite3_tokenizer *)")
def xdestroy(pTokenizer):
tkn = pTokenizer
del tokenizers[tkn]
return SQLITE_OK
@ffi.callback(
"int(sqlite3_tokenizer*, const char *, int, sqlite3_tokenizer_cursor **)"
)
def xopen(pTokenizer, pInput, nInput, ppCursor):
cur = ffi.new("sqlite3_tokenizer_cursor *")
tokenizer = ffi.from_handle(pTokenizer.t)
i = ffi.string(pInput).decode("utf-8")
tokens = [(n.encode("utf-8"), b, e) for n, b, e in tokenizer.tokenize(i) if n]
tknh = ffi.new_handle(iter(tokens))
cur.pTokenizer = pTokenizer
cur.tokens = tknh
cur.pos = 0
cur.offset = 0
cursors[cur] = tknh
ppCursor[0] = cur
return SQLITE_OK
@ffi.callback(
"int(sqlite3_tokenizer_cursor*, const char **, int *, int *, int *, int *)"
)
def xnext(pCursor, ppToken, pnBytes, piStartOffset, piEndOffset, piPosition):
try:
cur = pCursor[0]
tokens = ffi.from_handle(cur.tokens)
normalized, inputBegin, inputEnd = next(tokens)
ppToken[0] = ffi.from_buffer(normalized)
pnBytes[0] = len(normalized)
piStartOffset[0] = inputBegin
piEndOffset[0] = inputEnd
cur.offset = inputEnd
piPosition[0] = cur.pos
cur.pos += 1
except StopIteration:
return SQLITE_DONE
return SQLITE_OK
@ffi.callback("int(sqlite3_tokenizer_cursor *)")
def xclose(pCursor):
tk = ffi.from_handle(pCursor.pTokenizer.t)
on_close = getattr(tk, "on_close", None)
if on_close and hasattr(on_close, "__call__"):
on_close()
del cursors[pCursor]
return SQLITE_OK
tokenizer_module = ffi.new(
"sqlite3_tokenizer_module*", [0, xcreate, xdestroy, xopen, xclose, xnext]
)
tokenizer_modules[tokenizer] = (
tokenizer_module,
xcreate,
xdestroy,
xopen,
xclose,
xnext,
)
return tokenizer_module | 73f38b71f15b286a95a195296c5c265ba2da87f9 | 92 |
def looping_call(interval, callable):
"""
Returns a greenlet running your callable in a loop and an Event you can set
to terminate the loop cleanly.
"""
ev = Event()
def loop(interval, callable):
while not ev.wait(timeout=interval):
callable()
return gevent.spawn(loop, interval, callable), ev | 0df2a822c2eb56b8479224b0463bf9a2ad34f1e7 | 93 |
def rsquared_adj(r, nobs, df_res, has_constant=True):
"""
Compute the adjusted R^2, coefficient of determination.
Args:
r (float): rsquared value
nobs (int): number of observations the model was fit on
df_res (int): degrees of freedom of the residuals (nobs - number of model params)
has_constant (bool): whether the fitted model included a constant (intercept)
Returns:
float: adjusted coefficient of determination
"""
if has_constant:
return 1.0 - (nobs - 1) / df_res * (1.0 - r)
else:
return 1.0 - nobs / df_res * (1.0 - r) | 8d466437db7ec9de9bc7ee1d9d50a3355479209d | 94 |
def metadata_factory(repo, json=False, **kwargs):
"""
This generates a layout you would expect for metadata storage with files.
:type json: bool
:param json: if True, will return string instead.
"""
output = {
"baseline_filename": None,
"crontab": "0 0 * * *",
"exclude_regex": None,
"plugins": {
"AWSKeyDetector": {},
"ArtifactoryDetector": {},
"Base64HighEntropyString": {
"base64_limit": 4.5,
},
"BasicAuthDetector": {},
"HexHighEntropyString": {
"hex_limit": 3,
},
"KeywordDetector": {
'keyword_exclude': None
},
"MailchimpDetector": {},
"PrivateKeyDetector": {},
"SlackDetector": {},
"StripeDetector": {},
},
"repo": repo,
"sha": 'sha256-hash',
}
output.update(kwargs)
if json:
return json_module.dumps(output, indent=2, sort_keys=True)
return output | 8dc0cd4cb5aa194c915146efbe0a743b5047561d | 95 |
from typing import Optional
from typing import Sequence
def inpand(clip: vs.VideoNode, sw: int, sh: Optional[int] = None, mode: XxpandMode = XxpandMode.RECTANGLE,
thr: Optional[int] = None, planes: int | Sequence[int] | None = None) -> vs.VideoNode:
"""
Calls std.Minimum in order to shrink each pixel with the smallest value in its 3x3 neighbourhood
from the desired width and height.
:param clip: Source clip.
:param sw: Shrinking shape width.
:param sh: Shrinking shape height. If not specified, default to sw.
:param mode: Shape form. Ellipses are combinations of rectangles and losanges
and look more like octogons.
Losanges are truncated (not scaled) when sw and sh are not equal.
:param thr: Allows to limit how much pixels are changed.
Output pixels will not become less than ``input - threshold``.
The default is no limit.
:param planes: Specifies which planes will be processed. Any unprocessed planes will be simply copied.
:return: Transformed clip
"""
return morpho_transfo(clip, core.std.Minimum, sw, sh, mode, thr, planes) | 67d05b2ef31fdc3b544d063a571d39a1c1a3ecf8 | 96 |
def _extract_aggregate_functions(before_aggregate):
"""Converts `before_aggregate` to aggregation functions.
Args:
before_aggregate: The first result of splitting `after_broadcast` on
`intrinsic_defs.FEDERATED_AGGREGATE`.
Returns:
`zero`, `accumulate`, `merge` and `report` as specified by
`canonical_form.CanonicalForm`. All are instances of
`building_blocks.CompiledComputation`.
Raises:
transformations.CanonicalFormCompilationError: If we extract an ASTs of the
wrong type.
"""
# See `get_iterative_process_for_canonical_form()` above for the meaning of
# variable names used in the code below.
zero_index_in_before_aggregate_result = 1
zero_tff = transformations.select_output_from_lambda(
before_aggregate, zero_index_in_before_aggregate_result).result
accumulate_index_in_before_aggregate_result = 2
accumulate_tff = transformations.select_output_from_lambda(
before_aggregate, accumulate_index_in_before_aggregate_result).result
merge_index_in_before_aggregate_result = 3
merge_tff = transformations.select_output_from_lambda(
before_aggregate, merge_index_in_before_aggregate_result).result
report_index_in_before_aggregate_result = 4
report_tff = transformations.select_output_from_lambda(
before_aggregate, report_index_in_before_aggregate_result).result
zero = transformations.consolidate_and_extract_local_processing(zero_tff)
accumulate = transformations.consolidate_and_extract_local_processing(
accumulate_tff)
merge = transformations.consolidate_and_extract_local_processing(merge_tff)
report = transformations.consolidate_and_extract_local_processing(report_tff)
return zero, accumulate, merge, report | 22aff3c077b94c5eae8841448c2a55bbfa311487 | 97 |
def _make_system(A, M, x0, b):
"""Make a linear system Ax = b
Args:
A (cupy.ndarray or cupyx.scipy.sparse.spmatrix or
cupyx.scipy.sparse.LinearOperator): sparse or dense matrix.
M (cupy.ndarray or cupyx.scipy.sparse.spmatrix or
cupyx.scipy.sparse.LinearOperator): preconditioner.
x0 (cupy.ndarray): initial guess to iterative method.
b (cupy.ndarray): right hand side.
Returns:
tuple:
It returns (A, M, x, b).
A (LinaerOperator): matrix of linear system
M (LinearOperator): preconditioner
x (cupy.ndarray): initial guess
b (cupy.ndarray): right hand side.
"""
fast_matvec = _make_fast_matvec(A)
A = _interface.aslinearoperator(A)
if fast_matvec is not None:
A = _interface.LinearOperator(A.shape, matvec=fast_matvec,
rmatvec=A.rmatvec, dtype=A.dtype)
if A.shape[0] != A.shape[1]:
raise ValueError('expected square matrix (shape: {})'.format(A.shape))
if A.dtype.char not in 'fdFD':
raise TypeError('unsupprted dtype (actual: {})'.format(A.dtype))
n = A.shape[0]
if not (b.shape == (n,) or b.shape == (n, 1)):
raise ValueError('b has incompatible dimensions')
b = b.astype(A.dtype).ravel()
if x0 is None:
x = cupy.zeros((n,), dtype=A.dtype)
else:
if not (x0.shape == (n,) or x0.shape == (n, 1)):
raise ValueError('x0 has incompatible dimensions')
x = x0.astype(A.dtype).ravel()
if M is None:
M = _interface.IdentityOperator(shape=A.shape, dtype=A.dtype)
else:
fast_matvec = _make_fast_matvec(M)
M = _interface.aslinearoperator(M)
if fast_matvec is not None:
M = _interface.LinearOperator(M.shape, matvec=fast_matvec,
rmatvec=M.rmatvec, dtype=M.dtype)
if A.shape != M.shape:
raise ValueError('matrix and preconditioner have different shapes')
return A, M, x, b | 37d877dc8522a476c1ff0be34db01fe8d711dbb7 | 98 |
from typing import List
def merge_intersecting_segments(segments: List[Segment]) -> List[Segment]:
"""
Merges intersecting segments from the list.
"""
sorted_by_start = sorted(segments, key=lambda segment: segment.start)
merged = []
for segment in sorted_by_start:
if not merged:
merged.append(Segment(segment.start, segment.end))
continue
last_merged = merged[-1]
if segment.start <= last_merged.end:
last_merged.end = max(last_merged.end, segment.end)
else:
merged.append(Segment(segment.start, segment.end))
return merged | e18498d9a9695b2c5796fb6e006f375541f704c7 | 99 |
def change_log_root_key():
"""Root key of an entity group with change log."""
# Bump ID to rebuild the change log from *History entities.
return ndb.Key('AuthDBLog', 'v1') | 465ab46b7e884d7f5e217861d6c451c491e04f07 | 100 |
import numpy
def load_file(filename):
"""Loads a TESS *spoc* FITS file and returns TIME, PDCSAP_FLUX"""
hdu = fits.open(filename)
time = hdu[1].data['TIME']
flux = hdu[1].data['PDCSAP_FLUX']
flux[flux == 0] = numpy.nan
return time, flux | 50c777903b26c658c828346af53e3a659d1eb46b | 101 |
def create_insight_id_extension(
insight_id_value: str, insight_system: str
) -> Extension:
"""Creates an extension for an insight-id with a valueIdentifier
The insight id extension is defined in the IG at:
https://alvearie.io/alvearie-fhir-ig/StructureDefinition-insight-id.html
Args:
insight_id_value - the value of the insight id
insight_system - urn for the system used to create the insight
Returns: The insight id extension
Example:
>>> ext = create_insight_id_extension("insight-1", "urn:id:alvearie.io/patterns/QuickUMLS_v1.4.0")
>>> print(ext.json(indent=2))
{
"url": "http://ibm.com/fhir/cdm/StructureDefinition/insight-id",
"valueIdentifier": {
"system": "urn:id:alvearie.io/patterns/QuickUMLS_v1.4.0",
"value": "insight-1"
}
}
"""
insight_id_ext = Extension.construct()
insight_id_ext.url = alvearie_ext_url.INSIGHT_ID_URL
insight_id = Identifier.construct()
insight_id.system = insight_system
insight_id.value = insight_id_value
insight_id_ext.valueIdentifier = insight_id
return insight_id_ext | 72b000cdc3903308ca8692c815e562511fd50b91 | 102 |
def ReadNotifyResponseHeader(payload_size, data_type, data_count, sid, ioid):
"""
Construct a ``MessageHeader`` for a ReadNotifyResponse command.
Read value of a channel. Sent over TCP.
Parameters
----------
payload_size : integer
Size of DBR formatted data in payload.
data_type : integer
Payload format.
data_count : integer
Payload element count.
sid : integer
SID of the channel.
ioid : integer
IOID of this operation.
"""
struct_args = (15, payload_size, data_type, data_count, sid, ioid)
# If payload_size or data_count cannot fit into a 16-bit integer, use the
# extended header.
return (ExtendedMessageHeader(*struct_args)
if any((payload_size > 0xffff, data_count > 0xffff, ))
else MessageHeader(*struct_args)) | 5d088416f5fca6e0aeb3ef1f965ca7c00d8a6c90 | 103 |
def substitute_T5_cols(c, cols, nlu_identifier=True):
"""
rename cols with base name either <t5> or if not unique <t5_<task>>
"""
new_cols = {}
new_base_name = 't5' if nlu_identifier=='UNIQUE' else f't5_{nlu_identifier}'
for col in cols :
if '_results' in col : new_cols[col] = new_base_name
elif '_beginnings' in col : new_cols[col] = f'{new_base_name}_begin'
elif '_endings' in col : new_cols[col] = f'{new_base_name}_end'
elif '_embeddings' in col : continue # Token never stores Embeddings new_cols[col] = f'{new_base_name}_embedding'
elif '_types' in col : continue # new_cols[col] = f'{new_base_name}_type'
elif 'meta' in col:
if '_sentence' in col : new_cols[col] = f'{new_base_name}_origin_sentence' # maps to which sentence token comes from
else : logger.info(f'Dropping unmatched metadata_col={col} for c={c}')
# new_cols[col]= f"{new_base_name}_confidence"
return new_cols | 2820706faff786011abbd896551026c65bb0d848 | 104 |