Datasets:

bigcode

/

stack-dedup-python-fns

like 1

def getFileList(*args, **kwargs): """ Returns a list of files matching an optional wildcard pattern. Note that this command works directly on raw system files and does not go through standard Maya file path resolution. Flags: - filespec : fs (unicode) [create] wildcard specifier for search.Flag can appear in Create mode of commandFlag can have multiple arguments, passed either as a tuple or a list. - folder : fld (unicode) [create] return a directory listing Derived from mel command `maya.cmds.getFileList` """ pass

def export_descriptor(config, output_dir, args): """ # input 2 images, output keypoints and correspondence save prediction: pred: 'image': np(320,240) 'prob' (keypoints): np (N1, 2) 'desc': np (N2, 256) 'warped_image': np(320,240) 'warped_prob' (keypoints): np (N2, 2) 'warped_desc': np (N2, 256) 'homography': np (3,3) 'matches': np [N3, 4] """ from utils.loader import get_save_path from utils.var_dim import squeezeToNumpy # basic settings device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") logging.info("train on device: %s", device) with open(os.path.join(output_dir, "config.yml"), "w") as f: yaml.dump(config, f, default_flow_style=False) writer = SummaryWriter(getWriterPath(task=args.command, date=True)) save_path = get_save_path(output_dir) save_output = save_path / "../predictions" os.makedirs(save_output, exist_ok=True) ## parameters outputMatches = True subpixel = config["model"]["subpixel"]["enable"] patch_size = config["model"]["subpixel"]["patch_size"] # data loading from utils.loader import dataLoader_test as dataLoader task = config["data"]["dataset"] data = dataLoader(config, dataset=task) test_set, test_loader = data["test_set"], data["test_loader"] from utils.print_tool import datasize datasize(test_loader, config, tag="test") # model loading from utils.loader import get_module Val_model_heatmap = get_module("", config["front_end_model"]) ## load pretrained val_agent = Val_model_heatmap(config["model"], device=device) val_agent.loadModel() ## tracker tracker = PointTracker(max_length=2, nn_thresh=val_agent.nn_thresh) ###### check!!! count = 0 for i, sample in tqdm(enumerate(test_loader)): img_0, img_1 = sample["image"], sample["warped_image"] # first image, no matches # img = img_0 def get_pts_desc_from_agent(val_agent, img, device="cpu"): """ pts: list [numpy (3, N)] desc: list [numpy (256, N)] """ heatmap_batch = val_agent.run( img.to(device) ) # heatmap: numpy [batch, 1, H, W] # heatmap to pts pts = val_agent.heatmap_to_pts() # print("pts: ", pts) if subpixel: pts = val_agent.soft_argmax_points(pts, patch_size=patch_size) # heatmap, pts to desc desc_sparse = val_agent.desc_to_sparseDesc() # print("pts[0]: ", pts[0].shape, ", desc_sparse[0]: ", desc_sparse[0].shape) # print("pts[0]: ", pts[0].shape) outs = {"pts": pts[0], "desc": desc_sparse[0]} return outs def transpose_np_dict(outs): for entry in list(outs): outs[entry] = outs[entry].transpose() outs = get_pts_desc_from_agent(val_agent, img_0, device=device) pts, desc = outs["pts"], outs["desc"] # pts: np [3, N] if outputMatches == True: tracker.update(pts, desc) # save keypoints pred = {"image": squeezeToNumpy(img_0)} pred.update({"prob": pts.transpose(), "desc": desc.transpose()}) # second image, output matches outs = get_pts_desc_from_agent(val_agent, img_1, device=device) pts, desc = outs["pts"], outs["desc"] if outputMatches == True: tracker.update(pts, desc) pred.update({"warped_image": squeezeToNumpy(img_1)}) # print("total points: ", pts.shape) pred.update( { "warped_prob": pts.transpose(), "warped_desc": desc.transpose(), "homography": squeezeToNumpy(sample["homography"]), } ) if outputMatches == True: matches = tracker.get_matches() print("matches: ", matches.transpose().shape) pred.update({"matches": matches.transpose()}) print("pts: ", pts.shape, ", desc: ", desc.shape) # clean last descriptor tracker.clear_desc() filename = str(count) path = Path(save_output, "{}.npz".format(filename)) np.savez_compressed(path, **pred) # print("save: ", path) count += 1 print("output pairs: ", count)

def test_left_right_transitions_linear(): """Set a transition matrix generated by a left-right topology on a linear HMM""" hmm = deepcopy(hmm_lr) topology = _LinearTopology(n_states=5, random_state=rng) transitions = topology.random_transitions() hmm.transitions = transitions assert_equal(hmm.transitions, transitions)

def LinkSigningChain(*certs): """Sets up the parent cert ID property values for a chain of certs.""" for i, cert in enumerate(certs): if i == len(certs) - 1: cert.parent_certificate_id = 0 else: cert.parent_certificate_id = certs[i + 1].id

def meta_caption(meta) -> str: """makes text from metadata for captioning video""" caption = "" try: caption += meta.title + " - " except (TypeError, LookupError, AttributeError): pass try: caption += meta.artist except (TypeError, LookupError, AttributeError): pass return caption

def ticket_id_correctly_formatted(s: str) -> bool: """Checks if Ticket ID is in the form of 'PROJECTNAME-1234'""" return matches(r"^\w+-\d+$|^---$|^-$")(s)

def test_1(): """ f(x) = max(.2, sin(x)^2) """ test_graph = FunctionTree('Test_1') max_node = Max('max') const_node = Constant('0.2', .2) square_node = Square('square') sin_node = Sin('sin') test_graph.insert_node(max_node, 'Output', 'x') test_graph.insert_node(square_node, 'max', 'x') test_graph.insert_node(const_node, 'max') test_graph.insert_node(sin_node, 'square', 'x') return test_graph

def export_vector(vector, description, output_name, output_method='asset'): """Exports vector to GEE Asset in GEE or to shapefile in Google Drive. Parameters ---------- vector : ee.FeatureCollection Classified vector segments/clusters. description : str Description of the exported layer. output_name : str Path for the output file. Path must exist within Google Earth Engine Assets path or Google Drive. output_method : str Export method/destination. Options include 'asset' for export to Google Earth Engine Assets or 'drive' for export to Google Drive. Returns ------- output_message : str Message indicating location of the exported layer. Example ------- >>> import ee >>> peak_green = ee.Image('LANDSAT/LC08/C01/T1_SR/LC08_008057_20170602') >>> post_harvest = ee.Image('LANDSAT/LC08/C01/T1_SR/LC08_008057_20170906') >>> image_collection = ee.ImageCollection([peak_green, post_harvest]) >>> ndvi_diff = ndvi_diff_landsat8(image_collection, 1, 0) >>> study_area_boundary = ee.FeatureCollection("users/calekochenour/vegetation-change/drtt_study_area_boundary") >>> ndvi_change_thresholds = [-2.0, -0.5, -0.5, -0.35] >>> change_features = segment_snic(ndvi_diff, study_area_boundary, ndvi_change_thresholds) >>> change_primary_vector = raster_to_vector(change_features.get('primary'), study_area_boundary) >>> change_secondary_vector = raster_to_vector(change_features.get('secondary'), study_area_boundary) >>> change_primary_export = export_vector(vector=change_primary_vector, description='Primary Change', output_name=change_primary_asset_name, output_method='asset' >>> change_secondary_export = export_vector(vector=change_secondary_vector, description='Secondary Change', output_name=change_secondary_asset_name, output_method='asset') """ # Create export task for Google Drive if output_method.lower() == "drive": # Export vectors as shapefile to Google Drive task = ee.batch.Export.table.toDrive(**{ 'collection': vector, 'description': output_name, 'fileFormat': 'SHP'}) # Assign output message output_message = f"Exporting {output_name.split('/')[-1]} to Google Drive..." # Create task for GEE Asset elif output_method.lower() == "asset": # Export vectors to GEE Asset task = ee.batch.Export.table.toAsset(**{ 'collection': vector, 'description': description, 'assetId': output_name}) # Assign output message output_message = f"Exporting {output_name.split('/')[-1]} to GEE Asset..." else: # Rasie error raise ValueError("Invalid export method. Please specify 'Drive' or 'Asset'.") # Start export task task.start() # Return output message return print(output_message)

def gather_competition_data(comp_url, target_directory=None): """ gather all competition data from the url: "https://www.digitalrock.de/dav_calendar.php?no_dav=1&year=2019" :return: - nothing - but side efect are the competition files in target directory """ print("Fetching competition data from %r" % comp_url) response = requests.get(comp_url) html_content = response.text # try to create the target directory if it did not exist if not target_directory: target_directory = Directory if not os.path.exists(target_directory): raise Exception('directory does not exist: %r' % target_directory) for href in get_links_from_html(html_content): if not href or not href.startswith('/egroupware'): continue _, _, params = href.partition('!') if not params: continue competition = params.replace("&", "::") + '.json' filename = os.path.join(target_directory, competition) if os.path.exists(filename): print("File already exists: %r" % filename) continue print("fetching competition %r" % params) response = requests.get(json_url + params) if not response.ok: print("Error while fetchin data") continue jresp = json.loads(response.text) with open(filename, "w") as f: f.write(json.dumps(jresp, indent=4))

def fetch_configs(config=''): """ Fetch config files from the remote, via rsync. Specify a config directory, such as 'cylinder' to copy just one config. Config files are stored as, e.g. cylinder/config.dat and cylinder/config.xml Local path to use is specified in machines_user.json, and should normally point to a mount on entropy, i.e. /store4/blood/username/config_files This method is not intended for normal use, but is useful when the local machine cannot have an entropy mount, so that files can be copied to a local machine from entropy, and then transferred to the compute machine, via 'fab entropy fetch_configs; fab legion put_configs' """ with_config(config) if env.manual_gsissh: local( template( "globus-url-copy -cd -r -sync \ gsiftp://$remote/$job_config_path/ \ file://$job_config_path_local/" ) ) else: local( template( "rsync -pthrvz $username@$remote:$job_config_path/ \ $job_config_path_local" ) )

def test_bytes_head(path): """It should get the first lines of a file as bytes""" assert bytes_head(path('0_0.csv'), 1) == b'a,b\n' assert bytes_head(path('0_0.csv'), 100) == b'a,b\n0,0\n0,1'

def reminder() -> None: """Send reminder if no entry as of certian times""" utc_now = pytz.utc.localize(datetime.datetime.utcnow()) # Heroku scheduler usually runs a couple mins after hour, not at top, so just hour compared now = datetime.datetime.strftime(utc_now.astimezone(pytz.timezone("America/Chicago")), '%I: %p') if now in ["11: AM", "02: PM", "05: PM", "08: PM"]: if entry_today() == "no": sms_sender("I haven't heard from you today. How are you feeling? Reply with a # for: sleep, stress, joints," " energy, and your mood.", "+12064036747")

def optimize_centers_mvuiq(A, B, Q, centers, keep_sparsity=True): """ minimize reconstruction error after weighting by matrix A and make it unbiased min_{c_i} \|A.(\sum_i Q_i c_i) - B\|_F^2 such that sum(B-A(\sum_i Q_i c_i)) = 0 """ num_levels = len(centers) thr = sla.norm(A) * 1e-6 # 1- compute A*(Q==i) and store it. find the non-empty quantization bins in the process valid_idx = [] AQ = [np.zeros(1) for _ in range(num_levels)] for i in range(num_levels): AQ[i] = np.matmul(A, Q == i) if (sla.norm(AQ[i]) >= thr) and ((centers[i] != 0) or not keep_sparsity): # check whether the i-th bin has any effect on the quantization performance and # do not consider sparse values (center=0) valid_idx += [i] if not valid_idx: return # 2- find the optimum reconstruction points for the non-empty quantization bins # 2.a- create matrix M, used in the optimization problem num_valid = len(valid_idx) d = np.sum(B) f = np.zeros(num_valid) M = np.zeros(shape=(num_valid, num_valid)) e = np.zeros(shape=num_valid) for r in range(num_valid): f[r] = np.sum(AQ[valid_idx[r]]) for c in range(r, num_valid): # trace(AQ[valid_idx[c]].T @ AQ[valid_idx[r]]) M[r, c] = np.sum(AQ[valid_idx[c]] * AQ[valid_idx[r]]) M[c, r] = M[r, c] # trace(B.T @ AQ[valid_idx[r]]) e[r] = np.sum(AQ[valid_idx[r]] * B) # 2.b- solve for min |Mx-e| such that fx=d if num_valid == 0: v = 0 elif num_valid == 1: v = d / f[0] elif num_valid == 2: # for the special binary case, the solution can be found easily scale = sla.norm(f) + 1e-12 f /= scale d /= scale u = np.array([-f[1], f[0]]) a = (e - d * M.dot(f)).dot(u) / (M.dot(u).dot(u) + 1e-12) v = d * f + a * u else: # use quadratic programming (Goldfarb-Idnani algorithm) to solve the problem d = np.array([d]).astype(np.float) f = np.reshape(f, newshape=(-1, 1)) v = quadprog.solve_qp(M, e, f, d, 1)[0] # 3- copy the found center points centers[valid_idx] = v return centers

def container_instance_task_arns(cluster, instance_arn): """Fetch tasks for a container instance ARN.""" arns = ecs.list_tasks(cluster=cluster, containerInstance=instance_arn)['taskArns'] return arns

def sierpinski_triangle(order, length, upper_left_x, upper_left_y): """ :param order: int, the order of Sierpinski Triangle :param length: int, the length of order n Sierpinski Triangle :param upper_left_x: str, the upper left x coordinate of order n Sierpinski Triangle :param upper_left_y: str, the upper left y coordinate of order n Sierpinski Triangle :return: no return value in this function """ if order == 0: pass else: draw_tri(length, upper_left_x, upper_left_y) # upper left triangle sierpinski_triangle(order-1, length/2, upper_left_x, upper_left_y) # upper right triangle sierpinski_triangle(order-1, length/2, upper_left_x+length*0.5, upper_left_y) # bottom triangle sierpinski_triangle(order-1, length/2, upper_left_x+length*0.25, upper_left_y+length*0.433)

def control_logic(center_x,center_y): """ Purpose: --- This function should implement the control logic to balance the ball at a particular setpoint on the table. The orientation of the top table should "ONLY" be controlled by the servo motor as we would expect in a practical scenario. Hence "ONLY" the shaft of the servo motor or in other words the revolute joint between servo and servo fin should have 'motor enabled' and 'control loop enabled option' checked. Refer documentation for further understanding of these options. This function should use the necessary Legacy Python Remote APIs to control the revolute joints. NOTE: In real life, a 180 degree servo motor can rotate between -90 to +90 degrees or -1.57 to 1.57 radians only. Hence the command to be sent to servo motor should be between this range only. When the top plate is parallel to base plate, the revolute joint between servo and servo fin should be at 0 degrees orientation. Refer documentation for further understanding. NOTE: Since the simulation is dynamic in nature there should not by any bottlenecks in this code due to which the processing may take a lot of time. As a result 'control_logic' function should be called in every iteration of the while loop. Use global variables instead of reinitialising the varibles used in this function. Input Arguments: --- `center_x` : [ int ] the x centroid of the ball `center_y` : [ int ] the y centroid of the ball Returns: --- None Example call: --- control_logic(center_x,center_y) """ global setpoint, client_id, initial_error,setflag,setflag2,setflag3 ############## ADD YOUR CODE HERE ############## #posarray = [0,0,0,0] returnarray2 = [-1,-1,-1,-1] ##---## ##Initilialising streaming operations and getting joint properties #for i in range(4): #while returnarray2!=[0,0,0,0]: #_,posarray[0]=sim.simxGetJointPosition(client_id, handle_arr[0], sim.simx_opmode_streaming) #sim.simxSynchronousTrigger(client_id) #sim.simxSetJointTargetVelocity(client_id,handle_arr[0],360*np.pi/180,sim.simx_opmode_oneshot) #sim.simxSetJointMaxForce(client_id,handle_arr[0],10000,sim.simx_opmode_oneshot) #returnarray2[0]=sim.simxSetJointTargetPosition(client_id,handle_arr[0],0,sim.simx_opmode_oneshot) #_,posarray[1]=sim.simxGetJointPosition(client_id, handle_arr[1], sim.simx_opmode_streaming) #sim.simxSynchronousTrigger(client_id) #sim.simxSetJointTargetVelocity(client_id,handle_arr[0],360*np.pi/180,sim.simx_opmode_oneshot) #sim.simxSetJointMaxForce(client_id,handle_arr[0],10000,sim.simx_opmode_oneshot) #returnarray2[1]=sim.simxSetJointTargetPosition(client_id,handle_arr[1],0,sim.simx_opmode_oneshot) #_,posarray[2]=sim.simxGetJointPosition(client_id, handle_arr[2], sim.simx_opmode_streaming) ##sim.simxSynchronousTrigger(client_id) #sim.simxSetJointTargetVelocity(client_id,handle_arr[0],360*np.pi/180,sim.simx_opmode_oneshot) #sim.simxSetJointMaxForce(client_id,handle_arr[0],10000,sim.simx_opmode_oneshot) #returnarray2[2]=sim.simxSetJointTargetPosition(client_id,handle_arr[2],0,sim.simx_opmode_oneshot) #_,posarray[3]=sim.simxGetJointPosition(client_id, handle_arr[3], sim.simx_opmode_streaming) #sim.simxSynchronousTrigger(client_id) #sim.simxSetJointTargetVelocity(client_id,handle_arr[0],360*np.pi/180,sim.simx_opmode_oneshot) #sim.simxSetJointMaxForce(client_id,handle_arr[0],10000,sim.simx_opmode_oneshot) #returnarray2[3]=sim.simxSetJointTargetPosition(client_id,handle_arr[3],0,sim.simx_opmode_oneshot) #print(_,"pos code") print("out") #sim.simxGetPingTime(client_id) initial_error.append(center_x) initial_error.append(center_y) setflag=False setflag2=False setflag3=False perror_x=0 perror_y=0 control_angle(handle_arr,center_x,center_y) #print(sim.simxGetPingTime(client_id)) #sim.simxSynchronousTrigger(client_id) #center_x, center_y = ##################################################

def benchmark(pipelines=None, datasets=None, hyperparameters=None, metrics=METRICS, rank='f1', distributed=False, test_split=False, detrend=False, output_path=None): """Evaluate pipelines on the given datasets and evaluate the performance. The pipelines are used to analyze the given signals and later on the detected anomalies are scored against the known anomalies using the indicated metrics. Finally, the scores obtained with each metric are averaged accross all the signals, ranked by the indicated metric and returned on a ``pandas.DataFrame``. Args: pipelines (dict or list): dictionary with pipeline names as keys and their JSON paths as values. If a list is given, it should be of JSON paths, and the paths themselves will be used as names. If not give, all verified pipelines will be used for evaluation. datasets (dict or list): dictionary of dataset name as keys and list of signals as values. If a list is given then it will be under a generic name ``dataset``. If not given, all benchmark datasets will be used used. hyperparameters (dict or list): dictionary with pipeline names as keys and their hyperparameter JSON paths or dictionaries as values. If a list is given, it should be of corresponding order to pipelines. metrics (dict or list): dictionary with metric names as keys and scoring functions as values. If a list is given, it should be of scoring functions, and they ``__name__`` value will be used as the metric name. If not given, all the available metrics will be used. rank (str): Sort and rank the pipelines based on the given metric. If not given, rank using the first metric. distributed (bool): Whether to use dask for distributed computing. If not given, use ``False``. test_split (bool or float): Whether to use the prespecified train-test split. If float, then it should be between 0.0 and 1.0 and represent the proportion of the signal to include in the test split. If not given, use ``False``. detrend (bool): Whether to use ``scipy.detrend``. If not given, use ``False``. output_path (str): Location to save the intermediatry results. If not given, intermediatry results will not be saved. Returns: pandas.DataFrame: Table containing the scores obtained with each scoring function accross all the signals for each pipeline. """ pipelines = pipelines or VERIFIED_PIPELINES datasets = datasets or BENCHMARK_DATA if isinstance(pipelines, list): pipelines = {pipeline: pipeline for pipeline in pipelines} if isinstance(datasets, list): datasets = {'dataset': datasets} if isinstance(hyperparameters, list): hyperparameters = {pipeline: hyperparameter for pipeline, hyperparameter in zip(pipelines.keys(), hyperparameters)} if isinstance(metrics, list): metrics_ = dict() for metric in metrics: if callable(metric): metrics_[metric.__name__] = metric elif metric in METRICS: metrics_[metric] = METRICS[metric] else: raise ValueError('Unknown metric: {}'.format(metric)) metrics = metrics_ results = _evaluate_datasets( pipelines, datasets, hyperparameters, metrics, distributed, test_split, detrend) if output_path: LOGGER.info('Saving benchmark report to %s', output_path) results.to_csv(output_path) return _sort_leaderboard(results, rank, metrics)

def notNone(arg,default=None): """ Returns arg if not None, else returns default. """ return [arg,default][arg is None]

def get_scorer(scoring): """Get a scorer from string """ if isinstance(scoring, str) and scoring in _SCORERS: scoring = _SCORERS[scoring] return _metrics.get_scorer(scoring)

def triangle_num(value: int) -> int: """Returns triangular number for a given value. Parameters ---------- value : int Integer value to use in triangular number calculaton. Returns ------- int Triangular number. Examples: >>> triangle_num(0) 0 >>> triangle_num(1) 1 >>> triangle_num(4) 10 >>> triangle_num(10) 55 >>> triangle_num("A") Traceback (most recent call last): ... TypeError: '>' not supported between instances of 'str' and 'int' >>> triangle_num(-1) Traceback (most recent call last): ... TypeError: Please use positive integer value """ if value >= 0: tot : list = [0] def recur(n: int, t: list) -> Iterator: if n > 0: t[0] += n n -= 1 return recur(n, t) recur(value, tot) return tot[0] raise ValueError("Please use positive integer value.")

def show_whole_td_msg(whole_td_msg): """ 显示完整的td_msg :param whole_td_msg: np.ndarray, shape=(20, 16, 200, 1000) :return: """ img_path = '../tmp/td_msg' for tag in range(20): final = np.zeros((200, 1000), dtype=np.uint8) for i in range(16): pic = np.zeros((200, 1000), dtype=np.uint8) for r, bur in enumerate(whole_td_msg[tag, i]): for c, buc in enumerate(bur): if buc >= 1: pic[r, c] += buc final += pic for r, bur in enumerate(final): for c, buc in enumerate(bur): final[r, c] = int(255 * buc) img_name = img_path+'/'+str(tag)+'.bmp' cv.imwrite(img_name, final)

def locations_sim_euclidean(image:DataBunch, **kwargs): """ A locations similarity function that uses euclidean similarity between vectors. Predicts the anatomical locations of the input image, and then returns the eucliean similarity between the input embryo's locations vector and the locations vectors of the database embryos. Euclidean similarity and distance are computed between unnormalized, one-hot locations vectors. The euclidean similarity between two locations vectors is defined as 1/(1 + euclidean distance). Arguments: - image: The input image DataBunch Returns: A tensor of similarity values (one for each database image). Each similarity score is the euclidean similarity between locations vectors. """ locations_pred = run_inference(image, do_stage=False)[0] _, database_image_locations = retrieve_predictions() euclidean_distance = torch.norm(database_image_locations-locations_pred, dim=1).unsqueeze(1) return 1/(1+euclidean_distance)

def assert_almost_equal( actual: Tuple[numpy.float64, numpy.float64], desired: List[numpy.float64], decimal: int, err_msg: Literal["(4, 200)normal"], ): """ usage.statsmodels: 1 """ ...

def _butter_bandpass_filter(data, low_cut, high_cut, fs, axis=0, order=5): """Apply a bandpass butterworth filter with zero-phase filtering Args: data: (np.array) low_cut: (float) lower bound cutoff for high pass filter high_cut: (float) upper bound cutoff for low pass filter fs: (float) sampling frequency in Hz axis: (int) axis to perform filtering. order: (int) filter order for butterworth bandpass Returns: bandpass filtered data. """ nyq = 0.5 * fs b, a = butter(order, [low_cut / nyq, high_cut / nyq], btype="band") return filtfilt(b, a, data, axis=axis)

def transform_and_normalize(vecs, kernel, bias): """应用变换，然后标准化 """ if not (kernel is None or bias is None): vecs = (vecs + bias).dot(kernel) return vecs / (vecs**2).sum(axis=1, keepdims=True)**0.5

def mpesa_response(r): """ Create MpesaResponse object from requests.Response object Arguments: r (requests.Response) -- The response to convert """ r.__class__ = MpesaResponse json_response = r.json() r.response_description = json_response.get('ResponseDescription', '') r.error_code = json_response.get('errorCode') r.error_message = json_response.get('errorMessage', '') return r

def swap_flies(dataset, indices, flies1=0, flies2=1): """Swap flies in dataset. Caution: datavariables are currently hard-coded! Caution: Swap *may* be in place so *might* will alter original dataset. Args: dataset ([type]): Dataset for which to swap flies indices ([type]): List of indices at which to swap flies. flies1 (int or list/tuple, optional): Either a single value for all indices or a list with one value per item in indices. Defaults to 0. flies2 (int or list/tuple, optional): Either a single value for all indices or a list with one value per item in indices. Defaults to 1. Returns: dataset with swapped indices () """ for cnt, index in enumerate(indices): if isinstance(flies1, (list, tuple)) and isinstance(flies2, (list, tuple)): fly1, fly2 = flies1[cnt], flies2[cnt] else: fly1, fly2 = flies1, flies2 if 'pose_positions_allo' in dataset: dataset.pose_positions_allo.values[index:, [fly2, fly1], ...] = dataset.pose_positions_allo.values[index:, [fly1, fly2], ...] if 'pose_positions' in dataset: dataset.pose_positions.values[index:, [fly2, fly1], ...] = dataset.pose_positions.values[index:, [fly1, fly2], ...] if 'body_positions' in dataset: dataset.body_positions.values[index:, [fly2, fly1], ...] = dataset.body_positions.values[index:, [fly1, fly2], ...] return dataset

def get_log_events(logGroupName=None, logStreamName=None, startTime=None, endTime=None, nextToken=None, limit=None, startFromHead=None): """ Lists log events from the specified log stream. You can list all the log events or filter using a time range. By default, this operation returns as many log events as can fit in a response size of 1MB (up to 10,000 log events). If the results include tokens, there are more log events available. You can get additional log events by specifying one of the tokens in a subsequent call. See also: AWS API Documentation :example: response = client.get_log_events( logGroupName='string', logStreamName='string', startTime=123, endTime=123, nextToken='string', limit=123, startFromHead=True|False ) :type logGroupName: string :param logGroupName: [REQUIRED] The name of the log group. :type logStreamName: string :param logStreamName: [REQUIRED] The name of the log stream. :type startTime: integer :param startTime: The start of the time range, expressed as the number of milliseconds since Jan 1, 1970 00:00:00 UTC. Events with a timestamp earlier than this time are not included. :type endTime: integer :param endTime: The end of the time range, expressed as the number of milliseconds since Jan 1, 1970 00:00:00 UTC. Events with a timestamp later than this time are not included. :type nextToken: string :param nextToken: The token for the next set of items to return. (You received this token from a previous call.) :type limit: integer :param limit: The maximum number of log events returned. If you don't specify a value, the maximum is as many log events as can fit in a response size of 1MB, up to 10,000 log events. :type startFromHead: boolean :param startFromHead: If the value is true, the earliest log events are returned first. If the value is false, the latest log events are returned first. The default value is false. :rtype: dict :return: { 'events': [ { 'timestamp': 123, 'message': 'string', 'ingestionTime': 123 }, ], 'nextForwardToken': 'string', 'nextBackwardToken': 'string' } """ pass

def test_event_data(create_main_loop): """Test after_epoch and after_batch event args match the expectation.""" recording_hook = DataRecordingHook() model, dataset, mainloop = create_main_loop(epochs=3, model_class=RecordingModel, extra_hooks=[recording_hook], extra_streams=['valid']) mainloop.run_training() # check the epoch ids assert recording_hook.epoch_ids == [1, 2, 3] assert model.is_train_data == [True]*_DATASET_ITERS+[False]*_DATASET_ITERS+[True]*_DATASET_ITERS + \ [False]*_DATASET_ITERS+[True]*_DATASET_ITERS+[False]*_DATASET_ITERS # now the model recorded its outputs as a list of all the batches regardless the stream and epoch, i.e.: # [train_e1_b1, train_e1_b2, ..., valid_e1_b1, ... train_e2,b1, ...] # while the DataRecordingHook has the following structure: # {'train': [train_e1_b1, train_e1,b2, ..., train_e2,b1, ...], 'valid': [...]} # we will convert the 'model structure' to the 'hook structure' so that they are comparable def chunks(list_, size): """Split the given list_ into chunks of size consecutive elements.""" for i in range(0, len(list_), size): yield list_[i:i + size] output_data = model.output_data # pylint: disable=no-member input_data = model.input_data # pylint: disable=no-member model_outputs_by_stream_list = list(zip(*[(epoch[:len(epoch)//2], epoch[len(epoch)//2:]) for epoch in chunks(output_data, _DATASET_ITERS*2)])) model_inputs_by_stream_list = list(zip(*[(epoch[:len(epoch)//2], epoch[len(epoch)//2:]) for epoch in chunks(input_data, _DATASET_ITERS*2)])) model_outputs_by_stream = {'train': sum(model_outputs_by_stream_list[0], []), 'valid': sum(model_outputs_by_stream_list[1], [])} model_inputs_by_stream = {'train': sum(model_inputs_by_stream_list[0], []), 'valid': sum(model_inputs_by_stream_list[1], [])} # for all the streams for stream_name in ['valid', 'train']: assert stream_name in recording_hook.batch_data io_data = zip(recording_hook.batch_data[stream_name], model_outputs_by_stream[stream_name], model_inputs_by_stream[stream_name], dataset.batches[stream_name]) for hook_data, model_outputs, model_inputs, batches in io_data: # check if the hook_data and model_inputs contain correct stream sources for source_name in dataset.source_names: assert source_name in hook_data assert source_name in model_inputs assert np.alltrue(hook_data[source_name] == batches[source_name]) assert np.alltrue(model_inputs[source_name] == batches[source_name]) # check if the hook_data contains correct model outputs for output_name in model.output_names: assert output_name in hook_data assert np.alltrue(hook_data[output_name] == model_outputs[output_name])

def periodic_kernel(avetoas, log10_sigma=-7, log10_ell=2, log10_gam_p=0, log10_p=0): """Quasi-periodic kernel for DM""" r = np.abs(avetoas[None, :] - avetoas[:, None]) # convert units to seconds sigma = 10**log10_sigma l = 10**log10_ell * 86400 p = 10**log10_p * 3.16e7 gam_p = 10**log10_gam_p d = np.eye(r.shape[0]) * (sigma/500)**2 K = sigma**2 * np.exp(-r**2/2/l**2 - gam_p*np.sin(np.pi*r/p)**2) + d return K

def emails(request): """ A view to send emails out to hunt participants upon receiving a valid post request as well as rendering the staff email form page """ teams = Hunt.objects.get(is_current_hunt=True).real_teams people = [] for team in teams: people = people + list(team.person_set.all()) email_list = [person.user.email for person in people] if request.method == 'POST': email_form = EmailForm(request.POST) if email_form.is_valid(): subject = email_form.cleaned_data['subject'] message = email_form.cleaned_data['message'] email_to_chunks = [email_list[x: x + 80] for x in range(0, len(email_list), 80)] for to_chunk in email_to_chunks: email = EmailMessage(subject, message, 'puzzlehuntcmu@gmail.com', [], to_chunk) email.send() return HttpResponseRedirect('') else: email_form = EmailForm() context = {'email_list': (', ').join(email_list), 'email_form': email_form} return render(request, 'email.html', add_apps_to_context(context, request))

def _stochastic_universal_sampling(parents: Population, prob_distribution: list, n: int): """ Stochastic universal sampling (SUS) algorithm. Whenever more than one sample is to be drawn from the distribution the use of the stochastic universal sampling algorithm is preferred compared to roulette wheel algorithm. Parameters ---------- :param parents: beagle.Population Population from which n individuals are going to be selected. :param prob_distribution: list Cumulative probability distribution. :param n: int Length of the selected population. Returns ------- :return: list of beagle.Individual Selected individuals. Exceptions ----------- :raise Exception If the algorithm enters an infinite loop because random_num is greater than 1 an exception will occur. """ current_member, i = 0, 0 mating_pool = [None] * n random_num = np.random.uniform(low=0, high=(1/n)) while current_member < n: while random_num <= prob_distribution[i]: mating_pool[current_member] = parents[i] random_num += 1 / n current_member += 1 if random_num > 1: raise Exception( 'The SUS algorithm has entered an infinite loop. Verify that the selected population ' 'sizes are suitable for this type of operator.') i += 1 mating_pool = [deepcopy(individual) for individual in mating_pool] # Make a deepcopy of each selected individual return mating_pool

def format_exception_with_frame_info(e_type, e_value, e_traceback, shorten_filenames=False): """Need to suppress thonny frames to avoid confusion""" _traceback_message = "Traceback (most recent call last):\n" _cause_message = getattr( traceback, "_cause_message", ("\nThe above exception was the direct cause " + "of the following exception:") + "\n\n", ) _context_message = getattr( traceback, "_context_message", ("\nDuring handling of the above exception, " + "another exception occurred:") + "\n\n", ) def rec_format_exception_with_frame_info(etype, value, tb, chain=True): # Based on # https://www.python.org/dev/peps/pep-3134/#enhanced-reporting # and traceback.format_exception if etype is None: etype = type(value) if tb is None: tb = value.__traceback__ if chain: if value.__cause__ is not None: yield from rec_format_exception_with_frame_info(None, value.__cause__, None) yield (_cause_message, None, None, None) elif value.__context__ is not None and not value.__suppress_context__: yield from rec_format_exception_with_frame_info(None, value.__context__, None) yield (_context_message, None, None, None) if tb is not None: yield (_traceback_message, None, None, None) tb_temp = tb for entry in traceback.extract_tb(tb): assert tb_temp is not None # actual tb doesn't end before extract_tb if "cpython_backend" not in entry.filename and ( not entry.filename.endswith(os.sep + "ast.py") or entry.name != "parse" or etype is not SyntaxError ): fmt = ' File "{}", line {}, in {}\n'.format( entry.filename, entry.lineno, entry.name ) if entry.line: fmt += " {}\n".format(entry.line.strip()) yield (fmt, id(tb_temp.tb_frame), entry.filename, entry.lineno) tb_temp = tb_temp.tb_next assert tb_temp is None # tb was exhausted for line in traceback.format_exception_only(etype, value): if etype is SyntaxError and line.endswith("^\n"): # for some reason it may add several empty lines before ^-line partlines = line.splitlines() while len(partlines) >= 2 and partlines[-2].strip() == "": del partlines[-2] line = "\n".join(partlines) + "\n" yield (line, None, None, None) items = rec_format_exception_with_frame_info(e_type, e_value, e_traceback) return list(items)

def _add_simple_procparser(subparsers, name, helpstr, func, defname='proc', xd=False, yd=False, dualy=False, other_ftypes=True): """Add a simple subparser.""" parser = _add_procparser(subparsers, name, helpstr, func, defname=defname) _add_def_args(parser, xd=xd, yd=yd, dualy=dualy) return parser

def save_instrument_data_reference(msg_struct): """Checks to see if there is already an instrument data reference for this event code, and if there isn't, creates one. Instrument data references are used to allow the servers to track which events are pertinent to a particular instrument (some events are for all instruments, some only for specific instrument types). If an instrument data reference is to be added, this function also determines whether the reference is 'special' or not. If there is an entire special table devoted to the event (where 'description' is the table name), then it is classified as 'special'. Parameters ---------- msg_struct: dictionary Decoded version of msg, converted to python dictionary. """ db_refs = db.session.query(InstrumentDataReference)\ .filter(InstrumentDataReference.instrument_id == msg_struct['data']['instrument_id'])\ .filter(InstrumentDataReference.description == msg_struct['data']['description']).all() if not db_refs: special = "false" # "special" indicates whether this particular data description has its own table rows = db.session.execute('''SELECT column_name FROM information_schema.columns WHERE table_name = :table''', dict(table=msg_struct['data']['description'])).fetchall() if rows: special = "true" new_instrument_data_ref = InstrumentDataReference() new_instrument_data_ref.instrument_id = msg_struct['data']['instrument_id'] new_instrument_data_ref.description = msg_struct['data']['description'] new_instrument_data_ref.special = special db.session.add(new_instrument_data_ref) db.session.commit() EM_LOGGER.info("Saved new instrument data reference")

def addSortMethod(handle, sortMethod): """A stub implementation of the xbmcplugin addSortMethod() function""" return

def get_volumes(fn): """Return number of volumes in nifti""" return int(subprocess.check_output(['fslnvols', fn]))

async def _execSubprocess(command: str) -> tuple[int, bytes]: """Execute a command and check for errors. Args: command (str): commands as a string Returns: tuple[int, bytes]: tuple of return code (int) and stdout (str) """ async with SEM: process = await asyncio.create_subprocess_shell( command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, ) out = await process.communicate() exitCode = process.returncode return exitCode, out[0]

def submit_job(app_id, app_key, task_id, mimetype, text_col, dedupe): """Submit a job to the queue for the Celery worker. Create the required JSON message and post it to RabbitMQ.""" # These are the args that the Python function in the adjunct processor will use. kwargs = {"app_id": app_id, "app_key": app_key, "task_id": task_id, "format": mimetype, "text_col": text_col, "dedupe": dedupe, "s3_endpoint": S3ENDPOINT, "bucket": BUCKET, "redis_port": REDISPORT, "redis_host": REDISHOST} # Recreate a celery message manually so that we don't need to import celery_tasks.py which has heavy dependencies. job = {"id": task_id, # "task": "synapsify_adjunct.celery_tasks.synapsify_master", "task": "dc2_master", "kwargs": kwargs} # Connect to RabbitMQ and post. conn = amqp.Connection(host=RMQHOST, port=RMQPORT, userid=RMQUSERNAME, password=RMQPASSWORD, virtual_host=RMQVHOST, insist=False) cha = conn.channel() msg = amqp.Message(json.dumps(job)) msg.properties["content_type"] = "application/json" cha.basic_publish(routing_key=RMQEXCHANGE, msg=msg) cha.close() conn.close()

def comprspaces(*args): """ .. function:: comprspaces(text1, [text2,...]) -> text This function strips (from the beginning and the end) and compresses the spaces in its input. Examples: >>> table1(''' ... ' an example with spaces ' 'another example with spaces ' ... ''') >>> sql("select comprspaces(a,b) from table1") comprspaces(a,b) -------------------------------------------------- an example with spaces another example with spaces """ if len(args) == 1: return reduce_spaces.sub(' ', strip_remove_newlines.sub('', args[0])) out=[] for i in args: o=reduce_spaces.sub(' ', strip_remove_newlines.sub('', i)) out+=[o] return ' '.join(out)

def find_available_port(): """Find an available port. Simple trick: open a socket to localhost, see what port was allocated. Could fail in highly concurrent setups, though. """ s = socket.socket() s.bind(('localhost', 0)) _address, port = s.getsockname() s.close() return port

def redirect_std(): """ Connect stdin/stdout to controlling terminal even if the scripts input and output were redirected. This is useful in utilities based on termenu. """ stdin = sys.stdin stdout = sys.stdout if not sys.stdin.isatty(): sys.stdin = open_raw("/dev/tty", "r", 0) if not sys.stdout.isatty(): sys.stdout = open_raw("/dev/tty", "w", 0) return stdin, stdout

def merge_deep(dct1, dct2, merger=None): """ Deep merge by this spec below :param dct1: :param dct2: :param merger Optional merger :return: """ my_merger = merger or Merger( # pass in a list of tuples,with the # strategies you are looking to apply # to each type. [ (list, ["append"]), (dict, ["merge"]) ], # next, choose the fallback strategies, # applied to all other types: ["override"], # finally, choose the strategies in # the case where the types conflict: ["override"] ) return my_merger.merge(dct1, dct2)

def step( context, bind_to, data, title='', area=False, x_is_category=False, labels=False, vertical_grid_line=False, horizontal_grid_line=False, show_legend=True, zoom=False, group_tooltip=True, height=None, width=None ): """Generates javascript code to show a 'step' chart. Args: context: Context of template. bind_to: A string that specifics an HTML element (eg: id or class) that chart will be shown in that. (like: '#chart') data: It is dictinary that contains data of chart, some informations about extra lines, grouping of data and chart axis labels. eg: { 'x': ['2017-5-19', '2017-5-20', '2017-5-21', '2017-5-22'], 'horizontal_lines': [40], # 'vertical_lines': [40], 'data': [ {'title': 'A', 'values': [26, 35, 52, 34, 45, 74], 'color': '#FF34FF'}, # {'title': 'B', 'values': [54, 25, 52, 26, 20, 89]}, ], # 'groups': [('A', 'B')] } vertical_lines works just if x_is_category seted to False. title: A string that will be shown on top of the chart. area: It's a boolean option. If true, the area under the curve will be colored. x_is_category: It's a boolean option. If false, labels of X axis will be considered as real number and sortable. (they will be sorted automatically) labels: It's a boolean option. If true, value of record will be shown on column. vertical_grid_line: It's boolean option, If true some vertical rows will be drawn in chart. (grid lines) horizontal_grid_line: It's boolean option, If true some horizontal rows will be drawn in chart. (grid lines) show_legend: It's boolean option, If false, legends of the chart will be hidden. zoom: It's boolean option, If true, end user can scroll on chart to zoom in and zoom out. group_tooltip: It's boolean option, If true, data of all records in that point whill be shown to gather. height: It's an integer option, it will determine heigth of chart in pixel. width: It's an integer option, it will determine width of chart in pixel. Returns: A string contains chart js code and import code of C3 static files, if it did not imported yet. You can see structure of chart in chart_structur variable. """ # step chart structure in JS chart_structur = ( '\n<script type="text/javascript">' '\n var chart = c3.generate({' '\n bindto: "%s",' '\n data: {' '\n x: %s,' '\n columns: [' '\n %s' '\n ],' '\n type : "%s",' '\n colors: {' '\n %s' '\n },' '\n groups: [' '\n %s' '\n ],' '\n labels : %s' '\n },' '\n title: { text: "%s"},' '\n axis: { x: { type: "%s" } },' '\n grid: {' '\n x: { show: %s ,lines: [%s] },' '\n y: { show: %s ,lines: [%s] },' '\n },' '\n legend: { show: %s },' '\n zoom: { enabled: %s },' '\n tooltip: { grouped: %s },' '\n size: { height: %s, width: %s }' '\n });' '\n</script>' ) # convert parameters to strings to be acceptable in JS and C3 syntax. if area: _type = 'area-step' else: _type = 'step' if x_is_category: x_type = 'category' else: x_type = '' if labels: labels = 'true' else: labels = 'false' if vertical_grid_line: vertical_grid_line = 'true' else: vertical_grid_line = 'false' if horizontal_grid_line: horizontal_grid_line = 'true' else: horizontal_grid_line = 'false' if show_legend: show_legend = 'true' else: show_legend = 'false' if zoom: zoom = 'true' else: zoom = 'false' if group_tooltip: group_tooltip = 'true' else: group_tooltip = 'false' if height is not None: height = int(height) else: height = 'null' if width is not None: width = int(width) else: width = 'null' # read horizontal line points from data horizontal_lines = str() if 'horizontal_lines' in data.keys(): for line in data['horizontal_lines']: horizontal_lines = ''.join([horizontal_lines, '{ value: %s}' % line, ',']) # read vertical line points from data # raise an exception if x_is_category set to true and vertical_lines exists vertical_lines = str() if 'vertical_lines' in data.keys(): if x_is_category: raise Exception( "It's meaningless to use vertical_lines with x_is_category." ) for line in data['vertical_lines']: vertical_lines = ''.join( [vertical_lines, '{ value: %s}' % line, ',']) # reads 'x' field of data and creates X axis labels. # a hash is used to naming X axis labels x_labels = str() if 'x' in data.keys(): if x_is_category: x_labels = data['x'] else: x_labels = list(filter(lambda x: int(x), data['x'])) x_labels = ','.join([repr(str(label)) for label in x_labels]) x_labels = '["2d2014226823e74c2accfcce8e0ca141", %s],' % x_labels x_label_list_name = '"2d2014226823e74c2accfcce8e0ca141"' else: x_labels = '' x_label_list_name = "null" # read records points to draw on chart data_title_list = list() chart_data = str() for item in data['data']: values = ','.join([str(v) for v in item['values']]) item_data = '["%s", %s], ' % (item['title'], values) chart_data = ' '.join([chart_data, item_data]) data_title_list.append(item['title']) # add X axis labels to chart data chart_data = ''.join([chart_data, x_labels]) # read colors of data chart_color = str() for item in data['data']: if 'color' in item.keys(): item_color = '"%s": "%s", ' % (item['title'], item['color']) chart_color = ' '.join([chart_color, item_color]) # read grouping details of data total_group_string = str() if 'groups' in data.keys(): for group in data['groups']: group_string = str() for item in group: # raise an exception if mentioned key were not exist in data if item not in data_title_list: raise ValueError("%s is not exists in your data!" % item) group_string = ''.join([group_string, ',', repr(item)]) total_group_string = ''.join( [total_group_string, '[', group_string, ']', ',']) # pass arguments to chart structure chart = chart_structur % ( bind_to, x_label_list_name, chart_data, _type, chart_color, total_group_string, labels, title, x_type, vertical_grid_line, vertical_lines, horizontal_grid_line, horizontal_lines, show_legend, zoom, group_tooltip, height, width ) # add import C3 elements to it, if it does not imported yet and return it. if not ('import_js_c3' in context and context['import_js_c3']): context['import_js_c3'] = True return mark_safe('%s\n%s' % (import_c3(), chart)) else: return mark_safe(chart)

def get(user_request, url, **kwargs): """ A wrapper of requests.get. This method will automatically add user's session key as the cookie to enable sso Sends a GET request. Returns :class:`Response` object. :param user_request: The http request contains the authentication key and is triggered by user. :param url: URL for the new :class:`Request` object. :param \*\*kwargs: Optional arguments that ``request`` takes. """ _set_session_key(user_request, kwargs) if debug: log(user_request, url, "GET", kwargs=kwargs) return requests.get(url, **kwargs)

def get_baseline_y(line: PageXMLTextLine) -> List[int]: """Return the Y/vertical coordinates of a text line's baseline.""" if line_starts_with_big_capital(line): return [point[1] for point in line.baseline.points if point[1] < line.baseline.bottom - 20] else: return [point[1] for point in line.baseline.points]

def get_device_type(dev, num_try=1): """ Tries to get the device type with delay """ if num_try >= MAX_DEVICE_TYPE_CHECK_RETRIES: return time.sleep(1) # if devtype is checked to early it is reported as 'unknown' iface = xwiimote.iface(dev) device_type = iface.get_devtype() if not device_type or device_type == 'unknown': return get_device_type(dev, num_try + 1) return device_type

def register_barrier(): """So we don't have multiple jobs running simulateously""" register_job( user="vogels", project="sgd", experiment=experiment, job="barrier", priority=priority, n_workers=16, config_overrides={}, runtime_environment={"clone": {"code_package": code_package}, "script": "barrier.py"}, annotations={"description": description}, )

def index(): """ This is the grocery list. Concatenates the ingredients from all the upcoming recipes The ingredients dict that we pass to the template has this structure { "carrot": { "g": 200, "number": 4, "str": "200g, 4number", }, "salt": { "g": 20, "pinch": 3, "str": "20g, 3pinch", }, } If two ingredients have the same unit, I add the quantities, but trying to unify all the different ways of expressing ingredient units would be a lost cause. We add the str key because doing formatting work in the template is so much fun """ recipes = Recipe.query.filter_by(upcoming=True) ingredients = dict() for recipe in recipes: recipe_d = recipe.to_dict() for ingredient in recipe_d["ingredients"]: #worth changing the ingredients to a named tuple ? #would be better at least here name, unit, quantity = (ingredient["name"], ingredient["unit"], ingredient["quantity"]) quantity = quantity * recipe.upcoming_servings / recipe.servings if name in ingredients: if unit in ingredients[name]: ingredients[name][unit] += quantity else: ingredients[name][unit] = quantity else: ingredients[name] = { unit: quantity, } for name, d in ingredients.items(): s = ", ".join("{:g}{}".format( round(quantity, 2), unit) for unit, quantity in d.items()) ingredients[name]["str"] = s return render_template("grocery_list.html", title="Grocery list", recipes=recipes, ingredients=ingredients)

def test_Fit_MinFunc(): """ There are times where I don't pass just a simple function to the fitting algorithm. Instead I need to calculate the error myself and pass that to the model. This tests that ability. """ init = { 'm': 20, 'b': -10 } def func(X, *args): vecLinear = np.vectorize(funcs.linear) yThr = vecLinear(linearData['X'], *args) return np.sqrt(np.sum((linearData['Y'] - yThr) ** 2)) LinMod = model(func) LinMod.setParams(init) LinMod.fit(linearData['X'], linearData['Y']) results = LinMod.parameters.copy() for key in linearParams.keys(): error = np.abs((results[key]-linearParams[key])/linearParams[key])*100 assert error < 15

def BOP(data): """ Balance of Power Indicator :param pd.DataFrame data: pandas DataFrame with open, high, low, close data :return pd.Series: with indicator data calculation results """ fn = Function('BOP') return fn(data)

def get_infinite(emnist_client_data, num_pseudo_clients): """Converts a Federated EMNIST dataset into an Infinite Federated EMNIST set. Infinite Federated EMNIST expands each writer from the EMNIST dataset into some number of pseudo-clients each of whose characters are the same but apply a fixed random affine transformation to the original user's characters. The distribution over affine transformation is approximately equivalent to the one described at https://www.cs.toronto.edu/~tijmen/affNIST/. It applies the following transformations in this order: 1. A random rotation chosen uniformly between -20 and 20 degrees. 2. A random shearing adding between -0.2 to 0.2 of the x coordinate to the y coordinate (after centering). 3. A random scaling between 0.8 and 1.25 (sampled log uniformly). 4. A random translation between -5 and 5 pixels in both the x and y axes. Args: emnist_client_data: The `tff.simulation.ClientData` to convert. num_pseudo_clients: How many pseudo-clients to generate for each real client. Each pseudo-client is formed by applying a given random affine transformation to the characters written by a given real user. The first pseudo-client for a given user applies the identity transformation, so the original users are always included. Returns: An expanded `tff.simulation.ClientData`. """ num_client_ids = len(emnist_client_data.client_ids) return transforming_client_data.TransformingClientData( raw_client_data=emnist_client_data, make_transform_fn=_make_transform_fn, num_transformed_clients=(num_client_ids * num_pseudo_clients))

def extractHavingSubDomain(): """ [Passive] Sets the having_Sub_Domain feature after checking how many sub-domains the hostname has. This number include the "www." prefix and the top level domain like ".com" or ".uk" 1) -1 if the hostname has more than 3 parts after splitting along '.' ie "www." + some name + ".com". 2) 1 if the hostname has 3 or fewer parts after splitting along '.' """ list = elements.hostname.split(".") if len(list) > 3: features["having_Sub_Domain"] = -1 else: features["having_Sub_Domain"] = 1

def exec_crossover_once(ind1, ind2, cxpoint, n_degree): """single point crossover for two individuals Parameters ---------- ind1: individual 1 ind2: individual 2 cxpoint: crossover point n_degree: number of degree """ g1 = ind1.G g2 = ind2.G x = np.min(cxpoint) y = np.max(cxpoint) edge1 = set(sorted(ind1.G.edges)) edge2 = set(sorted(ind2.G.edges)) edge1_lower = {(i, j) for i, j in edge1 if i < x or (i == x and j <= y)} edge1_upper = edge1 - edge1_lower edge2_lower = {(i, j) for i, j in edge2 if i < x or (i == x and j <= y)} edge2_upper = edge2 - edge2_lower g1.remove_edges_from(edge1_lower) g1.add_edges_from(edge2_lower) g2.remove_edges_from(edge2_lower) g2.add_edges_from(edge1_lower) ind1.G = keep_regularity(g1, n_degree, random_state=0) ind2.G = keep_regularity(g2, n_degree, random_state=0) ind1.fitness = None ind2.fitness = None

def create_plot(df, title, carbon_unit, cost_unit, ylimit=None): """ :param df: :param title: string, plot title :param carbon_unit: string, the unit of carbon emissions used in the database/model, e.g. "tCO2" :param cost_unit: string, the unit of cost used in the database/model, e.g. "USD" :param ylimit: float/int, upper limit of y-axis; optional :return: """ if df.empty: return figure() # Set up data source source = ColumnDataSource(data=df) # Determine column types for plotting, legend and colors # Order of stacked_cols will define order of stacked areas in chart x_col = "period" line_col = "carbon_cap" stacked_cols = ["in_zone_project_emissions", "import_emissions_degen"] # Stacked Area Colors colors = ["#666666", "#999999"] # Set up the figure plot = figure( plot_width=800, plot_height=500, tools=["pan", "reset", "zoom_in", "zoom_out", "save", "help"], title=title, x_range=df[x_col] # sizing_mode="scale_both" ) # Add stacked bar chart to plot bar_renderers = plot.vbar_stack( stackers=stacked_cols, x=x_col, source=source, color=colors, width=0.5, ) # Add Carbon Cap target line chart to plot target_renderer = plot.circle( x=x_col, y=line_col, source=source, size=20, color="black", fill_alpha=0.2, line_width=2, ) # Create legend items legend_items = [ ("Project Emissions", [bar_renderers[0]]), ("Import Emissions", [bar_renderers[1]]), ("Carbon Target", [target_renderer]), ] # Add Legend legend = Legend(items=legend_items) plot.add_layout(legend, "right") plot.legend[0].items.reverse() # Reverse legend to match stacked order plot.legend.click_policy = "hide" # Add interactivity to the legend # Note: Doesn't rescale the graph down, simply hides the area # Note2: There's currently no way to auto-size legend based on graph size(?) # except for maybe changing font size automatically? show_hide_legend(plot=plot) # Hide legend on double click # Format Axes (labels, number formatting, range, etc.) plot.xaxis.axis_label = "Period" plot.yaxis.axis_label = "Emissions ({})".format(carbon_unit) plot.yaxis.formatter = NumeralTickFormatter(format="0,0") plot.y_range.end = ylimit # will be ignored if ylimit is None # Add delivered RPS HoverTool r_delivered = bar_renderers[0] # renderer for delivered RPS hover = HoverTool( tooltips=[ ("Period", "@period"), ( "Project Emissions", "@%s{0,0} %s (@fraction_of_project_emissions{0%%})" % (stacked_cols[0], carbon_unit), ), ], renderers=[r_delivered], toggleable=False, ) plot.add_tools(hover) # Add curtailed RPS HoverTool r_curtailed = bar_renderers[1] # renderer for curtailed RPS hover = HoverTool( tooltips=[ ("Period", "@period"), ( "Import Emissions", "@%s{0,0} %s (@fraction_of_import_emissions{0%%})" % (stacked_cols[1], carbon_unit), ), ], renderers=[r_curtailed], toggleable=False, ) plot.add_tools(hover) # Add RPS Target HoverTool hover = HoverTool( tooltips=[ ("Period", "@period"), ("Carbon Target", "@%s{0,0} %s" % (line_col, carbon_unit)), ( "Marginal Cost", "@carbon_cap_marginal_cost_per_emission{0,0} %s/%s" % (cost_unit, carbon_unit), ), ], renderers=[target_renderer], toggleable=False, ) plot.add_tools(hover) return plot

def get_app(name, **kwargs): """Returns an instantiated Application based on the name. Args: name (str): The name of the application kwargs (dict): Keyword arguments used for application instantiation Returns: deepcell.applications.Application: The instantiated application """ name = str(name).lower() app_map = dca.settings.VALID_APPLICATIONS try: return app_map[name]['class'](**kwargs) except KeyError: raise ValueError('{} is not a valid application name. ' 'Valid applications: {}'.format( name, list(app_map.keys())))

def test_subscriber__CreatorAnnotator__1(person): """`CreatorAnnotator` sets the creator on adding a person with browser.""" assert u'global editor' == IEditor(person).creator

def worker_complete(): """Complete worker.""" participant_id = request.args.get('participant_id') if not participant_id: return error_response( error_type="bad request", error_text='participantId parameter is required' ) try: _worker_complete(participant_id) except KeyError: return error_response(error_type='ParticipantId not found: {}'.format(participant_id)) return success_response(status="success")

def combine(connected_events): """ Combine connected events into a graph. :param connected_events: see polychronous.filter :return: graph_of_connected_events """ graph_of_connected_events = nx.Graph() graph_of_connected_events.add_edges_from(connected_events) return (graph_of_connected_events)

def set_config(**kwargs): """ Set SleepECG preferences and store them to the user configuration file. If a value is `None`, the corresponding key is deleted from the user configuration. See :ref:`configuration` for a list of possible settings. Parameters ---------- **kwargs: dict, optional The configuration keys and values to set. Examples -------- >>> set_config(data_dir='~/.sleepecg/datasets') """ default_config = _read_yaml(_DEFAULT_CONFIG_PATH) user_config = _read_yaml(_USER_CONFIG_PATH) # validate all parameters before setting anything for key, value in kwargs.items(): if key not in default_config: options = ', '.join(default_config) raise ValueError(f'Trying to set invalid config key: {key!r}, possible options: {options}') # noqa: E501 for key, value in kwargs.items(): if value is None: user_config.pop(key, None) else: user_config[key] = value _USER_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True) with open(_USER_CONFIG_PATH, 'w') as user_config_file: yaml.dump(user_config, user_config_file)

def calculate_hash(filepath, hash_name): """Calculate the hash of a file. The available hashes are given by the hashlib module. The available hashes can be listed with hashlib.algorithms_available.""" hash_name = hash_name.lower() if not hasattr(hashlib, hash_name): raise Exception('Hash algorithm not available : {}'\ .format(hash_name)) with open(filepath, 'rb') as f: checksum = getattr(hashlib, hash_name)() for chunk in iter(lambda: f.read(4096), b''): checksum.update(chunk) return checksum.hexdigest()

def specify_run_step( args: RunConfig, aml_resources: AMLResources, run_script_path: Path, loop_config_class: Type[OptimizerConfig], check_consistency: bool = True, ) -> Tuple[List[PythonScriptStep], List[PipelineData], Dict[str, List[str]], List[str]]: """ Create the pipeline step(s) to run the simulation. Args: aml_resources: an instance of AMLResources which contains the necessary information on AML resources to instantiate pipeline steps run_script_path: script that the run step should invoke loop_config_class: (subclass of) OptimizerConfig that should be instantiated check_consistency: whether to run data_and_simulation_are_consistent; normally we do, but this may be set to False for tests that check other parts of this functionality. Returns: A list of PythonScriptSteps, with one for each expansion, a list of output data locations in AML, a dictionary of styled subsets for plotting, and a list of the temporary spec files that have been created """ # Expand config selections_and_configs = list(load_resolutions_from_command(args, loop_config_class)) temp_spec_files = [] parallel_steps = [] all_run_outputs = [] styled_subsets: Dict[str, List[str]] = {} # For each expansion, create a PythonScriptStep to run the simulator script. num_selections = len(selections_and_configs) for index, pair_list in enumerate(selections_and_configs, 1): config0 = pair_list[0][1] if (not check_consistency) or data_and_simulation_are_consistent(config0): logging.info( f"Config resolution {index} of {num_selections} will have {len(pair_list)} runs included in pipeline" ) else: # pragma: no cover logging.error(f"Dropping config resolution {index} of {num_selections} from pipeline") continue for config_dct, config in pair_list: batch_strategy = config_dct["bayesopt"]["batch_strategy"] acquisition = config_dct["bayesopt"]["acquisition"] experiment_label = f"{batch_strategy} - {acquisition}" # TODO: what about acquisition, optimization_strategy? if batch_strategy not in styled_subsets: styled_subsets[batch_strategy] = [experiment_label] else: styled_subsets[batch_strategy].append(experiment_label) # pragma: no cover # set up the run configuration aml_run_config = RunConfiguration(_name=f"Parallel run combination {config.resolution_spec}.{config.seed}") aml_run_config.target = aml_resources.compute_target aml_run_config.environment = aml_resources.env # type: ignore # auto # create different versions of args for each combination temp_config_path = spec_file_basename(config.resolution_spec, config.seed or 0, suffix="yml") temp_spec_files.append(temp_config_path) with Path(temp_config_path).open("w") as fp: yaml.dump(config_dct, fp, Dumper=CustomDumper) args.spec_file = temp_config_path original_arg_list = sys.argv[1:] simulator_args = original_arg_list spec_file_index = simulator_args.index("--spec_file") simulator_args[spec_file_index + 1] = temp_config_path num_runs_index = simulator_args.index("--num_runs") if isinstance(num_runs_index, int) and num_runs_index >= 0: simulator_args[num_runs_index + 1] = "1" # pragma: no cover else: simulator_args += ["--num_runs", "1"] # create PipelineData to consume the output of this step in the next (plotting) step step_output = PipelineData( name=f"outputs_batch_{config.resolution_spec}_{config.seed}", output_name=f"outputs_batch_{config.resolution_spec}_{config.seed}", datastore=aml_resources.datastore, is_directory=True, ) all_run_outputs += [step_output] simulator_args += ["--output_dir", step_output] step = PythonScriptStep( script_name=str(run_script_path.absolute().relative_to(ROOT_DIR)), source_directory=ROOT_DIR, arguments=simulator_args, outputs=[step_output], compute_target=aml_resources.compute_target, runconfig=aml_run_config, ) parallel_steps.append(step) return parallel_steps, all_run_outputs, styled_subsets, temp_spec_files

def upgrade_to_blender2910(nodes): """ Blender 2.91 adds a new input to the BSDF node, emit strength in slot 18, moving the previous slot 18 up etc. Anything that connect to slot 18 or above from before 2.91 will have it's slot number increased by one. The input default values will also be updated to match :param nodes: node tree as dict, nodes or groups """ _BSDF_node_names = [] print('Upgrading nodes to Blender 2.91...') for n in nodes: node = nodes[n] if node['bl_idname'] == 'ShaderNodeBsdfPrincipled': # Save the node name for so connections can be updated _BSDF_node_names.append(node['name']) # Shift the input default values slots up for i in reversed(range(18, 22 + 1)): nodes[n]['inputs'][str(i)] = node['inputs'][str(i-1)] del nodes[n]['inputs']['18'] for n in nodes: node = nodes[n] try: for output, targets in node['outputs'].items(): for name, ids in targets.items(): if name in _BSDF_node_names: # increment if the slot is 18 or higher if isinstance(ids, int) and ids >= 18: nodes[n]['outputs'][output][name] = ids + 1 elif isinstance(ids, list): tmp_ids = ids.copy() for pos, i in enumerate(ids): if i >= 18: tmp_ids[pos] = i + 1 nodes[n]['outputs'][output][name] = tmp_ids except KeyError: print('No outputs in node: {}'.format(node['name'])) print('Nodes upgraded to comply with Blender 2.91')

def default_mp_value_parameters(): """Set the different default parameters used for mp-values. Returns ------- dict A default parameter set with keys: rescale_pca (whether the PCA should be scaled by variance explained) and nb_permutations (how many permutations to calculate empirical p-value). Defaults to True and 100, respectively. """ params = {"rescale_pca": True, "nb_permutations": 100} return params

def change_auth_keys(server, user, auth_keys): """ update authorize keys. ath_keys is list of keys. will get current auth_keys, remove keys with auth_tag, and add new auth_keys with auth_tag. return: if success, none. else, a dict: { stdout: xxx, stderr: yyy } """ auth_tag = os.getenv('AUTH_KEY_TAG') retcode, out, err = get_auth_keys(server, user) if retcode != 0: return {'stdout': out, 'stderr': err} current_keys = [x for x in out.strip().split('\n') if auth_tag not in x] for key in auth_keys: current_keys.append(f'{key} {auth_tag}') retcode, out, err = set_auth_keys(server, user, ':'.join(current_keys)) if retcode != 0: return {'stdout': out, 'stderr': err} return 0, None, None

def svn_wc_diff(*args): """ svn_wc_diff(svn_wc_adm_access_t anchor, char target, svn_wc_diff_callbacks_t callbacks, void callback_baton, svn_boolean_t recurse, apr_pool_t pool) -> svn_error_t """ return _wc.svn_wc_diff(*args)

def plot3d_gmphd_track(model, grid, gm_s_list=None, gm_list_list=None, observation_list=None, prediction_list=None, truth=None, title=None, contours=4, log_plot=True): """ Animate GM-PHD Filter result on 3D plot with mayavi Args: model (:obj:`pymrt.tracking.models.CVModel`): grid (:obj:`numpy.ndarray`): 3D mesh generated by :func:`numpy.mgrid` or :func:`numpy.meshgrid`. gm_s_list (:obj:`list`): List of PHD scalars at each time step. gm_list_list (:obj:`list`): List of Gaussian Mixtures at each time step. If ``gm_s_list`` is None, it is used along with ``grid`` to generate the PHD scalar at each time step. observation_list (:obj:`list`): List of observations at each time step. prediction_list (:obj:`list`): List of predictions at each time step. truth (:obj:`tuple`): A tuple of truth states (by step) title (:obj:`string`): Plot title. contours (:obj:`int`): Number of contour surfaces to draw. log_plot (:obj:`bool`): Plot ``gm_s`` in log scale. """ global frame frame = 0 if gm_s_list is None: if gm_list_list is None: raise ValueError("Must provide 3D sampled GM scalar gm_s or a " "Gaussian Mixture list") else: print('Sampling PHD in 3D space') from ...tracking.utils import gm_calculate gm_s_list = [] i = 0 for gm_list in gm_list_list: sys.stdout.write('calculate gm_scalar for step %d' % i) gm_s_list.append(gm_calculate( gm_list=gm_list, grid=grid )) i += 1 if title is None: title = 'PHD' print('Start Plotting with Mayavi') class Controller(HasTraits): run_calculation = Button('Next Frame') view = View(Item(name='run_calculation')) def _run_calculation_changed(self, value): # action = ThreadedAction(self.data, self.figure) # action.start() global frame print("Update 3D plots calculation in Frame %d" % frame, end=' ') truth_points, obs_points, pred_points, contour = self.data if log_plot: contour_s = np.log(gm_s_list[frame] + np.finfo(np.float).tiny) else: contour_s = gm_s_list[frame] contour.mlab_source.scalars = contour_s for i in range(frame, max(0, frame-8), -1): opacity = 1. - 0.1 * (frame - i) truth_points[i].actor.property.opacity = opacity obs_points[i].actor.property.opacity = opacity pred_points[i].actor.property.opacity = opacity print('done.') mlab.draw() frame += 1 @mayavi2.standalone def mayavi_main(): """Example showing how to view a 3D numpy array in mayavi2. """ figure = mlab.figure(title) if log_plot: contour_s = np.log(gm_s_list[frame] + np.finfo(np.float).tiny) else: contour_s = gm_s_list[frame] contour = mlab.contour3d( grid[0], grid[1], grid[2], contour_s, transparent=True, opacity=0.5 ) truth_points, obs_points, pred_points = plot3d_data_preparation( prediction=prediction_list, observation=observation_list, truth=truth, model=model ) for points in truth_points: points.actor.property.opacity = 0. for points in obs_points: points.actor.property.opacity = 0. for points in pred_points: points.actor.property.opacity = 0. truth_points[0].actor.property.opacity = 1. obs_points[0].actor.property.opacity = 1. pred_points[0].actor.property.opacity = 1. mlab.colorbar(contour, title='PHD', orientation='vertical') mlab.outline(contour) plot_data = (truth_points, obs_points, pred_points, contour) computation = Controller(data=plot_data, figure=figure) computation.edit_traits() mayavi_main()

def _FindResourceIds(header, resource_names): """Returns the numerical resource IDs that correspond to the given resource names, as #defined in the given header file." """ pattern = re.compile( r'^#define (%s) _Pragma\S+ (\d+)$' % '|'.join(resource_names)) with open(header, 'r') as f: res_ids = [ int(pattern.match(line).group(2)) for line in f if pattern.match(line) ] if len(res_ids) != len(resource_names): raise Exception('Find resource id failed: the result is ' + ', '.join(str(i) for i in res_ids)) return set(res_ids)

def resolve_request_path(requested_uri): """ Check for any aliases and alter the path accordingly. Returns resolved_uri """ for key, val in PATH_ALIASES.items(): if re.match(key, requested_uri): return re.sub(key, val, requested_uri) return requested_uri

async def test_import_invalid_ip(hass: HomeAssistant) -> None: """Test that invalid IP error is handled during import.""" name = "Vallox 90 MV" result = await hass.config_entries.flow.async_init( DOMAIN, context={"source": SOURCE_IMPORT}, data={"host": "vallox90mv.host.name", "name": name}, ) await hass.async_block_till_done() assert result["type"] == RESULT_TYPE_ABORT assert result["reason"] == "invalid_host"

def apim_api_delete( client, resource_group_name, service_name, api_id, delete_revisions=None, if_match=None, no_wait=False): """Deletes an existing API. """ cms = client.api return sdk_no_wait( no_wait, cms.delete, resource_group_name=resource_group_name, service_name=service_name, api_id=api_id, if_match="*" if if_match is None else if_match, delete_revisions=delete_revisions if delete_revisions is not None else False)

def deep_copy(obj): """Make deep copy of VTK object.""" copy = obj.NewInstance() copy.DeepCopy(obj) return copy

def search_exception(n, num_incr=1000): """ search for exception to perfect mirsky for given n, checking pairs checks in reversed order to check pairs with permutations of less fixed points first """ eigvals = [] in_rad = np.cos(np.pi/n) x_ranges, lines = pm_boundary(n) for P in reversed(list(cycle_types(n))): for Q in rev_symmetric_group(n): vals = [val for t in np.linspace(0,1,num=num_incr) for val in np.linalg.eigvals(t*P + (1-t)*Q)] eigvals = list(filter( lambda val: val.imag > 0 and val.real != 0 and abs(val)>in_rad, vals)) if len(eigvals) > 0: exc_lst = list(filter(lambda val: not in_region(val, x_ranges,lines), eigvals)) if len(exc_lst) > 0: print(f"EXCEPTION FOUND FOR n = {n}", "\n") print("eigenvalue:", exc_lst[0], "\n") print(P, "\n") print(Q, "\n") return print(f"No exception: n = {n}")

def get_dunn_index(fdist, *clusters): """ Returns the Dunn index for the given selection of nodes. J.C. Dunn. Well separated clusters and optimal fuzzy partitions. 1974. J.Cybern. 4. 95-104. """ if len(clusters)<2: raise ValueError, "At least 2 clusters are required" intra_dist = [] for c in clusters: for i in c.get_leaves(): if i is not None: # item intraclsuterdist -> Centroid Diameter a = fdist(i.profile, c.profile)*2 intra_dist.append(a) max_a = numpy.max(intra_dist) inter_dist = [] for i, ci in enumerate(clusters): for cj in clusters[i+1:]: # intracluster dist -> Centroid Linkage b = fdist(ci.profile, cj.profile) inter_dist.append(b) min_b = numpy.min(inter_dist) if max_a == 0.0: D = 0.0 else: D = min_b / max_a return D

def sample(words, n=10) -> str: """Sample n random words from a list of words.""" return [random.choice(words) for _ in range(n)]

def extract_peaks( imzml_path, db, tol_ppm=DEFAULT_TOL_PPM, tol_mode=DEFAULT_TOL_MODE, base_mz=DEFAULT_BASE_MZ, ): """ Extract all peaks from the given imzML file for the supplied database of molecules. :param imzml_path: :param db: A pandas DataFrame containing an 'mz' column. Additional metadata columns are also allowed. :param tol_ppm: The maximum distance from a theoretical m/z to search for peaks. e.g. 3 means +/- 3ppm :param tol_mode: The model for adjusting tol_ppm based on the area of the mass range. To match METASPACE, specify 'tof', which means 1ppm is always mz * 1e-6 (i.e. 1ppm at every mass) See the `ppm_to_daltons` function for more examples. :param base_mz: The base m/z for tolerance calculations. Doesn't matter with 'tof'. See the `ppm_to_daltons` function for more details. :return: coords_df - a DataFrame mapping spectrum idx to x,y values. Needed for converting 'peaks_df' values to images peaks - A list of dicts. Each dict contains: 'mol': A NamedTuple of the DB peak row. Access fields with e.g. peak['mol'].formula 'peaks_df': a DataFrame with one row per found peak. Columns: 'sp': Spectrum idx 'mz': m/z 'ints': Intensity value """ assert 'mz' in db.columns, 'db must have an "mz" column' assert tol_mode in TOL_MODES, f'invalid tol_mode: {tol_mode}' p = ImzMLParser(str(imzml_path)) coords_df = pd.DataFrame(p.coordinates, columns=['x', 'y', 'z'][:len(p.coordinates[0])], dtype='i') coords_df['x'] -= np.min(coords_df.x) coords_df['y'] -= np.min(coords_df.y) mz_tol_lo, mz_tol_hi = tol_edges(db.mz, tol_ppm, tol_mode, base_mz) # Uncomment this to add the tolerance boundaries to db for debugging: # db['mz_tol_lo'], db['mz_tol_hi'] = mz_tol_lo, mz_tol_hi mol_peaks = [[] for sp in range(len(coords_df))] for sp, x, y in coords_df[['x', 'y']].itertuples(True, None): mzs, ints = p.getspectrum(sp) mz_range_lo = np.searchsorted(mzs, mz_tol_lo, 'left') mz_range_hi = np.searchsorted(mzs, mz_tol_hi, 'right') mask = mz_range_lo != mz_range_hi for peak, idx_lo, idx_hi in zip(np.flatnonzero(mask), mz_range_lo[mask], mz_range_hi[mask]): for i in range(idx_lo, idx_hi): mol_peaks[peak].append((sp, mzs[i], ints[i])) empty_peaks_df = pd.DataFrame({ 'sp': pd.Series(dtype='i'), 'mz': pd.Series(dtype='f'), 'ints': pd.Series(dtype='f'), }) result = [{ 'mol': db_row, 'peaks_df': pd.DataFrame(peaks, columns=['sp', 'mz', 'ints']) if peaks else empty_peaks_df } for db_row, peaks in zip(db.itertuples(), mol_peaks)] return coords_df, result

def cov_dense(n_features=100, scale=0.5, edges='ones', pos=True, force_psd=True, random_state=None): """ Returns a covariance matrix with a constant diagonal and whose off diagnale elements are obtained from adj_mats.complete_graph() Parameters ---------- n_features: int scale: float Scale of the off diagonal entries. edges: str How the edges should be sampled. See adj_mats.complete_graph() pos: bool Should the off-diagonal entries be all positive. force_psd: bool Make sure the covariance matrix is positive semi-definite zeroing out all negative eigenvalues. random_state: None, int Random seed for sampling. Output ------ cov: array-like, (n_features, n_features) The sampled covariance matrix. """ cov = complete_graph(n_nodes=n_features, edges=edges, pos=pos, random_state=random_state) cov = cov * scale np.fill_diagonal(cov, 1.0) if force_psd: cov = project_psd(cov) return cov

def measure_fwhm(array): """Fit a Gaussian2D model to a PSF and return the FWHM Parameters ---------- array : numpy.ndarray Array containing PSF Returns ------- x_fwhm : float FWHM in x direction in units of pixels y_fwhm : float FWHM in y direction in units of pixels """ yp, xp = array.shape y, x, = np.mgrid[:yp, :xp] p_init = models.Gaussian2D() fit_p = fitting.LevMarLSQFitter() fitted_psf = fit_p(p_init, x, y, array) return fitted_psf.x_fwhm, fitted_psf.y_fwhm

def test_not_impartial(g): """ Test that these games are not impartial. """ assert not g.is_impartial

def exists(profile, bucket, name): """Check if a file exists in an S3 bucket. Args: profile A profile to connect to AWS with. bucket The name of the bucket you want to find the file in. name The name of a file. Returns: True if it exists, False if it doesn't. """ result = fetch_by_name(profile, bucket, name) return len(result) > 0

def fetchquota(adr): """Retrieves the account quota information and passes the interesting part of the json object along to the request source. Arguments: adr (str): The email account address of interest. Returns: The quota part of the json object for the response. """ debuginfo("Fetching quota info for account.") return apirequest("quota", {'emailaccount': adr})["response"]["quota"]

def saslocal(): """Set sasurl to local.""" set_sasurl(loc='local')

def print_basic_csv(file_name, delimiter=','): """This function extracts and prints csv content from given filename Details: https://docs.python.org/2/library/csv.html Args: file_name (str): file path to be read delimiter (str): delimiter used in csv. Default is comma (',') Returns: None """ csv_rows = list() csv_attr_dict = dict() csv_reader = None # read csv csv_reader = csv.reader(open(file_name, 'r'), delimiter=delimiter) # iterate and extract data for row in csv_reader: print(row) csv_rows.append(row) # prepare attribute lists for col in csv_rows[0]: csv_attr_dict[col]=list() # iterate and add data to attribute lists for row in csv_rows[1:]: csv_attr_dict['sno'].append(row[0]) csv_attr_dict['fruit'].append(row[1]) csv_attr_dict['color'].append(row[2]) csv_attr_dict['price'].append(row[3]) # print the result print("\n\n") print("CSV Attributes::") pprint(csv_attr_dict)

def project_login(driver): """ 針對多綫程執行設定不同樣本編號，若修改問卷，也許提供該問卷樣本編號的第一順位號碼。 """ SAMPLE_NUMBER = 20200101+sample_add try: WebDriverWait(driver, 3).until(EC.presence_of_element_located((By.XPATH, '//*[@name="{}"][1]' .format(str(SAMPLE_NUMBER))))).click() # 選擇樣本編號作答 sleep(1) driver.find_element_by_class_name('btn.btn-blue').click() # 點擊開始訪問 print("STEP 3[project_login]: Project Login Successfully !") form_basic_info(driver) except NoSuchElementException: driver.find_element_by_xpath('//*[@id="case_in_prj_next"]/a').click() # 若搜尋不到樣本編號則尋找下一頁按鈕 return project_login(driver) else: return "STEP 3[project_login]: Loading took too much time !"

def set_directory_request_data(directory, key, value): """Allows to associate a value to a key on the data object of a request :param directory: The name of the directory of the request to which the data will be associated :type directory: str :param key: The key to which the data will be associated :type key: str :param value: The value returned if the data does not exist :type value: str """ normalize() request_directory = normalize_request_directory(directory) request_directory["data"][key] = value write_dex()

def convert_convolutionfunction_to_image(cf): """ Convert ConvolutionFunction to an image :param cf: :return: """ return create_image_from_array(cf.data, cf.grid_wcs, cf.polarisation_frame)

def macro(libname): """Decorator for macros (Moya callables).""" def deco(f): exposed_elements[libname] = f return f return deco

def product(*generators): """generate the cartesian product of infinite generators.""" generators = list(map(GenCacher, generators)) for distance in itertools.count(0): for idxs in _summations(distance, len(generators)): yield tuple(gen[idx] for gen, idx in zip(generators, idxs))

def get_dataloaders(dataset, mode='train', root=None, shuffle=True, pin_memory=True, batch_size=8, logger=logging.getLogger(__name__), normalize=False, **kwargs): """A generic data loader Parameters ---------- dataset : {"openimages", "jetimages", "evaluation"} Name of the dataset to load root : str Path to the dataset root. If `None` uses the default one. kwargs : Additional arguments to `DataLoader`. Default values are modified. """ pin_memory = pin_memory and torch.cuda.is_available # only pin if GPU available Dataset = get_dataset(dataset) if root is None: dataset = Dataset(logger=logger, mode=mode, normalize=normalize, **kwargs) else: dataset = Dataset(root=root, logger=logger, mode=mode, normalize=normalize, **kwargs) return DataLoader(dataset, batch_size=batch_size, shuffle=shuffle, num_workers=NUM_DATASET_WORKERS, collate_fn=exception_collate_fn, pin_memory=pin_memory)

def ie(): """Interest Expense Function""" ww = float(input("for Short-Term Loan Press 1:\nfor Long-Term Loan Press 2:\nfor Bonds-Payable Press 3: ")) if(ww == 1): e = float(input("Please Enter The Principal Value: ")) ew = float(input("Please Enter Interest rate %: ")) ea = float(input("Please Enter Time in Months: ")) cc = ew/100 v = (e * cc) * (ea /12) l = round(v) jj = float(l) + float(e) oo = l / (ea * 30) print ">> Your Interest Expense for ",ea,"Months is ",l print ">> Total Amount Paid in Maturity Date is ",jj print ">> Your Interest Expense Per Day is",oo elif(ww == 2): spp = float(input(" for Single Payment Loan Press 1\n for Installment Payment Loan Press 2: ")) if(spp == 1): pv = float(input("Please Enter Principal Value: ")) ir = float(input("Please Enter Interest rate %: ")) lp = float(input("Please Enter The Loan Period (Years): ")) mp = (float(pv) * (float(ir) / float(100))) * (float(1) / float(12)) yp = float(mp) * float(12) semi = float(yp)/float(2) ap = float(yp) * float(lp) md = float(ap) + float(pv) print ">> Your Monthly Interest Expense is ",mp print ">> Your Semi-Annual Interest Expense is ",semi print ">> Your Interest Expense Per Year is ",yp print ">> Total Interest will be Paid is ",ap print ">> Principal Value at Maturity Date is ",md elif(spp == 2): pip = list(input("Please Enter Each Installment Payment: ")) iir = float(input("Please Enter Interest rate %: ")) su = sum(pip) le = len(pip) n = 0 tie = 0 while le != 0: iex = (float(su)*(float(iir)/float(100)))*(float(1)/float(12)) sm = float(iex)*float(6) an = float(iex)*float(12) ey = pip[0 + n] dr = float(ey)+float(an) n += 1 le -= 1 tie += float(an) tot = float(su)+float(tie) print "Information for Installment no.",n,"with Value Of ",ey print ">> Your Monthly Interest Expense is",iex print ">> Your Semi-Annual Interest Expense is",sm print ">> Your Annual Interest Expense is",an print ">> Total Amount Will Be Paid for The Installment is",dr,"\n" print ">> Total Interest Expense for The Loan is ",tie print ">> Your Total Payment for The Loan is",tot elif(ww == 3): from accountingpy import bp bp()

def stats_file(filename, shape, dtype=None, file_format='raw', out_of_core=True, buffer_size=None, max_memory=None, progress_frequency=None): """stats_file(filename, shape, dtype=None, file_format='raw', out_of_core=True, buffer_size=None, max_memory=None, progress_frequency=None) -> StatsInfo object returns a StatsInfo about the content of 'filename', which is a cube with 'shape'. If 'out_of_core' (out-of-core) is True, process 'buffer_size' elements at a time. """ shape = Shape(shape) filename = interpolate_filename(filename, shape=shape, file_format=file_format, dtype=dtype) if out_of_core and file_format == 'raw': stats_info = stats_info_out_of_core(filename, shape=shape, dtype=dtype, buffer_size=buffer_size, max_memory=max_memory, progress_frequency=progress_frequency) else: cube = read_cube(file=filename, shape=shape, dtype=dtype, file_format=file_format) stats_info = StatsInfo.stats_info(cube) return stats_info

def get_info(args): """ Loads todo.txt, sets up file paths, loads in any available star information, saves the relevant parameters for each of the two main routines and sets the plotting parameters. Parameters ---------- args : argparse.Namespace command-line arguments parallel : bool if pysyd will be running in parallel mode CLI : bool, optional if CLI is not being used (i.e. `False`), the modules draw default values from a different location Returns ------- args : argparse.Namespace the updated command-line arguments """ # Get parameters for all modules args = get_parameters(args) # Get invidual/specific star info from csv file (if it exists) args = get_csv_info(args) if args.cli: # Check the input variables check_input_args(args) args = get_command_line(args) set_plot_params() return args

def test_isupport_getattr(): """Test using ISUPPORT parameters as read-only attributes.""" instance = isupport.ISupport(awaylen=50) assert hasattr(instance, 'AWAYLEN') assert not hasattr(instance, 'awaylen'), 'attributes are ALL_UPPERCASE' assert not hasattr(instance, 'UNKNOWN') assert instance.AWAYLEN == 50 # you can't set attributes yourself with pytest.raises(AttributeError): instance.AWAYLEN = 20 with pytest.raises(AttributeError): instance.awaylen = 20 with pytest.raises(AttributeError): instance.UNKNOWN = 'not possible'

def _weight_func(dist): """Weight function to replace lambda d: d ** -2. The lambda function is not valid because: if d==0 then 0^-2 is not valid.""" # Dist could be multidimensional, flatten it so all values # can be looped with np.errstate(divide="ignore"): retval = 1.0 / dist return retval**2

def enable_logging( debug=False, http_debug=False, path=None, stream=None, format_stream=False, format_template='%(asctime)s %(levelname)s: %(name)s %(message)s', handlers=None, ): """Enable logging output. Helper function to enable logging. This function is available for debugging purposes and for folks doing simple applications who want an easy 'just make it work for me'. For more complex applications or for those who want more flexibility, the standard library ``logging`` package will receive these messages in any handlers you create. :param bool debug: Set this to ``True`` to receive debug messages. :param bool http_debug: Set this to ``True`` to receive debug messages including HTTP requests and responses. This implies ``debug=True``. :param str path: If a *path* is specified, logging output will written to that file in addition to sys.stderr. The path is passed to logging.FileHandler, which will append messages the file (and create it if needed). :param stream: One of ``None `` or ``sys.stdout`` or ``sys.stderr``. If it is ``None``, nothing is logged to a stream. If it isn't ``None``, console output is logged to this stream. :param bool format_stream: If format_stream is False, the default, apply ``format_template`` to ``path`` but not to ``stream`` outputs. If True, apply ``format_template`` to ``stream`` outputs as well. :param str format_template: Template to pass to :class:`logging.Formatter`. :rtype: None """ if not stream and not path: stream = sys.stdout if http_debug: debug = True if debug: level = logging.DEBUG else: level = logging.INFO formatter = logging.Formatter(format_template) if handlers: for handler in handlers: handler.setFormatter(formatter) else: handlers = [] if stream is not None: console = logging.StreamHandler(stream) if format_stream: console.setFormatter(formatter) handlers.append(console) if path is not None: file_handler = logging.FileHandler(path) file_handler.setFormatter(formatter) handlers.append(file_handler) setup_logging('openstack', handlers=handlers, level=level) setup_logging('keystoneauth', handlers=handlers, level=level) # Turn off logging on these so that if loggers higher in the tree # are more verbose we only get what we want out of the SDK. This is # particularly useful when combined with tools like ansible which set # debug logging level at the logging root. # If more complex logging is desired including stevedore debug logging, # enable_logging should not be used and instead python logging should # be configured directly. setup_logging( 'urllib3', handlers=[logging.NullHandler()], level=logging.INFO) setup_logging( 'stevedore', handlers=[logging.NullHandler()], level=logging.INFO) # Suppress warning about keystoneauth loggers setup_logging('keystoneauth.discovery') setup_logging('keystoneauth.identity.base') setup_logging('keystoneauth.identity.generic.base')

def two_poles(time_limit=_DEFAULT_TIME_LIMIT, random=None, environment_kwargs=None): """Returns the Cartpole Balance task with two poles.""" physics = Physics.from_xml_string(*get_model_and_assets(num_poles=2)) task = Balance(swing_up=True, sparse=False, random=random) environment_kwargs = environment_kwargs or {} return control.Environment( physics, task, time_limit=time_limit, **environment_kwargs)

def process_topic_entity(entity: dict, language: str) -> bool: """ Given a topic entity, gather its metadata :param entity :param language: :type entity dict :type language str :returns bool """ try: # Get ID remote_id = entity["title"] print("%s\t%s" % ("ID".ljust(16), remote_id)) # Get name from label name = entity["labels"][language]["value"].lower() print("%s\t%s" % ("name".ljust(16), name)) # Get brief brief = entity["descriptions"][language]["value"].lower() print("%s\t%s" % ("description".ljust(16), brief)) print_end() except Exception as err: print_err("%s error: %s" % (remote_id, err)) return False return True

def _no_grad_trunc_normal_(tensor: Tensor, mean: float, std: float, a: float, b: float) -> Tensor: """Cut & paste from PyTorch official master until it's in a few official releases - RW Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf Args: tensor (Tensor): An n-dimensional `Tensor`. mean (float): Mean of the normal distribution. std (float): Standard deviation of the normal distribution. a (float): Minimum cutoff value. b (float): Maximum cutoff value. """ def norm_cdf(x): # Computes standard normal cumulative distribution function return (1. + math.erf(x / math.sqrt(2.))) / 2. if (mean < a - 2 * std) or (mean > b + 2 * std): error_console.log( "mean is more than 2 std from [a, b] in nn.init.trunc_normal_. " "Fdistribution of values may be incorrect.", stacklevel=2 ) with torch.no_grad(): # Values are generated by using a truncated uniform distribution and # then using the inverse CDF for the normal distribution. # Get upper and lower cdf values l = norm_cdf((a - mean) / std) u = norm_cdf((b - mean) / std) # Uniformly fill image with values from [l, u], then translate to # [2l-1, 2u-1]. tensor.uniform_(2 * l - 1, 2 * u - 1) # Use inverse cdf transform for normal distribution to get truncated # standard normal tensor.erfinv_() # Transform to proper mean, std tensor.mul_(std * math.sqrt(2.)) tensor.add_(mean) # Clamp to ensure it's in the proper range tensor.clamp_(min=a, max=b) return tensor

def inverse_update(C, m, return_drop=False): """ Compute the inverse of a matrix with the m-th row and column dropped given knowledge of the inverse of the original matrix. C = inv(A) B = drop_col(drop_row(A, m),m) computes inv(B) given only C Args: C: inverse of full matirix m: row and col to drop return_drop: whether to also return the array used to drop the m-th row/col. Returns: B if return_drop: the array to drop row/col using jnp.take(v, drop_array) """ drop = drop_array(C.shape[0], m) _a = jnp.take(C, drop, axis=0) # drop m row a = jnp.take(_a, drop, axis=1) c = jnp.take(C, drop, axis=1)[None, m, :] # drop m col b = _a[:, m, None] d = C[m, m] res = a - (b @ c) / d if return_drop: return res, drop return res

def loss_calc(settings, all_batch, market_batch): """ Calculates nn's NEGATIVE loss. Args: settings: contains the neural net all_batch: the inputs to neural net market_batch: [open close high low] used to calculate loss Returns: cost: loss - l1 penalty """ loss = settings['nn'].loss_np(all_batch, market_batch) return -loss