content
stringlengths
35
762k
sha1
stringlengths
40
40
id
int64
0
3.66M
from typing import Iterator from typing import Tuple from typing import Any import itertools def _nonnull_powerset(iterable) -> Iterator[Tuple[Any]]: """Returns powerset of iterable, minus the empty set.""" s = list(iterable) return itertools.chain.from_iterable( itertools.combinations(s, r) for r in range(1, len(s) + 1))
ad02ab8ac02004adb54310bc639c6e2d84f19b02
11,300
import yaml def _parse_obs_status_file(filename): """ Parse a yaml file and return a dictionary. The dictionary will be of the form: {'obs': [], 'bad': [], 'mags: []} :param filename: :return: """ with open(filename) as fh: status = yaml.load(fh, Loader=yaml.SafeLoader) if 'obs' not in status: status['obs'] = [] if 'bad' not in status: status['bad'] = [] if 'mags' not in status: status['mags'] = [] if hasattr(status['bad'], 'items'): status['bad'] = list(status['bad'].items()) return status
389fc921867367964001e5fc2f56a7fa7defd7c8
11,301
def extract_optional_suffix(r): """ a | a b -> a b? """ modified = False def match_replace_fn(o): if isinstance(o, Antlr4Selection): potential_prefix = None potential_prefix_i = None to_remove = [] for i, c in enumerate(o): if potential_prefix is None: potential_prefix = c potential_prefix_i = i else: # check if the potential_prefix is really a prefix of this rule is_prefix, suffix = is_prefix_of_elem(potential_prefix, c) if is_prefix: # put suffix as a optional to a prefix if list(iter_non_visuals(suffix)): if not isinstance(potential_prefix, Antlr4Sequence): assert o[potential_prefix_i] is potential_prefix potential_prefix = Antlr4Sequence([potential_prefix, ]) o[potential_prefix_i] = potential_prefix if len(suffix) == 1: suffix = suffix[0] else: suffix = Antlr4Sequence(suffix) potential_prefix.append(Antlr4Option(suffix)) to_remove.append(c) potential_prefix = None potential_prefix_i = None modified = True else: potential_prefix = c potential_prefix_i = i for c in to_remove: o.remove(c) if len(o) == 1: return Antlr4Sequence([o[0], ]) replace_item_by_sequence(r, match_replace_fn) return modified
a1d4e6702ed1b23e0f94a44e5bea6fae16b47e17
11,302
def _heading_index(config, info, token, stack, level, blockquote_depth): """Get the next heading level, adjusting `stack` as a side effect.""" # Treat chapter titles specially. if level == 1: return tuple(str(i) for i in stack) # Moving up if level > len(stack): if (level > len(stack) + 1) and (blockquote_depth == 0): err(f"Heading {level} out of place", info, token) while len(stack) < level: stack.append(1) # Same level elif level == len(stack): stack[-1] += 1 # Going down else: while len(stack) > level: stack.pop() stack[-1] += 1 # Report. return tuple(str(i) for i in stack)
f42dd5c6aae942da687310d7bef81f70bfadad83
11,303
from typing import List def sin_salida_naive(vuelos: Data) -> List[str]: """Retorna una lista de aeropuertos a los cuales hayan llegado vuelos pero no hayan salido vuelos de este. :param vuelos: Información de los vuelos. :vuelos type: Dict[str, Dict[str, Union[str, float]]] :return: Lista de aeropuertos :rtype: List[str] """ salidas, llegadas, aeropuertos = [], [], [] for vuelo in vuelos.values(): salidas.append(vuelo['origen']) llegadas.append(vuelo['destino']) for aeropuerto in llegadas: if aeropuerto not in salidas: aeropuertos.append(aeropuerto) return aeropuertos
136b7c1e3428cecee5d3bc7046fac815276288e5
11,304
def converter(doc): """ This is a function for converting various kinds of objects we see inside a graffle document. """ if doc.nodeName == "#text": return str(doc.data) elif doc.nodeName == "string": return str(doc.firstChild.data) elif doc.nodeName == 'integer': return int(doc.firstChild.data) elif doc.nodeName == 'real': return float(doc.firstChild.data) elif doc.nodeName == 'dict': return convert_dict(doc) elif doc.nodeName == 'array': return convert_list(doc) elif doc.nodeName == 'plist': return convert_list(doc) else: return 'unknown:' + doc.nodeName
8820aa739f4b96251033c191ea405157cfe1e9fb
11,305
def printable_cmd(c): """Converts a `list` of `str`s representing a shell command to a printable `str`.""" return " ".join(map(lambda e: '"' + str(e) + '"', c))
b5e8a68fc535c186fdbadc8a669ed3dec0da3aee
11,306
def details_from_params( params: QueryParams, items_per_page: int, items_per_page_async: int = -1, ) -> common.Details: """Create details from request params.""" try: page = int(params.get('page', 1)) except (ValueError, TypeError): page = 1 try: anchor = int(params.get('anchor', 1)) except (ValueError, TypeError): anchor = -1 return common.Details( page=max(1, page), anchor=anchor, items_per_page=items_per_page, items_per_page_async=items_per_page_async, )
50e20619bc4f32af6811a3416b2d2f93820ba44a
11,307
import glob import os def run_nuclei_type_stat( pred_dir, true_dir, nuclei_type_dict, type_uid_list=None, exhaustive=True, rad=12, verbose=False ): """ rad = 12 if x40 rad = 6 if x20 """ def _get_type_name(uid, ntd=nuclei_type_dict): for name,v in ntd.items(): if v == uid: return name def calc_type_metrics(paired_true, paired_pred, unpaired_true, unpaired_pred, type_id, w): type_samples = (paired_true == type_id) | (paired_pred == type_id) paired_true = paired_true[type_samples] paired_pred = paired_pred[type_samples] # unpaired_pred_t = unpaired_pred[unpaired_pred == type_id] # (unpaired_pred == type_id).sum() # unpaired_true_t = unpaired_true[unpaired_true == type_id] # Original tp_dt = ((paired_true == type_id) & (paired_pred == type_id)).sum() tn_dt = ((paired_true != type_id) & (paired_pred != type_id)).sum() fp_dt = ((paired_true != type_id) & (paired_pred == type_id)).sum() fn_dt = ((paired_true == type_id) & (paired_pred != type_id)).sum() # Classification # TP - detected cell with GT label t, classified as t tp_dtc = ((paired_true == type_id) & (paired_pred == type_id)).sum() # TN - detected cell with GT label other than t, classified as other than t tn_dtc = ((paired_true != type_id) & (paired_pred != type_id)).sum() # FP - detected cell with GT label other than t classified as t fp_dtc = ((paired_true != type_id) & (paired_pred == type_id)).sum() # FN - detected cell with GT label t classified as other than t fn_dtc = ((paired_true == type_id) & (paired_pred != type_id)).sum() # Integrated classification # TP - detected cell with GT label t, classified as t tp_dtic = ((paired_true == type_id) & (paired_pred == type_id)).sum() # TN - detected or falsely detected cell with GT label other than t, classified as other than t tn_dtic = np.concatenate(( ((paired_true != type_id) & (paired_pred != type_id)), (unpaired_pred != type_id) # np.concatenate( # ((unpaired_true != type_id), (unpaired_pred != type_id)) # ) )).sum() # FP - detected or falsely detected cell with GT label other than t, classified as t fp_dtic = np.concatenate(( ((paired_true != type_id) & (paired_pred == type_id)), (unpaired_pred == type_id) # np.concatenate( # ((unpaired_true != type_id), (unpaired_pred == type_id)) # ) )).sum() # FN - detected cell with GT label t, classified as other than t and all cells with GT label t not detected fn_dtic = np.concatenate(( ((paired_true == type_id) & (paired_pred != type_id)), (unpaired_true == type_id) )).sum() if not exhaustive: ignore = (paired_true == -1).sum() fp_dt -= ignore tp_d = (paired_pred == type_id).sum() # tn_d = (paired_true == type_id).sum() fp_d = (unpaired_pred == type_id).sum() fn_d = (unpaired_true == type_id).sum() rec_dt = tp_d / (tp_d + fn_d) def __internal_metrics(tp, tn, fp, fn): # print (f"tp: {tp}, \ntn: {tn}, \nfp:{fp}, fn: {fn}\n") acc = (tp + tn) / (tp + fp + fn + tn) prec = tp / (tp + fp) recall = tp / (tp + fn) f1 = 2 * (prec * recall) / (prec + recall) # print (f"Accuracy: {acc}, \nPrecision: {prec}, \nRecall:{recall}, F1: {f1}\n") return acc, prec, recall, f1 res_class = __internal_metrics(tp_dtc, tn_dtc, fp_dtc, fn_dtc) dtc_tptnfpfn = (tp_dtc, tn_dtc, fp_dtc, fn_dtc) res_i_class = __internal_metrics(tp_dtic, tn_dtic, fp_dtic, fn_dtic) dtic_tptnfpfn = (tp_dtic, tn_dtic, fp_dtic, fn_dtic) # print (f"tp_dt: {tp_dt}") # TPc # print (f"tn_dt: {tn_dt}") # TNc # print (f"fp_dt: {fp_dt}") # FPc # print (f"fn_dt: {fn_dt}") # FNc # print (f"fp_d: {fp_d}") # print (f"fn_d: {fn_d}") tp_w = tp_dt + tn_dt fp_w = 2 * fp_dt + fp_d fn_w = 2 * fn_dt + fn_d w_f1_type = (2 * (tp_dt + tn_dt)) / ( 2 * (tp_dt + tn_dt) + w[0] * fp_dt + w[1] * fn_dt + w[2] * fp_d + w[3] * fn_d ) w_acc_type = (tp_w) / (tp_w + fp_w + fn_w) ## check w_precision_type = tp_w / (tp_w + fp_w) w_recall_type = tp_w / (tp_w + fn_w) weighted = (w_acc_type, w_precision_type, w_recall_type, w_f1_type) cls_r = (dtc_tptnfpfn, res_class) icls_r = (dtic_tptnfpfn, res_i_class) #return f1_type, precision_type, recall_type return ( rec_dt, ### Segmentation recall cls_r, ### Classification icls_r, ### Integrated classification weighted ### Weighted ) ###################################################### types = sorted([f"{v}:{k}" for k, v in nuclei_type_dict.items()]) if verbose: print(types) file_list = glob.glob(os.path.join(pred_dir, "*.mat")) file_list.sort() # ensure same order [1] paired_all = [] # unique matched index pair unpaired_true_all = [] # the index must exist in `true_inst_type_all` and unique unpaired_pred_all = [] # the index must exist in `pred_inst_type_all` and unique true_inst_type_all = [] # each index is 1 independent data point pred_inst_type_all = [] # each index is 1 independent data point for file_idx, filename in enumerate(file_list[:]): filename = os.path.basename(filename) basename = filename.split(".")[0] # print (basename) # true_info = sio.loadmat(os.path.join(true_dir, '{}.mat'.format(basename))) # # dont squeeze, may be 1 instance exist # true_centroid = (true_info['inst_centroid']).astype('float32') # true_inst_type = (true_info['inst_type']).astype('int32') true_info = np.load( os.path.join(true_dir, "{}.npy".format(basename)), allow_pickle=True ) # dont squeeze, may be 1 instance exist true_centroid = (true_info.item().get("inst_centroid")).astype("float32") true_inst_type = (true_info.item().get("inst_type")).astype("int32") if true_centroid.shape[0] != 0: true_inst_type = true_inst_type[:, 0] else: # no instance at all pass true_centroid = np.array([[0, 0]]) true_inst_type = np.array([0]) pred_info = sio.loadmat(os.path.join(pred_dir, "{}.mat".format(basename))) # dont squeeze, may be 1 instance exist pred_centroid = (pred_info["inst_centroid"]).astype("float32") pred_inst_type = (pred_info["inst_type"]).astype("int32") if pred_centroid.shape[0] != 0: pred_inst_type = pred_inst_type[:, 0] else: # no instance at all pass pred_centroid = np.array([[0, 0]]) pred_inst_type = np.array([0]) # ! if take longer than 1min for 1000 vs 1000 pairing, sthg is wrong with coord paired, unpaired_true, unpaired_pred = pair_coordinates( true_centroid, pred_centroid, rad ) # * Aggreate information # get the offset as each index represent 1 independent instance true_idx_offset = ( true_idx_offset + true_inst_type_all[-1].shape[0] if file_idx != 0 else 0 ) pred_idx_offset = ( pred_idx_offset + pred_inst_type_all[-1].shape[0] if file_idx != 0 else 0 ) true_inst_type_all.append(true_inst_type) pred_inst_type_all.append(pred_inst_type) # increment the pairing index statistic if paired.shape[0] != 0: # ! sanity paired[:, 0] += true_idx_offset paired[:, 1] += pred_idx_offset paired_all.append(paired) unpaired_true += true_idx_offset unpaired_pred += pred_idx_offset unpaired_true_all.append(unpaired_true) unpaired_pred_all.append(unpaired_pred) paired_all = np.concatenate(paired_all, axis=0) # (x, 2) # paired ids (found in GT and pred) unpaired_true_all = np.concatenate(unpaired_true_all, axis=0) # (x,) # unpaired ids (found in GT and NOT in pred) unpaired_pred_all = np.concatenate(unpaired_pred_all, axis=0) # (x,) # unpaired ids (NOT found in GT and found in pred) true_inst_type_all = np.concatenate(true_inst_type_all, axis=0) # all type ids in true [3,3,3...1,1,1] paired_true_type = true_inst_type_all[paired_all[:, 0]] # paired true type ids [3,3,3...1,1,1] unpaired_true_type = true_inst_type_all[unpaired_true_all] pred_inst_type_all = np.concatenate(pred_inst_type_all, axis=0) # all type ids in pred [3,3,3...1,1,1] paired_pred_type = pred_inst_type_all[paired_all[:, 1]] unpaired_pred_type = pred_inst_type_all[unpaired_pred_all] # true_inst_type_all = paired_true_type + unpaired_true_type ### # overall # * quite meaningless for not exhaustive annotated dataset tp_d = paired_pred_type.shape[0] fp_d = unpaired_pred_type.shape[0] fn_d = unpaired_true_type.shape[0] tp_tn_dt = (paired_pred_type == paired_true_type).sum() fp_fn_dt = (paired_pred_type != paired_true_type).sum() if not exhaustive: ignore = (paired_true_type == -1).sum() fp_fn_dt -= ignore w = [1, 1] acc_type = tp_tn_dt / (tp_tn_dt + fp_fn_dt) precision = tp_d / (tp_d + w[0] * fp_d) recall = tp_d / (tp_d + w[0] * fn_d) f1_d = 2 * tp_d / (2 * tp_d + w[0] * fp_d + w[1] * fn_d) # results_list = [acc_type, precision, recall, f1_d] results_all_types = [[acc_type], [precision], [recall], [f1_d]] w = [2, 2, 1, 1] if type_uid_list is None: type_uid_list = np.unique(true_inst_type_all).tolist() if 0 in type_uid_list: type_uid_list.remove(0) pred_type_uid_list = np.unique(pred_inst_type_all).tolist() if 0 in pred_type_uid_list: pred_type_uid_list.remove(0) if verbose: print(f"True type_uid_list: {type_uid_list}") print(f"Pred type_uid_list: {pred_type_uid_list}") res_all = {} for type_uid in type_uid_list: res = calc_type_metrics( paired_true_type, paired_pred_type, unpaired_true_type, unpaired_pred_type, type_uid, w, ) result_uid_metrics = [ [res[0]], # rec_dt ### Segmentation recall [res[1][1][0]], [res[1][1][1]], [res[1][1][2]], [res[1][1][3]], # (dtc_tptnfpfn, res_class), ### Classification [res[2][1][0]], [res[2][1][1]], [res[2][1][2]], [res[2][1][3]], # (dtic_tptnfpfn, res_i_class), ### Integrated classification [res[3][0]], [res[3][1]], [res[3][2]], [res[3][3]] # weighted ### Weighted ] res_all[f"{type_uid}:{_get_type_name(type_uid)}"] = result_uid_metrics ### I - integrated, W - weighted, Type - across all types cols_uid = ["Recall_dt", "Cls_acc", "Cls_precision", "Cls_recall", "Cls_F1", "ICls_acc", "ICls_precision", "ICls_recall", "ICls_F1", "WCls_acc", "WCls_precision", "WCls_recall", "WCls_F1"] # result_uid_metrics cols_all_types = ["Type_acc", "Type_precision", "Type_recall", "Type_F1"] # results_all_types df_all_types = pd.DataFrame(np.transpose(np.array(results_all_types)), columns=cols_all_types) df_uid = pd.DataFrame(np.squeeze(np.array(list(res_all.values()))), columns=cols_uid) df_uid["Type"] = list(res_all.keys()) df_uid = df_uid[["Type", *cols_uid]] if verbose: print() print(df_all_types.to_markdown(index=False)) print() print(df_uid.to_markdown(index=False)) return df_uid, df_all_types
9b24343a05c5111b80239c66f1500a934ea3ba33
11,308
from typing import Tuple from typing import Mapping def _signature_pre_process_predict( signature: _SignatureDef) -> Tuple[Text, Mapping[Text, Text]]: """Returns input tensor name and output alias tensor names from signature. Args: signature: SignatureDef Returns: A tuple of input tensor name and output alias tensor names. """ input_tensor_names = [value.name for value in signature.inputs.values()] input_tensor_types = dict([ (key, value.dtype) for key, value in signature.inputs.items() ]) output_alias_tensor_names = dict([ (key, output.name) for key, output in signature.outputs.items() ]) return input_tensor_names, input_tensor_types, output_alias_tensor_names
a53af746f7cebc7c3baaa316458dd3e7b88c2c38
11,309
def style_95_read_mode(line, patterns): """Style the EAC 95 read mode line.""" # Burst mode doesn't have multiple settings in one line if ',' not in line: return style_setting(line, 'bad') split_line = line.split(':', 1) read_mode = split_line[0].rstrip() line = line.replace(read_mode, '<span class="log5">{}</span>'.format(read_mode), 1) parts = split_line[1].lstrip().split(' ', 1) parts[1:] = [part.strip() for part in parts[1].split(',')] num = 0 p = patterns['95 settings'] for setting in [ p['Read mode'], p['C2 pointers'], p['Accurate stream'], p['Audio cache'], ]: if num == len(parts): break class_ = 'good' if setting in line else 'bad' line = line.replace( parts[num], '<span class="{}">{}</span>'.format(class_, parts[num]), 1 ) num += 1 return line
25c347acb87702f19ebcea85a3b4f0257df101ae
11,310
def trange( client, symbol, timeframe="6m", highcol="high", lowcol="low", closecol="close" ): """This will return a dataframe of true range for the given symbol across the given timeframe Args: client (pyEX.Client): Client symbol (string): Ticker timeframe (string): timeframe to use, for pyEX.chart highcol (string): column to use to calculate lowcol (string): column to use to calculate closecol (string): column to use to calculate Returns: DataFrame: result """ df = client.chartDF(symbol, timeframe) trange = t.TRANGE(df[highcol].values, df[lowcol].values, df[closecol].values) return pd.DataFrame( { highcol: df[highcol].values, lowcol: df[lowcol].values, closecol: df[closecol].values, "trange": trange, } )
94cf95eb86575a66e015e46fd81a5a8085277255
11,311
def ConvolveUsingAlm(map_in, psf_alm): """Convolve a map using a set of pre-computed ALM Parameters ---------- map_in : array_like HEALPix map to be convolved psf_alm : array_like The ALM represenation of the PSF Returns ------- map_out : array_like The smeared map """ norm = map_in.sum() nside = hp.pixelfunc.npix2nside(map_in.size) almmap = hp.sphtfunc.map2alm(map_in) almmap *= psf_alm outmap = hp.sphtfunc.alm2map(almmap, nside) outmap *= norm / outmap.sum() return outmap
0ebfa49c605f57ea2cc59b2686da8995dc01881f
11,312
def load_summary_data(): """ Function to load data param DATA_URL: data_url return: pandas dataframe """ DATA_URL = 'data/summary_df.csv' data = pd.read_csv(DATA_URL) return data
b5f09e845e1379fd00a03fd11b0174e3114eb7d3
11,313
import itertools def _enumerate_trees_w_leaves(n_leaves): """Construct all rooted trees with n leaves.""" def enumtree(*args): n_args = len(args) # trivial cases: if n_args == 0: return [] if n_args == 1: return args # general case of 2 or more args: # build index array idxs = range(0, n_args) trees = [] # we consider all possible subsets of size n_set to gather for n_set in range(2, n_args+1): idxsets = list(itertools.combinations(idxs, n_set)) for idxset in idxsets: # recurse by joining all subtrees with # n_set leaves and (n_args - n_set) leaves arg_set = tuple(args[i] for i in idxs if i in idxset) arg_coset = tuple(args[i] for i in idxs if i not in idxset) if arg_coset: trees.extend(tuple(itertools.product(enumtree(*arg_set), enumtree(*arg_coset)))) else: # trivial case where arg_set is entire set trees.append(arg_set) return trees # return enumerated trees with integers as leaves return enumtree(*range(n_leaves))
574a2d3ec63d3aeeb06292ec361b83aebba0ff84
11,314
from typing import get_args import sys import re def main(): """Make a jazz noise here""" args = get_args() sub = args.substring word = args.word # Sanity check if sub not in word: sys.exit(f'Substring "{sub}" does not appear in word "{word}"') # Create a pattern that replaces the length of the sub with any letters pattern = word.replace(sub, '[a-z]{' + str(len(sub)) + '}') regex = re.compile('^' + pattern + '$') # Find matches but exclude the original word def match(check): return check != word and regex.match(check) if words := list(filter(match, args.wordlist.read().lower().split())): print('\n'.join(words)) else: print('Womp womp')
0c2149e1f107967a0bc948fde0e7a25844664f24
11,315
def gen_tfidf(tokens, idf_dict): """ Given a segmented string and idf dict, return a dict of tfidf. """ # tokens = text.split() total = len(tokens) tfidf_dict = {} for w in tokens: tfidf_dict[w] = tfidf_dict.get(w, 0.0) + 1.0 for k in tfidf_dict: tfidf_dict[k] *= idf_dict.get(k, 0.0) / total return tfidf_dict
9217867b3661a8070cc1b2d577918c95d1ff7755
11,316
def timestamp_to_seconds(timestamp): """Convert timestamp to python (POSIX) time in seconds. :param timestamp: The timestamp. :return: The python time in float seconds. """ return (timestamp / 2**30) + EPOCH
3d5ca5f5ec93b54e1d1a6c53cefba1d49f8ebac2
11,317
import io import subprocess import time def launch_dpf(ansys_path, ip=LOCALHOST, port=DPF_DEFAULT_PORT, timeout=10, docker_name=None): """Launch Ansys DPF. Parameters ---------- ansys_path : str, optional Root path for the Ansys installation directory. For example, ``"/ansys_inc/v212/"``. The default is the latest Ansys installation. ip : str, optional IP address of the remote or local instance to connect to. The default is ``"LOCALHOST"``. port : int Port to connect to the remote instance on. The default is ``"DPF_DEFAULT_PORT"``, which is 50054. timeout : float, optional Maximum number of seconds for the initialization attempt. The default is ``10``. Once the specified number of seconds passes, the connection fails. docker_name : str, optional To start DPF server as a docker, specify the docker name here. Returns ------- process : subprocess.Popen DPF Process. """ process = _run_launch_server_process(ansys_path, ip, port, docker_name) # check to see if the service started lines = [] docker_id = [] def read_stdout(): for line in io.TextIOWrapper(process.stdout, encoding="utf-8"): LOG.debug(line) lines.append(line) if docker_name: docker_id.append(lines[0].replace("\n", "")) docker_process = subprocess.Popen(f"docker logs {docker_id[0]}", stdout=subprocess.PIPE, stderr=subprocess.PIPE) for line in io.TextIOWrapper(docker_process.stdout, encoding="utf-8"): LOG.debug(line) lines.append(line) errors = [] def read_stderr(): for line in io.TextIOWrapper(process.stderr, encoding="utf-8"): LOG.error(line) errors.append(line) # must be in the background since the process reader is blocking Thread(target=read_stdout, daemon=True).start() Thread(target=read_stderr, daemon=True).start() t_timeout = time.time() + timeout started = False while not started: started = any("server started" in line for line in lines) if time.time() > t_timeout: raise TimeoutError(f"Server did not start in {timeout} seconds") # verify there were no errors time.sleep(0.1) if errors: try: process.kill() except PermissionError: pass errstr = "\n".join(errors) if "Only one usage of each socket address" in errstr: raise errors.InvalidPortError(f"Port {port} in use") raise RuntimeError(errstr) if len(docker_id) > 0: return docker_id[0]
6d9d4039b702c3499ed256254f156f28eeb809a6
11,318
def fit_lowmass_mstar_mpeak_relation(mpeak_orig, mstar_orig, mpeak_mstar_fit_low_mpeak=default_mpeak_mstar_fit_low_mpeak, mpeak_mstar_fit_high_mpeak=default_mpeak_mstar_fit_high_mpeak): """ """ mid = 0.5*(mpeak_mstar_fit_low_mpeak + mpeak_mstar_fit_high_mpeak) mask = (mpeak_orig >= 10**mpeak_mstar_fit_low_mpeak) mask &= (mpeak_orig < 10**mpeak_mstar_fit_high_mpeak) # Add noise to mpeak to avoid particle discreteness effects in the fit _x = np.random.normal(loc=np.log10(mpeak_orig[mask])-mid, scale=0.002) _y = np.log10(mstar_orig[mask]) c1, c0 = np.polyfit(_x, _y, deg=1) return c0, c1, mid
620275ad18173bb00d38f3d468be132d150fc1fa
11,319
def load_ref_system(): """ Returns benzaldehyde as found in the IQMol fragment library. All credit to https://github.com/nutjunkie/IQmol """ return psr.make_system(""" C 0.3179 1.0449 -0.0067 C 1.6965 0.8596 -0.0102 C 2.2283 -0.4253 -0.0050 C 1.3808 -1.5297 0.0037 C 0.0035 -1.3492 0.0073 C -0.5347 -0.0596 0.0021 C -2.0103 0.0989 0.0061 O -2.5724 1.1709 0.0021 H 2.3631 1.7283 -0.0171 H 3.3139 -0.5693 -0.0078 H 1.8000 -2.5413 0.0078 H -0.6626 -2.2203 0.0142 H -2.6021 -0.8324 0.0131 H -0.1030 2.0579 -0.0108 """)
518ca10a84befa07fefa3c2f646e40095318d63c
11,320
def get_department_level_grade_data_completed(request_ctx, account_id, **request_kwargs): """ Returns the distribution of grades for students in courses in the department. Each data point is one student's current grade in one course; if a student is in multiple courses, he contributes one value per course, but if he's enrolled multiple times in the same course (e.g. a lecture section and a lab section), he only constributes on value for that course. Grades are binned to the nearest integer score; anomalous grades outside the 0 to 100 range are ignored. The raw counts are returned, not yet normalized by the total count. Shares the same variations on endpoint as the participation data. :param request_ctx: The request context :type request_ctx: :class:RequestContext :param account_id: (required) ID :type account_id: string :return: Get department-level grade data :rtype: requests.Response (with void data) """ path = '/v1/accounts/{account_id}/analytics/completed/grades' url = request_ctx.base_api_url + path.format(account_id=account_id) response = client.get(request_ctx, url, **request_kwargs) return response
8dd40c7b7c7a734aa66d4f808224424c0c0df81d
11,321
def allocate_samples_to_bins(n_samples, ideal_bin_count=100): """goal is as best as possible pick a number of bins and per bin samples to a achieve a given number of samples. Parameters ---------- Returns ---------- number of bins, list of samples per bin """ if n_samples <= ideal_bin_count: n_bins = n_samples samples_per_bin = [1 for _ in range(n_bins)] else: n_bins = ideal_bin_count remainer = n_samples % ideal_bin_count samples_per_bin = np.array([(n_samples - remainer) / ideal_bin_count for _ in range(n_bins)]) if remainer != 0: additional_samples_per_bin = distribute_samples(remainer, n_bins) samples_per_bin = samples_per_bin + additional_samples_per_bin return n_bins, np.array(samples_per_bin).astype(int)
66d5fe32a89478b543818d63c65f2745fe242b33
11,322
from typing import Any def create_algo(name: str, discrete: bool, **params: Any) -> AlgoBase: """Returns algorithm object from its name. Args: name (str): algorithm name in snake_case. discrete (bool): flag to use discrete action-space algorithm. params (any): arguments for algorithm. Returns: d3rlpy.algos.base.AlgoBase: algorithm. """ return get_algo(name, discrete)(**params)
4fab0f5581eb6036efba6074ab6e3b232bcf5679
11,323
def tf_inv(T): """ Invert 4x4 homogeneous transform """ assert T.shape == (4, 4) return np.linalg.inv(T)
5bf7d54456198c25029956a7aebe118d7ee4fa87
11,324
def send_reset_password_email(token, to, username): """ send email to user for reset password :param token: token :param to: email address :param username: user.username :return: """ url_to = current_app.config["WEB_BASE_URL"] + "/auth/reset-password?token=" + token response = _send_email( subject="请重置密码", to=to, html_body=render_template( "emails/reset_password.html", username=username, url_to=url_to ), ) return response.status_code
dddcb66425de79a1a736bbbcc5cbc3f5855e7db9
11,325
def part1(data): """Solve part 1""" countIncreased = 0 prevItem = None for row in data: if prevItem == None: prevItem = row continue if prevItem < row: countIncreased += 1; prevItem = row return countIncreased
e01b5edc9d9ac63a31189160d09b5e6e0f11e522
11,326
def yzrotation(theta = np.pi*3/20.0): """ Returns a simple planar rotation matrix that rotates vectors around the x-axis. args: theta: The angle by which we will perform the rotation. """ r = np.eye(3) r[1,1] = np.cos(theta) r[1,2] = -np.sin(theta) r[2,1] = np.sin(theta) r[2,2] = np.cos(theta) return r
59a2a251f8e8aa77548f749f49871536de29b0bb
11,327
def is_compiled_release(data): """ Returns whether the data is a compiled release (embedded or linked). """ return 'tag' in data and isinstance(data['tag'], list) and 'compiled' in data['tag']
ea8c8ae4f1ccdedbcc145bd57bde3b6040e5cab5
11,328
import numpy def resize_frame( frame: numpy.ndarray, width: int, height: int, mode: str = "RGB" ) -> numpy.ndarray: """ Use PIL to resize an RGB frame to an specified height and width. Args: frame: Target numpy array representing the image that will be resized. width: Width of the resized image. height: Height of the resized image. mode: Passed to Image.convert. Returns: The resized frame that matches the provided width and height. """ frame = Image.fromarray(frame) frame = frame.convert(mode).resize(size=(width, height)) return numpy.array(frame)
941eb73961843e46b4e67d48439a09c0223c2af0
11,329
def get_proxies(host, user, password, database, port=3306, unix_socket=None): """"Connect to a mysql database using pymysql and retrieve proxies for the scraping job. Args: host: The mysql database host user: The mysql user password: The database password port: The mysql port, by default 3306 unix_socket: Sometimes you need to specify the mysql socket file when mysql doesn't reside in a standard location. Returns; A list of proxies obtained from the database Raisese: An Exception when connecting to the database fails. """ try: conn = pymysql.connect(host=host, port=port, user=user, passwd=password, unix_socket=unix_socket) conn.select_db(database) cur = conn.cursor(pymysql.cursors.DictCursor) # Adapt this code for you to make it retrieving the proxies in the right format. cur.execute('SELECT host, port, username, password, protocol FROM proxies') proxies = [Proxy(proto=s['protocol'], host=s['host'], port=s['port'], username=s['username'], password=s['password']) for s in cur.fetchall()] return proxies except Exception as e: logger.error(e) raise
d4595440c9d4d07a7d5e27740bf7049176dbe432
11,330
def APIRevision(): """Gets the current API revision to use. Returns: str, The revision to use. """ return 'v1beta3'
c748e1917befe76da449e1f435540e10ee433444
11,331
def pretty_string_value_error(value, error, error_digits=2, use_unicode=True): """ Returns a value/error combination of numbers in a scientifically 'pretty' format. Scientific quantities often come as a *value* (the actual quantity) and the *error* (the uncertainty in the value). Given two floats, value and error, return the two in a 'pretty' formatted string: where the value and error are truncated at the correct precision. Parameters ---------- value : float The quantity in question error : float The uncertainty of the quantity error_digits : int, default 2 How many significant figures the error has. Scientific convention holds that errors have 1 or (at most) 2 significant figures. The larger number of digits is chosen here by default. Returns ------- new_string : str A new list of strings sorted numerically Examples -------- >>> pretty_string_value_error(1.23456789e8, 4.5678e5, error_digits=2) "1.2346 +/- 0.0046 * 10^+08" >>> pretty_string_value_error(5.6e-2, 2.0e-3, error_digits=1) "5.6 +/- 0.2 * 10^-02" """ if value is None: return "None" if error is None or not np.isfinite(error): if use_unicode: new_string = "{:.6E} \u00B1 UNKNOWN ERROR MARGIN".format(value) else: new_string = "{:.6E} +/- UNKNOWN ERROR MARGIN".format(value) else: if not np.isfinite(value): return str(value) assert "e" in "{:e}".format(value), "Cannot convert into scientific "\ "notation: {1}".format(value) value_mantissa_str, value_exponent_str = \ "{:e}".format(value).strip().split('e') value_mantissa = float(value_mantissa_str) value_exponent = int(value_exponent_str) error_mantissa_str, error_exponent_str = \ "{:e}".format(error).strip().split('e') error_mantissa = float(error_mantissa_str) error_exponent = int(error_exponent_str) padding = value_exponent - error_exponent + error_digits - 1 if padding < 1: padding = 1 exp_diff = error_exponent - value_exponent string_for_formatting = "{:.%df}" % padding new_value_mantissa = string_for_formatting.format(value_mantissa) new_error_mantissa = string_for_formatting.format( error_mantissa*10**exp_diff) if use_unicode: new_string = "%s \u00B1 %s * 10^%s" % ( new_value_mantissa, new_error_mantissa, value_exponent_str) else: new_string = "%s +/- %s * 10^%s" % ( new_value_mantissa, new_error_mantissa, value_exponent_str) return new_string
bd7b1496880e7d1cb4ffd04d23df20d679ac8ade
11,332
def update_resnet(model, debug=False): """ Update a ResNet model to use :class:`EltwiseSum` for the skip connection. Args: model (:class:`torchvision.models.resnet.ResNet`): ResNet model. debug (bool): If True, print debug statements. Returns: model (:class:`torchvision.models.resnet.ResNet`): ResNet model that uses :class:`EltwiseSum` for the skip connections. The forward functions of :class:`torchvision.models.resnet.BasicBlock` and :class:`torch.models.resnet.Bottleneck` are modified. """ assert isinstance(model, ResNet) def bottleneck_forward(self, x): identity = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) out = self.relu(out) out = self.conv3(out) out = self.bn3(out) if self.downsample is not None: identity = self.downsample(x) out = self.skip(out, identity) out = self.relu(out) return out def basicblock_forward(self, x): identity = x out = self.conv1(x) out = self.bn1(out) out = self.relu(out) out = self.conv2(out) out = self.bn2(out) if self.downsample is not None: identity = self.downsample(x) out = self.skip(out, identity) out = self.relu(out) return out for module_name, module in model.named_modules(): if isinstance(module, Bottleneck): module.skip = EltwiseSum() module.forward = bottleneck_forward.__get__(module) elif isinstance(module, BasicBlock): module.skip = EltwiseSum() module.forward = basicblock_forward.__get__(module) else: continue if debug: print('Adding EltwiseSum as skip connection in {}.'.format( module_name)) return model
a6baf031ff89b82b4e063795555c55885548f61e
11,333
def sameSize(arguments) -> bool: """Checks whether given vectors are the same size or not""" sameLength = True initialSize = len(vectors[arguments[0]]) for vector in arguments: if len(vectors[vector]) != initialSize: sameLength = False return sameLength
0840adcb0f6a84c56ff3b0ce3aa23892e45d942e
11,334
def db_read(src_path, read_type=set, read_int=False): """Read string data from a file into a variable of given type. Read from the file at 'src_path', line by line, skipping certain lines and removing trailing whitespace. If 'read_int' is True, convert the resulting string to int. Return read data as an object of the desired type specified by 'read_type'. """ def skip(s): """Bool func. for skipping a line. "#%# " is chosen as a comment indicator. """ return s == "\n" or s.startswith("#%# ") if read_type is list: result = list() with open(src_path, "r") as f: for i in f.readlines(): if not skip(i): result.append(int(i.strip()) if read_int else i.strip()) elif read_type is set: result = set() with open(src_path, "r") as f: for i in f.readlines(): if not skip(i): result.add(int(i.strip()) if read_int else i.strip()) elif read_type is dict: # Process the lines in pairs: First the key, then the corresponding # value, and then the next key... and so on. result = dict() with open(src_path, "r") as f: key_temp = "" for i in f.readlines(): if not skip(i): if key_temp: result[key_temp] = ( int(i.strip()) if read_int else i.strip() ) key_temp = "" else: key_temp = (int(i.strip()) if read_int else i.strip()) elif read_type is str: # Only read the first line of the file, strip and return it: with open(src_path, "r") as f: result = f.readline().rstrip() else: logger.error("db_read: read_type is not list, str, set or dict.") return None return result
811c6efb83d134d695c6dec2e34d3405818b8a48
11,335
import re def get_config_keys(): """Parses Keys.java to extract keys to be used in configuration files Args: None Returns: list: A list of dict containing the following keys - 'key': A dot separated name of the config key 'description': A list of str """ desc_re = re.compile(r"(/\*\*\n|\s+\*/|\s+\*)") key_match_re = re.compile(r"\(\n(.+)\);", re.DOTALL) key_split_re = re.compile(r",\s+", re.DOTALL) keys = [] with open(_KEYS_FILE, "r") as f: config = re.findall( r"(/\*\*.*?\*/)\n\s+(public static final Config.*?;)", f.read(), re.DOTALL ) for i in config: try: key_match = key_match_re.search(i[1]) if key_match: terms = [x.strip() for x in key_split_re.split(key_match.group(1))] key = terms[0].replace('"', "") description = [ x.strip().replace("\n", "") for x in desc_re.sub("\n", i[0]).strip().split("\n\n") ] if len(terms) == 3: description.append(f"Default: {terms[2]}") keys.append( { "key": key, "description": description, } ) except IndexError: # will continue if key_match.group(1) or terms[0] does not exist # for some reason pass return keys
8c04fcac2d05579ce47f5436999f0fe86fb1bdbd
11,336
def new(): """Create a new community.""" return render_template('invenio_communities/new.html')
60ee1560f749d94833f57b6a34e2d514e3e04ccb
11,337
import torch def interpolate(results_t, results_tp1, dt, K, c2w, img_wh): """ Interpolate between two results t and t+1 to produce t+dt, dt in (0, 1). For each sample on the ray (the sample points lie on the same distances, so they actually form planes), compute the optical flow on this plane, then use softsplat to splat the flows. Finally use MPI technique to compute the composite image. Used in test time only. Inputs: results_t, results_tp1: dictionaries of the @render_rays function. dt: float in (0, 1) K: (3, 3) intrinsics matrix (MUST BE THE SAME for results_t and results_tp1!) c2w: (3, 4) current pose (MUST BE THE SAME for results_t and results_tp1!) img_wh: image width and height Outputs: (img_wh[1], img_wh[0], 3) rgb interpolation result (img_wh[1], img_wh[0]) depth of the interpolation (in NDC) """ device = results_t['xyzs_fine'].device N_rays, N_samples = results_t['xyzs_fine'].shape[:2] w, h = img_wh rgba = torch.zeros((h, w, 4), device=device) depth = torch.zeros((h, w), device=device) c2w_ = torch.eye(4) c2w_[:3] = c2w w2c = torch.inverse(c2w_)[:3] w2c[1:] *= -1 # "right up back" to "right down forward" for cam projection P = K @ w2c # (3, 4) projection matrix grid = create_meshgrid(h, w, False, device) # (1, h, w, 2) xyzs = results_t['xyzs_fine'] # equals results_tp1['xyzs_fine'] zs = rearrange(results_t['zs_fine'], '(h w) n2 -> h w n2', w=w, h=h) # static buffers static_rgb = rearrange(results_t['static_rgbs_fine'], '(h w) n2 c -> h w n2 c', w=w, h=h, c=3) static_a = rearrange(results_t['static_alphas_fine'], '(h w) n2 -> h w n2 1', w=w, h=h) # compute forward buffers xyzs_w = ray_utils.ndc2world(rearrange(xyzs, 'n1 n2 c -> (n1 n2) c'), K) xyzs_fw_w = ray_utils.ndc2world( rearrange(xyzs+results_t['transient_flows_fw'], 'n1 n2 c -> (n1 n2) c'), K) # fw points with full flow xyzs_fw_w = xyzs_w + dt*(xyzs_fw_w-xyzs_w) # scale the flow with dt uvds_fw = P[:3, :3] @ rearrange(xyzs_fw_w, 'n c -> c n') + P[:3, 3:] uvs_fw = uvds_fw[:2] / uvds_fw[2] uvs_fw = rearrange(uvs_fw, 'c (n1 n2) -> c n1 n2', n1=N_rays, n2=N_samples) uvs_fw = rearrange(uvs_fw, 'c (h w) n2 -> n2 h w c', w=w, h=h) of_fw = rearrange(uvs_fw-grid, 'n2 h w c -> n2 c h w', c=2) transient_rgb_t = rearrange(results_t['transient_rgbs_fine'], '(h w) n2 c -> n2 c h w', w=w, h=h, c=3) transient_a_t = rearrange(results_t['transient_alphas_fine'], '(h w) n2 -> n2 1 h w', w=w, h=h) transient_rgba_t = torch.cat([transient_rgb_t, transient_a_t], 1) # compute backward buffers xyzs_bw_w = ray_utils.ndc2world( rearrange(xyzs+results_tp1['transient_flows_bw'], 'n1 n2 c -> (n1 n2) c'), K) # bw points with full flow xyzs_bw_w = xyzs_w + (1-dt)*(xyzs_bw_w-xyzs_w) # scale the flow with 1-dt uvds_bw = P[:3, :3] @ rearrange(xyzs_bw_w, 'n c -> c n') + P[:3, 3:] uvs_bw = uvds_bw[:2] / uvds_bw[2] uvs_bw = rearrange(uvs_bw, 'c (n1 n2) -> c n1 n2', n1=N_rays, n2=N_samples) uvs_bw = rearrange(uvs_bw, 'c (h w) n2 -> n2 h w c', w=w, h=h) of_bw = rearrange(uvs_bw-grid, 'n2 h w c -> n2 c h w', c=2) transient_rgb_tp1 = rearrange(results_tp1['transient_rgbs_fine'], '(h w) n2 c -> n2 c h w', w=w, h=h, c=3) transient_a_tp1 = rearrange(results_tp1['transient_alphas_fine'], '(h w) n2 -> n2 1 h w', w=w, h=h) transient_rgba_tp1 = torch.cat([transient_rgb_tp1, transient_a_tp1], 1) for s in range(N_samples): # compute MPI planes (front to back composition) transient_rgba_fw = FunctionSoftsplat(tenInput=transient_rgba_t[s:s+1].cuda(), tenFlow=of_fw[s:s+1].cuda(), tenMetric=None, strType='average').cpu() transient_rgba_fw = rearrange(transient_rgba_fw, '1 c h w -> h w c') transient_rgba_bw = FunctionSoftsplat(tenInput=transient_rgba_tp1[s:s+1].cuda(), tenFlow=of_bw[s:s+1].cuda(), tenMetric=None, strType='average').cpu() transient_rgba_bw = rearrange(transient_rgba_bw, '1 c h w -> h w c') composed_rgb = transient_rgba_fw[..., :3]*transient_rgba_fw[..., 3:]*(1-dt) + \ transient_rgba_bw[..., :3]*transient_rgba_bw[..., 3:]*dt + \ static_rgb[:, :, s]*static_a[:, :, s] composed_a = 1 - (1-(transient_rgba_fw[..., 3:]*(1-dt)+ transient_rgba_bw[..., 3:]*dt)) * \ (1-static_a[:, :, s]) rgba[..., :3] += (1-rgba[..., 3:])*composed_rgb depth += (1-rgba[..., 3])*composed_a[..., 0]*zs[..., s] rgba[..., 3:] += (1-rgba[..., 3:])*composed_a return rgba[..., :3], depth
d5cdae22a3fb324e9bdfdedabe0b69cb5d40ebdb
11,338
def divisor(baudrate): """Calculate the divisor for generating a given baudrate""" CLOCK_HZ = 50e6 return round(CLOCK_HZ / baudrate)
a09eee716889ee6950f8c5bba0f31cdd2b311ada
11,339
def scm_get_active_branch(*args, **kwargs): """ Get the active named branch of an existing SCM repository. :param str path: Path on the file system where the repository resides. If not specified, it defaults to the current work directory. :return: Name of the active branch :rtype: str """ if not _scm_handler: _load_scm_handler() return _scm_handler.get_active_branch(*args, **kwargs)
6c18454548732cd8db4ba85b45cdc9a8d9b47fce
11,340
def search_evaluations(campus, **kwargs): """ year (required) term_name (required): Winter|Spring|Summer|Autumn curriculum_abbreviation course_number section_id student_id (student number) """ url = "%s?%s" % (IAS_PREFIX, urlencode(kwargs)) data = get_resource_by_campus(url, campus) evaluations = _json_to_evaluation(data) return evaluations
d7069c2e9135b350141b0053e3ec1202650b7c28
11,341
from typing import Optional import select async def get_user(username: str, session: AsyncSession) -> Optional[User]: """ Returns a user with the given username """ return ( (await session.execute(select(User).where(User.name == username))) .scalars() .first() )
0975c069d76414fbf57f4b8f7370d0ada40e39f5
11,342
import os import time import stat from datetime import datetime def convert_modtime_to_date(path): """ Formats last modification date of a file into m/d/y form. Params: path (file path): the file to be documented Example: convert_modtime_to_date(/users/.../last_minute_submission.pdf) """ fileStatsObj = os.stat(path) modificationTime = time.ctime(fileStatsObj[stat.ST_MTIME]) return datetime.datetime.strptime(modificationTime,'%a %b %d %H:%M:%S %Y').strftime('%m/%d/%y')
7377e6c46e477a8af9fa1c500517e2a9b2d7df49
11,343
import pandas def compute_balances(flows): """ Balances by currency. :param flows: :return: """ flows = flows.set_index('date') flows_by_asset = flows.pivot(columns='asset', values='amount').apply(pandas.to_numeric) balances = flows_by_asset.fillna(0).cumsum() return balances
98728c2c687df60194eb11b479c08fc90502807a
11,344
import json def unjsonify(json_data): """ Converts the inputted JSON data to Python format. :param json_data | <variant> """ return json.loads(json_data, object_hook=json2py)
93a59f8a2ef96cbe25e89c2970969b0132b1a892
11,345
from typing import Tuple from typing import List def comp_state_dist(table: np.ndarray) -> Tuple[np.ndarray, List[str]]: """Compute the distribution of distinct states/diagnoses from a table of individual diagnoses detailing the patterns of lymphatic progression per patient. Args: table: Rows of patients and columns of LNLs, reporting which LNL was involved for which patient. Returns: A histogram of unique states and a list of the corresponding state labels. Note: This function cannot deal with parts of the diagnose being unknown. So if, e.g., one level isn't reported for a patient, that row will just be ignored. """ _, num_cols = table.shape table = table.astype(float) state_dist = np.zeros(shape=2**num_cols, dtype=int) for row in table: if not np.any(np.isnan(row)): idx = int(np.sum([n * 2**i for i,n in enumerate(row[::-1])])) state_dist[idx] += 1 state_labels = [] for i in range(2**num_cols): state_labels.append(change_base(i, 2, length=num_cols)) return state_dist, state_labels
1a2edacd40d4fea3ff3cc5ddd57d76bffc60c7bc
11,346
def polyConvert(coeffs, trans=(0, 1), backward=False): """ Converts polynomial coeffs for x (P = a0 + a1*x + a2*x**2 + ...) in polynomial coeffs for x~:=a+b*x (P~ = a0~ + a1~*x~ + a2~*x~**2 + ...). Therefore, (a,b)=(0,1) makes nothing. If backward, makes the opposite transformation. Note: backward transformation could be done using more general polynomial composition `polyval`, but forward transformation is a long standing issue in the general case (look for functional decomposition of univariate polynomial). """ a, b = trans if not backward: a = -float(a) / float(b) b = 1 / float(b) return N.dot(polyConvMatrix(len(coeffs), (a, b)), coeffs)
1a2607b28046a8dc67315726957a87a5d5c9a435
11,347
import random def uniform(_data, weights): """ Randomly initialize the weights with values between 0 and 1. Parameters ---------- _data: ndarray Data to pick to initialize weights. weights: ndarray Previous weight values. Returns ------- weights: ndarray New weight values """ return random.rand(*weights.shape)
fbf7e853f11a888ee01dc840c6ffcb214560c5a8
11,348
def ingresar_datos(): """Ingresa los datos de las secciones""" datos = {} while True: codigo = int_input('Ingrese el código de la sección: ') if codigo < 0: break cantidad = int_input( 'Ingrese la cantidad de alumnos: ', min=MIN, max=MAX ) datos[codigo] = cantidad return datos
3bacb0e5d6b234b2f90564c44a25d151a640fd1f
11,349
def fetch_credentials() -> Credentials: """Produces a Credentials object based on the contents of the CONFIG_FILE or, alternatively, interactively. """ if CONFIG_FILE_EXISTS: return parse_config_file(CONFIG_FILE) else: return get_credentials_interactively()
0b882c8c4c8066a1898771c66db6ccbe7cb09c37
11,350
def pool_adjacency_mat_reference_wrapper( adj: sparse.spmatrix, kernel_size=4, stride=2, padding=1 ) -> sparse.spmatrix: """Wraps `pool_adjacency_mat_reference` to provide the same API as `pool_adjacency_mat`""" adj = Variable(to_sparse_tensor(adj).to_dense()) adj_conv = pool_adjacency_mat_reference(adj, kernel_size, stride, padding) return sparse.coo_matrix(adj_conv.data.numpy(), dtype=np.int16)
e72cb1e50bf7542d4175b9b3b3989e70a8812373
11,351
def send(socket, obj, flags=0, protocol=-1): """stringify an object, and then send it""" s = str(obj) return socket.send_string(s)
a89165565837ad4a984905d5b5fdd73e398b35fd
11,352
def arraystr(A: Array) -> str: """Pretty print array""" B = np.asarray(A).ravel() if len(B) <= 3: return " ".join([itemstr(v) for v in B]) return " ".join([itemstr(B[0]), itemstr(B[1]), "...", itemstr(B[-1])])
9cceed63c83812a7fd87dba833fc4d5b5a75088c
11,353
def dist2_test(v1, v2, idx1, idx2, len2): """Square of distance equal""" return (v1-v2).mag2() == len2
3a268a3ba704a91f83345766245a952fe5d943dd
11,354
def extract_grid_cells(browser, grid_id): """ Given the ID of a legistar table, returns a list of dictionaries for each row mapping column headers to td elements. """ table = browser.find_element_by_id(grid_id) header_cells = table.find_elements_by_css_selector( 'thead:nth-child(2) > tr:nth-child(2) > th' ) headers = [extract_text(cell) for cell in header_cells] tbody = table.find_element_by_css_selector('tbody:nth-child(4)') rows = tbody.find_elements_by_tag_name('tr') result_rows = [] for row in rows: cells = {} td_elements = row.find_elements_by_tag_name('td') for header, cell in zip(headers, td_elements): cells[header] = cell result_rows.append(cells) return (headers, result_rows)
bee4265a18cfd428f25e3fdf3202fb5bfad820df
11,355
import ast def gatherAllParameters(a, keep_orig=True): """Gather all parameters in the tree. Names are returned along with their original names (which are used in variable mapping)""" if type(a) == list: allIds = set() for line in a: allIds |= gatherAllVariables(line) return allIds if not isinstance(a, ast.AST): return set() allIds = set() for node in ast.walk(a): if type(node) == ast.arg: origName = node.originalId if (keep_orig and hasattr(node, "originalId")) else None allIds |= set([(node.arg, origName)]) return allIds
e899e60d818750a4ff1656b039a6dc4413f8f181
11,356
def average_link_euclidian(X,verbose=0): """ Average link clustering based on data matrix. Parameters ---------- X array of shape (nbitem,dim): data matrix from which an Euclidian distance matrix is computed verbose=0, verbosity level Returns ------- t a weightForest structure that represents the dendrogram of the data Note ---- this method has not been optimized """ if X.shape[0]==np.size(X): X = np.reshape(X,(np.size(X),1)) if np.size(X)<10000: D = Euclidian_distance(X) else: raise ValueError, "The distance matrix is too large" t = average_link_distance(D,verbose) return t
17aae1e7f802f82765bcda8b403598a2c5a9f822
11,357
import functools def cached(func): """Decorator cached makes the function to cache its result and return it in duplicate calls.""" prop_name = '__cached_' + func.__name__ @functools.wraps(func) def _cached_func(self): try: return getattr(self, prop_name) except AttributeError: val = func(self) setattr(self, prop_name, val) return val return _cached_func
5b23c251c03160ba2c4e87848201be46ba2f34fb
11,358
def SX_inf(*args): """ create a matrix with all inf inf(int nrow, int ncol) -> SX inf((int,int) rc) -> SX inf(Sparsity sp) -> SX """ return _casadi.SX_inf(*args)
b11fba9e9b60eadb983d1203b1dd852abca9a2b7
11,359
def aes_encrypt(mode, aes_key, aes_iv, *data): """ Encrypt data with AES in specified mode. :param aes_key: aes_key to use :param aes_iv: initialization vector """ encryptor = Cipher(algorithms.AES(aes_key), mode(aes_iv), backend=default_backend()).encryptor() result = None for value in data: result = encryptor.update(value) encryptor.finalize() return result, None if not hasattr(encryptor, 'tag') else encryptor.tag
94a39ddabe3ea186463808e79e86bec171fbaeda
11,360
def _ebpm_gamma_update_a(init, b, plm, step=1, c=0.5, tau=0.5, max_iters=30): """Backtracking line search to select step size for Newton-Raphson update of a""" def loss(a): return -(a * np.log(b) + a * plm - sp.gammaln(a)).sum() obj = loss(init) d = (np.log(b) - sp.digamma(init) + plm).mean() / sp.polygamma(1, init) update = loss(init + step * d) while (not np.isfinite(update) or update > obj + c * step * d) and max_iters > 0: step *= tau update = loss(init + step * d) max_iters -= 1 if max_iters == 0: # Step size is small enough that update can be skipped return init else: return init + step * d
038fb28824b3429b03887299af7a7feeec16b689
11,361
def edge_distance_mapping(graph : Graph, iterations : int, lrgen : LearningRateGen, verbose : bool = True, reset_locations : bool = True): """ Stochastic Gradient Descent algorithm for performing graph vertex laoyout optimization using the path distances as target distance in the layout. The algorihm is adapted from the paper https://arxiv.org/pdf/1710.04626.pdf Args: graph : The graph to arrange iterations : number of iteration rounds lrgen : learning rate function that takes iteration round as input verbose : boolean, set True to print progress status information Returns: Vertex location stress value list that contains one summary stress value per iteration. """ # Create temporary lists of vertex list indices n_vertex = graph.vertex_count vertex_idx_list_a = np.arange(n_vertex) vertex_idx_list_b = np.arange(n_vertex) stress_list = [] # Calculate distance look-up table dist_arr, keys = __edge_distance_lut(graph) if reset_locations: __reset_locations(graph) # Main iteration loop for iter_round in range(iterations): stress = 0 lr = lrgen.get_lr(iter_round) if verbose: progress_print = ProgressPrint(n_vertex) a_loop = 0 np.random.shuffle(vertex_idx_list_a) for idx_a in vertex_idx_list_a: np.random.shuffle(vertex_idx_list_b) for idx_b in vertex_idx_list_b: if idx_a == idx_b: continue # Get path distance from vertex a to b. # Value -1 means there is no path. dist_target = dist_arr[idx_a, idx_b] if dist_target == np.inf: continue # Update the locations and get stress for the patg key_a = keys[idx_a] key_b = keys[idx_b] edge_stress = __coord_update(graph, key_a, key_b, dist_target, lr) stress += edge_stress # Progress monitoring if verbose: a_loop += 1 progress_print.print_update(iter_round, a_loop, stress) stress_list.append(stress) return stress_list
f5c93cf83a7cd7892936246eb6c90562030ad819
11,362
def strip_extension(name: str) -> str: """ Remove a single extension from a file name, if present. """ last_dot = name.rfind(".") if last_dot > -1: return name[:last_dot] else: return name
9dc1e3a3c9ad3251aba8a1b61f73de9f79f9a8be
11,363
import os def next_joystick_device(): """Finds the next available js device name.""" for i in range(100): dev = "/dev/input/js{0}".format(i) if not os.path.exists(dev): return dev
56e1b859fd26e546e7a63cbf2764b78c2cd41990
11,364
def validatePullRequest(data): """Validate pull request by action.""" if 'action' not in data: raise BadRequest('no event supplied') if 'pull_request' not in data or 'html_url' not in data.get('pull_request'): raise BadRequest('payload.pull_request.html_url missing') return True
a4577a1b719b11f1ea845fff436a78178ca9e370
11,365
def __adjust_data_for_log_scale(dataframe: pd.DataFrame) -> pd.DataFrame: """ This will clean and adjust some of the data so that Altair can plot it using a logarithmic scale. Altair does not allow zero values on the Y axis when plotting with a logarithmic scale, as log(0) is undefined. Args: dataframe: The data to plot on the chart. Returns: A new data frame with the appropriate adjustments for plotting on a log scale. """ return dataframe.replace(0, float('nan'))
30d7a73f2f0d564f6e52e1a2fa4b521fa1265c3d
11,366
import torch def predict_sentence(model,vocab,sentence): """Predicts the section value of a given sentence INPUT: Trained model, Model vocab, Sentence to predict OUTPUT: Assigned section to the sentence""" device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') nlp=spacy.load('en_core_sci_md') model=model.to(device) tokens=[t.text for t in nlp.tokenizer(sentence)] indexed = [vocab[t] for t in tokens] tensor_to_predict=torch.LongTensor(indexed).to(device) tensor_to_predict=tensor_to_predict.unsqueeze(1).T length_tensor= torch.LongTensor([len(indexed)]).to(device) prediction=model(tensor_to_predict,length_tensor) return prediction.argmax(1).item()
f8ef02bd92dfc3dfcea0f5a2e9d5da99050fe367
11,367
import spacy import re def ne_offsets_by_sent( text_nest_list=[], model='de_core_news_sm', ): """ extracts offsets of NEs and the NE-type grouped by sents :param text_nest_list: A list of list with following structure:\ [{"text": "Wien ist schön", "ner_dicts": [{"text": "Wien", "ne_type": "LOC"}]}] :param model: The name of the spacy model which should be used for sentence splitting. :return: A list of spacy-like NER Tuples [('some text'), entities{[(15, 19, 'place')]}] """ nlp = spacy.load(model) text_nes = text_nest_list results = [] for entry in text_nes: ner_dicts = entry['ner_dicts'] in_text = entry['text'] doc = nlp(in_text) for sent in doc.sents: entities = [] if sent.text != "": plain_text = sent.text for x in ner_dicts: for m in re.finditer(x['text'], plain_text): entities.append([m.start(), m.end(), x['ne_type']]) entities = [item for item in set(tuple(row) for row in entities)] entities = sorted(entities, key=lambda x: x[0]) ents = [] next_item_index = 1 for x in entities: cur_start = x[0] try: next_start = entities[next_item_index][0] except IndexError: next_start = 9999999999999999999999 if cur_start == next_start: pass else: ents.append(x) next_item_index = next_item_index + 1 train_data = ( plain_text, { "entities": ents } ) results.append(train_data) return results
1e4fdaba07bf562b1d91b5f2376955efa9974c56
11,368
from typing import Optional def clone_repo( url: str, path: str, branch: Optional[str] = None, ) -> bool: """Clone repo from URL (at branch if specified) to given path.""" cmd = ['git', 'clone', url, path] if branch: cmd += ['--branch', branch] return run(cmd)[0].returncode == 0
56bc8641c3418216f1da5f0c87d33478888775c7
11,369
def get_inputtype(name, object_type): """Get an input type based on the object type""" if object_type in _input_registry: return _input_registry[object_type] inputtype = type( name, (graphene.InputObjectType,), _get_input_attrs(object_type), ) _input_registry[object_type] = inputtype return inputtype
aee2a84c8aaf0d66554f022ac0fec0aaef808160
11,370
from src.common import lang import os def res_ex_response(e, original=False): """异常响应,结果必须可以作json序列化 参数: e # 原始错误信息 original # 是否返回原始错误信息,默认flase """ if os.getenv('ENV') != 'UnitTest': current_app.logger.error(e) msg = lang.resp('L_OPER_FAILED') if original: msg = str(e) return jsonify({"msg":msg, "code":4001, "status":False}), 200
810edae8d2081e208b27e19589d8c9c09d669a72
11,371
def get_engine_status(engine=None): """Return a report of the current engine status""" if engine is None: engine = crawler.engine global_tests = [ "time()-engine.start_time", "engine.is_idle()", "engine.has_capacity()", "engine.scheduler.is_idle()", "len(engine.scheduler.pending_requests)", "engine.downloader.is_idle()", "len(engine.downloader.sites)", "engine.scraper.is_idle()", "len(engine.scraper.sites)", ] spider_tests = [ "engine.spider_is_idle(spider)", "engine.closing.get(spider)", "engine.scheduler.spider_has_pending_requests(spider)", "len(engine.scheduler.pending_requests[spider])", "len(engine.downloader.sites[spider].queue)", "len(engine.downloader.sites[spider].active)", "len(engine.downloader.sites[spider].transferring)", "engine.downloader.sites[spider].closing", "engine.downloader.sites[spider].lastseen", "len(engine.scraper.sites[spider].queue)", "len(engine.scraper.sites[spider].active)", "engine.scraper.sites[spider].active_size", "engine.scraper.sites[spider].itemproc_size", "engine.scraper.sites[spider].needs_backout()", ] status = {'global': {}, 'spiders': {}} for test in global_tests: try: status['global'][test] = eval(test) except Exception, e: status['global'][test] = "%s (exception)" % type(e).__name__ for spider in engine.downloader.sites: x = {} for test in spider_tests: try: x[test] = eval(test) except Exception, e: x[test] = "%s (exception)" % type(e).__name__ status['spiders'][spider] = x return status
0d87692a991965c8b72204d241964a27a9499014
11,372
import tqdm import requests import json def stock_em_jgdy_tj(): """ 东方财富网-数据中心-特色数据-机构调研-机构调研统计 http://data.eastmoney.com/jgdy/tj.html :return: pandas.DataFrame """ url = "http://data.eastmoney.com/DataCenter_V3/jgdy/gsjsdy.ashx" page_num = _get_page_num_tj() temp_df = pd.DataFrame() for page in tqdm(range(1, page_num+1)): params = { "pagesize": "5000", "page": str(page), "js": "var sGrabtEb", "param": "", "sortRule": "-1", "sortType": "0", "rt": "52581365", } res = requests.get(url, params=params) data_json = json.loads(res.text[res.text.find("={")+1:]) temp_df = temp_df.append(pd.DataFrame(data_json["data"]), ignore_index=True) return temp_df
1841702e6fb5c677245a2d213f489d95a789d68b
11,373
def hpdi(x, prob=0.90, axis=0): """ Computes "highest posterior density interval" (HPDI) which is the narrowest interval with probability mass ``prob``. :param numpy.ndarray x: the input array. :param float prob: the probability mass of samples within the interval. :param int axis: the dimension to calculate hpdi. :return: quantiles of ``x`` at ``(1 - prob) / 2`` and ``(1 + prob) / 2``. :rtype: numpy.ndarray """ x = np.swapaxes(x, axis, 0) sorted_x = np.sort(x, axis=0) mass = x.shape[0] index_length = int(prob * mass) intervals_left = sorted_x[:(mass - index_length)] intervals_right = sorted_x[index_length:] intervals_length = intervals_right - intervals_left index_start = intervals_length.argmin(axis=0) index_end = index_start + index_length hpd_left = np.take_along_axis(sorted_x, index_start[None, ...], axis=0) hpd_left = np.swapaxes(hpd_left, axis, 0) hpd_right = np.take_along_axis(sorted_x, index_end[None, ...], axis=0) hpd_right = np.swapaxes(hpd_right, axis, 0) return np.concatenate([hpd_left, hpd_right], axis=axis)
579515ebb6d28c2a1578c85eab8cbff1b67bd5ee
11,374
def a(n, k): """calculates maximum power of p(n) needed >>> a(0, 20) 4 >>> a(1, 20) 2 >>> a(2, 20) 1 """ return floor(log(k) / log(p(n)))
581e2a23a3dc069fc457ed5a6fe7d5a355353242
11,375
import platform def is_windows(): """ détermine si le système actuel est windows """ return platform.system().lower() == "windows"
fc9e2ca948f7cc5dc6b6cc9afb52ba701222bb7a
11,376
def WTfilt_1d(sig): """ # 使用小波变换对单导联ECG滤波 # 参考:Martis R J, Acharya U R, Min L C. ECG beat classification using PCA, LDA, ICA and discrete wavelet transform[J].Biomedical Signal Processing and Control, 2013, 8(5): 437-448. :param sig: 1-D numpy Array,单导联ECG :return: 1-D numpy Array,滤波后信号 """ coeffs = pywt.wavedec(sig, 'db6', level=9) coeffs[-1] = np.zeros(len(coeffs[-1])) coeffs[-2] = np.zeros(len(coeffs[-2])) coeffs[0] = np.zeros(len(coeffs[0])) sig_filt = pywt.waverec(coeffs, 'db6') return sig_filt
8a3c65b35ac347b247a36e7d70705f76f41010d5
11,377
def discount_rewards(r): """ take 1D float array of rewards and compute discounted reward """ gamma = 0.99 discounted_r = np.zeros_like(r) running_add = 0 for t in reversed(range(0, r.size)): running_add = running_add * gamma + r[t] discounted_r[t] = running_add return discounted_r
b093c0d82ef82824c08d08ce4da1b840318bd7ed
11,378
def mvn(tensor): """Per row mean-variance normalization.""" epsilon = 1e-6 mean = K.mean(tensor, axis=1, keepdims=True) std = K.std(tensor, axis=1, keepdims=True) mvn = (tensor - mean) / (std + epsilon) return mvn
c205712d3a1a53450de0e0b9af0abe1b9d51f269
11,379
import re def grapheme_to_phoneme(text, g2p, lexicon=None): """Converts grapheme to phoneme""" phones = [] words = filter(None, re.split(r"(['(),:;.\-\?\!\s+])", text)) for w in words: if lexicon is not None and w.lower() in lexicon: phones += lexicon[w.lower()] else: phones += list(filter(lambda p: p != " ", g2p(w))) return phones
2bb5195a323aa712b2725851fdde64b8e38856f0
11,380
def mean_log_cosh_error(pred, target): """ Determine mean log cosh error. f(y_t, y) = sum(log(cosh(y_t-y)))/n where, y_t = predicted value y = target value n = number of values :param pred: {array}, shape(n_samples,) predicted values. :param target: {array}, shape(n_samples,) target values. :return: mean log cosh error. """ error = pred - target return np.mean(np.log(np.cosh(error)))
85fd6c3d582e7bc41271e3212d43c5cfea8bcf7e
11,381
def plot_abctraces(pools, surveypath=''): """ Input: a list of pools in the abc format Generates trace plots of the thetas,eps and metrics """ sns.set_style("white") matplotlib.rc("font", size=30) """ Plot Metric-Distances """ distances = np.array([pool.dists for pool in pools]) print(distances.shape) f, ax = plt.subplots() for ii in range(distances.shape[2]): ax.errorbar(np.arange(len(distances)), np.mean(distances, axis=1)[:, ii], np.std(distances, axis=1)[:, ii], label='$\\Delta_%i$' % (ii+1)) # sns.distplot(np.asarray(distances)[:, ii], axlabel="distances", label='M%i' % (ii)) #plt.title("Development of Metric Distances") plt.xlabel('Iteration') plt.ylabel('Distance $\Delta$ in metric') plt.legend() plt.savefig('%s/Metrics.png' % (surveypath)) """ Plot Variables """ thetas = np.array([pool.thetas for pool in pools]) print(thetas.shape) f, ax = plt.subplots() for ii in range(thetas.shape[2]): ax.errorbar(np.arange(len(thetas)), np.mean(thetas, axis=1)[:, ii], np.std(thetas, axis=1)[:, ii], label='$\\theta_%i$' % (ii+1)) #plt.title("Development of Parameters") plt.xlabel('Iteration') plt.ylabel('$\\theta_i$') plt.legend() plt.savefig('%s/Thetas.png' % (surveypath)) """ Plot Variables """ #TODO: Fix bug ... you need to call pools or pool? for ii, pool, in enumerate(pools): thetas = pool.thetas figure = corner.corner(thetas) plt.savefig('%s/CornerThetas_%02i.png' % (surveypath,ii)) """ corner.corner(distances) plots the various distances over each other to show if they are uncorrelated. This is not super important, you could also use correlated distances with this approach. On the other hand it is interesting to see if both metrices are independent, often this is a sign that they are good features! """ """ Plot Epsilon""" fig, ax = plt.subplots() eps_values = np.array([pool.eps for pool in pools]) for ii in range(distances.shape[2]): ax.plot(eps_values[:, ii], label='$\epsilon_%i$' % (ii)) ax.set_xlabel("Iteration") ax.set_ylabel(r"$\epsilon$", fontsize=15) ax.legend(loc="best") #ax.set_title("Thresholds $\epsilon$") plt.savefig('%s/Thresholds.png' % (surveypath)) """ Violin Plots """ fig, axes = plt.subplots(nrows=1, ncols=1, figsize=(9, 4)) # generate some random test data all_data = [pool.thetas[:,0] for pool in pools] len_pools = [pool.thetas.shape[0]/pool.ratio for pool in pools] print('len_pools:', len_pools, sum(len_pools)) mod_data = [np.concatenate((pool.thetas[:,0]+0.2, pool.thetas[:,0]), axis=0) for pool in pools] # plot violin plot #background = axes.violinplot(mod_data, # showmeans=False, # showmedians=False, showextrema=False) axes.violinplot(all_data, showmeans=False, showmedians=True) #for pc in background['bodies']: # pc.set_facecolor('grey') # pc.set_edgecolor('black') # pc.set_alpha(0.4) #for pc in foreground['bodies']: # pc.set_facecolor('cornflowerblue') # pc.set_edgecolor('black') # pc.set_alpha(1) # axes.set_title('violin plot') # adding horizontal grid lines axes.yaxis.grid(True) axes.set_xticks([y+1 for y in range(len(all_data))]) axes.set_xlabel('Iteration') axes.set_ylabel('$\\log_{10}(\\xi_e)$') axes.set_ylabel('$\\log_{10}(\\xi_e)$') # add x-tick labels plt.setp(axes, xticks=[y+1 for y in range(len(all_data))]) plt.savefig('%s/Violin.png' % (surveypath)) plt.savefig('%s/Violin.pdf' % (surveypath)) plt.clf() """ Plot Parameters pools[ii].thetas[:, 0] is a numpy array """ for ii, nouse in enumerate(pools): if thetas.shape[1] > 1: jg = sns.jointplot(pools[ii].thetas[:, 0], pools[ii].thetas[:, 1], #kind="kde", # BUG: creates an error ) jg.ax_joint.set_xlabel('var1') jg.ax_joint.set_ylabel('var2') plt.savefig('%s/FirstThetas_%i.png' % (surveypath, ii)) return 0
9fef0b6bf382648d4d9d0cdfc175ce239aaf1aff
11,382
def check_columns(board: list): """ Check column-wise compliance of the board for uniqueness (buildings of unique height) and visibility (top-bottom and vice versa). Same as for horizontal cases, but aggregated in one function for vertical case, i.e. columns. >>> check_columns(['***21**', '412453*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*1***']) False >>> check_columns(['***21**', '412453*', '423145*', '*543215', \ '*35214*', '*41232*', '*2*1***']) False >>> check_columns(['***21**', '412553*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*1***']) False >>> check_columns(['***22**', '412453*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*1***']) False >>> check_columns(['***21**', '412453*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*4***']) False """ return check_uniqueness_in_rows(get_board_columns(board), False) and \ check_horizontal_visibility(get_board_columns(board), False)
85fd1f02b392c6b6219ce989f7439ec0140b9fa2
11,383
import numpy import pathlib import tqdm import pandas import warnings def extract_header(mjds, path, keywords, dtypes=None, split_dbs=False, is_range=False): """Returns a `~pandas.DataFrame` with header information. For a list or range of MJDs, collects a series of header keywords for database files and organises them in a `~pandas.DataFrame` sorted by MJD and frame number. Parameters ---------- mjds : list The list of MJDs to extract. If the lenght of ``mjds`` is two and ``is_range=True``, all the MJDs between both values will be extracted. path : str The path to the database file. keywords : list A list of strings with the header keywords to extract. dtypes : list, optional A list of types to cast the keyword values. split_dbs : bool, optional If True, assumes that the DB is split into multiple files, one for each MJD. In that case, the path for each file is assumed to be ``path`` with the ``_{MJD}`` suffix. is_range : bool, optional If True, assumes that ``mjds`` are the extremes of a range of MJDs. """ mjds = numpy.atleast_1d(mjds) path = pathlib.Path(path) keywords = [key.lower() for key in keywords] if dtypes: assert len(dtypes) == len(keywords), 'inconsistent lenghts of keywords and dtypes' assert mjds.ndim == 1, 'invalid number of dimensions in mjds' if is_range: assert len(mjds) == 2, 'when is_range=True, mjds must be a list of lenght 2' mjds = numpy.arange(mjds[0], mjds[1] + 1) if not split_dbs: assert path.exists() database.init(str(path)) assert database.connect(), 'cannot connect to database' dataframes = [] with tqdm.trange(len(mjds)) as tt: for mjd in mjds: tt.set_description(str(mjd)) if split_dbs: suffix = path.suffix database_mjd = str(path).replace(suffix, f'_{mjd}{suffix}') if not pathlib.Path(database_mjd).exists(): tt.update() continue database.init(str(database_mjd)) assert database.connect(), 'cannot connect to database' Header = playhouse.reflection.Introspector.from_database( database).generate_models()['header'] fields = [Frame.mjd, Frame.frame] failed = any([not hasattr(Header, keyword) for keyword in keywords]) if failed: tt.update() continue for keyword in keywords: fields.append(getattr(Header, keyword)) data = Header.select(*fields).join(Frame, on=(Frame.pk == Header.frame_pk)).tuples() dataframes.append(pandas.DataFrame(list(data), columns=(['mjd', 'frame'] + keywords))) tt.update() dataframe = pandas.concat(dataframes) if dtypes: failed = False for ii, key in enumerate(keywords): try: dataframe[key] = dataframe[key].astype(dtypes[ii]) except ValueError as ee: warnings.warn(f'failed to apply astype: {ee!r}', exceptions.GuiderQAUserWarning) failed = True if not failed: dataframe = dataframe[dataframe > -999.] dataframe = dataframe.set_index(['mjd', 'frame']) dataframe.sort_index(inplace=True) return dataframe
65934d9b5e9c1e6eb639709a16e6e93c145b57e7
11,384
import pytz from datetime import datetime async def get_time(): """获取服务器时间 """ tz = pytz.timezone('Asia/Shanghai') return { 'nowtime': datetime.now(), 'utctime': datetime.utcnow(), 'localtime': datetime.now(tz) }
282eb1136713df8045c6ad5f659042484fe4ec8b
11,385
def health_check(): """Attempt to ping the database and respond with a status code 200. This endpoint is verify that the server is running and that the database is accessible. """ response = {"service": "OK"} try: postgres.session.query(text("1")).from_statement(text("SELECT 1")).all() response["database"] = "OK" except Exception as e: app.logger.error(e) response["database"] = "ERROR" try: mongo.connection.server_info() response["document_store"] = "OK" except Exception as e: app.logger.error(e) response["document_store"] = "ERROR" return response
cd47815ada53281f2b13542dd8cad93398be5203
11,386
def find_ad_adapter(bus): """Find the advertising manager interface. :param bus: D-Bus bus object that is searched. """ remote_om = dbus.Interface( bus.get_object(constants.BLUEZ_SERVICE_NAME, '/'), constants.DBUS_OM_IFACE) objects = remote_om.GetManagedObjects() for o, props in objects.items(): if constants.LE_ADVERTISING_MANAGER_IFACE in props: return o return None
6b5f49a5908948a54f99438a38865293fca51cc7
11,387
def leaky_relu(x, slope=0.2): """Leaky Rectified Linear Unit function. This function is expressed as :math:`f(x) = \max(x, ax)`, where :math:`a` is a configurable slope value. Args: x (~chainer.Variable): Input variable. slope (float): Slope value :math:`a`. Returns: ~chainer.Variable: Output variable. """ return LeakyReLU(slope)(x)
cf7624309543e24c70832249116b74d56c26d1f9
11,388
def GetConfig(user_config): """Decide number of vms needed to run oldisim.""" config = configs.LoadConfig(BENCHMARK_CONFIG, user_config, BENCHMARK_NAME) config['vm_groups']['default']['vm_count'] = (FLAGS.oldisim_num_leaves + NUM_DRIVERS + NUM_ROOTS) return config
b04380fe6dbc84ef4c353dd34354581fa69aac89
11,389
import os import shutil def build_tstuser_dir(username): """ Create a directory with files and return its structure in a list. :param username: str :return: tuple """ # md5("foo") = "acbd18db4cc2f85cedef654fccc4a4d8" # md5("bar") = "37b51d194a7513e45b56f6524f2d51f2" # md5("spam") = "e09f6a7593f8ae3994ea57e1117f67ec" file_contents = [ ('spamfile', 'spam', 'e09f6a7593f8ae3994ea57e1117f67ec'), (os.path.join('subdir', 'foofile.txt'), 'foo', 'acbd18db4cc2f85cedef654fccc4a4d8'), (os.path.join('subdir', 'barfile.md'), 'bar', '37b51d194a7513e45b56f6524f2d51f2'), ] user_root = userpath2serverpath(username) # If directory already exists, destroy it if os.path.isdir(user_root): shutil.rmtree(user_root) os.mkdir(user_root) expected_timestamp = None expected_snapshot = {} for user_filepath, content, md5 in file_contents: expected_timestamp = int(_create_file(username, user_filepath, content)) expected_snapshot[user_filepath] = [expected_timestamp, unicode(md5)] return expected_timestamp, expected_snapshot
bb6b62a11a778f83cd8161077dbcab5afb40d64c
11,390
import re def gen_answer(question, passages): """由于是MLM模型,所以可以直接argmax解码。 """ all_p_token_ids, token_ids, segment_ids = [], [], [] for passage in passages: passage = re.sub(u' |、|;|,', ',', passage) p_token_ids, _ = tokenizer.encode(passage, maxlen=max_p_len + 1) q_token_ids, _ = tokenizer.encode(question, maxlen=max_q_len + 1) all_p_token_ids.append(p_token_ids[1:]) token_ids.append([tokenizer._token_start_id]) token_ids[-1] += ([tokenizer._token_mask_id] * max_a_len) token_ids[-1] += [tokenizer._token_end_id] token_ids[-1] += (q_token_ids[1:] + p_token_ids[1:]) segment_ids.append([0] * len(token_ids[-1])) token_ids = sequence_padding(token_ids) segment_ids = sequence_padding(segment_ids) probas = model.predict([token_ids, segment_ids]) results = {} for t, p in zip(all_p_token_ids, probas): a, score = tuple(), 0. for i in range(max_a_len): idxs = list(get_ngram_set(t, i + 1)[a]) if tokenizer._token_end_id not in idxs: idxs.append(tokenizer._token_end_id) # pi是将passage以外的token的概率置零 pi = np.zeros_like(p[i]) pi[idxs] = p[i, idxs] a = a + (pi.argmax(),) score += pi.max() if a[-1] == tokenizer._token_end_id: break score = score / (i + 1) a = tokenizer.decode(a) if a: results[a] = results.get(a, []) + [score] results = { k: (np.array(v)**2).sum() / (sum(v) + 1) for k, v in results.items() } return results
536880c1318cc193be19561183e652c7668eb09b
11,391
def compile(function_or_sdfg, *args, **kwargs): """ Obtain a runnable binary from a Python (@dace.program) function. """ if isinstance(function_or_sdfg, dace.frontend.python.parser.DaceProgram): sdfg = dace.frontend.python.parser.parse_from_function( function_or_sdfg, *args, **kwargs) elif isinstance(function_or_sdfg, SDFG): sdfg = function_or_sdfg else: raise TypeError("Unsupported function type") return sdfg.compile(**kwargs)
7504344e8e9df5a395e51af1211db286188f3fcb
11,392
import re def is_untweeable(html): """ I'm not sure at the moment what constitutes untweeable HTML, but if we don't find DVIS in tiddlywiki, that is a blocker """ # the same regex used in tiddlywiki divs_re = re.compile( r'<div id="storeArea"(.*)</html>', re.DOTALL ) return bool(divs_re.search(html))
face6c6d30b6e26ffa3344ed8e42ed7d44cf2ea5
11,393
from typing import Optional def create_1m_cnn_model(only_digits: bool = False, seed: Optional[int] = 0): """A CNN model with slightly under 2^20 (roughly 1 million) params. A simple CNN model for the EMNIST character recognition task that is very similar to the default recommended model from `create_conv_dropout_model` but has slightly under 2^20 parameters. This is useful if the downstream task involves randomized Hadamard transform, which requires the model weights / gradients / deltas concatednated as a single vector to be padded to the nearest power-of-2 dimensions. This model is used in https://arxiv.org/abs/2102.06387. When `only_digits=False`, the returned model has 1,018,174 trainable parameters. For `only_digits=True`, the last dense layer is slightly smaller. Args: only_digits: If True, uses a final layer with 10 outputs, for use with the digits only EMNIST dataset. If False, uses 62 outputs for the larger dataset. seed: A random seed governing the model initialization and layer randomness. Returns: A `tf.keras.Model`. """ data_format = 'channels_last' initializer = tf.keras.initializers.GlorotUniform(seed=seed) model = tf.keras.models.Sequential([ tf.keras.layers.Conv2D( 32, kernel_size=(3, 3), activation='relu', data_format=data_format, input_shape=(28, 28, 1), kernel_initializer=initializer), tf.keras.layers.MaxPool2D(pool_size=(2, 2), data_format=data_format), tf.keras.layers.Conv2D( 64, kernel_size=(3, 3), activation='relu', data_format=data_format, kernel_initializer=initializer), tf.keras.layers.Dropout(0.25), tf.keras.layers.Flatten(), tf.keras.layers.Dense( 128, activation='relu', kernel_initializer=initializer), tf.keras.layers.Dropout(0.5), tf.keras.layers.Dense( 10 if only_digits else 62, activation=tf.nn.softmax, kernel_initializer=initializer), ]) return model
87353f8bd8e3b3d7602ad3dcd92b717b2590285b
11,394
def _check_index(target_expr, index_expr): """ helper function for making sure that an index is valid :param target_expr: the target tensor :param index_expr: the index :return: the index, wrapped as an expression if necessary """ if issubclass(index_expr.__class__, _Expression): index = index_expr else: index = _ConstScalar(index_expr) if index.proto_expr.dtype is lang.UNDEFINED_TYPE: raise TypeError('Can only index with a scalar.') if type(index) is _ConstScalar: if target_expr.size <= index.value() or index.value() < 0: raise IndexError('Index out of bounds.') return index
96d5bf6d6d19bfca0de30ea9915a38237cf9c80f
11,395
def create_access_token(user: UserModel, expires_delta: timedelta = None) -> str: """ Create an access token for a user :param user: CTSUser -> The user :param expires_delta: timedelta -> The expiration of the token. If not given a default will be used :return: str -> A token """ load_all_config() to_encode = user.dict() if not expires_delta: expires_delta = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) return __generate_jwt_token(to_encode, expires_delta)
d5ba53f0ecc7e7755988ad2540e4cd4c520b30dd
11,396
def is_async_mode(): """Tests if we're in the async part of the code or not.""" async def f(): """Unasync transforms async functions in sync functions.""" return None obj = f() if obj is None: return False obj.close() # prevent unawaited coroutine warning return True
8e515efc767f75c4b90486089f0d8a7203da59d7
11,397
def remove_arm(frame): """ Removes the human arm portion from the image. """ ##print("Removing arm...") # Cropping 15 pixels from the bottom. height, width = frame.shape[:2] frame = frame[:height - 15, :] ##print("Done!") return frame
99b998da87f1aa2eca0a02b67fc5adc411603ee4
11,398
def cumulative_spread(array, x): """ >>> import numpy as np >>> a = np.array([1., 2., 3., 4.]) >>> cumulative_spread(a, 0.) array([0., 0., 0., 0.]) >>> cumulative_spread(a, 5.) array([1., 2., 2., 0.]) >>> cumulative_spread(a, 6.) array([1., 2., 3., 0.]) >>> cumulative_spread(a, 12.) array([1., 2., 3., 4.]) """ # This is probably inefficient. cumulative_effect = np.cumsum(array) - array b = x - cumulative_effect return np.fmin(array, np.fmax(0, b))
c6966a97945f30cce6a794325091a31716a36e54
11,399