content
stringlengths
35
762k
sha1
stringlengths
40
40
id
int64
0
3.66M
def residual_block(filters, repetitions,kernel_size=(3,3),strides=(2,2), is_first_layer=False): """Builds a residual block with repeating bottleneck blocks. """ def f(input): for i in range(repetitions): init_strides = (1, 1) if i == 0 and not is_first_layer: init_strides = strides input = basic_block(filters=filters,kernel_size=kernel_size, init_strides=init_strides, is_first_block_of_first_layer=(is_first_layer and i == 0))(input) return input return f
d3771289e034c4cd06f38caa715c925d7b947ab1
9,500
def vpg_omega(X,Y,Gamma=1, sigma=1, polarIn=False): """ Vorticity distribution for 2D Gaussian vortex patch """ if polarIn: r = X else: r = np.sqrt(X ** 2 + Y ** 2) omega_z = Gamma/(np.pi*sigma) * (np.exp(- r**2/sigma**2)) return omega_z
d7964152c9d21defc395e2a31d8709fe9c5d94c8
9,501
from typing import Tuple def get_outgroup(tree: CassiopeiaTree, triplet: Tuple[str, str, str]) -> str: """Infers the outgroup of a triplet from a CassioepiaTree. Finds the outgroup based on the depth of the latest-common-ancestors of each pair of items. The pair with the deepest LCA is the ingroup and the remaining leaf is the outgroup. We infer the depth of the LCA from the number of shared ancestors. Args: tree: CassiopeiaTree triplet: A tuple of three leaves constituting a triplet. Returns: The outgroup (i.e. the most distal leaf in the triplet.) """ i, j, k = triplet[0], triplet[1], triplet[2] i_ancestors = tree.get_all_ancestors(i) j_ancestors = tree.get_all_ancestors(j) k_ancestors = tree.get_all_ancestors(k) ij_common = len(set(i_ancestors) & set(j_ancestors)) ik_common = len(set(i_ancestors) & set(k_ancestors)) jk_common = len(set(j_ancestors) & set(k_ancestors)) out_group = "None" if ij_common > jk_common and ij_common > ik_common: out_group = k elif ik_common > jk_common and ik_common > ij_common: out_group = j elif jk_common > ij_common and jk_common > ik_common: out_group = i return out_group
c48e7121a8622876b6fb1269f881da4afe9cd8da
9,502
from unittest.mock import call def delete_host(resource_root, host_id): """ Delete a host by id @param resource_root: The root Resource object. @param host_id: Host id @return: The deleted ApiHost object """ return call(resource_root.delete, "%s/%s" % (HOSTS_PATH, host_id), ApiHost)
8d4349c0722517e0f4f8d74ea74b2d74bbc08227
9,503
from typing import Union from typing import Tuple from typing import List def get_preds(model: nn.Module, image: Union[np.array, str], **kwargs) -> Tuple[List]: """ Generated predictions for the given `image` using `model`. """ logger = _get_logger(name=__name__) # load in the image if string is give if isinstance(image, str): image = Image.open(image).convert("RGB") # Convert PIL image to array image = np.array(image) # Convert Image to a tensor tensor_image = transforms(image=image)["image"] # Generate predicitons model.eval() pred = model.predict([tensor_image]) # Gather the bbox, scores & labels from the preds pred_boxes = pred[0]["boxes"] # Bounding boxes pred_class = pred[0]["labels"] # predicted class labels pred_score = pred[0]["scores"] # predicted scores # Process detections boxes = list(pred_boxes.cpu().numpy()) clas = list(pred_class.cpu().numpy()) scores = list(pred_score.cpu().numpy()) return boxes, clas, scores
8778f43fd65bccca8fc9372454aba2a7cd2544d5
9,504
async def unblock_func(func_name:object, func_args, logger=None, default_res=None, is_new_loop=False,): """ 异步函数非阻塞 :param func_name: def 函数对象名 :param func_args: 请求参数可迭代对象(必须遵循元素入参顺序!) :param logger: :param default_res: 默认返回结果 :param is_new_loop: 是否开启新loop, True容易造成OSError, too many file open错误 :return: """ # todo notice: 一个进程/线程只能一个 event loop loop = get_event_loop() if not is_new_loop else new_event_loop() try: default_res = await loop.run_in_executor(None, func_name, *func_args) except Exception as e: _print(msg='遇到错误:', logger=logger, log_level=2, exception=e) finally: # loop.close() try: del loop except: pass collect() return default_res
a8f0a6f4f1171f01df4b637ca002c30efc8954e0
9,505
from typing import Dict from typing import Tuple import re def replace_if_has_wiki_link(line: str, folder_dict: Dict) -> Tuple[str, int]: """ ^title :return: (string with all wikis replaced, replacement count) """ embed_rule = re.compile(re_md_reference) wiki_partial_rule = re.compile(re_md_wiki_partial) wiki_rule = re.compile(re_md_wiki) new_line = line wiki_count = 0 # ![[xxxx.png]] -> ![xxx](...xxxx.png) while (match := re.search(embed_rule, new_line)): new_line = handle_rewrite(match, new_line, folder_dict, "embed") wiki_count += 1 # [[xxxx|yyy]] -> [[yyy]](...xxxx.md) todo: not implemented while (match := re.search(wiki_partial_rule, new_line)): new_line = handle_rewrite(match, new_line, folder_dict, "md_partial") wiki_count += 1 # [[xxxx]] -> [xxx](...xxxx.md) while (match := re.search(wiki_rule, new_line)): new_line = handle_rewrite(match, new_line, folder_dict, "md") wiki_count +=1 # new_line=line if no changes made return new_line, wiki_count
5e7a1111685e5543a6624756809da59ae4b37f47
9,506
def init_w(w, n): """ :purpose: Initialize a weight array consistent of 1s if none is given This is called at the start of each function containing a w param :params: w : a weight vector, if one was given to the initial function, else None NOTE: w MUST be an array of np.float64. so, even if you want a boolean w, convert it to np.float64 (using w.astype(np.float64)) before passing it to any function n : the desired length of the vector of 1s (often set to len(u)) :returns: w : an array of 1s with shape (n,) if w is None, else return w un-changed """ if w is None: return np.ones(n) else: return w
2157f12410c2a909a32f37b9fcae4a489361fb6e
9,507
def _ensure_min_resources(progs, cores, memory, min_memory): """Ensure setting match minimum resources required for used programs. """ for p in progs: if p in min_memory: if not memory or cores * memory < min_memory[p]: memory = float(min_memory[p]) / cores return cores, memory
f311259242a73a7bc527e3601765c95153a08748
9,508
import ctypes def ctypes_pointer(name): """Create a ctypes type representing a C pointer to a custom data type ``name``.""" return type("c_%s_p" % name, (ctypes.c_void_p,), {})
d87f10ac06391379a24f166272fd42fa938e3676
9,509
def generate_linear_data(n, betas, sigma): """Generate pandas df with x and y variables related by a linear equation. Export data as csv. :param n: Number of observations. :param betas: beta parameters. :param sigma: standard deviation :return: None """ x = np.linspace(start=0.0, stop=1.0, num=n) y = betas[0] + betas[1]*x + np.random.normal(loc=1, scale=sigma, size=n) df = pd.DataFrame({'x': x, 'y': y}) df.to_csv('data/train_data.csv', index=False) return None
2f8b99a3c11ecf75afee51bd5df31f22efaddf58
9,510
def entry( text, *, foreground: str = "", background: str = "", sgr: str = "", jump_line: str = "\n> ", ) -> str: """ This function is derived from the input, but with the option of coloring it and some different formatting. Note: If you use Windows, the coloring option will not work. >>> from snakypy.helpers import entry, FG >>> entry("What's your name?", foreground=FG().QUESTION) ➜ What's your name? > 'snakypy' >>> entry("What's your name?", foreground=FG().BLUE) ➜ What's your name? > 'snakypy' >>> entry("What's your name?", foreground=FG().GREEN) ➜ What's your name? > 'snakypy' Args: text (object): Argument must receive an object foreground (str): This named argument should optionally receive \ an object of class "snakypy.helpers.ansi.FG" for the foreground \ color of the text. This object will be text with ansi code. \ (default: '') background (str): This named argument should optionally receive \ an object of class "snakypy.helpers.ansi.BG" for the background \ color of the text. This object will be text with ansi code. \ (default: '') sgr (str): This named argument should optionally receive \ an object of class "snakypy.helpers.ansi.SGR" for the effect \ of the text. This object will be text with ansi code. \ (default: '') jump_line (str): Named argument that makes the action of skipping a line \ and adding a greater sign to represent an arrow. You change \ that argument to your liking. (default: '[bar]n> ') \ """ # TODO: DEPRECATED # check_fg_bg_sgr(FG, BG, SGR, foreground, background, sgr) try: return input(f"{NONE}{sgr}{foreground}{background}{text}{jump_line}{NONE}") except KeyboardInterrupt: print(f"\n{FG().WARNING} Aborted by user.{NONE}") return "Aborted by user." except TypeError: print(f"\n{FG().ERROR} Input value not defined.{NONE}") return "Input value not defined."
c0bbbf5bfc675407088a3d820e3a543d9ad167c9
9,511
def vrotate_3D(vec: np.ndarray, ref: np.ndarray) -> np.ndarray: """Rotates a vector in a 3D space. Returns the rotation matrix for `vec` to match the orientation of a reference vector `ref`. https://math.stackexchange.com/questions/180418/calculate-rotation-matrix-to-align-vector-a-to-vector-b-in-3d/476311#476311 Parameters ---------- vec Vector to rotate, as a numpy 1D array ref Reference vector, as a numpy 1D array Returns ------- np.ndarray (3,3) rotation matrix, as a numpy 2D array """ def norm(A): return sqrt(np.dot(A, A)) # G = np.matrix([ # [np.dot(A, B), -norm(np.cross(A, B)), 0.0], # [norm(np.cross(A, B)), np.dot(A, B), 0.0], # [0.0, 0.0, 1.0] # ]) # F = np.matrix([ # A, # (B-np.dot(A, B)*A)/norm(B-np.dot(A, B)*A), # np.cross(B, A)/norm(np.cross(B, A)) # ]) # return F.I*G*F V = np.cross(vec, ref) S = norm(V) if abs(S) < 1.0e-6: # Already collinear, nothing to do return np.eye(3) else: C = np.dot(vec, ref) Vx = np.matrix([[0.0, -V[2], V[1]], [V[2], 0.0, -V[0]], [-V[1], V[0], 0.0]]) return np.eye(3) + Vx + Vx**2*(1.0-C)/S**2
4cea9d84d8fba2dd5bd9399b83ca9f1aca79b830
9,512
def asymptotic_decay(learning_rate, t, max_iter): """Decay function of the learning process. Parameters ---------- learning_rate : float current learning rate. t : int current iteration. max_iter : int maximum number of iterations for the training. """ return learning_rate / (1+t/(max_iter/2))
7cc699caed4ddcbde67f5d6e4199fc8479364585
9,513
def get_cell_content(browser, author): """ get novel cells return [cell, cell, cell] """ content = list() cells = browser.find_all(class_='t t2') for cell in cells: if cell.find(class_='r_two').b.string != author: continue for cell_content in cell.find(class_=['tpc_content do_not_catch', 'tpc_content']).strings: content.append(cell_content.strip()) return "\n".join(content)
eb498d937b8ffd51ef7805a30940833e09571ed5
9,514
def triangle_area(a, h): """Given length of a side and high return area for a triangle. >>> triangle_area(5, 3) 7.5 """ #[SOLUTION] return a * h / 2.0
9890d5e8332e667fab6dd672f62ca852f6f8f8c0
9,515
from nicos.core import ConfigurationError import urllib import logging def create_mongo_handler(config): """ :param config: configuration dictionary :return: [MongoLogHandler, ] if 'mongo_logger' is in options, else [] """ if hasattr(config, 'mongo_logger'): url = urllib.parse.urlparse(config.mongo_logger) if not url.netloc: raise ConfigurationError('mongo_logger: invalid url') mongo_handler = MongoLogHandler() mongo_handler.setLevel(logging.WARNING) return mongo_handler
c7ac39574a21c44519ae57c6fb40b8f6ca679311
9,516
def split_and_load(data, ctx_list, batch_axis=0, even_split=True): """Splits an NDArray into `len(ctx_list)` slices along `batch_axis` and loads each slice to one context in `ctx_list`. Parameters ---------- data : NDArray A batch of data. ctx_list : list of Context A list of Contexts. batch_axis : int, default 0 The axis along which to slice. even_split : bool, default True Whether to force all slices to have the same number of elements. Returns ------- list of NDArray Each corresponds to a context in `ctx_list`. """ if len(ctx_list) == 1: return [d.as_in_context(ctx_list[0]) for d in data] size = len(data) num_slice = len(ctx_list) step = size // num_slice for i in range(num_slice): for k in range(i*step, (i+1)*step): data[k].as_in_context(ctx_list[i]) return data
4b8f0d1b6b256895da3e37fbb4b1be0cd0da5c46
9,517
def _get_scoped_outputs(comp, g, explicit_outs): """Return a list of output varnames scoped to the given name.""" cnamedot = comp.name + '.' outputs = set() if explicit_outs is None: explicit_outs = () for u,v in g.list_connections(): if u.startswith(cnamedot): outputs.add(u) outputs.update([n for n in explicit_outs if n.startswith(cnamedot)]) if not outputs: return None return [n.split('.',1)[1] for n in outputs]
8ff2cfe49dc3d892c4ed4adaeb9300e9395c790b
9,518
def judge_1d100_with_6_ver(target: int, dice: int): """ Judge 1d100 dice result, and return text and color for message. Result is critical, success, failure or fumble. Arguments: target {int} -- target value (ex. skill value) dice {int} -- dice value Returns: message {string} rgb_color {string} """ if dice <= target: if dice <= 5: return "クリティカル", yig.config.COLOR_CRITICAL return "成功", yig.config.COLOR_SUCCESS if dice >= 96: return "ファンブル", yig.config.COLOR_FUMBLE return "失敗", yig.config.COLOR_FAILURE
f870f6ffee3bb90046eb2f1660e827b899c59f04
9,519
def get_normals(self, indices=None, loc="center"): """Return the array of the normals coordinates. Parameters ---------- self : MeshVTK a MeshVTK object indices : list list of the points to extract (optional) loc : str localization of the normals ("center" or "point") Returns ------- normals: ndarray Normals coordinates """ # Get surfaces surf = self.get_surf() if loc == "center": normals = surf.cell_normals elif loc == "point": if self.node_normals is None: self.surf.compute_normals( cell_normals=False, point_normals=True, inplace=True ) self.node_normals = self.surf["Normals"] normals = self.node_normals if indices is None: return normals else: return normals[indices, :]
5d08247f70e1012eef7d525ae63f7aebe294e700
9,520
def string_to_weld_literal(s): """ Converts a string to a UTF-8 encoded Weld literal byte-vector. Examples -------- >>> string_to_weld_literal('hello') '[104c,101c,108c,108c,111c]' """ return "[" + ",".join([str(b) + 'c' for b in list(s.encode('utf-8'))]) + "]"
d85b016091988c9307cbed56aafdd5766c3c9be5
9,521
def verify_model_licensed(class_name : str, model_path:str): """ Load a licensed model from HDD """ try : m = eval(class_name).load(model_path) return m except: print(f"Could not load Annotator class={class_name} located in {model_path}. Try updaing spark-nlp-jsl")
057987d838982a85925f70c93ff2f4166b038cec
9,522
def examine_api(api): """Find all style issues in the given parsed API.""" global failures failures = {} for key in sorted(api.keys()): examine_clazz(api[key]) return failures
c94efa9a2be66e30597c63b376adf74bd2ef6462
9,523
from logging.handlers import RotatingFileHandler import sys from pathlib import Path import logging def enable_logging_app_factory(log_file: Path, level) -> logging.Logger: """ Enable logging for the system. :param level: Logging Level :param log_file: Log File path :return: """ logger = logging.getLogger(LOGGER) formatter = logging.Formatter(LOGGER + ': %(asctime)s %(levelname)7s: %(message)s') fileHandler = RotatingFileHandler(log_file, mode="a+", maxBytes=5000000, backupCount=5) fileHandler.setFormatter(formatter) consoleHandler = logging.StreamHandler(sys.stdout) consoleHandler.setFormatter(formatter) consoleHandler.setLevel(logging.INFO) logger.setLevel(level) logger.addHandler(fileHandler) logger.addHandler(consoleHandler) return logger
827b99db1980c826bdebd0cfe0c559d6d1647ce8
9,524
def launch(): """ Initialize the module. """ return BinCounterWorker(BinCounter, PT_STATS_RESPONSE, STATS_RESPONSE)
07bfc99731088a8572616aa1cbfbd0be74db5492
9,525
def make_map(source): """Creates a Bokeh figure displaying the source data on a map Args: source: A GeoJSONDataSource object containing bike data Returns: A Bokeh figure with a map displaying the data """ tile_provider = get_provider(Vendors.STAMEN_TERRAIN_RETINA) TOOLTIPS = [ ('bikes available', '@bikes'), ] p = figure(x_range=(-8596413.91, -8558195.48), y_range=(4724114.13, 4696902.60), x_axis_type="mercator", y_axis_type="mercator", width=1200, height=700, tooltips=TOOLTIPS) p.add_tile(tile_provider) p.xaxis.visible = False p.yaxis.visible = False p.circle(x='x', y='y', size='size', color='color', alpha=0.7, source=source) color_bar_palette = viridis(256) color_mapper = LinearColorMapper(palette=color_bar_palette, low=0, high=100) color_bar = ColorBar(color_mapper=color_mapper, background_fill_alpha=0.7, title='% Full', title_text_align='left', title_standoff=10) p.add_layout(color_bar) label = Label(x=820, y=665, x_units='screen', y_units='screen', text='Dot size represents total docks in station', render_mode='css', border_line_color=None, background_fill_color='white', background_fill_alpha=0.7) p.add_layout(label) return p
51578186a1fabd071e31e46b20568c23c79bc693
9,526
import os def save_all_pages(pages, root='.'): """Save picture references in pages on the form: pages = { urn1 : [page1, page2, ..., pageN], urn2: [page1, ..., pageM]}, ... urnK: [page1, ..., pageL] } Each page reference is a URL. """ # In case urn is an actual URN, works also if urn is passed as sesamid for urn in pages: folder_name = urn.split(':')[-1] folder_ref = os.path.join(root, folder_name) try: os.mkdir(folder_ref) except FileExistsError: True for p in pages[urn]: # pell ut entydig referanse til bildet fra URL-en i bildelisten som filnavn filename = p.split('/')[6].split(':')[-1] + '.jpg' path = os.path.join(folder_ref, filename) get_picture_from_url(p).save(path) return True
5472be4a2d6f84eef9a256eb114e9d3ce17a5375
9,527
def rotate_images(images, rot90_scalars=(0, 1, 2, 3)): """Return the input image and its 90, 180, and 270 degree rotations.""" images_rotated = [ images, # 0 degree tf.image.flip_up_down(tf.image.transpose_image(images)), # 90 degrees tf.image.flip_left_right(tf.image.flip_up_down(images)), # 180 degrees tf.image.transpose_image(tf.image.flip_up_down(images)) # 270 degrees ] results = tf.stack([images_rotated[i] for i in rot90_scalars]) results = tf.reshape(results, [-1] + images.get_shape().as_list()[1:]) return results
dd151b83918eba9b62a91b499273772e66af6ba9
9,528
def csv(args:[str])->str: """create a string of comma-separated values""" return ','.join(args)
1e48583c236940f2af10f8e050af8ad70ace51f6
9,529
import types def _update_class(oldclass, newclass): """Update a class object.""" # XXX What about __slots__? olddict = oldclass.__dict__ newdict = newclass.__dict__ # PDF changed to remove use of set as not in Jython 2.2 for name in olddict.keys(): if name not in newdict: delattr(oldclass, name) for name in newdict.keys(): if name not in ["__dict__", "__doc__"]: if name not in olddict: setattr(oldclass, name, newdict[name]) continue new = getattr(newclass, name) old = getattr(oldclass, name, None) if new == old: continue if old is None: setattr(oldclass, name, new) continue if isinstance(new, types.MethodType): changed = _update_method(old, new) setattr(oldclass, name, changed) elif isinstance(new, types.FunctionType): # __init__ is a function changed = _update_function(old, new) setattr(oldclass, name, changed) else: # Fallback to just replace the item setattr(oldclass, name, new) return oldclass
123eb4eadf7bf6ee65ae5df6ae9ed6df444c25d3
9,530
import google def update_signature(): """Create and update signature in gmail. Returns:Draft object, including updated signature. Load pre-authorized user credentials from the environment. TODO(developer) - See https://developers.google.com/identity for guides on implementing OAuth2 for the application. """ creds, _ = google.auth.default() try: # create gmail api client service = build('gmail', 'v1', credentials=creds) primary_alias = None # pylint: disable=E1101 aliases = service.users().settings().sendAs().list(userId='me')\ .execute() for alias in aliases.get('sendAs'): if alias.get('isPrimary'): primary_alias = alias break send_as_configuration = { 'displayName': primary_alias.get('sendAsEmail'), 'signature': 'Automated Signature' } # pylint: disable=E1101 result = service.users().settings().sendAs() \ .patch(userId='me', sendAsEmail=primary_alias.get('sendAsEmail'), body=send_as_configuration).execute() print(F'Updated signature for: {result.get("displayName")}') except HttpError as error: print(F'An error occurred: {error}') result = None return result.get('signature')
77e9a9aef4b1ab1471cf147f57008874497d28e3
9,531
def generate_block(constraints, p, rng=None): """Generated a balanced set of trials, might be only part of a run.""" if rng is None: rng = np.random.RandomState() n_trials = constraints.trials_per_run # --- Assign trial components # Assign the target to a side gen_dist = np.repeat([0, 1], n_trials // 2) while max_repeat(gen_dist) > constraints.max_dist_repeat: gen_dist = rng.permutation(gen_dist) # Assign pulse counts to each trial count_support = np.arange(p.pulse_count[-1], p.pulse_count_max) + 1 count_pmf = trunc_geom_pmf(count_support, p.pulse_count[1]) expected_count_dist = count_pmf * n_trials count_error = np.inf while count_error > constraints.sum_count_error: pulse_count = flexible_values(p.pulse_count, n_trials, rng, max=p.pulse_count_max).astype(int) count_dist = np.bincount(pulse_count, minlength=p.pulse_count_max + 1) count_error = np.sum(np.abs(count_dist[count_support] - expected_count_dist)) # Assign initial ITI to each trial total_iti = np.inf while not_in_range(total_iti, constraints.iti_range): wait_iti = flexible_values(p.wait_iti, n_trials, rng) total_iti = wait_iti.sum() # Use the first random sample if we're not being precise # about the overall time of the run (i.e. in psychophys rig) if not p.keep_on_time: break # --- Build the trial_info structure trial = np.arange(1, n_trials + 1) trial_info = pd.DataFrame(dict( trial=trial, gen_dist=gen_dist, pulse_count=pulse_count.astype(int), wait_iti=wait_iti, )) # --- Assign trial components # Map from trial to pulse trial = np.concatenate([ np.full(c, i, dtype=np.int) for i, c in enumerate(pulse_count, 1) ]) pulse = np.concatenate([ np.arange(c) + 1 for c in pulse_count ]) n_pulses = pulse_count.sum() # Assign gaps between pulses run_duration = np.inf while not_in_range(run_duration, constraints.run_range): wait_pre_stim = flexible_values(p.pulse_gap, n_trials, rng) gap_dur = flexible_values(p.pulse_gap, n_pulses, rng) run_duration = np.sum([ wait_iti.sum(), wait_pre_stim.sum(), gap_dur.sum(), p.pulse_dur * n_pulses, ]) # Use the first random sample if we're not being precise # about the overall time of the run (i.e. in psychophys rig) if not p.keep_on_time: break # Assign pulse intensities max_contrast = np.log10(1 / np.sqrt(p.stim_gratings)) log_contrast = np.zeros(n_pulses) pulse_dist = np.concatenate([ np.full(n, i, dtype=np.int) for n, i in zip(pulse_count, gen_dist) ]) llr_mean = np.inf llr_sd = np.inf expected_acc = np.inf while (not_in_range(llr_mean, constraints.mean_range) or not_in_range(llr_sd, constraints.sd_range) or not_in_range(expected_acc, constraints.acc_range)): for i in [0, 1]: dist = "norm", p.dist_means[i], p.dist_sds[i] rows = pulse_dist == i n = rows.sum() log_contrast[rows] = flexible_values(dist, n, rng, max=max_contrast) pulse_llr = compute_llr(log_contrast, p) target_llr = np.where(pulse_dist, pulse_llr, -1 * pulse_llr) llr_mean = target_llr.mean() llr_sd = target_llr.std() dv = pd.Series(target_llr).groupby(pd.Series(trial)).sum() dv_sd = np.sqrt(constraints.sigma ** 2 * pulse_count) expected_acc = stats.norm(dv, dv_sd).sf(0).mean() # --- Build the pulse_info structure pulse_info = pd.DataFrame(dict( trial=trial, pulse=pulse, gap_dur=gap_dur, log_contrast=log_contrast, contrast=10 ** log_contrast, pulse_llr=pulse_llr, )) # --- Update the trial_info structure trial_info["wait_pre_stim"] = wait_pre_stim trial_llr = (pulse_info .groupby("trial") .sum() .loc[:, "pulse_llr"] .rename("trial_llr")) trial_info = trial_info.join(trial_llr, on="trial") # TODO reorder the columns so they are more intuitively organized? return trial_info, pulse_info
3c712f94e6fc4e7b5317f13a733afd1c13d7a723
9,532
def mean_by_weekday(day, val): """ Returns a list that contain weekday, mean of beginning and end of presence. """ return [day_abbr[day], mean(val['start']), mean(val['end'])]
8aa7ac3dde83db88b44d2178ba19c5b731af683c
9,533
def parse_metrics(match, key): """Gets the metrics out of the parsed logger stream""" elements = match.split(' ')[1:] elements = filter(lambda x: len(x) > 2, elements) elements = [float(e) for e in elements] metrics = dict(zip(['key', 'precision', 'recall', 'f1'], [key] + elements)) return metrics
70de1ad16edfe827e0a851c719d902695696700f
9,534
def minecraftify(clip: vs.VideoNode, div: float = 64.0, mod: int | None = None) -> vs.VideoNode: """ Function that transforms your clip into a Minecraft. Idea from Meme-Maji's Kobayashi memery (love you varde). :param clip: Input clip :param div: How much to divide the clip's resolution with :param mod: Force the downscaled clip to be MOD# compliant :return: A Minecraft. """ ow, oh = round(clip.width/div), round(clip.height/div) if mod is not None: ow, oh = force_mod(ow, mod), force_mod(oh, mod) i444 = core.resize.Bicubic(clip, format=vs.YUV444PS) down = Point().scale(i444, ow, oh) return Point().scale(down, clip.width, clip.height)
4f8338cfe2df8bff8d4f2c7571fa38688e39496c
9,535
def processGOTerm(goTerm): """ In an object representing a GO term, replace single-element lists with their only member. Returns the modified object as a dictionary. """ ret = dict(goTerm) #Input is a defaultdict, might express unexpected behaviour for key, value in ret.items(): if len(value) == 1: ret[key] = value[0] return ret
541916a0060726bbc972b784f9a011541e7c8128
9,536
import urllib def searchxapian_show(request): """ zeigt den Inhalt eines Dokumentes """ SORT_BY = { -1: _(u'Relevanz'), 0: _(u'URL'), 1: _(u'Überschrift/Titel'), 2: _(u'Datum der letzten Änderung') } if request.path.find('index.html') < 0: my_path = request.path.replace('searchxapian', 'index.html/searchxapian') else: my_path = request.path item_container = get_item_container(my_path, '/searchxapian/') def get_sort_by_choices(): ret = [] ret.append((-1, SORT_BY[-1])) # Siehe SORT_BY ret.append((0, SORT_BY[0])) ret.append((1, SORT_BY[1])) ret.append((2, SORT_BY[2])) return ret def get_domain_choices(): """ """ ret = [] ret.append( ('', _(u'Alle Seiten')) ) if item_container != None: url = item_container.container.site.url[7:] ret.append( (url, _(u'Nur Seiten der Domaine <i>') + url + '</i>') ) return ret class DmsItemForm(forms.Form): query = forms.CharField(required=False, max_length=60, widget=forms.TextInput(attrs={'size':60}) ) sort_by = forms.CharField( widget=forms.Select(choices= get_sort_by_choices(), attrs={'size':4, 'style':'width:60%'} ) ) domain = forms.ChoiceField(required=False, choices=get_domain_choices(), widget=forms.RadioSelect() ) def get_prev_next(query, offset, delta, domain, sort_by, count): aquery = u'query=%s' % urllib.quote_plus(query) if domain == '': site = '' else: site = '&domain=' + domain show_prev = '' show_next = '' show_middle = '' n_start = 0 if count > offset + 10*delta: show_next_more = True count = offset + 10*delta else: show_next_more = False if offset > 10*delta: show_prev_more = True n_start = offset - 10*delta else: show_prev_more = False n = n_start while n < count: if n < offset: show_prev += show_link(u'./?%s&offset=%i&sort_by=%i%s' % (aquery, n, sort_by, site), smart_unicode(n), url_class='navLink') + ' ' elif n == offset: show_middle = '<b>%i</b> ' % n else: show_next += show_link(u'./?%s&offset=%i&sort_by=%i%s' % \ (aquery, n, sort_by, site), smart_unicode(n), url_class='navLink') + ' ' n += delta if show_next_more: show_next += show_link(u'./?%s&offset=%i&sort_by=%i%s' % \ (aquery, n, sort_by, site), ' &raquo; Weiter', url_class='navLink') if show_prev_more: show_prev = show_link(u'./?%s&offset=%i&sort_by=%i%s' % \ (aquery, n_start-delta, sort_by, site), 'Zurück &laquo; ', url_class='navLink') + show_prev if count < delta: show_middle = '' return show_prev, show_middle, show_next def get_search_results(request): sort_by = -1 offset = 0 delta = 20 count = -1 if show_errors: data = request.POST.copy() query = data['query'] domain = data['domain'] else: data = { 'query': '', 'sort_by': -1,} query = '' domain = '' if params.has_key('offset'): offset = int(params['offset']) if params.has_key('sort_by'): sort_by = int(params['sort_by']) if params.has_key('domain'): domain = params['domain'] if params.has_key('query'): query = params['query'] data = { 'query': query, 'sort_by': sort_by, 'domain': domain} s = xmlrpclib.Server('http://localhost:3000') sort_by = int(data['sort_by']) ascending = sort_by==2 res = s.search(query, offset, delta, domain, sort_by, ascending) return res, query, offset, delta, domain, sort_by, data def get_link_list(rs): results = [] for r in rs: this_link = show_link(r['url'], r['title']) + u' {%s}' % r['percent'] # --- Siehe SORT_BY if sort_by == 0: this_link += '<br />' + r['url'] elif sort_by == 2: this_link += ', ' + get_german_date(r['date']) results.append(this_link) return results app_name = 'searchxapian' my_title = _(u'Suchanfrage stellen') if item_container != None: my_absolute_url = item_container.get_absolute_url() else: my_absolute_url = './' show_errors = ( request.method == 'POST' ) params = request.GET.copy() if params!={} or show_errors: res, query, offset, delta, domain, sort_by, data = get_search_results(request) query = decode_html(query) # --- Rohdaten in Liste ueberfuehren count = res['count'] rs = res['results'] results = get_link_list(rs) if query.find('&') >= 0: q = query else: try: q = encode_html(query.decode('iso-8859-1')) except: q = encode_html(query) show_prev, show_middle, show_next = \ get_prev_next(q, offset, delta, domain, sort_by, count) else : sort_by = -1 query = '' count = 20 data = { 'query': '', 'sort_by': sort_by, 'doamin': '', } results = [] show_prev = '' show_middle = '' show_next = '' f = DmsItemForm(data) # --- Reihenfolge, Ueberschriften, Hilfetexte tabs = [ ('tab_base',['query',]), ('tab_more', ['sort_by', 'domain', ]) ] # --- Formular zusammenbauen content = get_tabbed_form(tabs, help_form, app_name , f) # --- externe Suchmaschinen search_engines = get_search_engines() links = [] for engine in search_engines: if query.find('&') < 0: url = engine.url_query % (urllib.quote_plus(encode_html(query.decode('iso-8859-1'))), SEARCH_DOMAIN) else: url = engine.url_query % (urllib.quote_plus(query), SEARCH_DOMAIN) links.append(show_link(url, engine.name, url_class="navLink")) t = get_template('utils/info_slot_right_list_simple.html') c = Context ( { 'header': _(u'Externe Suche'), 'links': links } ) slot_info_right = t.render(c) # --- Zur Ausgangsseite back_link = show_link(my_absolute_url, _(u'Zur Ausgangsseite ...'), url_class="navLink") t = get_template('utils/info_slot_right.html') c = Context ( { 'header': _(u'Ausgangsseite'), 'info': back_link } ) slot_info_right += '<br /><br />\n' + t.render(c) vars = get_item_vars_add(request, item_container, app_name, my_title, content, show_errors) vars['next'] = get_site_url(item_container, 'searchxapian/') vars['path'] = item_container.container.path + 'searchxapian/' vars['sub_title'] = '' vars['slot_right_info'] = slot_info_right vars['action'] = '' vars['results'] = results vars['count'] = count vars['show_prev'] = show_prev vars['show_middle'] = show_middle vars['show_next'] = show_next vars['sort_by'] = SORT_BY[sort_by] vars['google_search'] = 'google' vars['no_top_main_navigation'] = True return render_to_response ( 'app/searchxapian/base.html', vars )
bd1f252107bfcf2aa02cf58ef6d1a302d71edbd8
9,537
import re def html2plaintext(html, body_id=None, encoding='utf-8'): """ From an HTML text, convert the HTML to plain text. If @param body_id is provided then this is the tag where the body (not necessarily <body>) starts. """ ## (c) Fry-IT, www.fry-it.com, 2007 ## <[email protected]> ## download here: http://www.peterbe.com/plog/html2plaintext html = ustr(html) tree = etree.fromstring(html, parser=etree.HTMLParser()) if body_id is not None: source = tree.xpath('//*[@id=%s]' % (body_id,)) else: source = tree.xpath('//body') if len(source): tree = source[0] url_index = [] i = 0 for link in tree.findall('.//a'): url = link.get('href') if url: i += 1 link.tag = 'span' link.text = '%s [%s]' % (link.text, i) url_index.append(url) html = ustr(etree.tostring(tree, encoding=encoding)) # \r char is converted into &#13;, must remove it html = html.replace('&#13;', '') html = html.replace('<strong>', '*').replace('</strong>', '*') html = html.replace('<b>', '*').replace('</b>', '*') html = html.replace('<h3>', '*').replace('</h3>', '*') html = html.replace('<h2>', '**').replace('</h2>', '**') html = html.replace('<h1>', '**').replace('</h1>', '**') html = html.replace('<em>', '/').replace('</em>', '/') html = html.replace('<tr>', '\n') html = html.replace('</p>', '\n') html = re.sub('<br\s*/?>', '\n', html) html = re.sub('<.*?>', ' ', html) html = html.replace(' ' * 2, ' ') # strip all lines html = '\n'.join([x.strip() for x in html.splitlines()]) html = html.replace('\n' * 2, '\n') for i, url in enumerate(url_index): if i == 0: html += '\n\n' html += ustr('[%s] %s\n') % (i + 1, url) return html
70a7af7e557b6cffac05e33a7a394fdccbf7bc84
9,538
def _create_regularization_of_grad(param, grad, regularization=None): """ Create and add backward regularization Operators Function helper of append_regularization_ops. """ # If no gradient or no regularization is specified, then we don't need to do anything if grad is None or (param.regularizer is None and regularization is None): return grad regularization_term = None if param.regularizer is not None: # Add variable for regularization term in grad block regularization_term = param.regularizer(param, grad, grad.block) elif regularization is not None: regularization_term = regularization(param, grad, grad.block) assert regularization_term is not None new_grad = grad if grad.type == core.VarDesc.VarType.SELECTED_ROWS: # FIXME(zcd): If the grad is SELECTED_ROWS, after regularization, # the grad's type and name will be changed. But the gradient's name # is used in ParallelExecutor Reduce mode, so I add a flag for # the new_grad here. new_grad = grad.block.create_var( name=grad.name + core.kNewGradSuffix(), dtype=param.dtype, shape=param.shape, lod_level=param.lod_level, type=core.VarDesc.VarType.LOD_TENSOR) inputs = {"X": [grad, regularization_term]} outputs = {"Out": [new_grad]} if in_dygraph_mode(): core.ops.sum(inputs, {}, outputs) else: grad.block.append_op(type='sum', inputs=inputs, outputs=outputs) return new_grad
c3c027bc72cf2a0ced45ca2ed686301303582588
9,539
def MooreSpace(q): """ Triangulation of the mod `q` Moore space. INPUT: - ``q`` -0 integer, at least 2 This is a simplicial complex with simplices of dimension 0, 1, and 2, such that its reduced homology is isomorphic to `\\ZZ/q\\ZZ` in dimension 1, zero otherwise. If `q=2`, this is the real projective plane. If `q>2`, then construct it as follows: start with a triangle with vertices 1, 2, 3. We take a `3q`-gon forming a `q`-fold cover of the triangle, and we form the resulting complex as an identification space of the `3q`-gon. To triangulate this identification space, put `q` vertices `A_0`, ..., `A_{q-1}`, in the interior, each of which is connected to 1, 2, 3 (two facets each: `[1, 2, A_i]`, `[2, 3, A_i]`). Put `q` more vertices in the interior: `B_0`, ..., `B_{q-1}`, with facets `[3, 1, B_i]`, `[3, B_i, A_i]`, `[1, B_i, A_{i+1}]`, `[B_i, A_i, A_{i+1}]`. Then triangulate the interior polygon with vertices `A_0`, `A_1`, ..., `A_{q-1}`. EXAMPLES:: sage: simplicial_complexes.MooreSpace(2) Minimal triangulation of the real projective plane sage: simplicial_complexes.MooreSpace(3).homology()[1] C3 sage: simplicial_complexes.MooreSpace(4).suspension().homology()[2] C4 sage: simplicial_complexes.MooreSpace(8) Triangulation of the mod 8 Moore space """ if q <= 1: raise ValueError("the mod q Moore space is only defined if q is at least 2") if q == 2: return RealProjectivePlane() facets = [] for i in range(q): Ai = "A" + str(i) Aiplus = "A" + str((i+1) % q) Bi = "B" + str(i) facets.append([1, 2, Ai]) facets.append([2, 3, Ai]) facets.append([3, 1, Bi]) facets.append([3, Bi, Ai]) facets.append([1, Bi, Aiplus]) facets.append([Bi, Ai, Aiplus]) for i in range(1, q-1): Ai = "A" + str(i) Aiplus = "A" + str((i+1) % q) facets.append(["A0", Ai, Aiplus]) return UniqueSimplicialComplex(facets, name='Triangulation of the mod {} Moore space'.format(q))
448e948782d530f6b1ee0909fae02b66606da94d
9,540
def show(tournament_name, params=[], filter_response=True): """Retrieve a single tournament record by `tournament name`""" utils._validate_query_params(params=params, valid_params=VALID_PARAMS, route_type='tournament') uri = TOURNAMENT_PREFIX + tournament_name response = api.get(uri, params) if filter_response: response = _filter_tournament_response(response, params) return response
d854c97e312a0bd6860a5c7fa7cbd36cd79d4ffd
9,541
def auto_run_api_pk(**kwargs): """run api by pk and config """ id = kwargs['id'] env = kwargs['config'] config_name = 'rig_prod' if env == 1 else 'rig_test' api = models.API.objects.get(id=id) config = eval(models.Config.objects.get(name=config_name, project=api.project).body) test_case = eval(api.body) summary = loader.debug_api(test_case, api.project.id, config=config) api_request = summary['details'][0]['records'][0]['meta_data']['request'] api_response = summary['details'][0]['records'][0]['meta_data']['response'] # API执行成功,设置tag为自动运行成功 if summary['stat']['failures'] == 0 and summary['stat']['errors'] == 0: models.API.objects.filter(id=id).update(tag=3) return 'success' elif summary['stat']['failures'] == 1: # models.API.objects.filter(id=id).update(tag=2) return 'fail'
ba0e424d7ccbc3d1a6d3f8f0ec58892f4172d215
9,542
from typing import Optional from datetime import datetime def create(arxiv_id: ArXivID, arxiv_ver: int, resource_type: str, resource_id: str, description: str, creator: Optional[str]) -> Relation: """ Create a new relation for an e-print. Parameters ---------- arxiv_id: ArXivID The arXiv ID of the e-print. arxiv_ver: int The version of the e-print. resource_type: str The type of the corresponding resource. resource_id: str An identifier of the resource e.g., DOI. description: str A description for the relation. creator: Optional[str] Info of the user/app who requested this relation creation. Returns ------- Relation The newly-created relation. """ # store it to DB rel_data = RelationDB(rel_type=RelationType.ADD, arxiv_id=str(arxiv_id), arxiv_ver=arxiv_ver, resource_type=resource_type, resource_id=resource_id, description=description, added_at=datetime.now(UTC), creator=creator, supercedes_or_suppresses=None) try: db.session.add(rel_data) db.session.commit() except Exception as e: db.session.rollback() raise StorageError from e # return the result return relation_from_DB(rel_data)
e1cbe374bba359b66d8564134ee27ac777c4a16e
9,543
def p_contain_resist(D, t, f_y, f_u=None): """Pressure containment resistance in accordance with DNVGL-ST-F101. (press_contain_resis) Reference: DNVGL-ST-F101 (2017-12) sec:5.4.2.2 eq:5.8 p:94 $p_{b}(t)$ """ if f_u is None: f_cb = f_y else: f_cb = np.minimum(f_y, f_u/1.15) p_b = (2*t/(D-t) * f_cb * 2/np.sqrt(3)) return p_b
1c771eebf2ed43115b8ae32405172cd8576d66a2
9,544
def revalue(request): """其它设备参数修改""" value = request.GET.get('value') name = request.GET.get('name') others = Machines().filter_machines(OtherMachineInfo, pk=request.GET.get('dID'))[0] if name == 'remark': others.remark = value elif name == 'machine_name': others.machine_name = value elif name == 'reson_str': others.reson_str = value elif name == 'oth_cab_id': return '再考虑考虑' others.save() return JsonResponse({'is_ok': 1})
0a7ab179932466e171a119c87871e04e2a3ae252
9,545
import authl.handlers.indieauth import json def indieauth_endpoint(): """ IndieAuth token endpoint """ if 'me' in flask.request.args: # A ticket request is being made me_url = flask.request.args['me'] try: endpoint, _ = authl.handlers.indieauth.find_endpoint(me_url, rel='ticket_endpoint') except RuntimeError: endpoint = None if not endpoint: raise http_error.BadRequest("Could not get ticket endpoint") LOGGER.info("endpoint: %s", endpoint) send_auth_ticket(me_url, flask.request.url_root, endpoint) return "Ticket sent", 202 if 'grant_type' in flask.request.form: # token grant if flask.request.form['grant_type'] == 'ticket': # TicketAuth if 'ticket' not in flask.request.form: raise http_error.BadRequest("Missing ticket") ticket = parse_token(flask.request.form['ticket']) LOGGER.info("Redeeming ticket for %s; scopes=%s", ticket['me'], ticket['scope']) scopes = set(ticket.get('scope', '').split()) if 'ticket' not in scopes: raise http_error.BadRequest("Missing 'ticket' scope") scopes.remove('ticket') scope = ' '.join(scopes) token = get_token(ticket['me'], config.token_lifetime, scope) response = { 'access_token': token, 'token_type': 'Bearer', 'me': ticket['me'], 'expires_in': config.token_lifetime, 'refresh_token': get_token(ticket['me'], config.token_lifetime, ticket['scope']) } if scope: response['scope'] = scope return json.dumps(response), {'Content-Type': 'application/json'} raise http_error.BadRequest("Unknown grant type") if 'action' in flask.request.form: raise http_error.BadRequest() if 'Authorization' in flask.request.headers: # ticket verification parts = flask.request.headers['Authorization'].split() if parts[0].lower() == 'bearer': token = parse_token(parts[1]) return json.dumps(token), {'Content-Type': 'application/json'} raise http_error.Unauthorized("Invalid authorization header") raise http_error.BadRequest()
29809af2c243a08b675738b0169bdc794965c934
9,546
def policy_simulation_c(model,var,ages): """ policy simulation for couples""" if var == 'd': return {'hs': lifecycle_c(model,var=var,MA=[0],ST_w=[1,3],ages=ages,calc='sum')['y'][0] + lifecycle_c(model,var=var,MA=[1],ST_h=[1,3],ages=ages,calc='sum')['y'][0], 'hs_f': lifecycle_c(model,var=var,MA=[0],ST_w=[1,3],ages=ages,calc='sum')['y'][0], 'hs_m': lifecycle_c(model,var=var,MA=[1],ST_h=[1,3],ages=ages,calc='sum')['y'][0], 'base': lifecycle_c(model,var=var,MA=[0,1],ages=ages,calc='sum')['y'][0], 'base_f': lifecycle_c(model,var=var,MA=[0],ages=ages,calc='sum')['y'][0], 'base_m': lifecycle_c(model,var=var,MA=[1],ages=ages,calc='sum')['y'][0], 'ls': lifecycle_c(model,var=var,MA=[0],ST_w=[0,2],ages=ages,calc='sum')['y'][0] + lifecycle_c(model,var=var,MA=[1],ST_h=[0,2],ages=ages,calc='sum')['y'][0], 'ls_f': lifecycle_c(model,var=var,MA=[0],ST_w=[0,2],ages=ages,calc='sum')['y'][0], 'ls_m': lifecycle_c(model,var=var,MA=[1],ST_h=[0,2],ages=ages,calc='sum')['y'][0] } if var == 'probs': return {'base_f': retirement_probs_c(model,ma=0), 'base_m': retirement_probs_c(model,ma=1) } if var == 'GovS': return lifecycle_c(model,var=var,MA=[0,1],ages=ages,calc='total_sum')['y'][0] if var == 'RetAge': return {'hs': np.mean(np.concatenate((RetAge_C(model,ma=0,ST_w=[1,3]), RetAge_C(model,ma=1,ST_h=[1,3])))), 'base_m': np.mean(RetAge_C(model,ma=1)), 'base_f': np.mean(RetAge_C(model,ma=0)), 'base': np.mean(np.concatenate((RetAge_C(model,ma=0), RetAge_C(model,ma=1)))), 'ls': np.mean(np.concatenate((RetAge_C(model,ma=0,ST_w=[0,2]), RetAge_C(model,ma=1,ST_h=[0,2])))) }
d81ddd950eafb23b8cb219638b358a65084ae08d
9,547
def emit_obj_db_entry(target, source, env): """Emitter for object files. We add each object file built into a global variable for later use""" for t in target: if str(t) is None: continue OBJ_DB.append(t) return target, source
e02c2b4e3f3b1aad15097c6b4701407ef1902b77
9,548
def listtimes(list, c): """multiplies the elements in the list by the given scalar value c""" ret = [] for i in range(0, len(list)): ret.extend([list[i]]*c); return ret;
8aef63677a1a926f355644187d58b47e437e152c
9,549
import os import stat import traceback import sys def get(request): """Given a Request, return a Resource object (with caching). We need the request because it carries media_type_default. """ # XXX This is not thread-safe. It used to be, but then I simplified it # when I switched to diesel. Now that we have multiple engines, some of # which are threaded, we need to make this thread-safe again. # Get a cache Entry object. # ========================= if request.fs not in __cache__: entry = Entry() __cache__[request.fs] = entry entry = __cache__[request.fs] # Process the resource. # ===================== mtime = os.stat(request.fs)[stat.ST_MTIME] if entry.mtime == mtime: # cache hit if entry.exc is not None: raise entry.exc else: # cache miss try: entry.resource = load(request, mtime) except: # capture any Exception entry.exc = ( LoadError(traceback.format_exc()) , sys.exc_info()[2] ) else: # reset any previous Exception entry.exc = None entry.mtime = mtime if entry.exc is not None: raise entry.exc[0] # TODO Why [0] here, and not above? # Return # ====== # The caller must take care to avoid mutating any context dictionary at # entry.resource.pages[0]. return entry.resource
dcc573fff237fde0b444dc5a655865a6593a27b1
9,550
def split_audio_ixs(n_samples, rate=STEP_SIZE_EM, min_coverage=0.75): """ Create audio,mel slice indices for the audio clip Args: Returns: """ assert 0 < min_coverage <= 1 # Compute how many frames separate two partial utterances samples_per_frame = int((SAMPLING_RATE * WINDOW_STEP_DIARIZATION / 1000)) n_frames = int(np.ceil((n_samples + 1) / samples_per_frame)) frame_step = int(np.round((SAMPLING_RATE / rate) / samples_per_frame)) assert 0 < frame_step, "The rate is too high" assert frame_step <= H_L, "The rate is too low, it should be %f at least" % \ (SAMPLING_RATE / (samples_per_frame * H_L)) wav_slices, mel_slices = [], [] steps = max(1, n_frames - H_L + frame_step + 1) for i in range(0, steps, frame_step): mel_range = np.array([i, i + H_L]) wav_range = mel_range * samples_per_frame mel_slices.append(slice(*mel_range)) wav_slices.append(slice(*wav_range)) last_wav_range = wav_slices[-1] coverage = (n_samples - last_wav_range.start) / \ (last_wav_range.stop - last_wav_range.start) if coverage < min_coverage and len(mel_slices) > 1: mel_slices = mel_slices[:-1] wav_slices = wav_slices[:-1] return wav_slices, mel_slices
d3a71082c9f551dffb5a0457ba79fc3318f6df6a
9,551
def new(w: int, h: int, fmt: str, bg: int) -> 'Image': """ Creates new image by given size and format and fills it with bg color """ if fmt not in ('RGB', 'RGBA', 'L', 'LA'): raise ValueError('invalid format') c = len(fmt) image = Image() image.im = _new_image(w, h, c) lib.image_draw_rect(image.im, 0, 0, w, h, bg) return image
c570eab9d62def584a2a12b8a228b30c57cfed76
9,552
def eval_f(f, xs): """Takes a function f = f(x) and a list xs of values that should be used as arguments for f. The function eval_f should apply the function f subsequently to every value x in xs, and return a list fs of function values. I.e. for an input argument xs=[x0, x1, x2,..., xn] the function eval_f(f, xs) should return [f(x0), f(x1), f(x2), ..., f(xn)].""" return [f(x) for x in xs] # alternatively: return list(map(f, xs))
00c6ed7fc59b213a3ec9fec9feeb3d91b1522061
9,553
def cie94_loss(x1: Tensor, x2: Tensor, squared: bool = False, **kwargs) -> Tensor: """ Computes the L2-norm over all pixels of the CIEDE2000 Color-Difference for two RGB inputs. Parameters ---------- x1 : Tensor: First input. x2 : Tensor: Second input (of size matching x1). squared : bool Returns the squared L2-norm. Returns ------- ΔE_00_l2 : Tensor The L2-norm over all pixels of the CIEDE2000 Color-Difference. """ ΔE_94_squared = rgb_cie94_color_difference(x1, x2, squared=True, **kwargs).flatten(1) ε = kwargs.get('ε', 0) if squared: return ΔE_94_squared.sum(1) return ΔE_94_squared.sum(1).clamp_min(ε).sqrt()
1044585ce4cf8158caa3b969a8b94001681815db
9,554
def get_current_user_id() -> str: """ This functions gets the id of the current user that is signed in to the Azure CLI. In order to get this information, it looks like there are two different services, "Microsoft Graph" (developer.microsoft.com/graph) and "Azure AD Graph" (graph.windows.net), the latter being deprecated (https://devblogs.microsoft.com/microsoft365dev/microsoft-graph-or-azure-ad-graph/). I think these services correspond to two different python libraries, msal (https://docs.microsoft.com/en-us/python/api/overview/azure/active-directory?view=azure-python) and adal (https://docs.microsoft.com/en-us/python/api/adal/adal?view=azure-python), but these libraries don't appear to do anything super useful on their own. The deprecated Azure Graph API seems to correspond to a higher-level library azure-graphrbac, which does seem to have the functionality we need: azure.graphrbac.GraphRbacManagementClient.signed_in_user, but is deprecated along with Azure Graph (https://github.com/Azure/azure-sdk-for-python/issues/14022#issuecomment-752279618). The msgraph library that we use here seems to be a not-very-high-level library for Microsoft Graph (https://github.com/microsoftgraph/msgraph-sdk-python-core). As a side note, another way to get this information is to use the command line to call `az ad signed-in-user show`, but that appears to be relying on the deprecated Azure Graph API as it gives a deprecation warning. """ # crucial scopes parameter is needed, see # https://github.com/microsoftgraph/msgraph-sdk-python-core/issues/106#issuecomment-969281260 with get_credential() as credential: client = GraphClient( credential=credential, scopes=["https://graph.microsoft.com"] ) # https://docs.microsoft.com/en-us/graph/api/user-get?view=graph-rest-1.0&tabs=http result = client.get("/me") return result.json()["id"]
79a557762c9c4c2a6546370f492f879f3f046f67
9,555
def scale_labels(subject_labels): """Saves two lines of code by wrapping up the fitting and transform methods of the LabelEncoder Parameters :param subject_labels: ndarray Label array to be scaled :return: ndarray Scaled label array """ encoder = preprocessing.LabelEncoder() _ = encoder.fit(subject_labels) return encoder.transform(subject_labels)
e7c4e4c01f7bc7b43519f1eaf97ff9ce0fda9bbd
9,556
def _get_basemap(grid_metadata_dict): """Creates basemap. M = number of rows in grid M = number of columns in grid :param grid_metadata_dict: Dictionary created by `grids.create_equidistant_grid`. :return: basemap_object: Basemap handle (instance of `mpl_toolkits.basemap.Basemap`). :return: basemap_x_matrix_metres: M-by-N numpy array of x-coordinates under Basemap projection (different than pyproj projection). :return: basemap_y_matrix_metres: Same but for y-coordinates. """ x_matrix_metres, y_matrix_metres = grids.xy_vectors_to_matrices( x_unique_metres=grid_metadata_dict[grids.X_COORDS_KEY], y_unique_metres=grid_metadata_dict[grids.Y_COORDS_KEY] ) projection_object = grid_metadata_dict[grids.PROJECTION_KEY] latitude_matrix_deg, longitude_matrix_deg = ( projections.project_xy_to_latlng( x_coords_metres=x_matrix_metres, y_coords_metres=y_matrix_metres, projection_object=projection_object) ) standard_latitudes_deg, central_longitude_deg = _get_lcc_params( projection_object) basemap_object = Basemap( projection='lcc', lat_1=standard_latitudes_deg[0], lat_2=standard_latitudes_deg[1], lon_0=central_longitude_deg, rsphere=projections.DEFAULT_EARTH_RADIUS_METRES, ellps=projections.SPHERE_NAME, resolution=RESOLUTION_STRING, llcrnrx=x_matrix_metres[0, 0], llcrnry=y_matrix_metres[0, 0], urcrnrx=x_matrix_metres[-1, -1], urcrnry=y_matrix_metres[-1, -1] ) basemap_x_matrix_metres, basemap_y_matrix_metres = basemap_object( longitude_matrix_deg, latitude_matrix_deg) return basemap_object, basemap_x_matrix_metres, basemap_y_matrix_metres
caeac576f5a6345378c71e8e0e690f9bafda0995
9,557
import types def unary_math_intr(fn, intrcode): """ Implement the math function *fn* using the LLVM intrinsic *intrcode*. """ @lower(fn, types.Float) def float_impl(context, builder, sig, args): res = call_fp_intrinsic(builder, intrcode, args) return impl_ret_untracked(context, builder, sig.return_type, res) unary_math_int_impl(fn, float_impl) return float_impl
cd3a4c22dab5ea1776987a717c32fbbc71d75da7
9,558
def is_is_int(a): """Return `True` if `a` is an expression of the form IsInt(b). >>> x = Real('x') >>> is_is_int(IsInt(x)) True >>> is_is_int(x) False """ return is_app_of(a, Kind.IS_INTEGER)
d7565102a228119ba3157e9569495c5531ea5d74
9,559
def getTestSuite(select="unit"): """ Get test suite select is one of the following: "unit" return suite of unit tests only "component" return suite of unit and component tests "all" return suite of unit, component and integration tests "pending" return suite of pending tests name a single named test to be run """ testdict = { "unit": [ "testUnits" , "testNull" ], "component": [ "testComponents" , "testReadMe" , "testCreateFile" , "testRewriteFile" , "testUpdateFile" , "testDeleteFile" ], "integration": [ "testIntegration" ], "pending": [ "testPending" , "testWebDAVFile" , "testWebDAVFileUrlLib" ] } return TestUtils.getTestSuite(TestWebDAVAccess, testdict, select=select)
8ea94ad556dd77d28d5abdb2034b51858c996042
9,560
import torch def normalize_channel_wise(tensor: torch.Tensor, mean: torch.Tensor, std: torch.Tensor) -> torch.Tensor: """Normalizes given tensor channel-wise Parameters ---------- tensor: torch.Tensor Tensor to be normalized mean: torch.tensor Mean to be subtracted std: torch.Tensor Std to be divided by Returns ------- result: torch.Tensor """ if len(tensor.size()) != 3: raise ValueError for channel in range(tensor.size(0)): tensor[channel, :, :] -= mean[channel] tensor[channel, :, :] /= std[channel] return tensor
862a5497d9c4379a974e8e2543acc0c1282faea5
9,561
import tqdm def load_images(shot_paths): """ images = { shot1: { frame_id1: PIL image1, ... }, ... } """ images = list(tqdm(map(load_image, shot_paths), total=len(shot_paths), desc='loading images')) images = {k: v for k, v in images} return images
4916c68e1b4255d066bc624284cde77036764dd6
9,562
import numpy def rmSingles(fluxcomponent, targetstring='target'): """ Filter out targets in fluxcomponent that have only one ALMA source. """ nindiv = len(fluxcomponent) flagger = numpy.zeros(nindiv) for icomp in range(nindiv): target = fluxcomponent[targetstring][icomp] match = fluxcomponent[targetstring] == target nmatch = fluxcomponent[targetstring][match].size if nmatch == 1: flagger[icomp] = 1 goodflag = flagger == 0 fluxcomponent = fluxcomponent[goodflag] return fluxcomponent
013d5f3169fd1dcb277733627ecd5b0135bc33fb
9,563
import os import json def discover_guids(file_path, keys): """ """ # Now we revise the files if isinstance(file_path, list): discovered_files = file_path else: discovered_files = [os.path.join(file_path, f) for f in os.listdir(file_path)] known_guids = set() for f in discovered_files: dir_path, fname = os.path.split(f) if fname.startswith("_"): continue with open(f, 'r') as fp: data = json.load(fp) results = _recursive_guid(None, data, keys) known_guids = known_guids.union(results) return list(known_guids)
a858024d7d93ab65607e41f6f8b392b28b2baab4
9,564
def gray(): """Convert image to gray scale.""" form = ImageForm(meta={'csrf': False}) current_app.logger.debug(f"request: {request.form}") if form.validate(): service_info = cv_services["gray"] json_format = request.args.get("json", False) # Image Processing image = services.convert_to_image(request.files["image"].read()) err, image = services.gray(image) current_app.logger.debug(f"respond: {image}") respond = services.convert_to_base64(image) # Respond respond = jsonify({"image": str(respond)}), 200 else: respond = jsonify(message=form.errors), 404 return respond
93ad57e1d66b65ea4af351c942aa6defe5ee4e60
9,565
import torch def compute_accuracy(outputs, targets, topk=(1,)): """Computes the accuracy over the k top predictions for the specified values of k""" with torch.no_grad(): maxk = max(topk) batch_size = targets.size(0) _, preds = outputs.topk(maxk, 1, True, True) preds = preds.t() corrects = preds.eq(targets[None]) result_list = [] for k in topk: correct_k = corrects[:k].flatten().sum(dtype=torch.float32) result_list.append(correct_k * (100.0 / batch_size)) return result_list
6cfcc9e43aaaed09baae567f9cc27818c555fe5f
9,566
import io def unpack_text_io_wrapper(fp, encoding): """ If *fp* is a #io.TextIOWrapper object, this function returns the underlying binary stream and the encoding of the IO-wrapper object. If *encoding* is not None and does not match with the encoding specified in the IO-wrapper, a #RuntimeError is raised. """ if isinstance(fp, io.TextIOWrapper): if fp.writable() and encoding is not None and fp.encoding != encoding: msg = 'TextIOWrapper.encoding({0!r}) != {1!r}' raise RuntimeError(msg.format(fp.encoding, encoding)) if encoding is None: encoding = fp.encoding fp = fp.buffer return fp, encoding
f2c93babab4bff1f08e6fe5c04fbd97dd1ee8a84
9,567
def dummy_blob(size_arr=(9, 9, 9), pixdim=(1, 1, 1), coordvox=None): """ Create an image with a non-null voxels at coordinates specified by coordvox. :param size_arr: :param pixdim: :param coordvox: If None: will create a single voxel in the middle of the FOV. If tuple: (x,y,z): Create single voxel at specified coordinate If list of tuples: [(x1,y1,z1), (x2,y2,z2)]: Create multiple voxels. :return: Image object """ # nx, ny, nz = size_arr data = np.zeros(size_arr) # if not specified, voxel coordinate is set at the middle of the volume if coordvox is None: coordvox = tuple([round(i / 2) for i in size_arr]) elif isinstance(coordvox, list): for icoord in coordvox: data[icoord] = 1 elif isinstance(coordvox, tuple): data[coordvox] = 1 else: ValueError("Wrong type for coordvox") # Create image with default orientation LPI affine = np.eye(4) affine[0:3, 0:3] = affine[0:3, 0:3] * pixdim nii = nib.nifti1.Nifti1Image(data, affine) img = Image(data, hdr=nii.header, dim=nii.header.get_data_shape()) return img
2426ca5cddfa3da660bd5e7436f8093b1d7fa109
9,568
import torch def poly_edges(P, T): """ Returns the ordered edges from the given polygons Parameters ---------- P : Tensor a (N, D,) points set tensor T : LongTensor a (M, T,) topology tensor Returns ------- tuple a tuple containing the edges of the given polygons """ p = P[torch.cat((T, T[0].unsqueeze(0)), dim=0)] return tuple(p[1:]-p[:-1])
c8d838bf1ada319cebc5c08719f66846959ce2c2
9,569
def make_list(v): """ If the object is not a list already, it converts it to one Examples: [1, 2, 3] -> [1, 2, 3] [1] -> [1] 1 -> [1] """ if not jsoncfg.node_is_array(v): if jsoncfg.node_is_scalar(v): location = jsoncfg.node_location(v) line = location.line column = location.column else: line = v.line column = v.column a = jsoncfg.config_classes.ConfigJSONArray(line, column) a._append(v) return a return v
c5288cc726d103667e5f51055bc4e8cd4a90816e
9,570
def score_game(game_core): """Запускаем игру 1000 раз, чтобы узнать, как быстро игра угадывает число""" count_ls = [] np.random.seed(1) # фиксируем RANDOM SEED, чтобы ваш эксперимент был воспроизводим! random_array = np.random.randint(1, 101, 1000) for number in random_array: count_ls.append(game_core(number)) score = int(np.mean(count_ls)) print(f"Ваш алгоритм угадывает число в среднем за {score} попыток") return score
74a8c4b44ff2caec31f38f136c3fc2336909759f
9,571
def add_plot( lon, lat, kind=None, props=None, ax=None, break_on_change=False, transform=identity ): """Add a plot with different props for different 'kind' values to an existing map Parameters ---------- lon : sequence of float lat : sequence of float kind : sequence of hashable, optional Controls what props are used. Length must match lon/lat and values are used to index into the `props` map. props : dict, optional. Maps `kind` of first and last point of each segment to plot style. By default, sorted values from `kind` are mapped to 'axes.prop_cycle'. `props` for segments between points with different `kind` value are looked up under `None`. If `None` is missing, these points are not plotted. ax : matplotlib axes object, optional break_on_change : bool, optional Whether to create a new segment when kind changes. Generally True for fishing plots and False for vessel plots. transform : cartopy.crs.Projection, optional Returns ------- dict mapping keys to Line2D Values are suitable for passing to legend. """ if ax is None: ax = plt.gca() assert len(lon) == len(lat) if kind is None: kind = np.ones(len(lon)) else: kind = np.asarray(kind) assert len(kind) == len(lon) if props is None: props = styles.create_props(np.unique(kind)) handles = {} for k1, k2 in sorted(props.keys()): mask = _build_mask(kind, k1, k2, break_on_change) if mask.sum(): ml_coords = _build_multiline_string_coords(lon, lat, mask, break_on_change) mls = MultiLineString(ml_coords) p = props[k1, k2].copy() if "legend" in p: key = p.pop("legend") else: key = k1 if (k1 == k2) else f"{k1}-{k2}" ax.add_geometries([mls], crs=transform, **p) if key: handles[key] = Line2D( [0], [0], color=p["edgecolor"], lw=p.get("linewidth", 1) ) return handles
c5d6b5234fe560e9d954d4ea8d0a7aef0e810f89
9,572
def can_review_faults(user): """ users can review faults if one of the the following applies: a) No fault review groups exist and they have can_review permissions b) Fault review groups exist, they are a member of one, and they have review permissions """ can_review = user.has_perm("faults.can_review") review_groups = [frg.group for frg in FaultReviewGroup.objects.select_related("group")] if review_groups: can_review = can_review and len(set(review_groups) & set(user.groups.all())) > 0 return can_review
c66f022b6f52144d8e9fde6865f0a8a263819813
9,573
import requests def create_freshservice_object(obj_type, data): """Use the Freshservice v2 API to create an object. Accepts an object name (string) and a dict of key values. """ url = '{}/{}'.format(settings.FRESHSERVICE_ENDPOINT, obj_type) resp = requests.post(url, auth=FRESHSERVICE_AUTH, json=data) return resp
597348b744d6193beb12dcf2a3a4958808f09d24
9,574
def print_begin(*args, sep=' ', end='\n', file=None, ret_value='') -> str: """Print the function name and start.""" print(_prefix('begin'), *args, sep=sep, end=end, file=file, flush=True) return ret_value
8e9ac418d161a0d2b5b7c0c9de7b81da42ea5017
9,575
def scale_bounding_box(bounding_box,scale): """Scales bounding box coords (in dict from {x1,y1,x2,y2}) by x and y given by sclae in dict form {x,y}""" scaled_bounding_box = { "x1" : int(round(bounding_box["x1"]*scale["x"])) ,"y1" : int(round(bounding_box["y1"]*scale["y"])) ,"x2" : int(round(bounding_box["x2"]*scale["x"])) ,"y2" : int(round(bounding_box["y2"]*scale["y"])) } return scaled_bounding_box
8aa374537ed2ae3ae2324bd8a4819e981f281b71
9,576
import click def is_command(obj) -> bool: """ Return whether ``obj`` is a click command. :param obj: """ return isinstance(obj, click.Command)
8159aea42baca70b3218a0b82e2f4dc3f34278aa
9,577
def GetContigs(orthologs): """get map of contigs to orthologs. An ortholog can be part of only one contig, but the same ortholog_id can be part of several contigs. """ contigs = {} for id, oo in orthologs.items(): for o in oo: if o.contig not in contigs: contigs[o.contig] = [] contigs[o.contig].append(o) return contigs
0c449a31e60f1a149317de815d630c4d8a817ca1
9,578
import logging import json def _save_training_results( mltk_model:MltkModel, keras_model:KerasModel, training_history, logger: logging.Logger, show:bool = False ) -> TrainingResults: """Save the training history as .json and .png""" results = TrainingResults(mltk_model, keras_model, training_history) metric, best_val = results.get_best_metric() logger.info(f'\n\n*** Best training {metric} = {best_val:.3f}\n\n') try: history_json_path = f'{mltk_model.log_dir}/train/training-history.json' logger.debug(f'Generating {history_json_path}') with open(history_json_path, 'w') as f: json.dump(results.asdict(), f, indent=2) except Exception as e: logger.warning(f'Error while saving training results to {history_json_path}, err: {e}') # See https://github.com/keras-team/keras/blob/master/keras/losses.py supported_metrics = {} supported_metrics['accuracy'] = 'Accuracy' supported_metrics['loss'] = 'Loss' supported_metrics['mse'] = 'Mean Square Error' supported_metrics['mae'] = 'Mean Absolute Error' supported_metrics['mape'] = 'Mean Absolute Percentage Error' supported_metrics['msle '] = 'Mean Square Logarithmic Error' supported_metrics['bce '] = 'Binary Cross-entropy' supported_metrics['cce'] = 'Categorical Cross-entropy' found_metrics = [] history = results.history for metric in history: if not metric in supported_metrics: continue if not f'val_{metric}' in history: continue found_metrics.append(dict( name=metric, train=history[metric], validation=history[f'val_{metric}'], )) fig, _ = plt.subplots(figsize=(6, 6), clear=True) fig.suptitle(f'{mltk_model.name} Training History') # %% Plot training and validation metrics for i, metric in enumerate(found_metrics): plt.subplot(len(found_metrics), 1, i + 1) plt.plot(metric['train']) plt.plot(metric['validation']) plt.title(f'{supported_metrics[metric["name"]]}') plt.ylabel(supported_metrics[metric['name']]) plt.xlabel('Epoch') plt.legend(['Train', 'Test'], loc='upper left') plt.subplots_adjust(hspace=.5) training_results_path = f'{mltk_model.log_dir}/train/training-history.png' logger.debug(f'Generating {training_results_path}') plt.savefig(training_results_path) if show: plt.show(block=False) else: fig.clear() plt.close(fig) return results
fbc8cdb44dcada27df4c47dfdc394dc1900eeb9f
9,579
def set_backwards_pass(op, backwards): """ Returns new operation which behaves like `op` in the forward pass but like `backwards` in the backwards pass. """ return backwards + tf.stop_gradient(op - backwards)
13287ac73c52ac01808c41c81ba5311bc3f49b91
9,580
def remove_hydrogens(list_of_lines): """ Removes hydrogen from the pdb file. To add back the hydrogens, run the reduce program on the file. """ return (line for line in list_of_lines if line['element']!=" H")
164ac79171cf6b3632fe7909ace91ffe75192b61
9,581
def crash_random_instance(org: str, space: str, appname: str, configuration: Configuration, count: int = 1): """ Crash one or more random application instances. :param org: String; Cloud Foundry organization containing the application. :param space: String; Cloud Foundry space containing the application. :param appname: String; Application in Cloud Foundry which is to be targeted. :param count: int; Number of instances to kill. :param configuration: Configuration; Configuration details, see `README.md`. :return: A JSON Object representing the application which was targeted. """ return run_ctk( lambda app: app.crash_random_instance(count=count), configuration, org, space, appname, "Crashing {} random app instance(s)...".format(count) )
652ab95038d405b6a193809804aae7f3bc15978f
9,582
def spc_dict_from_spc_info(spc_info: dict, resonance: bool = True) -> dict: """ Generate a species dictionary from species info. Args: spc_info (dict): Species info contains the label and species geom info. resonance (bool): Whether generate resonance geom in the species dictionary. Returns: dict: The species dictionary generated from the spc_info. """ spc_dict = {} for label, spc in spc_info.items(): species = species_from_spc_info(spc) if not species: continue if resonance: species.generate_resonance_structures() spc_dict[label] = species return spc_dict
0a291f2fd50134b1c1259adc36b5637e30e21118
9,583
import torch def label_smooth_loss(log_prob, label, confidence=0.9): """ :param log_prob: log probability :param label: one hot encoded :param confidence: we replace one (in the one hot) with confidence. 0 <= confidence <= 1. :return: """ N = log_prob.size(0) C = log_prob.size(1) smoothed_label = torch.full(size=(N, C), fill_value=(1-confidence) / (C - 1)).to(log_prob) smoothed_label.scatter_(dim=1, index=torch.unsqueeze(label, dim=1), value=confidence) loss = - torch.sum(log_prob * smoothed_label) / N return loss
f1164d1a41d2c275ae4e406e2a46a0d50a2d240d
9,584
def update(self, using=None, **kwargs): """ Updates specified attributes on the current instance. """ assert self.pk, "Cannot update an instance that has not yet been created." using = using or router.db_for_write(self.__class__, instance=self) for field in self._meta.fields: if getattr(field, 'auto_now', False) and field.name not in kwargs: kwargs[field.name] = field.pre_save(self, False) affected = self.__class__._base_manager.using(using).filter(pk=self.pk).update(**kwargs) for k, v in kwargs.iteritems(): if isinstance(v, ExpressionNode): v = resolve_expression_node(self, v) setattr(self, k, v) if affected == 1: signals.post_save.send(sender=self.__class__, instance=self, created=False) return True elif affected == 0: return False elif affected < 0: raise ValueError("Somehow we have updated a negative amount of rows, you seem to have a problem with your db backend.") else: raise ValueError("Somehow we have updated multiple rows, and you are now royally fucked.")
b3400f43c0a744de17225ee6c029fc41465b784d
9,585
def differential_privacy_with_risk( dfg_freq, dfg_time, delta, precision, aggregate_type=AggregateType.SUM): """ This method adds the differential privacy to the DFG of both time and frequencies. * It calculates the epsilon using the guessing advantage technique. * It adds laplace noise to the DFGs. * It calculates the distance resulted from the noise """ accuracy=1 # calculate epsilon epsilon_freq,senstivity_freq=calculate_epsilon_freq(dfg_freq,delta) epsilon_time,senstivity_time=calculate_epsilon_time(dfg_time,delta,precision, aggregate_type) # adding laplace noise to DFG freq dfg_freq_new = add_laplace_noise_freq(dfg_freq, epsilon_freq) # adding laplace noise to DFG time dfg_time, dfg_time_new = add_laplace_noise_time(aggregate_type, dfg_time, epsilon_time) # Calculate earth moving distance emd_freq=earth_mover_dist(dfg_freq,dfg_freq_new) emd_time=earth_mover_dist(dfg_time,dfg_time_new) #calculating the APE, MAPE, and SMAPE MAPE_freq, SMAPE_freq, APE_dist_freq,SMAPE_dist_freq=error_calculation(dfg_freq,dfg_freq_new) MAPE_time, SMAPE_time, APE_dist_time, SMAPE_dist_time = error_calculation(dfg_time,dfg_time_new) # return dfg_freq_new, dfg_time_new, epsilon_freq,epsilon_time, emd_freq, emd_time, percent_freq,percent_time,percent_freq_dist,percent_time_dist return dfg_freq_new, dfg_time_new, epsilon_freq,epsilon_time, MAPE_freq, SMAPE_freq, APE_dist_freq, MAPE_time, SMAPE_time, APE_dist_time, SMAPE_dist_freq, SMAPE_dist_time
a85035b8786bb6bf9a5cc0af88433a490faac77f
9,586
from typing import Iterable from typing import Counter def get_all_values(string: str) -> Iterable[int]: """Return all kinds of candidates, with ordering: Dec, Hex, Oct, Bin.""" if string.startswith('0x'): return filter(bool, [parse_hex(string[2:])]) # type: ignore[list-item] if string.startswith('0o'): return filter(bool, [parse_oct(string[2:])]) # type: ignore[list-item] if string.startswith('0b'): return filter(bool, [parse_bin(string[2:])]) # type: ignore[list-item] # try each base when no prefix return Counter(filter(bool, map(lambda f: f(string), # type: ignore[arg-type,return-value] [parse_dec, parse_hex, parse_oct, parse_bin])))
d9e12290339cbf31dc572c9e3d49ec503949250d
9,587
def svn_auth_get_simple_provider(*args): """svn_auth_get_simple_provider(apr_pool_t pool)""" return _core.svn_auth_get_simple_provider(*args)
e91c2198f5ee214fb1db9e8969711a806caf19c6
9,588
def preferred_language(): """ It just returns first language from acceptable """ return acceptable_languages()[0]
6e5c2b069f84c5a6601b579616858457598f2cf4
9,589
def get_frequencies(trial = 1): """ get frequency lists """ if trial =="run_fast_publish": lb_targ, ub_targ, obs_hz = 340, 350, 10 elif trial == 1: lb_targ, ub_targ, obs_hz = 210, 560, int(320 / 2) elif trial == 2: lb_targ, ub_targ, obs_hz = 340, 640, 280 elif trial == 3: lb_targ, ub_targ, obs_hz = 340, 350, 20#40 elif trial == 4: lb_targ, ub_targ, obs_hz = 60, 350, 40 elif trial == 5: lb_targ, ub_targ, obs_hz = 50, 200, 40 if trial == 6: lb_targ, ub_targ, obs_hz = 130, 530, 130 if trial == 7: lb_targ, ub_targ, obs_hz = 500, 900, 250 obs_list = list( range( lb_targ - obs_hz, lb_targ)) obs_list += list( range( ub_targ, ub_targ + obs_hz)) resp_list = list( range( lb_targ, ub_targ)) return obs_list, resp_list
e6c7f33865ffd76532a19426f0748d4dd22e37f8
9,590
from sys import path def load_csv(file_path: str = None, clean: bool = True) -> pd.DataFrame: """Load the dataset CSV file. Args: file_path (str, optional): Path to CSV file. Can be omitted, to load the default dataset. Defaults to None. drop (list[str], optional): Optionally supply a list of column names to drop. Defaults to None. Returns: pd.DataFrame: A Pandas dataframe representing the dataset. """ if file_path is None: file_path = get_path() if not path.exists(file_path): _generate_minimized(file_path) df = pd.DataFrame(pd.read_csv(file_path)) if "datetime" in df.columns: df.index = pd.to_datetime(df.pop("datetime")) if clean: df = _clean_data(df) return df
8afa250f4d91b349193682b5bb7bd9c8b1d4eec4
9,591
import re def parse_field_pubblicazione(field): """ Extracts year, place and publisher from the field `pubblicazione` by applying a cascade of regexps. """ exp2 = r'^(?P<place>\D+)(?:\s?\W\s?)(?P<publisher>.*?)\D{1}?(?P<year>\d+)?$' exp1 = r'^(?P<place>.*?)(?::)(?P<publisher>.*?)\D{1}?(?P<year>\d+)?$' exp3 = r'(?:.*?)?(?P<year>\d{4})' exp4 = r'^(?P<place>\D{3,})$' not_matched = 0 partly_matched = 0 result = {} result1 = re.match(exp1,field) if(result1 is None): result2 = re.match(exp2,field) if(result2 is None): result3 = re.match(exp3,field) if(result3 is None): result4 = re.match(exp4,field) if(result4 is None): not_matched += 1 else: result = result4.groupdict() else: result = result3.groupdict() else: result = result2.groupdict() else: result = result1.groupdict() return result
91aee4dabf62b3ec5bccff2a07d664312226448c
9,592
def test_api_calendar(): """Return a test calendar object used in API responses.""" return TEST_API_CALENDAR
1c73e63bf19cef92dbbe328825c2ae4e867c1e84
9,593
def apply_custom_colormap(image_gray, cmap=plt.get_cmap("seismic")): """ Implementation of applyColorMap in OpenCV using colormaps in Matplotlib. """ assert image_gray.dtype == np.uint8, "must be np.uint8 image" if image_gray.ndim == 3: image_gray = image_gray.squeeze(-1) # Initialize the matplotlib color map sm = plt.cm.ScalarMappable(cmap=cmap) # Obtain linear color range color_range = sm.to_rgba(np.linspace(0, 1, 256))[:, 0:3] # color range RGBA => RGB color_range = (color_range * 255.0).astype(np.uint8) # [0,1] => [0,255] color_range = np.squeeze( np.dstack([color_range[:, 2], color_range[:, 1], color_range[:, 0]]), 0 ) # RGB => BGR # Apply colormap for each channel individually channels = [cv2.LUT(image_gray, color_range[:, i]) for i in range(3)] return np.dstack(channels)
e2f3c9a8900f47c0e7183f4ebe72f41a7f6d26b9
9,594
from typing import Callable def _cond_with_per_branch_args(pred, true_operand, true_fun: Callable, false_operand, false_fun: Callable): """Conditionally apply ``true_fun`` or ``false_fun``. Has equivalent semantics to this Python implementation:: def cond(pred, true_operand, true_fun, false_operand, false_fun): if pred: return true_fun(true_operand) else: return false_fun(false_operand) Pred has to be a scalar type, collection types (list, tuple) are not supported """ if not (callable(true_fun) and callable(false_fun)): raise TypeError("lax.cond: true_fun and false_fun arguments should be callable.") return _cond(pred, lambda op: true_fun(op[0]), lambda op: false_fun(op[1]), (true_operand, false_operand))
e942124beafebb69fed80e3175164a34f088cb9e
9,595
import urllib def msgSet(key, notUsed, queryString, body): """no treatment on the body (we send exactly the body like we received it)""" dict = urllib.parse.parse_qs(body.decode('utf-8')) #sendSMS.writeRawMsg(body) user = dict['user'][0] print(dict) sendSMS.writeMsgUser(dict['msg'][0], user) return "Message sent to " + user
b67663f516f54af9a7dbbece67933ee1d04ee7a2
9,596
import re def _strip_build_number(api_version): """Removes the build number component from a full api version string.""" match = re.match(r"^([A-Z]+-)?([0-9]+)(\.[0-9]+){2}$", api_version) if match: return api_version[:match.start(3)] # if there aren't exactly 3 version number components, just leave it unchanged return api_version
20d8023281f05dfcb8c9fdd021b77796c72e1001
9,597
def get_me(): """サインインしている自分自身の情報を取得""" jia_user_id = get_user_id_from_session() return {"jia_user_id": jia_user_id}
c31f6a1a8c794e4a2aa70779f9c8b2559baccd84
9,598
def dec_file(name, out=None, **kwargs): """ This is a helper function to decrypt a file and return its contents. You can provide an optional output file using `out` `name` can be a local file or when not using `salt-run` can be a url like `salt://`, `https://` etc. CLI Examples: .. code-block:: bash salt-run nacl.dec_file name=/tmp/id_rsa.nacl salt-call nacl.dec_file name=salt://crt/mycert.nacl out=/tmp/id_rsa salt-run nacl.dec_file name=/tmp/id_rsa.nacl box_type=secretbox \ sk_file=/etc/salt/pki/master/nacl.pub """ kwargs["opts"] = __opts__ return salt.utils.nacl.dec_file(name, out, **kwargs)
3ff74b9300fa8b441a22daf65d546f329e414447
9,599