Datasets:

bigcode

/

stack-dedup-python-fns

like 1

def fits_downloaded_correctly(fits_loc): """ Is there a readable fits image at fits_loc? Does NOT check for bad pixels Args: fits_loc (str): location of fits file to open Returns: (bool) True if file at fits_loc is readable, else False """ try: img, _ = fits.getdata(fits_loc, 0, header=True) return True except Exception: # image fails to open return False

def union_of_rects(rects): """ Calculates union of two rectangular boxes Assumes both rects of form N x [xmin, ymin, xmax, ymax] """ xA = np.min(rects[:, 0]) yA = np.min(rects[:, 1]) xB = np.max(rects[:, 2]) yB = np.max(rects[:, 3]) return np.array([xA, yA, xB, yB], dtype=np.int32)

def configure_services(config: List[Dict]) -> Dict[str, GcpServiceQuery]: """ Generate GcpServiceQuery list from config :param config: list with GcpServieQuery's configuration :return: mapping of service name to GcpServiceQuery objects """ if not isinstance(config, list): raise GcpServiceQueryConfigError(f"Invalid GcpServiceQuery config {config}") result = {} for entry in config: if not isinstance(entry, dict): raise GcpServiceQueryConfigError(f"Invalid GcpServiceQuery entry type: '{entry}'. " f"Should be dict, is {type(entry)}") serviceName = entry.get(SERVICE_NAME, None) version = entry.get(VERSION, None) queries = entry.get(QUERIES, None) if not serviceName or not version or not queries: raise GcpServiceQueryConfigError(f"Missing required key for entry {entry}") gcp_service_query = GcpServiceQuery(serviceName, version) # Check multiple entries with same name if serviceName in result: raise GcpServiceQueryConfigError(f"Multiple GCP service with same name: {serviceName}") result[serviceName] = gcp_service_query return result

def tags_get(): """ Get endpoint /api/tag args: optional company_filter(int) - id of a company, will only return tag relation to said company optional crowd(int) - 0 - 2 specifing crowd sourcing option. Key: 0 - all tags 1 - Only crowd sourced tags 2 - Only non crowd sourced tags optional only_ids - if set only returns ids of tags return: List Tags - A json list of all tags that match the optional args. """ request_data = request.get_json() company_filter = get_if_exist(request_data, "company_filter") only_ids = get_if_exist(request_data,"only_ids") crowd = get_if_exist(request_data, "crowd") if crowd: if crowd > 2: return status.HTTP_400_BAD_REQUEST crowd = 0 if company_filter: t = db.session.query( Tag_company.tag, ).filter(Tag_company.company == int(company_filter)).group_by(Tag_company.tag).subquery('t') Tag_query = Tag.query.filter( Tag.id == t.c.tag ) else: Tag_query = Tag.query if crowd != 0: crowd = (1==crowd) Tag_query = Tag_query.filter_by(crowd_soured = crowd) tags = Tag_query.all() if only_ids: return jsonify([tag.id for tag in tags]), status.HTTP_200_OK else: return jsonify([tag.serialize for tag in tags]), status.HTTP_200_OK

def gunzip(filename, targetdir): """Decompress a gzip-compressed file into a target directory. Args: filename: Full path to gzip file. targetdir: Directory to decompress file into. Returns: The output file name. Raises: FileNotFoundError: `filename` does not exist. """ # We delete the .gz suffix and put the decompressed file into `targetdir`. if not os.path.isfile(filename): raise FileNotFoundError(f"File '{filename}' does not exist.") targetfile = os.path.join( targetdir, re.sub('\\.gz$', '', os.path.basename(filename)) ) cprint(f"Decompressing '{filename}'...", 'yellow') try: with open(targetfile, 'xb') as o, gzip.open(filename, 'rb') as i: shutil.copyfileobj(i, o) except Exception: # Clean up target file. if os.path.isfile(targetfile): cprint(f"Removing file '{targetfile}'...", 'red') os.remove(targetfile) raise assert targetfile assert os.path.isfile(targetfile) cprint(f"Successfully created file '{targetfile}'.", 'green') return targetfile

def async_sendmail(subject, message, to): """异步邮件发送，可用于多线程及非Web上下文环境""" def send_async_email(app): with app.test_request_context(): app.preprocess_request() sendmail(subject, message, to) app = current_app._get_current_object() t = Thread(target=send_async_email, args=[app]) t.start()

def get_accept_languages(accept): """Returns a list of languages, by order of preference, based on an HTTP Accept-Language string.See W3C RFC 2616 (http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html) for specification. """ langs = parse_http_accept_header(accept) for index, lang in enumerate(langs): langs[index] = lang_in_gettext_format(lang) return langs

def get_princ_axes_xyz(tensor): """ Gets the principal stress axes from a stress tensor. Modified from beachball.py from ObsPy, written by Robert Barsch. That code is modified from Generic Mapping Tools (gmt.soest.hawaii.edu) Returns 'PrincipalAxis' classes, which have attributes val, trend, plunge Returns T, N, P """ tensor = np.array(tensor) (D, V) = sorted_eigens(tensor) pl = np.arcsin( -V[2] ) # 2 az = np.arctan2( V[0], -V[1] ) # 0 # 1 for i in range(0, 3): if pl[i] <= 0: pl[i] = -pl[i] az[i] += np.pi if az[i] < 0: az[i] += 2 * np.pi if az[i] > 2 * np.pi: az[i] -= 2 * np.pi pl *= 180 / np.pi az *= 180 / np.pi T = PrincipalAxis( D[0], az[0], pl[0] ) # 0 0 0 N = PrincipalAxis( D[1], az[1], pl[1] ) P = PrincipalAxis( D[2], az[2], pl[2] ) # 2 2 2 return(T, N, P)

def extractYoushoku(item): """ """ vol, chp, frag, postfix = extractVolChapterFragmentPostfix(item['title']) if 'The Other World Dining Hall' in item['tags'] and (chp or vol): return buildReleaseMessageWithType(item, 'The Other World Dining Hall', vol, chp, frag=frag, postfix=postfix) return False

def _perform_Miecalculations(diam, wavelength, n, noOfAngles=100.): """ Performs Mie calculations Parameters ---------- diam: NumPy array of floats Array of diameters over which to perform Mie calculations; units are um wavelength: float Wavelength of light in um for which to perform calculations n: complex Ensemble complex index of refraction Returns panda DataTable with the diameters as the index and the mie results in the different collumns total_extinction_coefficient: this takes the sum of all particles crossections of the particular diameter in a qubic meter. This is in principle the AOD of an L """ diam = np.asarray(diam) extinction_efficiency = np.zeros(diam.shape) scattering_efficiency = np.zeros(diam.shape) absorption_efficiency = np.zeros(diam.shape) extinction_crossection = np.zeros(diam.shape) scattering_crossection = np.zeros(diam.shape) absorption_crossection = np.zeros(diam.shape) # phase_function_natural = pd.DataFrame() angular_scattering_natural = pd.DataFrame() # extinction_coefficient = np.zeros(diam.shape) # scattering_coefficient = np.zeros(diam.shape) # absorption_coefficient = np.zeros(diam.shape) # Function for calculating the size parameter for wavelength l and radius r sp = lambda r, l: 2. * np.pi * r / l for e, d in enumerate(diam): radius = d / 2. # print('sp(radius, wavelength)', sp(radius, wavelength)) # print('n', n) # print('d', d) mie = bhmie.bhmie_hagen(sp(radius, wavelength), n, noOfAngles, diameter=d) values = mie.return_Values_as_dict() extinction_efficiency[e] = values['extinction_efficiency'] # print("values['extinction_crosssection']",values['extinction_crosssection']) scattering_efficiency[e] = values['scattering_efficiency'] absorption_efficiency[e] = values['extinction_efficiency'] - values['scattering_efficiency'] extinction_crossection[e] = values['extinction_crosssection'] scattering_crossection[e] = values['scattering_crosssection'] absorption_crossection[e] = values['extinction_crosssection'] - values['scattering_crosssection'] # phase_function_natural[d] = values['phaseFct_natural']['Phase_function_natural'].values angular_scattering_natural[d] = mie.get_angular_scatt_func().natural.values # print('\n') # phase_function_natural.index = values['phaseFct_natural'].index angular_scattering_natural.index = mie.get_angular_scatt_func().index out = pd.DataFrame(index=diam) out['extinction_efficiency'] = pd.Series(extinction_efficiency, index=diam) out['scattering_efficiency'] = pd.Series(scattering_efficiency, index=diam) out['absorption_efficiency'] = pd.Series(absorption_efficiency, index=diam) out['extinction_crossection'] = pd.Series(extinction_crossection, index=diam) out['scattering_crossection'] = pd.Series(scattering_crossection, index=diam) out['absorption_crossection'] = pd.Series(absorption_crossection, index=diam) return out, angular_scattering_natural

def load_config_dict(pipette_id: str) -> Tuple[ 'PipetteFusedSpec', 'PipetteModel']: """ Give updated config with overrides for a pipette. This will add the default value for a mutable config before returning the modified config value. """ override = load_overrides(pipette_id) model = override['model'] config = fuse_specs(model) if 'quirks' not in override.keys(): override['quirks'] = {key: True for key in config['quirks']} for top_level_key in config.keys(): if top_level_key != 'quirks': add_default(config[top_level_key]) # type: ignore config.update(override) # type: ignore return config, model

def ErrorAddEncKey(builder, encKey): """This method is deprecated. Please switch to AddEncKey.""" return AddEncKey(builder, encKey)

def test_run_without_exception(): """Not a good test at all. :(""" try: settings = { "LINKEDIN_USER": os.getenv("LINKEDIN_USER"), "LINKEDIN_PASSWORD": os.getenv("LINKEDIN_PASSWORD"), "LINKEDIN_BROWSER": "Chrome", "LINKEDIN_BROWSER_DRIVER": "/Users/dayhatt/workspace/drivers/chromedriver", "LINKEDIN_BROWSER_HEADLESS": 0, "LINKEDIN_BROWSER_CRON": 0, "LINKEDIN_CRON_USER": "dayhatt", "LINKEDIN_PREFERRED_USER": "./data/user_preferred.txt", "LINKEDIN_NOT_PREFERRED_USER": "./data/user_not_preferred.txt", } run_script(settings=settings) except Exception as e: # noqa pytest.fail("Test failed: Scripts failed to run.")

def _read_txs_from_file(f): """ Validate headers and read buy/sell transactions from the open file-like object 'f'. Note: we use the seek method on f. """ ans = [] f.seek(0) workbook = openpyxl.load_workbook(f) sheet = workbook.active all_contents = list(sheet.rows) _validate_header(all_contents[0]) contents = all_contents[1:] for row in contents: item = _tx_from_gemini_row(row) if item is not None: ans.append(item) return ans

def get_generator_regulation_lower_term_4(data, trader_id, intervention) -> Union[float, None]: """Get L5RE term 4 in FCAS availability calculation""" # Term parameters enablement_min = get_effective_enablement_min(data, trader_id, 'L5RE') energy_target = lookup.get_trader_solution_attribute(data, trader_id, '@EnergyTarget', float, intervention) lower_slope_coefficient = get_lower_slope_coefficient(data, trader_id, 'L5RE') # Ignore limit if slope coefficient = 0 if lower_slope_coefficient == 0: return None return 0 if (lower_slope_coefficient is None) else (energy_target - enablement_min) / lower_slope_coefficient

def count_parameters(model): """count model parameters""" return sum(p.numel() for p in model.parameters() if p.requires_grad)

def scenario(l_staticObject, l_cross, l_road): """ Coordinates of objects in a scenario. Include: l_staticObject: list of static objects l_cross: list of pedestrian crosses l_road: list of road layouts """ # road layout road = Road( left=np.array([[-100, 2], [100, 2]]), right=np.array([[-100, -4], [100, -4]]), lane=np.array([[-100, -1], [100, -1]]) ) l_road.append(road) sx = [-20, 180] sy = [-10, -4] sz = 5 step = 7 idx = 1 for i in range(sx[0], sx[1], step): if i > 10 and i < 40: continue idx += 1 obs = StaticObject( idx=idx, poly=np.array([[i, sy[0]], [i+sz, sy[0]], [i+sz, sy[1]], [i, sy[1]]])) l_staticObject.append(obs) obs2 = StaticObject( idx=21, poly=np.array([[-60, -20], [-25, -20], [-25, -5], [-60, -5]])) l_staticObject.append(obs2) obs3 = StaticObject( idx=31, poly=np.array([[-40, 20], [-2, 20], [-2, 8], [-40, 8]])) l_staticObject.append(obs3) obs4 = StaticObject( idx=41, poly=np.array([[5, 20], [60, 20], [60, 5], [5, 5]])) l_staticObject.append(obs4) # # static object # obs11 = StaticObject( # idx=11, # poly=np.array([[-40, -20], [-15, -20], [-14, -10], # [-20, -6], [-40, -6]])) # l_staticObject.append(obs11) # obs12 = StaticObject( # idx=12, # poly=np.array([[-80, -20], [-43, -20], [-43, -8], # [-50, -6], [-70, -6]])) # l_staticObject.append(obs12) # obs13 = StaticObject( # idx=13, # poly=np.array([[-25, -70], [-16, -23], [-40, -23], # [-49, -70]])) # l_staticObject.append(obs13) # obs21 = StaticObject( # idx=21, # poly=np.array([[5, -20], [30, -20], [30, -5], [8, -5]])) # l_staticObject.append(obs21) # obs22 = StaticObject( # idx=22, # poly=np.array([[4, -23], [10, -23], [8, -50], # [-2, -50]])) # l_staticObject.append(obs22) # obs23 = StaticObject( # idx=23, # poly=np.array([[33, -20], [50, -20], [50, -5], [33, -5]])) # l_staticObject.append(obs23) # obs31 = StaticObject( # idx=31, # poly=np.array([[-80, 5], [-70, 5], [-63, 8], # [-63, 20], [-80, 20]])) # l_staticObject.append(obs31) # obs32 = StaticObject( # idx=32, # poly=np.array([[-60, 5], [-50, 5], [-43, 8], # [-43, 20], [-60, 20]])) # l_staticObject.append(obs32) # obs33 = StaticObject( # idx=33, # poly=np.array([[-40, 5], [-30, 5], [-23, 8], # [-23, 20], [-40, 20]])) # l_staticObject.append(obs33) # obs34 = StaticObject( # idx=34, # poly=np.array([[-20, 5], [-15, 5], [-10, 8], # [-6, 20], [-20, 20]])) # l_staticObject.append(obs34) # obs35 = StaticObject( # idx=35, # poly=np.array([[-20, 23], [-6, 23], [-6, 35], # [-8, 35], [-20, 35]])) # l_staticObject.append(obs35) # obs41 = StaticObject( # idx=41, # poly=np.array([[10, 7], [20, 7], [20, 20], # [11, 20]])) # l_staticObject.append(obs41) # obs42 = StaticObject( # idx=42, # poly=np.array([[12, 23], [20, 23], [20, 40], # [14, 40]])) # l_staticObject.append(obs42) # obs43 = StaticObject( # idx=43, # poly=np.array([[23, 7], [40, 7], [40, 30], # [23, 30]])) # l_staticObject.append(obs43) # # pedestrian cross # cross1 = PedestrianCross( # left=np.array([[-10, -6], [-6, 6]]), # right=np.array([[-8, -6], [-4, 6]]), # density=0.8 # ) # cross2 = PedestrianCross( # left=np.array([[2, -6], [6, 6]]), # right=np.array([[4, -6], [8, 6]]), # density=0.8 # ) # l_cross.append(cross1) # l_cross.append(cross2) # # road layout # road1 = Road( # left=np.array([[-100, 4], [-4, 4]]), # right=np.array([[-100, -4], [-6, -4]]), # lane=np.array([[-100, 0], [-4, 0]]) # ) # road2 = Road( # left=np.array([[-4, 4], [16, 100]]), # right=np.array([[4, 4], [24, 100]]), # lane=np.array([[0, 4], [20, 100]]) # ) # road3 = Road( # left=np.array([[4, 4], [100, 4]]), # right=np.array([[2, -4], [100, -4]]), # lane=np.array([[4, 0], [100, 0]]) # ) # road4 = Road( # left=np.array([[-26, -100], [-6, -4]]), # right=np.array([[-18, -100], [2, -4]]), # lane=np.array([[-22, -100], [-2, -4]]) # ) # l_road.extend([road1, road2, road3, road4])

def string_rule_variable(label=None, params=None, options=None, public=True): """ Decorator to make a function into a string rule variable. NOTE: add **kwargs argument to receive Rule as parameters :param label: Label for Variable :param params: Parameters expected by the Variable function :param options: Options parameter to specify expected options for the variable. The value used in the Condition IS NOT checked against this list. :param public: Flag to identify if a variable is public or not :return: Decorator function wrapper """ return _rule_variable_wrapper(StringType, label, params=params, options=options, public=public)

def detect_horizon_lines(image_thre, row, busbar, cell_size, thre=0.6, split=50, peak_interval=None, margin=None): """ Detect horizontal edges by segmenting image into vertical splits Parameters --------- image_thre: array Adaptive threshold of raw images row: int Number of rows of solar module busbar: int Number of busbars of a solar cell cell_size: int Output cell size in pixel thre: float Peak intensity above THRE will be set as 1. Note that the edge's peak intensity should be lowest because edges are black split: int Number of splits peak_interval: int Distance between each peak. Returns ------- hline_abs_couple: array Suppose a line is y=a*x+b. Return 'a' and 'b' of a couple edges (top and bottom of a cell). """ #width = image_thre.shape[1] #end = int(width / split) #image_vsplits = np.hsplit(image_thre[:, :end * split], split) # vertical splits #image_vsplits.append(image_thre[:, end * split:]) image_vsplits = split_img(image_thre, split=split, direction=1) edge_y = [] inx_x = [] for inx, im_split in enumerate(image_vsplits): #sum_split = np.sum(im_split, axis=1) #sum_split = sum_split / np.max(sum_split) #sum_split[sum_split > thre] = 1 #if peak_interval is None: # peak_interval = int(cell_size / (busbar + 1) * 0.5) #peak, _ = find_peaks(-1 * sum_split, distance=peak_interval) peak = detect_peaks(im_split, 1, cell_size, busbar, thre, peak_interval, margin=margin) if len(peak) >= row * (busbar + 1) - 1: peak_new = [peak[0]] for i in range(1, len(peak) - 1): if np.abs(peak[i] - peak[i + 1]) < 15: peak_mean = (peak[i] + peak[i + 1]) / 2 peak_new.append(peak_mean) elif np.abs(peak[i] - peak[i - 1]) > 15: peak_new.append(peak[i]) peak_new.append(peak[-1]) peak_new = np.array(peak_new) peak_new_a = np.delete(peak_new, 0) peak_new_b = np.delete(peak_new, -1) peak_new_detect = peak_new[detectoutliers(np.abs(peak_new_a - peak_new_b), rate=0.5, option=1)] if len(peak_new_detect) == (busbar + 1) * row + 1: edge_y.append(peak_new_detect) inx_mean = ((2 * inx + 1) * (image_thre.shape[1] / split) - 1) / 2 inx_x.append(inx_mean) edge_y = np.array(edge_y) hlines = list(zip(*edge_y)) hlines = np.array(hlines) inx_x = np.array(inx_x) # for lines in hlines: # lines_new = self.detectoutliers(lines, option=0) # while np.std(lines_new) > 10: # lines_new = self.detectoutliers(lines, rate=1, option=0) # hb_abs = [] # all lines including busbar hb_abs = linear_regression(inx_x, hlines, outlier_filter=True) hline_abs_couple = [] # all lines excluding busbar # for horizonline in hlines: # ab, _ = curve_fit(self.linear, inx_x, horizonline) # y = ax + b # hb_abs.append(ab) hline_abs_couple = [(hb_abs[(busbar + 1) * i], hb_abs[(busbar + 1) * (i + 1)]) for i in range(row)] # hline_abs = [(hb_abs[(4+1)*i],hb_abs[(4+1)*(i+1)]) for i in range(6)] # hline_abs = [(hb_abs[(self.busbar+2)*i],hb_abs[(self.busbar+2)*(i+1)-1]) for i in range(self.row)] return hline_abs_couple

def countRoem(cards, trumpSuit=None): """Counts the amount of roem (additional points) in a list of cards Args: Returns: Integer value how many points of roem are in the cards in total """ roem = 0 # Stuk # Without a trumpSuit, stuk is impossible if trumpSuit is not None: #trumpKing = list(filter(lambda c: c.suit == trumpSuit and c.rank == 4, cards)) #trumpQueen = list(filter(lambda c: c.suit == trumpSuit and c.rank == 5, cards)) trumpKing = [card for card in cards if card.suit == trumpSuit and card.rank == 4] trumpQueen = [card for card in cards if card.suit == trumpSuit and card.rank == 5] if trumpKing and trumpQueen: roem += 20 # Normal roem # For each suit we check whether there are 3 cards in that suit, if so there is chance for roem for i in range(4): #cardsInSuit = list(filter(lambda c: c.suit == i, cards)) cardsInSuit = [card for card in cards if card.suit == i] if len(cardsInSuit) >= 3: cards = cardsInSuit # We sort the list and check the difference between consecutive cards cards.sort(key=lambda c: c.rank) subtractList = [] for i in range(len(cards) - 1): #subtract = abs(cards[i].roemRank - cards[i+1].roemRank) subtract = abs(ROEMRANKS[cards[i].rank] - ROEMRANKS[cards[i].rank]) subtractList.append(subtract) # If more than 1 difference equals 1, we know at least 3 cards have consecutive ranks #lenOfOnes = len(list(filter(lambda x: x == 1, subtractList))) lenOfOnes = len([x for x in subtractList if x == 1]) if lenOfOnes == 2: roem += 20 elif lenOfOnes == 3: roem += 50 return roem

def batch_to_space( data: NodeInput, block_shape: NodeInput, crops_begin: NodeInput, crops_end: NodeInput, name: Optional[str] = None, ) -> Node: """Perform BatchToSpace operation on the input tensor. BatchToSpace permutes data from the batch dimension of the data tensor into spatial dimensions. :param data: Node producing the data tensor. :param block_shape: The sizes of the block of values to be moved. :param crops_begin: Specifies the amount to crop from the beginning along each axis of `data`. :param crops_end: Specifies the amount to crop from the end along each axis of `data`. :param name: Optional output node name. :return: The new node performing a BatchToSpace operation. """ return _get_node_factory_opset2().create( "BatchToSpace", as_nodes(data, block_shape, crops_begin, crops_end), )

def test_DetectionMAP(): """ test DetectionMAP :return: """ train_program = fluid.Program() startup_program = fluid.Program() with fluid.unique_name.guard(): with fluid.program_guard(train_program, startup_program): detect_res = fluid.layers.data( name='detect_res', shape=[10, 6], append_batch_size=False, dtype='float32') label = fluid.layers.data( name='label', shape=[10, 1], append_batch_size=False, dtype='float32') box = fluid.layers.data( name='bbox', shape=[10, 4], append_batch_size=False, dtype='float32') map_eval = fluid.metrics.DetectionMAP( detect_res, label, box, class_num=21) cur_map, accm_map = map_eval.get_map_var() assert cur_map is not None assert accm_map is not None

def url_in(url): """ Send a URL and I'll post it to Hive """ custom_json = {'url': url} trx_id , success = send_notification(custom_json) return trx_id, success

def login(): """ Display a basic login form in order to log in a user """ if request.method == 'GET': return render_template('login.html') else: try: usr = User.query.get(request.form['user_id']) if bcrypt.checkpw(request.form['user_password'].encode('utf-8'),usr.password): login_user(usr, remember=True) flash('Logged in successfully') return redirect(session['next_url']) except Exception as e: print("Sorry this user don't exist") print(e) return render_template('login.html')

def hflip(stream): """Flip the input video horizontally. Official documentation: `hflip <https://ffmpeg.org/ffmpeg-filters.html#hflip>`__ """ return FilterNode(stream, hflip.__name__).stream()

def get_diagonal_ripple_rainbows_2(): """ Returns 11 diagonal ripple rainbows Programs that use this function: - Diagonal Ripple 3 - Diagonal Ripple 4 """ rainbow01 = [ [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1H, C2, C3, C4, C5, C6, C7, C8] ] rainbow02 = [ [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1H, C2, C3, C4, C5, C6, C7, C8], [C1, C2H, C3, C4, C5, C6, C7, C8] ] rainbow03 = [ [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1H, C2, C3, C4, C5, C6, C7, C8], [C1, C2H, C3, C4, C5, C6, C7, C8], [C1, C2, C3H, C4, C5, C6, C7, C8] ] rainbow04 = [ [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1H, C2, C3, C4, C5, C6, C7, C8], [C1, C2H, C3, C4, C5, C6, C7, C8], [C1, C2, C3H, C4, C5, C6, C7, C8], [C1, C2, C3, C4H, C5, C6, C7, C8] ] rainbow05 = [ [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1H, C2, C3, C4, C5, C6, C7, C8], [C1, C2H, C3, C4, C5, C6, C7, C8], [C1, C2, C3H, C4, C5, C6, C7, C8], [C1, C2, C3, C4H, C5, C6, C7, C8], [C1, C2, C3, C4, C5H, C6, C7, C8] ] rainbow06 = [ [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1H, C2, C3, C4, C5, C6, C7, C8], [C1, C2H, C3, C4, C5, C6, C7, C8], [C1, C2, C3H, C4, C5, C6, C7, C8], [C1, C2, C3, C4H, C5, C6, C7, C8], [C1, C2, C3, C4, C5H, C6, C7, C8], [C1, C2, C3, C4, C5, C6H, C7, C8] ] rainbow07 = [ [C1, C2, C3, C4, C5, C6, C7, C8], [C1H, C2, C3, C4, C5, C6, C7, C8], [C1, C2H, C3, C4, C5, C6, C7, C8], [C1, C2, C3H, C4, C5, C6, C7, C8], [C1, C2, C3, C4H, C5, C6, C7, C8], [C1, C2, C3, C4, C5H, C6, C7, C8], [C1, C2, C3, C4, C5, C6H, C7, C8], [C1, C2, C3, C4, C5, C6, C7H, C8] ] rainbow08 = [ [C1H, C2, C3, C4, C5, C6, C7, C8], [C1, C2H, C3, C4, C5, C6, C7, C8], [C1, C2, C3H, C4, C5, C6, C7, C8], [C1, C2, C3, C4H, C5, C6, C7, C8], [C1, C2, C3, C4, C5H, C6, C7, C8], [C1, C2, C3, C4, C5, C6H, C7, C8], [C1, C2, C3, C4, C5, C6, C7H, C8], [C1, C2, C3, C4, C5, C6, C7, C8H] ] rainbow09 = [ [C1, C2H, C3, C4, C5, C6, C7, C8], [C1, C2, C3H, C4, C5, C6, C7, C8], [C1, C2, C3, C4H, C5, C6, C7, C8], [C1, C2, C3, C4, C5H, C6, C7, C8], [C1, C2, C3, C4, C5, C6H, C7, C8], [C1, C2, C3, C4, C5, C6, C7H, C8], [C1, C2, C3, C4, C5, C6, C7, C8H], [C1, C2, C3, C4, C5, C6, C7, C8] ] rainbow10 = [ [C1, C2, C3H, C4, C5, C6, C7, C8], [C1, C2, C3, C4H, C5, C6, C7, C8], [C1, C2, C3, C4, C5H, C6, C7, C8], [C1, C2, C3, C4, C5, C6H, C7, C8], [C1, C2, C3, C4, C5, C6, C7H, C8], [C1, C2, C3, C4, C5, C6, C7, C8H], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8] ] rainbow11 = [ [C1, C2, C3, C4H, C5, C6, C7, C8], [C1, C2, C3, C4, C5H, C6, C7, C8], [C1, C2, C3, C4, C5, C6H, C7, C8], [C1, C2, C3, C4, C5, C6, C7H, C8], [C1, C2, C3, C4, C5, C6, C7, C8H], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8] ] rainbow12 = [ [C1, C2, C3, C4, C5H, C6, C7, C8], [C1, C2, C3, C4, C5, C6H, C7, C8], [C1, C2, C3, C4, C5, C6, C7H, C8], [C1, C2, C3, C4, C5, C6, C7, C8H], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8] ] rainbow13 = [ [C1, C2, C3, C4, C5, C6H, C7, C8], [C1, C2, C3, C4, C5, C6, C7H, C8], [C1, C2, C3, C4, C5, C6, C7, C8H], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8] ] rainbow14 = [ [C1, C2, C3, C4, C5, C6, C7H, C8], [C1, C2, C3, C4, C5, C6, C7, C8H], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8] ] rainbow15 = [ [C1, C2, C3, C4, C5, C6, C7, C8H], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8], [C1, C2, C3, C4, C5, C6, C7, C8] ] return rainbow01, rainbow02, rainbow03, rainbow04, rainbow05, \ rainbow06, rainbow07, rainbow08, rainbow09, rainbow10, \ rainbow11, rainbow12, rainbow13, rainbow14, rainbow15

def add_file(original_filepath: Path, path_from_repo: Path) -> None: """Copies the file from the repository to staging area. All parent folders will be created, albeit empty. """ hierarchy = paths.staging_area / path_from_repo if not hierarchy.exists(): hierarchy.mkdir(parents=True) shutil.copy2(original_filepath, hierarchy)

def matrix_prod(A, B, display = False): """ Computes the matrix product of two matrices using array slicing and vector operations. """ if A.shape[1] != B.shape[0]: raise ValueError("Dimensions not compatible.") # Not allowed!? #matrix = A.dot(B) # Dotproduct of each A.row*B.clm matrix = np.array([[np.sum(A[i,:]*B[:,j]) for j in range(B.shape[1])] for i in range(A.shape[0])]) if display: print(matrix) return matrix

def remove_quat_discontinuities(rotations): """ Removing quat discontinuities on the time dimension (removing flips) :param rotations: Array of quaternions of shape (T, J, 4) :return: The processed array without quaternion inversion. """ rots_inv = -rotations for i in range(1, rotations.shape[0]): # Compare dot products replace_mask = np.sum(rotations[i - 1: i] * rotations[i: i + 1], axis=-1) < np.sum( rotations[i - 1: i] * rots_inv[i: i + 1], axis=-1) replace_mask = replace_mask[..., np.newaxis] rotations[i] = replace_mask * rots_inv[i] + (1.0 - replace_mask) * rotations[i] return rotations

def compute_profile_from_frames(frames_str, ax, bt, box, N_bins=100, \ shift=None, verbose=False): """ Compute a density profile from a batch of xyz frames. Input ===== - frames_str: a regex containing frames in xyz format - ax: axis along which to compute the profile - bt: bead type - box: box size, a (3, 3) matrix - N_bins: number of bins Output ====== - r: position vector - pr: density profile vector """ frames = glob.glob(frames_str) assert len(frames) != 0, "No xyz frames captured." Nf = len(frames) N = int(open(frames[0], "r").readline()) if verbose: print(frames) L = np.diag(box) bins = np.linspace(0, L[ax], N_bins + 1) dr = bins[1] - bins[0] r = dr / 2.0 + bins[:-1] Lsurf = L[list(set(range(3)).difference([ax]))] # cross-sectional surface pr = np.zeros_like(r) for frame in frames: bl, X0 = read_xyz(frame) if shift is not None: assert len(shift) == 3, "Vector of shifting must be of size 3." shift = np.array(shift) X0 = X0 + shift X0 = X0 % L if bt == -1: X = X0 else: X = X0[bl == bt] pr += np.histogram(X[:, ax], bins=bins)[0] pr = pr / (dr * np.prod(Lsurf)) / Nf return r, pr

def wikipedia_search(query, lang="en", max_result=1): """ https://www.mediawiki.org/wiki/API:Opensearch """ query = any2unicode(query) params = { "action":"opensearch", "search": query, "format":"json", #"formatversion":2, #"namespace":0, "suggest":"true", "limit": 10 } urlBase = "https://{}.wikipedia.org/w/api.php?".format(lang) url = urlBase + urllib.urlencode(any2utf8(params)) #logging.info(url) r = requests.get(url) jsonData = json.loads(r.content) #logging.info(jsonData) items = [] ret = {"query":query, "itemList":items} for idx, label in enumerate(jsonData[1][0:max_result]): description = jsonData[2][idx] url = jsonData[3][idx] item = { "name": label, "description":description, "url": url, } items.append(item) return ret

def group_result(result, func): """ :param result: A list of rows from the database: e.g. [(key, data1), (key, data2)] :param func: the function to reduce the data e.g. func=median :return: the data that is reduced. e.g. [(key, (data1+data2)/2)] """ data = {} for key, value in result: if key in data.keys(): data[key].append(value) else: data[key] = [value] for key in data: data[key] = func(data[key]) return data.items()

def prep_image(img, inp_dim): """ Prepare image for inputting to the neural network. Returns a Variable """ orig_im = img dim = orig_im.shape[1], orig_im.shape[0] img = cv2.resize(orig_im, (inp_dim, inp_dim)) # img_ = img[:,:,::-1].transpose((2,0,1)).copy() img_ = img.transpose((2,0,1)).copy() img_ = torch.from_numpy(img_).float().div(255.0).unsqueeze(0) return img_, orig_im, dim

def add_periodic_callback(doc, component, interval): """ Add periodic callback to doc in a way that avoids reference cycles If we instead use ``doc.add_periodic_callback(component.update, 100)`` then the component stays in memory as a reference cycle because its method is still around. This way we avoid that and let things clean up a bit more nicely. TODO: we still have reference cycles. Docs seem to be referred to by their add_periodic_callback methods. """ ref = weakref.ref(component) doc.add_periodic_callback(lambda: update(ref), interval) _attach(doc, component)

def s11_warmup_plot( freq: np.ndarray, s11_re: Dict[str, List[np.ndarray]], s11_im: Dict[str, List[np.ndarray]], temperatures: np.ndarray, filename=None, ): """Plot all the S11 measurements taken in warmup, to illustrate convergence.""" nfreq = len(freq) assert len(s11_re) == len(s11_im) freq0 = freq[0] freq1 = freq[nfreq // 2] freq2 = freq[-1] fig, ax = plt.subplots(5, 1, sharex=True, figsize=(12, 12)) for i, load in enumerate(s11_re.keys()): re = np.atleast_2d(np.array(s11_re[load])) im = np.atleast_2d(np.array(s11_im[load])) ax[0].plot(re[:, 0], ls="-", color=f"C{i}", label=f"{load} (Re)") ax[0].plot(im[:, 0], ls="--", color=f"C{i}", label=f"{load} (Im)") ax[0].set_title(f"{freq0:.2f} MHz") ax[1].plot(re[:, nfreq // 2]) ax[1].plot(im[:, nfreq // 2]) ax[1].set_title(f"{freq1:.2f} MHz") ax[2].plot(re[:, -1]) ax[2].plot(im[:, -1]) ax[2].set_title(f"{freq2:.2f} MHz") ax[3].plot(np.sqrt(np.mean(np.square(re[1:] - re[:-1]), axis=1))) ax[3].plot(np.sqrt(np.mean(np.square(im[1:] - im[:-1]), axis=1))) ax[3].set_title("RMS of difference between measurements") ax[4].plot(temperatures) ax[4].set_title(f"{freq0:.2f} MHz") ax[4].set_title("Thermistor Temp.") ax[0].legend() if filename: plt.savefig(filename)

def extractLogData(context): """ helper function to extract all important data from the web context. :param context: the web.py context object :return: a dictionary with all information for the logging. """ logData = {} logData['ip'] = context.ip logData['account'] = context.env.get('HTTP_RUCIO_ACCOUNT') logData['appid'] = 'clients' # has to changed, but atm no appid is send with the clients logData['clientref'] = context.env.get('HTTP_RUCIO_CLIENTREF') logData['uri'] = context.method + ' ' + context.protocol + "://" + context.host + context.homepath + context.fullpath logData['requestid'] = uuid() logData['requestHeader'] = context.env logData['responseHeader'] = '' logData['httpCode'] = '' logData['duration'] = '' return logData

def slithering_snake_32(): """ Lights up then turns off the LEDs on arms 3 and 2 """ LOGGER.debug("SLITHERING SNAKE 32") sleep_speed = 0.10 # Light up Snake 32 PYGLOW.led(13, 100) sleep(sleep_speed) PYGLOW.led(14, 100) sleep(sleep_speed) PYGLOW.led(15, 100) sleep(sleep_speed) PYGLOW.led(16, 100) sleep(sleep_speed) PYGLOW.led(17, 100) sleep(sleep_speed) PYGLOW.led(6, 100) sleep(sleep_speed) PYGLOW.led(12, 100) sleep(sleep_speed) PYGLOW.led(11, 100) sleep(sleep_speed) PYGLOW.led(10, 100) sleep(sleep_speed) PYGLOW.led(9, 100) sleep(sleep_speed) PYGLOW.led(8, 100) sleep(sleep_speed) PYGLOW.led(7, 100) sleep(sleep_speed) # Turn off Snake 32 PYGLOW.led(13, 0) sleep(sleep_speed) PYGLOW.led(14, 0) sleep(sleep_speed) PYGLOW.led(15, 0) sleep(sleep_speed) PYGLOW.led(16, 0) sleep(sleep_speed) PYGLOW.led(17, 0) sleep(sleep_speed) PYGLOW.led(6, 0) sleep(sleep_speed) PYGLOW.led(12, 0) sleep(sleep_speed) PYGLOW.led(11, 0) sleep(sleep_speed) PYGLOW.led(10, 0) sleep(sleep_speed) PYGLOW.led(9, 0) sleep(sleep_speed) PYGLOW.led(8, 0) sleep(sleep_speed) PYGLOW.led(7, 0)

def balance_test(): """Balance the site frequency spectrum""" pos = [1, 10, 20, 30] stop = [2, 11, 21, 31] ref = ['A', 'C', 'T', 'G'] alt = ['T', 'G', 'G', 'A'] p = [0.1, 0.9, 0.3, 0.2] l = vr.VariantList(pos, stop, ref, alt, p) # The core things here are to make sure the sfs is balanced AND the rank ordering is maintained as far as possible p_sfs = [0.1, 0.2, 0.3] f_sfs = [0.5, 0.25, 0.25] l.balance_probabilities(p_sfs, f_sfs) assert_array_almost_equal(l.variants['p'], [0.1, 0.3, 0.2, 0.1], decimal=3)

def Backbone(backbone_type='ResNet50', use_pretrain=True): """Backbone Model""" weights = None if use_pretrain: weights = 'imagenet' def backbone(x_in): if backbone_type == 'ResNet50': return ResNet50(input_shape=x_in.shape[1:], include_top=False, weights=weights)(x_in) elif backbone_type == 'MobileNetV2': return MobileNetV2(input_shape=x_in.shape[1:], include_top=False, weights=weights)(x_in) else: raise TypeError('backbone_type error!') return backbone

def start(ctx, vca_client, **kwargs): """ power on server and wait network connection availability for host """ # combine properties obj = combine_properties( ctx, kwargs=kwargs, names=['server'], properties=[VCLOUD_VAPP_NAME, 'management_network']) # get external if obj.get('use_external_resource'): ctx.logger.info('not starting server since an external server is ' 'being used') else: vapp_name = get_vapp_name(ctx.instance.runtime_properties) config = get_vcloud_config() vdc = vca_client.get_vdc(config['vdc']) vapp = vca_client.get_vapp(vdc, vapp_name) _power_on_vm(ctx, vca_client, vapp, vapp_name) if not _get_state(ctx=ctx, vca_client=vca_client): return ctx.operation.retry( message="Waiting for VM's configuration to complete", retry_after=5)

def softplus(z): """Numerically stable version of log(1 + exp(z)).""" # see stabilizing softplus: http://sachinashanbhag.blogspot.com/2014/05/numerically-approximation-of-log-1-expy.html # noqa mu = z.copy() mu[z > 35] = z[z > 35] mu[z < -10] = np.exp(z[z < -10]) mu[(z >= -10) & (z <= 35)] = log1p(np.exp(z[(z >= -10) & (z <= 35)])) return mu

def merge_indexes( indexes: Mapping[Hashable, Union[Hashable, Sequence[Hashable]]], variables: Mapping[Hashable, Variable], coord_names: Set[Hashable], append: bool = False, ) -> "Tuple[OrderedDict[Any, Variable], Set[Hashable]]": """Merge variables into multi-indexes. Not public API. Used in Dataset and DataArray set_index methods. """ vars_to_replace = {} # Dict[Any, Variable] vars_to_remove = [] # type: list error_msg = "{} is not the name of an existing variable." for dim, var_names in indexes.items(): if isinstance(var_names, str) or not isinstance(var_names, Sequence): var_names = [var_names] names, codes, levels = [], [], [] # type: (list, list, list) current_index_variable = variables.get(dim) for n in var_names: try: var = variables[n] except KeyError: raise ValueError(error_msg.format(n)) if ( current_index_variable is not None and var.dims != current_index_variable.dims ): raise ValueError( "dimension mismatch between %r %s and %r %s" % (dim, current_index_variable.dims, n, var.dims) ) if current_index_variable is not None and append: current_index = current_index_variable.to_index() if isinstance(current_index, pd.MultiIndex): try: current_codes = current_index.codes except AttributeError: # fpr pandas<0.24 current_codes = current_index.labels names.extend(current_index.names) codes.extend(current_codes) levels.extend(current_index.levels) else: names.append("%s_level_0" % dim) cat = pd.Categorical(current_index.values, ordered=True) codes.append(cat.codes) levels.append(cat.categories) if not len(names) and len(var_names) == 1: idx = pd.Index(variables[var_names[0]].values) else: for n in var_names: try: var = variables[n] except KeyError: raise ValueError(error_msg.format(n)) names.append(n) cat = pd.Categorical(var.values, ordered=True) codes.append(cat.codes) levels.append(cat.categories) idx = pd.MultiIndex(levels, codes, names=names) vars_to_replace[dim] = IndexVariable(dim, idx) vars_to_remove.extend(var_names) new_variables = OrderedDict( [(k, v) for k, v in variables.items() if k not in vars_to_remove] ) new_variables.update(vars_to_replace) new_coord_names = coord_names | set(vars_to_replace) new_coord_names -= set(vars_to_remove) return new_variables, new_coord_names

def least_squares(m, n): """ Create a least squares problem with m datapoints and n dimensions """ A = np.random.randn(m, n) _x = np.random.randn(n) b = A.dot(_x) x = cp.Variable(n) return (x, cp.Problem(cp.Minimize(cp.sum_squares(A * x - b) + cp.norm(x, 2))))

def main(): """ Implements the first step of the experiment pipeline. Creates feature \ sets for each one of the folds. Returns: None """ # Construct argument parser and parse arguments ap = argparse.ArgumentParser() ap.add_argument('-fpath', required=True) args = vars(ap.parse_args()) t1 = time.time() # Create folder to store experiment date_time = datetime.datetime.now().strftime("%d-%m-%Y_%H-%M-%S") exp_path = os.path.join(Config.base_dir, 'experiments', f'exp_{date_time}') os.makedirs(exp_path) # Create folder to store feature extraction results results_path = os.path.join(exp_path, 'features_extraction_results') os.makedirs(results_path) copyfile('./geocoding/config.py', os.path.join(exp_path, 'config.py')) # Load dataset into dataframe df = feat_ut.load_points_df(os.path.join(Config.base_dir, args['fpath'])) # Shuffle dataframe df = df.sample(frac=1).reset_index(drop=True) # Encode labels df, encoder = feat_ut.encode_labels(df) df.to_csv(os.path.join(results_path, 'train_df.csv'), index=False) pickle.dump(encoder, open(os.path.join(results_path, 'encoder.pkl'), 'wb')) feat_ut.get_required_external_files(df, results_path) addresses, targets = list(df['address']), list(df['target']) skf = StratifiedKFold(n_splits=Config.n_folds) fold = 1 for train_idxs, test_idxs in skf.split(addresses, targets): fold_path = os.path.join(results_path, 'fold_' + str(fold)) os.makedirs(fold_path) os.makedirs(os.path.join(fold_path, 'features')) os.makedirs(os.path.join(fold_path, 'pickled_objects')) X_train = feat_ut.create_train_features(df.iloc[train_idxs].reset_index(), results_path, fold_path) X_test = feat_ut.create_test_features( df.iloc[test_idxs].reset_index(), results_path, os.path.join(fold_path, 'pickled_objects'), fold_path ) y_train, y_test = df['target'][train_idxs], df['target'][test_idxs] np.save(os.path.join(fold_path, f'X_train.npy'), X_train) np.save(os.path.join(fold_path, f'X_test.npy'), X_test) np.save(os.path.join(fold_path, f'y_train.npy'), y_train) np.save(os.path.join(fold_path, f'y_test.npy'), y_test) fold += 1 wrtrs.write_feats_space(os.path.join(results_path, 'included_features.csv')) print(f'Feature extraction done in {time.time() - t1:.3f} sec.') return

def getRef(refFile): """Returns a genome reference.""" refDict={} hdList=[] ref='' num=0 try: f=open(refFile) except IOError: errlog.error('Cannot find reference file ' +refFile+'. Please check pathname.') sys.exit('Cannot find reference file '+refFile+'. Please check pathname.') i=f.readline() head=i[1:51].rstrip() i=f.readline().rstrip() while i: if i[0]!='>': ref+=i.rstrip() i=f.readline() else: if head in hdList: num+=1 head=head+str(num) ref=ref.upper() for l in 'RYMKSWHBVD': ref=ref.replace(l,'N') refDict[head]=ref hdList.append(head) head=i[1:51].rstrip() i=f.readline() ref='' ref=ref.upper() for l in 'RYMKSWHBVD': ref=ref.replace(l,'N') refDict[head]=ref errlog.debug('Reference file successfully parsed.') return refDict

def cleanup_path(paths, removedir=True): """ remove unreable files and directories from the input path collection, skipped include two type of elements: unwanted directories if removedir is True or unaccessible files/directories """ checked = [] skipped = [] for ele in paths: ele = os.path.abspath(ele) if os.path.exists(ele) and os.access(ele, os.R_OK): if os.path.isdir(ele) and removedir: skipped.append(ele) else: checked.append(ele) else: skipped.append(ele) return checked, skipped

def expand_amn(a, kpoints, idx, Rvectors, nproj_atom=None): """ Expand the projections matrix by translations of the orbitals Parameters ---------- a : ndarray, shape (nkpts, nbnds, nproj) kpoints : ndarray, shape (nkpts, 3) idx : ndarray indices of translated orbitals Rvectors: ndarray translation vectors for the orbitals nproj_atom: ndarray, optional number of projections on each atom, with idx and Rvectors now describing atoms instead of orbitals """ assert len(Rvectors) == len(idx) if nproj_atom is not None: assert len(nproj_atom) == len(idx) idx_new = [] Rvectors_new = [] for iatom, i in enumerate(idx): offset = np.sum(nproj_atom[:i]) for j in range(nproj_atom[i]): idx_new.append(offset+j) Rvectors_new.append(Rvectors[iatom]) idx = idx_new Rvectors = Rvectors_new nkpts, nbnds, nproj = a.shape a1 = np.zeros((nkpts, nbnds, len(idx)), dtype=complex) k_dot_R = np.einsum('ki,ri->kr', kpoints, Rvectors) exp_factors = np.exp(-1j * 2*np.pi * k_dot_R) a1 = a[:, :, idx] * exp_factors[:, np.newaxis, :] return a1

def combine_basis_vectors(weights, vectors, default_value=None, node_num=None): """ Combine basis vectors using ``weights`` as the Manning's n value for each basis vector. If a ``default_value`` is set then all nodes with out data are set to the ``default_value``. :type weights: :class:`numpy.ndarray` :param weights: array of size (num_of_basis_vec, 1) :type vectors: list of dicts OR :class:`numpy.ndarray` of size (node_num, num_of_basis_vec) :param vectors: basis vectors :returns: an array of size (node_num, 1) containing the manningsn value at all nodes in numerical order or a dictionary """ if len(weights) != len(vectors): raise LenError('weights, vectors', 'dimensions do not match') if isinstance(vectors[0], np.array): combine_bv_array(weights, vectors) elif default_value and node_num: return dict_to_array(add_dict(vectors, weights)[0], default_value, node_num) else: return add_dict(vectors, weights)[0]

def demo1(): """ 假设我们有三台洗衣机, 现在有三批衣服需要分别放到这三台洗衣机里面洗. """ def washing1(): sleep(3) # 第一台洗衣机, 需要洗3秒才能洗完 (只是打个比方) print('washer1 finished') # 洗完的时候, 洗衣机会响一下, 告诉我们洗完了 def washing2(): sleep(2) print('washer2 finished') def washing3(): sleep(5) print('washer3 finished') washing1() washing2() washing3() """ 这个还是很容易理解的, 运行 demo1(), 那么需要10秒钟才能把全部衣服洗完. 没错, 大部分时间都花在挨个地等洗衣机上了. """

def test_managed_static_method_handler(): """Test managed static method handlers.""" ob = EventTest() EventTest.s_value = 0 ob.PublicEvent += ob.StaticHandler assert EventTest.s_value == 0 ob.OnPublicEvent(EventArgsTest(10)) assert EventTest.s_value == 10 ob.PublicEvent -= ob.StaticHandler assert EventTest.s_value == 10 ob.OnPublicEvent(EventArgsTest(20)) assert EventTest.s_value == 10

def _prepare_data_for_node_classification( graph: nx.Graph, seed_node: int ) -> List[Tuple[Any, Any]]: """ Position seed node as the first node in the data. TensorFlow GNN has a convention whereby the node to be classified, the "seed node", is positioned first in the component. This is for use with layers such as `tfgnn.keras.layers.ReadoutFirstNode` which extracts the first node from a component. """ seed_data = graph.nodes(data=True)[seed_node] data = [(seed_data["features"], seed_data["label"])] data += [ (data["features"], data["label"]) for node, data in graph.nodes(data=True) if node != seed_node ] return data

def init(): """ Init the application and add routes """ logging.basicConfig(format='%(asctime)s: [%(levelname)s]: %(message)s', level=logging.DEBUG) global theconfig theconfig = get_config() global rc rc = init_redis(theconfig) app = default_app() return app

def norm_potential(latitude, longitude, h, refell, lmax): """ Calculates the normal potential at a given latitude and height Arguments --------- latitude: latitude in degrees longitude: longitude in degrees height: height above reference ellipsoid in meters refell: reference ellipsoid name lmax: maximum spherical harmonic degree Returns ------- U: normal potential at height h dU_dr: derivative of normal potential with respect to radius dU_dtheta: derivative of normal potential with respect to theta """ #-- get ellipsoid parameters for refell ellip = ref_ellipsoid(refell) a = np.float128(ellip['a']) ecc1 = np.float128(ellip['ecc1']) GM = np.float128(ellip['GM']) J2 = np.float128(ellip['J2']) #-- convert from geodetic latitude to geocentric latitude latitude_geodetic_rad = (np.pi*latitude/180.0).astype(np.float128) longitude_rad = (np.pi*longitude/180.0).astype(np.float128) N = a/np.sqrt(1.0 - ecc1**2.0*np.sin(latitude_geodetic_rad)**2.0) X = (N + h) * np.cos(latitude_geodetic_rad) * np.cos(longitude_rad) Y = (N + h) * np.cos(latitude_geodetic_rad) * np.sin(longitude_rad) Z = (N * (1.0 - ecc1**2.0) + h) * np.sin(latitude_geodetic_rad) rr = np.sqrt(X**2.0 + Y**2.0 + Z**2.0) latitude_geocentric = np.arctan(Z / np.sqrt(X**2.0 + Y**2.0)) #-- calculate even zonal harmonics n = np.arange(2, 12+2, 2, dtype=np.float128) J2n = cosine_even_zonals(J2, ecc1, n/2.0) #-- normalized cosine harmonics: Cn = -Jn/np.sqrt(2.0*n+1.0) #-- J2 = 0.108262982131e-2 C_2 = -J2n[0]/np.sqrt(5.0) #-- J4 = -0.237091120053e-5 C_4 = -J2n[1]/np.sqrt(9.0) #-- J6 = 0.608346498882e-8 C_6 = -J2n[2]/np.sqrt(13.0) #-- J8 = -0.142681087920e-10 C_8 = -J2n[3]/np.sqrt(17.0) #-- J10 = 0.121439275882e-13 C_10 = -J2n[4]/np.sqrt(21.0) #-- J12 = 0.205395070709e-15 C_12 = -J2n[5]/np.sqrt(25.0) #-- calculate legendre polynomials at latitude and their first derivative Pl,dPl = legendre_polynomials(lmax, np.sin(latitude_geocentric), ASTYPE=np.float128) #-- normal potentials and derivatives U = (GM/rr) * (1.0 + (a/rr)**2.*C_2*Pl[2,:] + (a/rr)**4.*C_4*Pl[4,:] + \ (a/rr)**6.*C_6*Pl[6,:] + (a/rr)**8.*C_8*Pl[8,:] + \ (a/rr)**10.*C_10*Pl[10,:] + (a/rr)**12.*C_12*Pl[12,:]) dU_dr = GM * (-1.0 / rr**2.0 - 3.0*(a**2.0/rr**4.0)*C_2*Pl[2,:] - \ 5.0*(a**4.0/rr**6.0)*C_4*Pl[4,:] -7.0*(a**6.0/rr**8.0)*C_6*Pl[6,:] - \ 9.0*(a**8.0/rr**10.)*C_8*Pl[8,:] -11.*(a**10./rr**12.)*C_10*Pl[10,:] - \ 13.*(a**12./rr**14.)*C_12*Pl[12,:]) dU_dtheta = (GM/rr) * (1.0 + (a/rr)**2.0*C_2*dPl[2,:] + \ (a/rr)**4.0*C_4*dPl[4,:] + (a/rr)**6.0*C_6*dPl[6,:] + \ (a/rr)**8.0*C_8*dPl[8,:] + (a/rr)**10.0*C_10*dPl[10,:] + \ (a/rr)**12.0*C_12*dPl[12,:]) #-- return the potentials return (U, dU_dr, dU_dtheta)

def _findPlugInfo(rootDir): """ Find every pluginInfo.json files below the root directory. :param str rootDir: the search start from here :return: a list of files path :rtype: [str] """ files = [] for root, dirnames, filenames in os.walk(rootDir): files.extend(glob.glob(root + '/plugInfo.json')) return files

def get_pp_gene_chains(chain_class_file, v=False): """Get gene: pp chains dict.""" gene_to_pp_chains = defaultdict(list) # init the dict f = open(chain_class_file, "r") # open file with classifications f.__next__() # skip header for line in f: line_data = line.rstrip().split("\t") # line contains the following fields" # gene orthologs paralogs trans p_pseudogenes trans = line_data[0] # proc_pseudogene chains are in the 4th field pp_genes_field = line_data[4] if pp_genes_field == "0": # it 0 -> no ppgene chains -> skip continue # parse comma-separated string and save to dict pp_genes = [int(x) for x in pp_genes_field.split(",") if x != ""] gene_to_pp_chains[trans] = pp_genes f.close() if v: verbose(f"Extracted {len(gene_to_pp_chains)} genes with proc pseudogenes") return gene_to_pp_chains

def test_load_accessor(test_df): """Function_docstring.""" check.is_not_none(getattr(test_df, "mp_pivot")) check.is_not_none(getattr(test_df.mp_pivot, "run")) check.is_not_none(getattr(test_df.mp_pivot, "display")) check.is_not_none(getattr(test_df.mp_pivot, "tee")) check.is_not_none(getattr(test_df.mp_pivot, "tee_exec")) check.is_not_none(getattr(test_df.mp_pivot, "filter")) check.is_not_none(getattr(test_df.mp_pivot, "filter_cols")) check.is_not_none(getattr(test_df.mp_pivot, "sort"))

def rec_search(wildcard): """ Traverse all subfolders and match files against the wildcard. Returns: A list of all matching files absolute paths. """ matched = [] for dirpath, _, files in os.walk(os.getcwd()): fn_files = [os.path.join(dirpath, fn_file) for fn_file in fnmatch.filter(files, wildcard)] matched.extend(fn_files) return matched

def skip_object(change_mode, change): """ If `Mode` is `change`: we do not care about the `Conditions` Else: If `cfn` objects: - We can omit the `Conditions`, objects will be involed when `Mode` is `provision` or `destroy`. (Original design. Backward compatibility.) - In case `Conditions` is declared, objects will be involed when `Mode` matches with `Conditions`. If `aws` objects: we must declare `Conditions` and match with `Mode`, or else the engine will skip that Object/Block. OR If `Mode` is `change`: we do not care about the `Conditions` Else: If we omit the `Conditions`: - Only `cfn` objects are involed when `Mode` is `provision` or `destroy`. (Original design. Backward compatibility.) - Others will be skipped. Else: Objects will be involed when `Mode` matches with `Conditions`. Return: - `True` means skipped - `False` means involved """ if (change_mode!=CHANGE_MODE_CHANGE): if ('Conditions' not in change): if (change['Object']==STR_CFN) and (change_mode in [CHANGE_MODE_PROVISION,CHANGE_MODE_DESTROY]): return False return True elif (change_mode not in change['Conditions']): return True return False

def rootfinder(*args): """ rootfinder(str name, str solver, dict:SX rfp, dict opts) -> Function Create a solver for rootfinding problems Takes a function where one of the rootfinder(str name, str solver, dict:MX rfp, dict opts) -> Function rootfinder(str name, str solver, Function f, dict opts) -> Function > rootfinder(str name, str solver, dict:SX rfp, dict opts) ------------------------------------------------------------------------ Create a solver for rootfinding problems Takes a function where one of the inputs is unknown and one of the outputs is a residual function that is always zero, defines a new function where the the unknown input has been replaced by a guess for the unknown and the residual output has been replaced by the calculated value for the input. For a function [y0, y1, ...,yi, .., yn] = F(x0, x1, ..., xj, ..., xm), where xj is unknown and yi=0, defines a new function [y0, y1, ...,xj, .., yn] = G(x0, x1, ..., xj_guess, ..., xm), xj and yi must have the same dimension and d(yi)/d(xj) must be invertable. By default, the first input is unknown and the first output is the residual. General information =================== >List of available options +------------------+-----------------+------------------+------------------+ | Id | Type | Description | Used in | +==================+=================+==================+==================+ | common_options | OT_DICT | Options for | casadi::OracleFu | | | | auto-generated | nction | | | | functions | | +------------------+-----------------+------------------+------------------+ | constraints | OT_INTVECTOR | Constrain the | casadi::Rootfind | | | | unknowns. 0 | er | | | | (default): no | | | | | constraint on | | | | | ui, 1: ui >= | | | | | 0.0, -1: ui <= | | | | | 0.0, 2: ui > | | | | | 0.0, -2: ui < | | | | | 0.0. | | +------------------+-----------------+------------------+------------------+ | error_on_fail | OT_BOOL | When the | casadi::Rootfind | | | | numerical | er | | | | process returns | | | | | unsuccessfully, | | | | | raise an error | | | | | (default false). | | +------------------+-----------------+------------------+------------------+ | implicit_input | OT_INT | Index of the | casadi::Rootfind | | | | input that | er | | | | corresponds to | | | | | the actual root- | | | | | finding | | +------------------+-----------------+------------------+------------------+ | implicit_output | OT_INT | Index of the | casadi::Rootfind | | | | output that | er | | | | corresponds to | | | | | the actual root- | | | | | finding | | +------------------+-----------------+------------------+------------------+ | jacobian_functio | OT_FUNCTION | Function object | casadi::Rootfind | | n | | for calculating | er | | | | the Jacobian | | | | | (autogenerated | | | | | by default) | | +------------------+-----------------+------------------+------------------+ | linear_solver | OT_STRING | User-defined | casadi::Rootfind | | | | linear solver | er | | | | class. Needed | | | | | for | | | | | sensitivities. | | +------------------+-----------------+------------------+------------------+ | linear_solver_op | OT_DICT | Options to be | casadi::Rootfind | | tions | | passed to the | er | | | | linear solver. | | +------------------+-----------------+------------------+------------------+ | monitor | OT_STRINGVECTOR | Set of user | casadi::OracleFu | | | | problem | nction | | | | functions to be | | | | | monitored | | +------------------+-----------------+------------------+------------------+ | specific_options | OT_DICT | Options for | casadi::OracleFu | | | | specific auto- | nction | | | | generated | | | | | functions, | | | | | overwriting the | | | | | defaults from | | | | | common_options. | | | | | Nested | | | | | dictionary. | | +------------------+-----------------+------------------+------------------+ >Input scheme: casadi::RootfinderInput (ROOTFINDER_NUM_IN = 2) +---------------+-------+---------------------------------+ | Full name | Short | Description | +===============+=======+=================================+ | ROOTFINDER_X0 | x0 | Initial guess for the solution. | +---------------+-------+---------------------------------+ | ROOTFINDER_P | p | Parameters. | +---------------+-------+---------------------------------+ >Output scheme: casadi::RootfinderOutput (ROOTFINDER_NUM_OUT = 1) +--------------+-------+--------------------------------------+ | Full name | Short | Description | +==============+=======+======================================+ | ROOTFINDER_X | x | Solution to the system of equations. | +--------------+-------+--------------------------------------+ List of plugins =============== - kinsol - fast_newton - nlpsol - newton Note: some of the plugins in this list might not be available on your system. Also, there might be extra plugins available to you that are not listed here. You can obtain their documentation with Rootfinder.doc("myextraplugin") -------------------------------------------------------------------------------- kinsol ------ KINSOL interface from the Sundials suite >List of available options +---------------------------+-----------------+----------------------------+ | Id | Type | Description | +===========================+=================+============================+ | abstol | OT_DOUBLE | Stopping criterion | | | | tolerance | +---------------------------+-----------------+----------------------------+ | disable_internal_warnings | OT_BOOL | Disable KINSOL internal | | | | warning messages | +---------------------------+-----------------+----------------------------+ | exact_jacobian | OT_BOOL | Use exact Jacobian | | | | information | +---------------------------+-----------------+----------------------------+ | f_scale | OT_DOUBLEVECTOR | Equation scaling factors | +---------------------------+-----------------+----------------------------+ | iterative_solver | OT_STRING | gmres|bcgstab|tfqmr | +---------------------------+-----------------+----------------------------+ | linear_solver_type | OT_STRING | dense|banded|iterative|use | | | | r_defined | +---------------------------+-----------------+----------------------------+ | lower_bandwidth | OT_INT | Lower bandwidth for banded | | | | linear solvers | +---------------------------+-----------------+----------------------------+ | max_iter | OT_INT | Maximum number of Newton | | | | iterations. Putting 0 sets | | | | the default value of | | | | KinSol. | +---------------------------+-----------------+----------------------------+ | max_krylov | OT_INT | Maximum Krylov space | | | | dimension | +---------------------------+-----------------+----------------------------+ | pretype | OT_STRING | Type of preconditioner | +---------------------------+-----------------+----------------------------+ | strategy | OT_STRING | Globalization strategy | +---------------------------+-----------------+----------------------------+ | u_scale | OT_DOUBLEVECTOR | Variable scaling factors | +---------------------------+-----------------+----------------------------+ | upper_bandwidth | OT_INT | Upper bandwidth for banded | | | | linear solvers | +---------------------------+-----------------+----------------------------+ | use_preconditioner | OT_BOOL | Precondition an iterative | | | | solver | +---------------------------+-----------------+----------------------------+ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- fast_newton ----------- Implements simple newton iterations to solve an implicit function. >List of available options +------------+-----------+-------------------------------------------------+ | Id | Type | Description | +============+===========+=================================================+ | abstol | OT_DOUBLE | Stopping criterion tolerance on ||g||__inf) | +------------+-----------+-------------------------------------------------+ | abstolStep | OT_DOUBLE | Stopping criterion tolerance on step size | +------------+-----------+-------------------------------------------------+ | max_iter | OT_INT | Maximum number of Newton iterations to perform | | | | before returning. | +------------+-----------+-------------------------------------------------+ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- nlpsol ------ -------------------------------------------------------------------------------- -------------------------------------------------------------------------------- newton ------ Implements simple newton iterations to solve an implicit function. >List of available options +-----------------+-----------+--------------------------------------------+ | Id | Type | Description | +=================+===========+============================================+ | abstol | OT_DOUBLE | Stopping criterion tolerance on max(|F|) | +-----------------+-----------+--------------------------------------------+ | abstolStep | OT_DOUBLE | Stopping criterion tolerance on step size | +-----------------+-----------+--------------------------------------------+ | max_iter | OT_INT | Maximum number of Newton iterations to | | | | perform before returning. | +-----------------+-----------+--------------------------------------------+ | print_iteration | OT_BOOL | Print information about each iteration | +-----------------+-----------+--------------------------------------------+ -------------------------------------------------------------------------------- Joel Andersson > rootfinder(str name, str solver, dict:MX rfp, dict opts) > rootfinder(str name, str solver, Function f, dict opts) ------------------------------------------------------------------------ """ return _casadi.rootfinder(*args)

def f18(x, rotation=None, shift=None, shuffle=None): """ Hybrid Function 8 (N=5) Args: x (array): Input vector of dimension 2, 10, 20, 30, 50 or 100. rotation (matrix): Optional rotation matrix. If None (default), the official matrix from the benchmark suite will be used. shift (array): Optional shift vector. If None (default), the official vector from the benchmark suite will be used. shuffle (array): Optionbal shuffle vector. If None (default), the official permutation vector from the benchmark suite will be used. """ nx = len(x) if rotation is None: rotation = transforms.rotations[nx][17] if shift is None: shift = transforms.shifts[17][:nx] if shuffle is None: shuffle = transforms.shuffles[nx][7] x_transformed = np.matmul(rotation, x - shift) x_parts = _shuffle_and_partition(x_transformed, shuffle, [0.2, 0.2, 0.2, 0.2, 0.2]) y = basic.high_conditioned_elliptic(x_parts[0]) y += basic.ackley(x_parts[1]) y += basic.rastrigin(x_parts[2]) y += basic.h_g_bat(x_parts[3]) y += basic.discus(x_parts[4]) return y + 1800.0

def shake_256_len(data: bytes, length: int) -> hashes.MessageDigest: """ Convenience function to hash a message. """ return HashlibHash.hash(hashes.shake_256_len(length), data)

def rgb_to_cmyk(color_values: tp.List[float]) -> tp.List[float]: """Converts list of RGB values to CMYK. :param color_values: (list) 3-member RGB color value list :return: (list) 4-member CMYK color value list """ if color_values == [0.0, 0.0, 0.0]: return [0.0, 0.0, 0.0, 1.0] r, g, b = color_values c = 1.0 - r m = 1.0 - g y = 1.0 - b min_cmy = min(c, m, y) c = (c - min_cmy) / (1 - min_cmy) m = (m - min_cmy) / (1 - min_cmy) y = (y - min_cmy) / (1 - min_cmy) k = min_cmy return [c, m, y, k]

def check_family(matrix): """Check the validity of a family matrix for the vine copula. Parameters: ---------- matrix : array The pair-copula families. Returns ------- matrix : array The corrected matrix. """ # TODO: check if the families are in the list of copulas matrix = check_matrix(matrix) matrix = check_triangular(matrix, k=1) dim = matrix.shape[0] for i in range(dim): for j in range(i): if isinstance(matrix[i, j], str): matrix[i, j] = int( R_VINECOPULA.BiCopName(matrix[i, j], False)[0]) elif isinstance(matrix[i, j], np.integer): pass matrix = matrix.astype(int) return matrix

def parse_pgt_programmearray(url): """ Parse filter.js programmearray for pgt information :param url: base url for timetabling system :return: pgt programme name to id dict """ # get filter.js file source = get_filterjs(url) name_to_id = {} # e.g. programmearray[340] [0] = "MSc Finance and Investment (Business Analytics)/F/02 - MSc Finance and # Investment (Business Analytics)"; matches = re.findall(r'programmearray\[(\d{1,3})\] \[0\] = "(.*)";\s+' r'programmearray\[\1\] \[1\] = ".*";\s+' r'programmearray\[\1\] \[2\] = "(PGT/.*)"', source) for match in matches: # match e.g. ('0', 'MA Applied Linguistics/F/01 - EG04 Applied Linguistics', 'PGT/C1014/C7PAPLST/F/01') name_to_id[match[1]] = match[2] return name_to_id

def distance_calc(x1, y1, x2, y2): """Calculates distance between two points""" return ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

def LoadNasaData(lat, lon, show= False, selectparms= None): """ Execute a request from NASA API for 10 years of atmospheric data required to prepare daily statistical data used in Solar Insolation calculations """ cmd = formulateRequest(-0.2739, 36.3765, selectparms) jdi = requests.get(cmd[0]).json() cols = cmd[1] df = pd.json_normalize(jdi['features'][0]['properties']['parameter'][cols[0]]).T df.index = pd.to_datetime(df.index) df.rename(columns={0: cols[0]}, inplace= True) for c in cols[1:]: dfc = pd.json_normalize(jdi['features'][0]['properties']['parameter'][c]).T dfc.index = pd.to_datetime(df.index) dfc.rename(columns={0: c}, inplace= True) df = df.join(dfc) df['DayofYear'] = df.index.dayofyear df = df[df['DayofYear'] != 366] #drop a day for leap years atmo_dict = dict() dg = df.groupby('DayofYear') for col in cols: dp = pd.DataFrame(dg[col].min()) dp.rename(columns={col: 'Min'}, inplace= True) atmo_dict[col] = dp dp = pd.DataFrame(dg[col].max()) dp.rename(columns={col: 'Max'}, inplace= True) atmo_dict[col] = atmo_dict[col].join(dp) dp = pd.DataFrame(dg[col].mean()) dp.rename(columns={col: 'S-Mean'}, inplace= True) atmo_dict[col] = atmo_dict[col].join(dp) dp = pd.DataFrame(dg[col].std()) dp.rename(columns={col: 'STDV'}, inplace= True) atmo_dict[col] = atmo_dict[col].join(dp) return atmo_dict

def mmyy_date_slicer(date_str): """Return start and end point for given date in mm-yy format. :param date_str: date in mmyy format, i.e. "1222" or "0108". :return: start and end date string for a given mmyy formatted date string """ # Initialize output start = "" end = "" if mmyy_valid_date(date_str): today = date.today() # Check if date is in the future dt_check = datetime.strptime(date_str, "%m%y") if dt_check.date() <= today: # Determine the start date string datetime_object = datetime.strptime(date_str[0:2], "%m") mo = datetime_object.strftime("%b") yyyy = f"20{date_str[2:]}" start = f'1 {mo}, {yyyy}' # Determine the end date string. mm = int(date_str[0:2]) if mm == today.month: pass elif mm == 12: end = f"1 Jan, {int(yyyy)+1}" else: mm1 = int(date_str[0:2]) + 1 datetime_object = datetime.strptime(f"{mm1}", "%m") mo1 = datetime_object.strftime("%b") end = f'1 {mo1}, {yyyy}' else: # print(f'date in the future! > {date_str}') return "", "" else: # print(f'date malformed! > {date_str}') return "", "" return start, end

def constant_arg(name: str): """ Promises that the given arg will not be modified Only affects mutable data types Removes the need to copy the data during inlining """ def annotation(target: typing.Callable): optimiser = _schedule_optimisation(target) optimiser.constant_args.add(name) return target return annotation

def place_connection(body): # noqa: E501 """Place an connection request from the SDX-Controller # noqa: E501 :param body: order placed for creating a connection :type body: dict | bytes :rtype: Connection """ if connexion.request.is_json: body = Connection.from_dict(connexion.request.get_json()) # noqa: E501 return 'do some magic!'

def tag_list(request): """展示所有标签""" return render(request, 'admin/tags_list.html')

def scan_url(urls): """ Scan the url using the API Args: urls: the list of urls Returns: A tuple of a bool indicating if all the urls are safe and a list indicating the safeness of individual urls """ is_safe = True safe_list = [True] * len(urls) safe_browsing_url = "https://safebrowsing.googleapis.com/v4/threatMatches:find" params = {"key": GOOGLE_TOKEN} json = { "threatInfo": { "threatTypes": [ "THREAT_TYPE_UNSPECIFIED", "MALWARE", "SOCIAL_ENGINEERING", "UNWANTED_SOFTWARE", "POTENTIALLY_HARMFUL_APPLICATION", ], "platformTypes": ["ANY_PLATFORM"], "threatEntryTypes": ["URL"], "threatEntries": [{"url": url} for url in urls], } } r = requests.post(safe_browsing_url, params=params, json=json) if r.status_code == 200: results = r.json() if "matches" in results and results["matches"]: is_safe = False matches = results["matches"] urls_dict = {k: v for v, k in enumerate(urls)} for match in matches: safe_list[urls_dict[match["threat"]["url"]]] = False return is_safe, safe_list

def test_chain_rewrite_save_one_before_last(): """Take chain of length 5, save first node.""" tf.reset_default_graph() tf_dev = tf.device('/cpu:0') tf_dev.__enter__() n = 5 a0, a1, a2, a3, a4 = make_chain_tanh_constant(n) grad = memory_saving_gradients.gradients([a4], [a0], checkpoints=[a2])[0] expected_peak = (n+1-2)*10**6 sess = create_session() sessrun(tf.global_variables_initializer()) sessrun(grad.op) peak_memory = cpu_peak() util.report_memory(peak_memory, expected_peak) if not REMOVE_ASSERTS: assert (peak_memory - expected_peak) < 1.1e6, "Difference too large."

def head_to_tree(head, len_, prune, subj_pos, obj_pos): """ Convert a sequence of head indexes into a tree object. """ head = head[:len_].tolist() root = None if prune < 0: nodes = [Tree() for _ in head] for i in range(len(nodes)): h = head[i] nodes[i].idx = i nodes[i].dist = -1 # just a filler if h == 0: root = nodes[i] else: nodes[h-1].add_child(nodes[i]) else: # find dependency path subj_pos = [i for i in range(len_) if subj_pos[i] == 0] obj_pos = [i for i in range(len_) if obj_pos[i] == 0] cas = None subj_ancestors = set(subj_pos) for s in subj_pos: h = head[s] tmp = [s] while h > 0: tmp += [h-1] subj_ancestors.add(h-1) h = head[h-1] if cas is None: cas = set(tmp) else: cas.intersection_update(tmp) obj_ancestors = set(obj_pos) for o in obj_pos: h = head[o] tmp = [o] while h > 0: tmp += [h-1] obj_ancestors.add(h-1) h = head[h-1] cas.intersection_update(tmp) # find lowest common ancestor if len(cas) == 1: lca = list(cas)[0] else: child_count = {k: 0 for k in cas} for ca in cas: if head[ca] > 0 and head[ca] - 1 in cas: child_count[head[ca] - 1] += 1 # the LCA has no child in the CA set for ca in cas: if child_count[ca] == 0: lca = ca break path_nodes = subj_ancestors.union(obj_ancestors).difference(cas) path_nodes.add(lca) # compute distance to path_nodes dist = [-1 if i not in path_nodes else 0 for i in range(len_)] for i in range(len_): if dist[i] < 0: stack = [i] while stack[-1] >= 0 and stack[-1] not in path_nodes: stack.append(head[stack[-1]] - 1) if stack[-1] in path_nodes: for d, j in enumerate(reversed(stack)): dist[j] = d else: for j in stack: if j >= 0 and dist[j] < 0: dist[j] = int(1e4) # aka infinity highest_node = lca nodes = [Tree() if dist[i] <= prune else None for i in range(len_)] for i in range(len(nodes)): if nodes[i] is None: continue h = head[i] nodes[i].idx = i nodes[i].dist = dist[i] if h > 0 and i != highest_node: assert nodes[h-1] is not None nodes[h-1].add_child(nodes[i]) root = nodes[highest_node] assert root is not None return root

def capped_subtraction(x, y): """Saturated arithmetics. Returns x - y truncated to the int64_t range.""" assert_is_int64(x) assert_is_int64(y) if y == 0: return x if x == y: if x == INT_MAX or x == INT_MIN: raise OverflowError( 'Integer NaN: subtracting INT_MAX or INT_MIN to itself') return 0 if x == INT_MAX or x == INT_MIN: return x if y == INT_MAX: return INT_MIN if y == INT_MIN: return INT_MAX return to_capped_int64(x - y)

def plotInterestPoint(ax): """ """ from pandas import read_excel filepath="../data/points.xls" points=read_excel(filepath, sheet_name="Map3" ) for lon, lat, cname, h_alig in zip(points.lon, points.lat, points.name, points.h_alig): #range(len(cities_name)): ax.plot(lon, lat, label=cname, marker='o', transform=ccrs.Geodetic()) #, c='b' ax.text(lon, lat, cname, fontsize=8, horizontalalignment=h_alig, transform=ccrs.Geodetic()) return

def evaluate_points(func, begin, total_samps, var_list, attr): """ Inputs: func- the lambda function used to generate the data from the evaluation vector begin- the index to start at in the `attr` array total_samps- the total number of samples to generate var_list- list of the variables attr- the attribute that holds the values to be used in the evaluation vector Identical to evaluate_points_verbose, but doesn't check for a verbose option every iteration. This version also deals with indexing only part of eval_vect. """ var_count = len(var_list) term_count = func(np.zeros(var_count)).shape if len(term_count) > 0: term_count = term_count[1] # len(func(np.zeros(var_count))) else: term_count = 1 eval_vect = np.zeros([total_samps, var_count]) matrix = np.zeros([total_samps, term_count]) end = begin + total_samps for j in range(var_count): attr_arr = getattr(var_list[j], attr) eval_vect[:, j] = attr_arr[begin:end].T for i in range(total_samps): matrix[i, :] = func(eval_vect[i, :]) return matrix

def get_username(): """Return username Return a useful username even if we are running under HT-Condor. Returns ------- str : username """ batch_system = os.environ.get('BATCH_SYSTEM') if batch_system == 'HTCondor': return os.environ.get('USER', '*Unknown user*') return os.getlogin()

def corresponding_chromaticities_prediction_CIE1994(experiment=1): """ Returns the corresponding chromaticities prediction for *CIE 1994* chromatic adaptation model. Parameters ---------- experiment : integer or CorrespondingColourDataset, optional {1, 2, 3, 4, 6, 8, 9, 11, 12} *Breneman (1987)* experiment number or :class:`colour.CorrespondingColourDataset` class instance. Returns ------- tuple Corresponding chromaticities prediction. References ---------- :cite:`Breneman1987b`, :cite:`CIETC1-321994b` Examples -------- >>> from pprint import pprint >>> pr = corresponding_chromaticities_prediction_CIE1994(2) >>> pr = [(p.uv_m, p.uv_p) for p in pr] >>> pprint(pr) # doctest: +ELLIPSIS [(array([ 0.207, 0.486]), array([ 0.2273130..., 0.5267609...])), (array([ 0.449, 0.511]), array([ 0.4612181..., 0.5191849...])), (array([ 0.263, 0.505]), array([ 0.2872404..., 0.5306938...])), (array([ 0.322, 0.545]), array([ 0.3489822..., 0.5454398...])), (array([ 0.316, 0.537]), array([ 0.3371612..., 0.5421567...])), (array([ 0.265, 0.553]), array([ 0.2889416..., 0.5534074...])), (array([ 0.221, 0.538]), array([ 0.2412195..., 0.5464301...])), (array([ 0.135, 0.532]), array([ 0.1530344..., 0.5488239...])), (array([ 0.145, 0.472]), array([ 0.1568709..., 0.5258835...])), (array([ 0.163, 0.331]), array([ 0.1499762..., 0.4401747...])), (array([ 0.176, 0.431]), array([ 0.1876711..., 0.5039627...])), (array([ 0.244, 0.349]), array([ 0.2560012..., 0.4546263...]))] """ experiment_results = (convert_experiment_results_Breneman1987(experiment) if is_numeric(experiment) else experiment) with domain_range_scale(1): XYZ_t, XYZ_r = experiment_results.XYZ_t, experiment_results.XYZ_r xy_o1, xy_o2 = XYZ_to_xy([XYZ_t, XYZ_r]) uv_t = Luv_to_uv(XYZ_to_Luv(experiment_results.XYZ_ct, xy_o1), xy_o1) uv_m = Luv_to_uv(XYZ_to_Luv(experiment_results.XYZ_cr, xy_o2), xy_o2) Y_r = experiment_results.B_r E_o1, E_o2 = experiment_results.Y_t, experiment_results.Y_r XYZ_1 = experiment_results.XYZ_ct XYZ_2 = chromatic_adaptation_CIE1994(XYZ_1, xy_o1, xy_o2, Y_r, E_o1, E_o2) uv_p = Luv_to_uv(XYZ_to_Luv(XYZ_2, xy_o2), xy_o2) return tuple([ CorrespondingChromaticitiesPrediction(experiment_results.name, uv_t[i], uv_m[i], uv_p[i]) for i in range(len(uv_t)) ])

def interpExtrap(x, xp, yp): """numpy.interp interpolation function extended by linear extrapolation.""" y = np.interp(x, xp, yp) y = np.where(x < xp[0], yp[0]+(x-xp[0])*(yp[0]-yp[1])/(xp[0]-xp[1]), y) return np.where(x > xp[-1], yp[-1]+(x-xp[-1])*(yp[-1]-yp[-2]) / (xp[-1]-xp[-2]), y)

def get_operating(): """Get latest operating budgets from shared drive.""" logging.info('Retrieving latest operating budget') command = "smbclient //ad.sannet.gov/dfs " \ + "--user={adname}%{adpass} -W ad -c " \ + "'prompt OFF;"\ + " cd \"FMGT-Shared/Shared/BUDGET/" \ + "Open Data/Open Data Portal/" \ + "Shared with Performance and Analytics/" \ + "Budget/Operating/\";" \ + " lcd \"/data/temp/\";" \ + " mget FY*BUDGET.xlsx;'" command = command.format(adname=conf['alb_sannet_user'], adpass=conf['alb_sannet_pass'], temp_dir=conf['temp_data_dir']) logging.info(command) try: p = subprocess.check_output(command, shell=True, stderr=subprocess.STDOUT) return p except subprocess.CalledProcessError as e: return e.output

def test_parameter_creation(mock_settings_env_vars) -> None: # type: ignore """Test the creation of parameters to be used in settings.""" aws_parameter = AwsParameterStore(name="Setting", check_settings=True) assert aws_parameter.name == "Setting" with mock.patch.dict(os.environ, {"SETTINGS_NAME": "", "SETTINGS_ENVIRONMENT": ""}): with pytest.raises(ValueError): AwsParameterStore(name="Setting", check_settings=True) aws_parameter_2 = AwsParameterStore(name="Setting") assert aws_parameter_2.name == "Setting" assert aws_parameter_2.location == "/environments/Setting" aws_parameter_3 = AwsParameterStore(name="Setting", location="/def") assert aws_parameter_3.location == "/def" aws_parameter_4 = AwsParameterStore(name="Setting", location_path="/def") assert aws_parameter_4.location_path == "/def" assert aws_parameter_4.location == "/def/Setting"

def removeNodesFromMRMLScene(nodesToRemove): """Removes the input nodes from the scene. Nodes will no longer be accessible from the mrmlScene or from the UI. Parameters ---------- nodesToRemove: List[vtkMRMLNode] or vtkMRMLNode Objects to remove from the scene """ for node in nodesToRemove: removeNodeFromMRMLScene(node)

def get_nome_socio(id): """pega o nome de um livro pelo id.""" if request.method == 'GET': try: socio = db.query_bd('select * from socio where id = "%s"' % id) if socio: print(socio) socio = socio[0] print(socio) content = { 'nome': socio['nome'], 'status': socio['status'] } return json.dumps(content) except Exception as e: print(e) return render_template('404.html')

def processDeps(element: etree.Element, params: dict = {}) -> None: """Function to NAF deps layer to RDF Args: element: element containing the deps layer params: dict of params to store results Returns: None """ output = params["out"] for dep in element: if dep.tag == "dep": # depname = genDepName(params) # output.write(" xl:type naf-base:dep ;\n") rfunc = dep.attrib["rfunc"] to_term = dep.attrib["to_term"] from_term = dep.attrib["from_term"] output.write( "_:" + from_term + " " + "naf-rfunc:" + rfunc + " _:" + to_term + "\n" ) # for key in dep.attrib.keys(): # if (key != "id"): # if key == "rfunc": # output.write(" naf-base:"+attrib2pred(key)+' naf-base:'+dep.attrib[key]+' ;\n') # else: # output.write(" naf-base:"+attrib2pred(key)+' _:'+dep.attrib[key]+' ;\n') output.write(" .\n") return None

def fit_solution_matrix(weights, design_matrix, cache=None, hash_decimal=10, fit_mat_key=None): """ Calculate the linear least squares solution matrix from a design matrix, A and a weights matrix W S = [A^T W A]^{-1} A^T W Parameters ---------- weights: array-like ndata x ndata matrix of data weights design_matrx: array-like ndata x n_fit_params matrix transforming fit_parameters to data cache: optional dictionary optional dictionary storing pre-computed fitting matrix. hash_decimal: int optional the number of decimals to use in hash for caching. default is 10 fit_mat_key: optional hashable variable optional key. If none is used, hash fit matrix against design and weighting matrix. Returns ----------- array-like n_fit_params x n_fit_params matrix S = [A^T W A]^{-1} A ^T W """ if cache is None: cache = {} ndata = weights.shape[0] if not weights.shape[0] == weights.shape[1]: raise ValueError("weights must be a square matrix") if not design_matrix.shape[0] == ndata: raise ValueError("weights matrix incompatible with design_matrix!") if fit_mat_key is None: opkey = ('fitting_matrix',) + tuple(np.round(weights.flatten(), hash_decimal))\ +tuple(np.round(design_matrix.flatten(), hash_decimal)) else: opkey = fit_mat_key if not opkey in cache: #check condition number cmat = np.conj(design_matrix.T) @ weights @ design_matrix #should there be a conjugation!?! if np.linalg.cond(cmat)>=1e9: warn('Warning!!!!: Poorly conditioned matrix! Your linear inpainting IS WRONG!') cache[opkey] = np.linalg.pinv(cmat) @ np.conj(design_matrix.T) @ weights else: try: cache[opkey] = np.linalg.inv(cmat) @ np.conj(design_matrix.T) @ weights except np.linalg.LinAlgError as error: print(error) cache[opkey] = None return cache[opkey]

def version_from(schema_path, document_path): """HACK A DID ACK derives non-default 1.1 version from path.""" LOG.debug("xml version derivation flat inspection schema_path=%s", schema_path) if CRVF_PRE_OASIS_SEMANTIC_VERSION in str(schema_path): return CRVF_PRE_OASIS_SEMANTIC_VERSION if CRVF_DEFAULT_SEMANTIC_VERSION in str(schema_path): return CRVF_DEFAULT_SEMANTIC_VERSION LOG.debug("xml version derivation deep call document_path=%s", document_path) return version_peek(document_path)

def nessus_vuln_check(request): """ Get the detailed vulnerability information. :param request: :return: """ if request.method == 'GET': id_vul = request.GET['vuln_id'] else: id_vul = '' vul_dat = nessus_report_db.objects.filter(vul_id=id_vul) return render(request, 'nessus_vuln_data.html', {'vul_dat': vul_dat})

def wait_for_job_completion(namespace, timeout, error_msg): """ This is a WORKAROUND of particular ocsci design choices: I just wait for one pod in the namespace, and then ask for the pod again to get it's name (but it would be much better to just wait for the job to finish instead, then ask for a name of the successful pod and use it to get logs ...) Returns: str: name of Pod resource of the finished job """ ocp_pod = ocp.OCP(kind="Pod", namespace=namespace) try: ocp_pod.wait_for_resource( resource_count=1, condition=constants.STATUS_COMPLETED, timeout=timeout, sleep=30) except TimeoutExpiredError as ex: # report some high level error as well logger.error(error_msg) # TODO: log both describe and the output from the fio pods, as DEBUG ex.message = error_msg raise(ex) # indentify pod of the completed job pod_data = ocp_pod.get() # explicit list of assumptions, if these assumptions are not met, the # code won't work and it either means that something went terrible # wrong or that the code needs to be changed assert pod_data['kind'] == "List" pod_dict = pod_data['items'][0] assert pod_dict['kind'] == "Pod" pod_name = pod_dict['metadata']['name'] logger.info(f"Identified pod name of the finished Job: {pod_name}") pod_name = pod_dict['metadata']['name'] return pod_name

def delete_data(data, object_name, **kwargs): """ Delete data """ data.delete() is_queryset = isinstance(data, QuerySet) return { "is_queryset": is_queryset, "data": data, "object_name": object_name, }

def test_create_box(client, default_qr_code): """Verify base GraphQL query endpoint""" box_creation_input_string = f"""{{ product_id: 1, items: 9999, location_id: 100000005, comments: "", size_id: 1, qr_barcode: "{default_qr_code["code"]}", created_by: "1" }}""" # TODO: add location, product and qr to the responses for this gql_mutation_string = f"""mutation {{ createBox( box_creation_input : {box_creation_input_string} ) {{ id items }} }}""" data = {"query": gql_mutation_string} response_data = client.post("/graphql", json=data) # TODO: fix this test created_box = response_data.json["data"]["createBox"] assert response_data.status_code == 200 assert created_box["items"] == 9999

def get_g(source): """ Read the Graph from a textfile """ G = {} Grev = {} for i in range(1, N+1): G[i] = [] Grev[i] = [] fin = open(source) for line in fin: v1 = int(line.split()[0]) v2 = int(line.split()[1]) G[v1].append(v2) Grev[v2].append(v1) fin.close() return G, Grev

def _mercator(lat_long): """ Calculate the 2D X and Y coordinates from a set of coordinates based on radius, latitude and longitude using the Mercator projection. :param lat_long: The coordinates of the points to be projected expressed as radius, latitude and longitude. :type lat_long: list[tuple] :return: The projected coordinates in the XY-plane. :rtype: ndarray """ x = np.array([coord[0] * coord[2] for coord in lat_long]) y = np.array([coord[0] * np.log(np.tan(np.pi / 4 + coord[1] / 2)) for coord in lat_long]) return np.vstack((x, y)).T

def subjectForm(request, experiment_id): """ Generates the fourth page, the demographic/participant data form of an experiment. """ experiment = get_object_or_404(Experiment, pk=experiment_id) form = SubjectDataForm(experiment=experiment) t = Template(experiment.demographic_data_page_tpl) c = RequestContext(request, {'subject_data_form': form, 'experiment': experiment, 'recaptcha_site_key': settings.GOOGLE_RECAPTCHA_SITE_KEY}) return HttpResponse(t.render(c))

def sigma_0(x): """First rotational + shifting mixing function σ_256_0(x) = ROTR_7(x) ⊕ ROTR_18(x) ⊕ SHR_3(x) """ return ROTR(x, 7) ^ ROTR(x, 18) ^ SHR(x, 3)

def mat_mult(a=[1.0, 0.0], b=[1.0, 0.0], n=3, result=[0.0, 0.0]): """Multiply two square matrices (not element-wise). Stores the result in `result`. Parameters ---------- a: list b: list n: int : number of rows/columns result: list """ i, j, k = declare('int', 3) for i in range(n): for k in range(n): s = 0.0 for j in range(n): s += a[n*i + j] * b[n*j + k] result[n*i + k] = s

def edit_entry(edit_result): """Edit entry""" new_entry = edit_result.copy() edit_key = None edit_value = None date_keys = ["Date"] int_keys = ["Time Spent"] while edit_key not in edit_result: reset_screen("key", "Please type the key you want to edit.") for key, value in edit_result.items(): print(f"{key}: {value}") edit_key = get_input(str) if edit_key not in edit_result: reset_screen(error=True, sub_title="Input is not a valid key.") if edit_key in date_keys: input_type = datetime elif edit_key in int_keys: input_type = int else: input_type = str while not edit_value: reset_screen("new value", ENTRY_QUESTIONS[edit_key]) edit_value = get_input(input_type, newline=False) new_entry[edit_key] = edit_value entries = get_entries() entries[entries.index(edit_result)] = new_entry csvfile = open("entries.csv", "w") csvfile.close() for entry in entries: write_to_csv(entry) return new_entry

def build_input_files(filename, base_path = 'input_files', out = sys.stdout): """ build_input_files(filename, base_path = 'input_files') takes a 'well-formated' input fileand outputs a directory structure with the properly formated input files created in them. """ calling_dir = os.getcwd() # I'm doing this because I need it later file_path, file_name = os.path.split(filename) with open(filename, 'r') as f: txt = f.read() ## First Parse the FDS file param_dict, IOoutput = FDSa_parser(txt, file_name, out) # param_dict, sweep_param_dict, prms_in_axis = calculate_params(param_dict, axes) for key_ in param_dict.keys(): txt = txt.replace(param_dict[key_][0], key_) formatted_trials, logfile, IOoutput = eval_parsed_FDS(param_dict, out) print("formatted_trials", formatted_trials[0]) ## Make input files and directories for i, value_set in enumerate(formatted_trials): print(i,value_set) tmp_txt = txt # make a directory case_name = 'case_'+int2base(i, 26) # FDS uses uppercase reseved keywords, and so will we value_set['TITLE'] = case_name input_directory_builder(case_name, base_path) # populate the input file print(tmp_txt.count(list(value_set.keys())[1])) print(value_set) with open('tmp_txt', 'w') as f: f.write(str(tmp_txt)) tmp_txt = tmp_txt.format(**value_set) ## The format command doesn't like : or . because it things its a float format # create the file name fname = os.path.join(calling_dir, base_path, case_name, case_name + '.fds') # write the input file to the directory with open(fname, 'w') as f: f.write(str(tmp_txt)) log_path_name = os.path.join(calling_dir, base_path, file_name[:-4] + '.log') # write the augmented fds log file with open(log_path_name, 'a') as f: f.write(logfile) return IOoutput

def srpd(mvec, k, ra, Nmax, w, V): """ Calculate the Steered Response Power Density (SRPD) :param mvec: SHD coefficients for the TF bin to be analysed :param k: Wave number (2*pi*f/c) :param ra: Radius of the microphone array :param Nmax: Maximum SHD order to be used :param w: Diagonal eigenvalue matrix :param V: Reduced eigenvector matrix :return: SRPD for the given pixel """ assert np.size(mvec) == (Nmax + 1) ** 2 V = V[0:(Nmax + 1) ** 2, 0:(Nmax + 1) ** 2] w = w[0:(Nmax + 1) ** 2] kra = k * ra jn, jnp, yn, ynp = sph_jnyn(Nmax, kra) # jn, jnp, yn, ynp = spec.sph_jnyn(Nmax, kra) hn = jn - 1j * yn hnp = jnp - 1j * ynp bnkra = jn - (jnp / hnp) * hn b = [] for n in range(Nmax + 1): for count in range(-n, n + 1): b.append(1 / (4 * np.pi * (1j) ** n * bnkra[n])) b = np.array(b) p = b * mvec B0 = np.conj(np.matrix(np.conj(p)) * V).T B0s = np.diag(w) * np.multiply(B0, np.conj(B0)) srpval = B0s.sum() return srpval

def batch_inverse(tensor): """ Compute the matrix inverse of a batch of square matrices. This routine is used for removing rotational motion during the molecular dynamics simulation. Taken from https://stackoverflow.com/questions/46595157 Args: tensor (torch.Tensor): Tensor of square matrices with the shape n_batch x dim1 x dim1 Returns: torch.Tensor: Tensor of the inverted square matrices with the same shape as the input tensor. """ eye = tensor.new_ones(tensor.size(-1), device=tensor.device).diag().expand_as(tensor) tensor_inv, _ = torch.gesv(eye, tensor) return tensor_inv

def create(**kwds): """ Add data. """ status_code = 200 message = "Successfully added data." articles = [] for a in kwds.get("articles", []): a = Article.query.filter_by(id=a).first() if a: articles.append(a) cols = {"user_id": current_user.id, "name": kwds["name"]} model = Bookmark.query.filter_by(**cols).first() if model: for a in articles: exist = model.articles.filter_by(id=a.id).first() if not exist: model.articles.append(a) db_commit() else: cols["articles"] = articles model = Bookmark(**cols) db_add(model) return {"code": status_code, "message": message}