Datasets:

YoLo2000

/

python-stack-functions-filtered

like 1

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

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

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

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

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

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

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

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

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

def RPL_ENDOFINFO(sender, receipient, message): """ Reply Code 374 """ return "<" + sender + ">: " + message

02fc0ef666caf7921e4f4a78a908686fd3dded17

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def inf_set_stack_ldbl(*args): """ inf_set_stack_ldbl(_v=True) -> bool """ return _ida_ida.inf_set_stack_ldbl(*args)

2b343bb66229f6ba5f834b3d543fcd75ad08875c

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

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

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

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

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

def trim(str): """Remove multiple spaces""" return ' '.join(str.strip().split())

ed98f521c1cea24552959aa334ffb0c314b9f112

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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