content
stringlengths
35
762k
sha1
stringlengths
40
40
id
int64
0
3.66M
def load_summary_data(): """ Function to load data param DATA_URL: data_url return: pandas dataframe """ DATA_URL = 'data/summary_df.csv' data = pd.read_csv(DATA_URL) return data
b5f09e845e1379fd00a03fd11b0174e3114eb7d3
11,313
import itertools def _enumerate_trees_w_leaves(n_leaves): """Construct all rooted trees with n leaves.""" def enumtree(*args): n_args = len(args) # trivial cases: if n_args == 0: return [] if n_args == 1: return args # general case of 2 or more args: # build index array idxs = range(0, n_args) trees = [] # we consider all possible subsets of size n_set to gather for n_set in range(2, n_args+1): idxsets = list(itertools.combinations(idxs, n_set)) for idxset in idxsets: # recurse by joining all subtrees with # n_set leaves and (n_args - n_set) leaves arg_set = tuple(args[i] for i in idxs if i in idxset) arg_coset = tuple(args[i] for i in idxs if i not in idxset) if arg_coset: trees.extend(tuple(itertools.product(enumtree(*arg_set), enumtree(*arg_coset)))) else: # trivial case where arg_set is entire set trees.append(arg_set) return trees # return enumerated trees with integers as leaves return enumtree(*range(n_leaves))
574a2d3ec63d3aeeb06292ec361b83aebba0ff84
11,314
def gen_tfidf(tokens, idf_dict): """ Given a segmented string and idf dict, return a dict of tfidf. """ # tokens = text.split() total = len(tokens) tfidf_dict = {} for w in tokens: tfidf_dict[w] = tfidf_dict.get(w, 0.0) + 1.0 for k in tfidf_dict: tfidf_dict[k] *= idf_dict.get(k, 0.0) / total return tfidf_dict
9217867b3661a8070cc1b2d577918c95d1ff7755
11,316
def timestamp_to_seconds(timestamp): """Convert timestamp to python (POSIX) time in seconds. :param timestamp: The timestamp. :return: The python time in float seconds. """ return (timestamp / 2**30) + EPOCH
3d5ca5f5ec93b54e1d1a6c53cefba1d49f8ebac2
11,317
def fit_lowmass_mstar_mpeak_relation(mpeak_orig, mstar_orig, mpeak_mstar_fit_low_mpeak=default_mpeak_mstar_fit_low_mpeak, mpeak_mstar_fit_high_mpeak=default_mpeak_mstar_fit_high_mpeak): """ """ mid = 0.5*(mpeak_mstar_fit_low_mpeak + mpeak_mstar_fit_high_mpeak) mask = (mpeak_orig >= 10**mpeak_mstar_fit_low_mpeak) mask &= (mpeak_orig < 10**mpeak_mstar_fit_high_mpeak) # Add noise to mpeak to avoid particle discreteness effects in the fit _x = np.random.normal(loc=np.log10(mpeak_orig[mask])-mid, scale=0.002) _y = np.log10(mstar_orig[mask]) c1, c0 = np.polyfit(_x, _y, deg=1) return c0, c1, mid
620275ad18173bb00d38f3d468be132d150fc1fa
11,319
def load_ref_system(): """ Returns benzaldehyde as found in the IQMol fragment library. All credit to https://github.com/nutjunkie/IQmol """ return psr.make_system(""" C 0.3179 1.0449 -0.0067 C 1.6965 0.8596 -0.0102 C 2.2283 -0.4253 -0.0050 C 1.3808 -1.5297 0.0037 C 0.0035 -1.3492 0.0073 C -0.5347 -0.0596 0.0021 C -2.0103 0.0989 0.0061 O -2.5724 1.1709 0.0021 H 2.3631 1.7283 -0.0171 H 3.3139 -0.5693 -0.0078 H 1.8000 -2.5413 0.0078 H -0.6626 -2.2203 0.0142 H -2.6021 -0.8324 0.0131 H -0.1030 2.0579 -0.0108 """)
518ca10a84befa07fefa3c2f646e40095318d63c
11,320
def get_department_level_grade_data_completed(request_ctx, account_id, **request_kwargs): """ Returns the distribution of grades for students in courses in the department. Each data point is one student's current grade in one course; if a student is in multiple courses, he contributes one value per course, but if he's enrolled multiple times in the same course (e.g. a lecture section and a lab section), he only constributes on value for that course. Grades are binned to the nearest integer score; anomalous grades outside the 0 to 100 range are ignored. The raw counts are returned, not yet normalized by the total count. Shares the same variations on endpoint as the participation data. :param request_ctx: The request context :type request_ctx: :class:RequestContext :param account_id: (required) ID :type account_id: string :return: Get department-level grade data :rtype: requests.Response (with void data) """ path = '/v1/accounts/{account_id}/analytics/completed/grades' url = request_ctx.base_api_url + path.format(account_id=account_id) response = client.get(request_ctx, url, **request_kwargs) return response
8dd40c7b7c7a734aa66d4f808224424c0c0df81d
11,321
def allocate_samples_to_bins(n_samples, ideal_bin_count=100): """goal is as best as possible pick a number of bins and per bin samples to a achieve a given number of samples. Parameters ---------- Returns ---------- number of bins, list of samples per bin """ if n_samples <= ideal_bin_count: n_bins = n_samples samples_per_bin = [1 for _ in range(n_bins)] else: n_bins = ideal_bin_count remainer = n_samples % ideal_bin_count samples_per_bin = np.array([(n_samples - remainer) / ideal_bin_count for _ in range(n_bins)]) if remainer != 0: additional_samples_per_bin = distribute_samples(remainer, n_bins) samples_per_bin = samples_per_bin + additional_samples_per_bin return n_bins, np.array(samples_per_bin).astype(int)
66d5fe32a89478b543818d63c65f2745fe242b33
11,322
from typing import Any def create_algo(name: str, discrete: bool, **params: Any) -> AlgoBase: """Returns algorithm object from its name. Args: name (str): algorithm name in snake_case. discrete (bool): flag to use discrete action-space algorithm. params (any): arguments for algorithm. Returns: d3rlpy.algos.base.AlgoBase: algorithm. """ return get_algo(name, discrete)(**params)
4fab0f5581eb6036efba6074ab6e3b232bcf5679
11,323
def tf_inv(T): """ Invert 4x4 homogeneous transform """ assert T.shape == (4, 4) return np.linalg.inv(T)
5bf7d54456198c25029956a7aebe118d7ee4fa87
11,324
def send_reset_password_email(token, to, username): """ send email to user for reset password :param token: token :param to: email address :param username: user.username :return: """ url_to = current_app.config["WEB_BASE_URL"] + "/auth/reset-password?token=" + token response = _send_email( subject="请重置密码", to=to, html_body=render_template( "emails/reset_password.html", username=username, url_to=url_to ), ) return response.status_code
dddcb66425de79a1a736bbbcc5cbc3f5855e7db9
11,325
def part1(data): """Solve part 1""" countIncreased = 0 prevItem = None for row in data: if prevItem == None: prevItem = row continue if prevItem < row: countIncreased += 1; prevItem = row return countIncreased
e01b5edc9d9ac63a31189160d09b5e6e0f11e522
11,326
def yzrotation(theta = np.pi*3/20.0): """ Returns a simple planar rotation matrix that rotates vectors around the x-axis. args: theta: The angle by which we will perform the rotation. """ r = np.eye(3) r[1,1] = np.cos(theta) r[1,2] = -np.sin(theta) r[2,1] = np.sin(theta) r[2,2] = np.cos(theta) return r
59a2a251f8e8aa77548f749f49871536de29b0bb
11,327
def is_compiled_release(data): """ Returns whether the data is a compiled release (embedded or linked). """ return 'tag' in data and isinstance(data['tag'], list) and 'compiled' in data['tag']
ea8c8ae4f1ccdedbcc145bd57bde3b6040e5cab5
11,328
import numpy def resize_frame( frame: numpy.ndarray, width: int, height: int, mode: str = "RGB" ) -> numpy.ndarray: """ Use PIL to resize an RGB frame to an specified height and width. Args: frame: Target numpy array representing the image that will be resized. width: Width of the resized image. height: Height of the resized image. mode: Passed to Image.convert. Returns: The resized frame that matches the provided width and height. """ frame = Image.fromarray(frame) frame = frame.convert(mode).resize(size=(width, height)) return numpy.array(frame)
941eb73961843e46b4e67d48439a09c0223c2af0
11,329
def get_proxies(host, user, password, database, port=3306, unix_socket=None): """"Connect to a mysql database using pymysql and retrieve proxies for the scraping job. Args: host: The mysql database host user: The mysql user password: The database password port: The mysql port, by default 3306 unix_socket: Sometimes you need to specify the mysql socket file when mysql doesn't reside in a standard location. Returns; A list of proxies obtained from the database Raisese: An Exception when connecting to the database fails. """ try: conn = pymysql.connect(host=host, port=port, user=user, passwd=password, unix_socket=unix_socket) conn.select_db(database) cur = conn.cursor(pymysql.cursors.DictCursor) # Adapt this code for you to make it retrieving the proxies in the right format. cur.execute('SELECT host, port, username, password, protocol FROM proxies') proxies = [Proxy(proto=s['protocol'], host=s['host'], port=s['port'], username=s['username'], password=s['password']) for s in cur.fetchall()] return proxies except Exception as e: logger.error(e) raise
d4595440c9d4d07a7d5e27740bf7049176dbe432
11,330
def APIRevision(): """Gets the current API revision to use. Returns: str, The revision to use. """ return 'v1beta3'
c748e1917befe76da449e1f435540e10ee433444
11,331
def pretty_string_value_error(value, error, error_digits=2, use_unicode=True): """ Returns a value/error combination of numbers in a scientifically 'pretty' format. Scientific quantities often come as a *value* (the actual quantity) and the *error* (the uncertainty in the value). Given two floats, value and error, return the two in a 'pretty' formatted string: where the value and error are truncated at the correct precision. Parameters ---------- value : float The quantity in question error : float The uncertainty of the quantity error_digits : int, default 2 How many significant figures the error has. Scientific convention holds that errors have 1 or (at most) 2 significant figures. The larger number of digits is chosen here by default. Returns ------- new_string : str A new list of strings sorted numerically Examples -------- >>> pretty_string_value_error(1.23456789e8, 4.5678e5, error_digits=2) "1.2346 +/- 0.0046 * 10^+08" >>> pretty_string_value_error(5.6e-2, 2.0e-3, error_digits=1) "5.6 +/- 0.2 * 10^-02" """ if value is None: return "None" if error is None or not np.isfinite(error): if use_unicode: new_string = "{:.6E} \u00B1 UNKNOWN ERROR MARGIN".format(value) else: new_string = "{:.6E} +/- UNKNOWN ERROR MARGIN".format(value) else: if not np.isfinite(value): return str(value) assert "e" in "{:e}".format(value), "Cannot convert into scientific "\ "notation: {1}".format(value) value_mantissa_str, value_exponent_str = \ "{:e}".format(value).strip().split('e') value_mantissa = float(value_mantissa_str) value_exponent = int(value_exponent_str) error_mantissa_str, error_exponent_str = \ "{:e}".format(error).strip().split('e') error_mantissa = float(error_mantissa_str) error_exponent = int(error_exponent_str) padding = value_exponent - error_exponent + error_digits - 1 if padding < 1: padding = 1 exp_diff = error_exponent - value_exponent string_for_formatting = "{:.%df}" % padding new_value_mantissa = string_for_formatting.format(value_mantissa) new_error_mantissa = string_for_formatting.format( error_mantissa*10**exp_diff) if use_unicode: new_string = "%s \u00B1 %s * 10^%s" % ( new_value_mantissa, new_error_mantissa, value_exponent_str) else: new_string = "%s +/- %s * 10^%s" % ( new_value_mantissa, new_error_mantissa, value_exponent_str) return new_string
bd7b1496880e7d1cb4ffd04d23df20d679ac8ade
11,332
def sameSize(arguments) -> bool: """Checks whether given vectors are the same size or not""" sameLength = True initialSize = len(vectors[arguments[0]]) for vector in arguments: if len(vectors[vector]) != initialSize: sameLength = False return sameLength
0840adcb0f6a84c56ff3b0ce3aa23892e45d942e
11,334
def db_read(src_path, read_type=set, read_int=False): """Read string data from a file into a variable of given type. Read from the file at 'src_path', line by line, skipping certain lines and removing trailing whitespace. If 'read_int' is True, convert the resulting string to int. Return read data as an object of the desired type specified by 'read_type'. """ def skip(s): """Bool func. for skipping a line. "#%# " is chosen as a comment indicator. """ return s == "\n" or s.startswith("#%# ") if read_type is list: result = list() with open(src_path, "r") as f: for i in f.readlines(): if not skip(i): result.append(int(i.strip()) if read_int else i.strip()) elif read_type is set: result = set() with open(src_path, "r") as f: for i in f.readlines(): if not skip(i): result.add(int(i.strip()) if read_int else i.strip()) elif read_type is dict: # Process the lines in pairs: First the key, then the corresponding # value, and then the next key... and so on. result = dict() with open(src_path, "r") as f: key_temp = "" for i in f.readlines(): if not skip(i): if key_temp: result[key_temp] = ( int(i.strip()) if read_int else i.strip() ) key_temp = "" else: key_temp = (int(i.strip()) if read_int else i.strip()) elif read_type is str: # Only read the first line of the file, strip and return it: with open(src_path, "r") as f: result = f.readline().rstrip() else: logger.error("db_read: read_type is not list, str, set or dict.") return None return result
811c6efb83d134d695c6dec2e34d3405818b8a48
11,335
import re def get_config_keys(): """Parses Keys.java to extract keys to be used in configuration files Args: None Returns: list: A list of dict containing the following keys - 'key': A dot separated name of the config key 'description': A list of str """ desc_re = re.compile(r"(/\*\*\n|\s+\*/|\s+\*)") key_match_re = re.compile(r"\(\n(.+)\);", re.DOTALL) key_split_re = re.compile(r",\s+", re.DOTALL) keys = [] with open(_KEYS_FILE, "r") as f: config = re.findall( r"(/\*\*.*?\*/)\n\s+(public static final Config.*?;)", f.read(), re.DOTALL ) for i in config: try: key_match = key_match_re.search(i[1]) if key_match: terms = [x.strip() for x in key_split_re.split(key_match.group(1))] key = terms[0].replace('"', "") description = [ x.strip().replace("\n", "") for x in desc_re.sub("\n", i[0]).strip().split("\n\n") ] if len(terms) == 3: description.append(f"Default: {terms[2]}") keys.append( { "key": key, "description": description, } ) except IndexError: # will continue if key_match.group(1) or terms[0] does not exist # for some reason pass return keys
8c04fcac2d05579ce47f5436999f0fe86fb1bdbd
11,336
def new(): """Create a new community.""" return render_template('invenio_communities/new.html')
60ee1560f749d94833f57b6a34e2d514e3e04ccb
11,337
import torch def interpolate(results_t, results_tp1, dt, K, c2w, img_wh): """ Interpolate between two results t and t+1 to produce t+dt, dt in (0, 1). For each sample on the ray (the sample points lie on the same distances, so they actually form planes), compute the optical flow on this plane, then use softsplat to splat the flows. Finally use MPI technique to compute the composite image. Used in test time only. Inputs: results_t, results_tp1: dictionaries of the @render_rays function. dt: float in (0, 1) K: (3, 3) intrinsics matrix (MUST BE THE SAME for results_t and results_tp1!) c2w: (3, 4) current pose (MUST BE THE SAME for results_t and results_tp1!) img_wh: image width and height Outputs: (img_wh[1], img_wh[0], 3) rgb interpolation result (img_wh[1], img_wh[0]) depth of the interpolation (in NDC) """ device = results_t['xyzs_fine'].device N_rays, N_samples = results_t['xyzs_fine'].shape[:2] w, h = img_wh rgba = torch.zeros((h, w, 4), device=device) depth = torch.zeros((h, w), device=device) c2w_ = torch.eye(4) c2w_[:3] = c2w w2c = torch.inverse(c2w_)[:3] w2c[1:] *= -1 # "right up back" to "right down forward" for cam projection P = K @ w2c # (3, 4) projection matrix grid = create_meshgrid(h, w, False, device) # (1, h, w, 2) xyzs = results_t['xyzs_fine'] # equals results_tp1['xyzs_fine'] zs = rearrange(results_t['zs_fine'], '(h w) n2 -> h w n2', w=w, h=h) # static buffers static_rgb = rearrange(results_t['static_rgbs_fine'], '(h w) n2 c -> h w n2 c', w=w, h=h, c=3) static_a = rearrange(results_t['static_alphas_fine'], '(h w) n2 -> h w n2 1', w=w, h=h) # compute forward buffers xyzs_w = ray_utils.ndc2world(rearrange(xyzs, 'n1 n2 c -> (n1 n2) c'), K) xyzs_fw_w = ray_utils.ndc2world( rearrange(xyzs+results_t['transient_flows_fw'], 'n1 n2 c -> (n1 n2) c'), K) # fw points with full flow xyzs_fw_w = xyzs_w + dt*(xyzs_fw_w-xyzs_w) # scale the flow with dt uvds_fw = P[:3, :3] @ rearrange(xyzs_fw_w, 'n c -> c n') + P[:3, 3:] uvs_fw = uvds_fw[:2] / uvds_fw[2] uvs_fw = rearrange(uvs_fw, 'c (n1 n2) -> c n1 n2', n1=N_rays, n2=N_samples) uvs_fw = rearrange(uvs_fw, 'c (h w) n2 -> n2 h w c', w=w, h=h) of_fw = rearrange(uvs_fw-grid, 'n2 h w c -> n2 c h w', c=2) transient_rgb_t = rearrange(results_t['transient_rgbs_fine'], '(h w) n2 c -> n2 c h w', w=w, h=h, c=3) transient_a_t = rearrange(results_t['transient_alphas_fine'], '(h w) n2 -> n2 1 h w', w=w, h=h) transient_rgba_t = torch.cat([transient_rgb_t, transient_a_t], 1) # compute backward buffers xyzs_bw_w = ray_utils.ndc2world( rearrange(xyzs+results_tp1['transient_flows_bw'], 'n1 n2 c -> (n1 n2) c'), K) # bw points with full flow xyzs_bw_w = xyzs_w + (1-dt)*(xyzs_bw_w-xyzs_w) # scale the flow with 1-dt uvds_bw = P[:3, :3] @ rearrange(xyzs_bw_w, 'n c -> c n') + P[:3, 3:] uvs_bw = uvds_bw[:2] / uvds_bw[2] uvs_bw = rearrange(uvs_bw, 'c (n1 n2) -> c n1 n2', n1=N_rays, n2=N_samples) uvs_bw = rearrange(uvs_bw, 'c (h w) n2 -> n2 h w c', w=w, h=h) of_bw = rearrange(uvs_bw-grid, 'n2 h w c -> n2 c h w', c=2) transient_rgb_tp1 = rearrange(results_tp1['transient_rgbs_fine'], '(h w) n2 c -> n2 c h w', w=w, h=h, c=3) transient_a_tp1 = rearrange(results_tp1['transient_alphas_fine'], '(h w) n2 -> n2 1 h w', w=w, h=h) transient_rgba_tp1 = torch.cat([transient_rgb_tp1, transient_a_tp1], 1) for s in range(N_samples): # compute MPI planes (front to back composition) transient_rgba_fw = FunctionSoftsplat(tenInput=transient_rgba_t[s:s+1].cuda(), tenFlow=of_fw[s:s+1].cuda(), tenMetric=None, strType='average').cpu() transient_rgba_fw = rearrange(transient_rgba_fw, '1 c h w -> h w c') transient_rgba_bw = FunctionSoftsplat(tenInput=transient_rgba_tp1[s:s+1].cuda(), tenFlow=of_bw[s:s+1].cuda(), tenMetric=None, strType='average').cpu() transient_rgba_bw = rearrange(transient_rgba_bw, '1 c h w -> h w c') composed_rgb = transient_rgba_fw[..., :3]*transient_rgba_fw[..., 3:]*(1-dt) + \ transient_rgba_bw[..., :3]*transient_rgba_bw[..., 3:]*dt + \ static_rgb[:, :, s]*static_a[:, :, s] composed_a = 1 - (1-(transient_rgba_fw[..., 3:]*(1-dt)+ transient_rgba_bw[..., 3:]*dt)) * \ (1-static_a[:, :, s]) rgba[..., :3] += (1-rgba[..., 3:])*composed_rgb depth += (1-rgba[..., 3])*composed_a[..., 0]*zs[..., s] rgba[..., 3:] += (1-rgba[..., 3:])*composed_a return rgba[..., :3], depth
d5cdae22a3fb324e9bdfdedabe0b69cb5d40ebdb
11,338
def divisor(baudrate): """Calculate the divisor for generating a given baudrate""" CLOCK_HZ = 50e6 return round(CLOCK_HZ / baudrate)
a09eee716889ee6950f8c5bba0f31cdd2b311ada
11,339
def scm_get_active_branch(*args, **kwargs): """ Get the active named branch of an existing SCM repository. :param str path: Path on the file system where the repository resides. If not specified, it defaults to the current work directory. :return: Name of the active branch :rtype: str """ if not _scm_handler: _load_scm_handler() return _scm_handler.get_active_branch(*args, **kwargs)
6c18454548732cd8db4ba85b45cdc9a8d9b47fce
11,340
def search_evaluations(campus, **kwargs): """ year (required) term_name (required): Winter|Spring|Summer|Autumn curriculum_abbreviation course_number section_id student_id (student number) """ url = "%s?%s" % (IAS_PREFIX, urlencode(kwargs)) data = get_resource_by_campus(url, campus) evaluations = _json_to_evaluation(data) return evaluations
d7069c2e9135b350141b0053e3ec1202650b7c28
11,341
from typing import Optional import select async def get_user(username: str, session: AsyncSession) -> Optional[User]: """ Returns a user with the given username """ return ( (await session.execute(select(User).where(User.name == username))) .scalars() .first() )
0975c069d76414fbf57f4b8f7370d0ada40e39f5
11,342
import pandas def compute_balances(flows): """ Balances by currency. :param flows: :return: """ flows = flows.set_index('date') flows_by_asset = flows.pivot(columns='asset', values='amount').apply(pandas.to_numeric) balances = flows_by_asset.fillna(0).cumsum() return balances
98728c2c687df60194eb11b479c08fc90502807a
11,344
import json def unjsonify(json_data): """ Converts the inputted JSON data to Python format. :param json_data | <variant> """ return json.loads(json_data, object_hook=json2py)
93a59f8a2ef96cbe25e89c2970969b0132b1a892
11,345
from typing import Tuple from typing import List def comp_state_dist(table: np.ndarray) -> Tuple[np.ndarray, List[str]]: """Compute the distribution of distinct states/diagnoses from a table of individual diagnoses detailing the patterns of lymphatic progression per patient. Args: table: Rows of patients and columns of LNLs, reporting which LNL was involved for which patient. Returns: A histogram of unique states and a list of the corresponding state labels. Note: This function cannot deal with parts of the diagnose being unknown. So if, e.g., one level isn't reported for a patient, that row will just be ignored. """ _, num_cols = table.shape table = table.astype(float) state_dist = np.zeros(shape=2**num_cols, dtype=int) for row in table: if not np.any(np.isnan(row)): idx = int(np.sum([n * 2**i for i,n in enumerate(row[::-1])])) state_dist[idx] += 1 state_labels = [] for i in range(2**num_cols): state_labels.append(change_base(i, 2, length=num_cols)) return state_dist, state_labels
1a2edacd40d4fea3ff3cc5ddd57d76bffc60c7bc
11,346
def polyConvert(coeffs, trans=(0, 1), backward=False): """ Converts polynomial coeffs for x (P = a0 + a1*x + a2*x**2 + ...) in polynomial coeffs for x~:=a+b*x (P~ = a0~ + a1~*x~ + a2~*x~**2 + ...). Therefore, (a,b)=(0,1) makes nothing. If backward, makes the opposite transformation. Note: backward transformation could be done using more general polynomial composition `polyval`, but forward transformation is a long standing issue in the general case (look for functional decomposition of univariate polynomial). """ a, b = trans if not backward: a = -float(a) / float(b) b = 1 / float(b) return N.dot(polyConvMatrix(len(coeffs), (a, b)), coeffs)
1a2607b28046a8dc67315726957a87a5d5c9a435
11,347
import random def uniform(_data, weights): """ Randomly initialize the weights with values between 0 and 1. Parameters ---------- _data: ndarray Data to pick to initialize weights. weights: ndarray Previous weight values. Returns ------- weights: ndarray New weight values """ return random.rand(*weights.shape)
fbf7e853f11a888ee01dc840c6ffcb214560c5a8
11,348
def ingresar_datos(): """Ingresa los datos de las secciones""" datos = {} while True: codigo = int_input('Ingrese el código de la sección: ') if codigo < 0: break cantidad = int_input( 'Ingrese la cantidad de alumnos: ', min=MIN, max=MAX ) datos[codigo] = cantidad return datos
3bacb0e5d6b234b2f90564c44a25d151a640fd1f
11,349
def fetch_credentials() -> Credentials: """Produces a Credentials object based on the contents of the CONFIG_FILE or, alternatively, interactively. """ if CONFIG_FILE_EXISTS: return parse_config_file(CONFIG_FILE) else: return get_credentials_interactively()
0b882c8c4c8066a1898771c66db6ccbe7cb09c37
11,350
def pool_adjacency_mat_reference_wrapper( adj: sparse.spmatrix, kernel_size=4, stride=2, padding=1 ) -> sparse.spmatrix: """Wraps `pool_adjacency_mat_reference` to provide the same API as `pool_adjacency_mat`""" adj = Variable(to_sparse_tensor(adj).to_dense()) adj_conv = pool_adjacency_mat_reference(adj, kernel_size, stride, padding) return sparse.coo_matrix(adj_conv.data.numpy(), dtype=np.int16)
e72cb1e50bf7542d4175b9b3b3989e70a8812373
11,351
def send(socket, obj, flags=0, protocol=-1): """stringify an object, and then send it""" s = str(obj) return socket.send_string(s)
a89165565837ad4a984905d5b5fdd73e398b35fd
11,352
def arraystr(A: Array) -> str: """Pretty print array""" B = np.asarray(A).ravel() if len(B) <= 3: return " ".join([itemstr(v) for v in B]) return " ".join([itemstr(B[0]), itemstr(B[1]), "...", itemstr(B[-1])])
9cceed63c83812a7fd87dba833fc4d5b5a75088c
11,353
def dist2_test(v1, v2, idx1, idx2, len2): """Square of distance equal""" return (v1-v2).mag2() == len2
3a268a3ba704a91f83345766245a952fe5d943dd
11,354
def extract_grid_cells(browser, grid_id): """ Given the ID of a legistar table, returns a list of dictionaries for each row mapping column headers to td elements. """ table = browser.find_element_by_id(grid_id) header_cells = table.find_elements_by_css_selector( 'thead:nth-child(2) > tr:nth-child(2) > th' ) headers = [extract_text(cell) for cell in header_cells] tbody = table.find_element_by_css_selector('tbody:nth-child(4)') rows = tbody.find_elements_by_tag_name('tr') result_rows = [] for row in rows: cells = {} td_elements = row.find_elements_by_tag_name('td') for header, cell in zip(headers, td_elements): cells[header] = cell result_rows.append(cells) return (headers, result_rows)
bee4265a18cfd428f25e3fdf3202fb5bfad820df
11,355
import ast def gatherAllParameters(a, keep_orig=True): """Gather all parameters in the tree. Names are returned along with their original names (which are used in variable mapping)""" if type(a) == list: allIds = set() for line in a: allIds |= gatherAllVariables(line) return allIds if not isinstance(a, ast.AST): return set() allIds = set() for node in ast.walk(a): if type(node) == ast.arg: origName = node.originalId if (keep_orig and hasattr(node, "originalId")) else None allIds |= set([(node.arg, origName)]) return allIds
e899e60d818750a4ff1656b039a6dc4413f8f181
11,356
def average_link_euclidian(X,verbose=0): """ Average link clustering based on data matrix. Parameters ---------- X array of shape (nbitem,dim): data matrix from which an Euclidian distance matrix is computed verbose=0, verbosity level Returns ------- t a weightForest structure that represents the dendrogram of the data Note ---- this method has not been optimized """ if X.shape[0]==np.size(X): X = np.reshape(X,(np.size(X),1)) if np.size(X)<10000: D = Euclidian_distance(X) else: raise ValueError, "The distance matrix is too large" t = average_link_distance(D,verbose) return t
17aae1e7f802f82765bcda8b403598a2c5a9f822
11,357
import functools def cached(func): """Decorator cached makes the function to cache its result and return it in duplicate calls.""" prop_name = '__cached_' + func.__name__ @functools.wraps(func) def _cached_func(self): try: return getattr(self, prop_name) except AttributeError: val = func(self) setattr(self, prop_name, val) return val return _cached_func
5b23c251c03160ba2c4e87848201be46ba2f34fb
11,358
def SX_inf(*args): """ create a matrix with all inf inf(int nrow, int ncol) -> SX inf((int,int) rc) -> SX inf(Sparsity sp) -> SX """ return _casadi.SX_inf(*args)
b11fba9e9b60eadb983d1203b1dd852abca9a2b7
11,359
def aes_encrypt(mode, aes_key, aes_iv, *data): """ Encrypt data with AES in specified mode. :param aes_key: aes_key to use :param aes_iv: initialization vector """ encryptor = Cipher(algorithms.AES(aes_key), mode(aes_iv), backend=default_backend()).encryptor() result = None for value in data: result = encryptor.update(value) encryptor.finalize() return result, None if not hasattr(encryptor, 'tag') else encryptor.tag
94a39ddabe3ea186463808e79e86bec171fbaeda
11,360
def _ebpm_gamma_update_a(init, b, plm, step=1, c=0.5, tau=0.5, max_iters=30): """Backtracking line search to select step size for Newton-Raphson update of a""" def loss(a): return -(a * np.log(b) + a * plm - sp.gammaln(a)).sum() obj = loss(init) d = (np.log(b) - sp.digamma(init) + plm).mean() / sp.polygamma(1, init) update = loss(init + step * d) while (not np.isfinite(update) or update > obj + c * step * d) and max_iters > 0: step *= tau update = loss(init + step * d) max_iters -= 1 if max_iters == 0: # Step size is small enough that update can be skipped return init else: return init + step * d
038fb28824b3429b03887299af7a7feeec16b689
11,361
def edge_distance_mapping(graph : Graph, iterations : int, lrgen : LearningRateGen, verbose : bool = True, reset_locations : bool = True): """ Stochastic Gradient Descent algorithm for performing graph vertex laoyout optimization using the path distances as target distance in the layout. The algorihm is adapted from the paper https://arxiv.org/pdf/1710.04626.pdf Args: graph : The graph to arrange iterations : number of iteration rounds lrgen : learning rate function that takes iteration round as input verbose : boolean, set True to print progress status information Returns: Vertex location stress value list that contains one summary stress value per iteration. """ # Create temporary lists of vertex list indices n_vertex = graph.vertex_count vertex_idx_list_a = np.arange(n_vertex) vertex_idx_list_b = np.arange(n_vertex) stress_list = [] # Calculate distance look-up table dist_arr, keys = __edge_distance_lut(graph) if reset_locations: __reset_locations(graph) # Main iteration loop for iter_round in range(iterations): stress = 0 lr = lrgen.get_lr(iter_round) if verbose: progress_print = ProgressPrint(n_vertex) a_loop = 0 np.random.shuffle(vertex_idx_list_a) for idx_a in vertex_idx_list_a: np.random.shuffle(vertex_idx_list_b) for idx_b in vertex_idx_list_b: if idx_a == idx_b: continue # Get path distance from vertex a to b. # Value -1 means there is no path. dist_target = dist_arr[idx_a, idx_b] if dist_target == np.inf: continue # Update the locations and get stress for the patg key_a = keys[idx_a] key_b = keys[idx_b] edge_stress = __coord_update(graph, key_a, key_b, dist_target, lr) stress += edge_stress # Progress monitoring if verbose: a_loop += 1 progress_print.print_update(iter_round, a_loop, stress) stress_list.append(stress) return stress_list
f5c93cf83a7cd7892936246eb6c90562030ad819
11,362
def strip_extension(name: str) -> str: """ Remove a single extension from a file name, if present. """ last_dot = name.rfind(".") if last_dot > -1: return name[:last_dot] else: return name
9dc1e3a3c9ad3251aba8a1b61f73de9f79f9a8be
11,363
def validatePullRequest(data): """Validate pull request by action.""" if 'action' not in data: raise BadRequest('no event supplied') if 'pull_request' not in data or 'html_url' not in data.get('pull_request'): raise BadRequest('payload.pull_request.html_url missing') return True
a4577a1b719b11f1ea845fff436a78178ca9e370
11,365
def __adjust_data_for_log_scale(dataframe: pd.DataFrame) -> pd.DataFrame: """ This will clean and adjust some of the data so that Altair can plot it using a logarithmic scale. Altair does not allow zero values on the Y axis when plotting with a logarithmic scale, as log(0) is undefined. Args: dataframe: The data to plot on the chart. Returns: A new data frame with the appropriate adjustments for plotting on a log scale. """ return dataframe.replace(0, float('nan'))
30d7a73f2f0d564f6e52e1a2fa4b521fa1265c3d
11,366
import torch def predict_sentence(model,vocab,sentence): """Predicts the section value of a given sentence INPUT: Trained model, Model vocab, Sentence to predict OUTPUT: Assigned section to the sentence""" device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') nlp=spacy.load('en_core_sci_md') model=model.to(device) tokens=[t.text for t in nlp.tokenizer(sentence)] indexed = [vocab[t] for t in tokens] tensor_to_predict=torch.LongTensor(indexed).to(device) tensor_to_predict=tensor_to_predict.unsqueeze(1).T length_tensor= torch.LongTensor([len(indexed)]).to(device) prediction=model(tensor_to_predict,length_tensor) return prediction.argmax(1).item()
f8ef02bd92dfc3dfcea0f5a2e9d5da99050fe367
11,367
import spacy import re def ne_offsets_by_sent( text_nest_list=[], model='de_core_news_sm', ): """ extracts offsets of NEs and the NE-type grouped by sents :param text_nest_list: A list of list with following structure:\ [{"text": "Wien ist schön", "ner_dicts": [{"text": "Wien", "ne_type": "LOC"}]}] :param model: The name of the spacy model which should be used for sentence splitting. :return: A list of spacy-like NER Tuples [('some text'), entities{[(15, 19, 'place')]}] """ nlp = spacy.load(model) text_nes = text_nest_list results = [] for entry in text_nes: ner_dicts = entry['ner_dicts'] in_text = entry['text'] doc = nlp(in_text) for sent in doc.sents: entities = [] if sent.text != "": plain_text = sent.text for x in ner_dicts: for m in re.finditer(x['text'], plain_text): entities.append([m.start(), m.end(), x['ne_type']]) entities = [item for item in set(tuple(row) for row in entities)] entities = sorted(entities, key=lambda x: x[0]) ents = [] next_item_index = 1 for x in entities: cur_start = x[0] try: next_start = entities[next_item_index][0] except IndexError: next_start = 9999999999999999999999 if cur_start == next_start: pass else: ents.append(x) next_item_index = next_item_index + 1 train_data = ( plain_text, { "entities": ents } ) results.append(train_data) return results
1e4fdaba07bf562b1d91b5f2376955efa9974c56
11,368
from typing import Optional def clone_repo( url: str, path: str, branch: Optional[str] = None, ) -> bool: """Clone repo from URL (at branch if specified) to given path.""" cmd = ['git', 'clone', url, path] if branch: cmd += ['--branch', branch] return run(cmd)[0].returncode == 0
56bc8641c3418216f1da5f0c87d33478888775c7
11,369
def get_inputtype(name, object_type): """Get an input type based on the object type""" if object_type in _input_registry: return _input_registry[object_type] inputtype = type( name, (graphene.InputObjectType,), _get_input_attrs(object_type), ) _input_registry[object_type] = inputtype return inputtype
aee2a84c8aaf0d66554f022ac0fec0aaef808160
11,370
def get_engine_status(engine=None): """Return a report of the current engine status""" if engine is None: engine = crawler.engine global_tests = [ "time()-engine.start_time", "engine.is_idle()", "engine.has_capacity()", "engine.scheduler.is_idle()", "len(engine.scheduler.pending_requests)", "engine.downloader.is_idle()", "len(engine.downloader.sites)", "engine.scraper.is_idle()", "len(engine.scraper.sites)", ] spider_tests = [ "engine.spider_is_idle(spider)", "engine.closing.get(spider)", "engine.scheduler.spider_has_pending_requests(spider)", "len(engine.scheduler.pending_requests[spider])", "len(engine.downloader.sites[spider].queue)", "len(engine.downloader.sites[spider].active)", "len(engine.downloader.sites[spider].transferring)", "engine.downloader.sites[spider].closing", "engine.downloader.sites[spider].lastseen", "len(engine.scraper.sites[spider].queue)", "len(engine.scraper.sites[spider].active)", "engine.scraper.sites[spider].active_size", "engine.scraper.sites[spider].itemproc_size", "engine.scraper.sites[spider].needs_backout()", ] status = {'global': {}, 'spiders': {}} for test in global_tests: try: status['global'][test] = eval(test) except Exception, e: status['global'][test] = "%s (exception)" % type(e).__name__ for spider in engine.downloader.sites: x = {} for test in spider_tests: try: x[test] = eval(test) except Exception, e: x[test] = "%s (exception)" % type(e).__name__ status['spiders'][spider] = x return status
0d87692a991965c8b72204d241964a27a9499014
11,372
import tqdm import requests import json def stock_em_jgdy_tj(): """ 东方财富网-数据中心-特色数据-机构调研-机构调研统计 http://data.eastmoney.com/jgdy/tj.html :return: pandas.DataFrame """ url = "http://data.eastmoney.com/DataCenter_V3/jgdy/gsjsdy.ashx" page_num = _get_page_num_tj() temp_df = pd.DataFrame() for page in tqdm(range(1, page_num+1)): params = { "pagesize": "5000", "page": str(page), "js": "var sGrabtEb", "param": "", "sortRule": "-1", "sortType": "0", "rt": "52581365", } res = requests.get(url, params=params) data_json = json.loads(res.text[res.text.find("={")+1:]) temp_df = temp_df.append(pd.DataFrame(data_json["data"]), ignore_index=True) return temp_df
1841702e6fb5c677245a2d213f489d95a789d68b
11,373
def hpdi(x, prob=0.90, axis=0): """ Computes "highest posterior density interval" (HPDI) which is the narrowest interval with probability mass ``prob``. :param numpy.ndarray x: the input array. :param float prob: the probability mass of samples within the interval. :param int axis: the dimension to calculate hpdi. :return: quantiles of ``x`` at ``(1 - prob) / 2`` and ``(1 + prob) / 2``. :rtype: numpy.ndarray """ x = np.swapaxes(x, axis, 0) sorted_x = np.sort(x, axis=0) mass = x.shape[0] index_length = int(prob * mass) intervals_left = sorted_x[:(mass - index_length)] intervals_right = sorted_x[index_length:] intervals_length = intervals_right - intervals_left index_start = intervals_length.argmin(axis=0) index_end = index_start + index_length hpd_left = np.take_along_axis(sorted_x, index_start[None, ...], axis=0) hpd_left = np.swapaxes(hpd_left, axis, 0) hpd_right = np.take_along_axis(sorted_x, index_end[None, ...], axis=0) hpd_right = np.swapaxes(hpd_right, axis, 0) return np.concatenate([hpd_left, hpd_right], axis=axis)
579515ebb6d28c2a1578c85eab8cbff1b67bd5ee
11,374
def a(n, k): """calculates maximum power of p(n) needed >>> a(0, 20) 4 >>> a(1, 20) 2 >>> a(2, 20) 1 """ return floor(log(k) / log(p(n)))
581e2a23a3dc069fc457ed5a6fe7d5a355353242
11,375
import platform def is_windows(): """ détermine si le système actuel est windows """ return platform.system().lower() == "windows"
fc9e2ca948f7cc5dc6b6cc9afb52ba701222bb7a
11,376
def WTfilt_1d(sig): """ # 使用小波变换对单导联ECG滤波 # 参考:Martis R J, Acharya U R, Min L C. ECG beat classification using PCA, LDA, ICA and discrete wavelet transform[J].Biomedical Signal Processing and Control, 2013, 8(5): 437-448. :param sig: 1-D numpy Array,单导联ECG :return: 1-D numpy Array,滤波后信号 """ coeffs = pywt.wavedec(sig, 'db6', level=9) coeffs[-1] = np.zeros(len(coeffs[-1])) coeffs[-2] = np.zeros(len(coeffs[-2])) coeffs[0] = np.zeros(len(coeffs[0])) sig_filt = pywt.waverec(coeffs, 'db6') return sig_filt
8a3c65b35ac347b247a36e7d70705f76f41010d5
11,377
def discount_rewards(r): """ take 1D float array of rewards and compute discounted reward """ gamma = 0.99 discounted_r = np.zeros_like(r) running_add = 0 for t in reversed(range(0, r.size)): running_add = running_add * gamma + r[t] discounted_r[t] = running_add return discounted_r
b093c0d82ef82824c08d08ce4da1b840318bd7ed
11,378
def mvn(tensor): """Per row mean-variance normalization.""" epsilon = 1e-6 mean = K.mean(tensor, axis=1, keepdims=True) std = K.std(tensor, axis=1, keepdims=True) mvn = (tensor - mean) / (std + epsilon) return mvn
c205712d3a1a53450de0e0b9af0abe1b9d51f269
11,379
import re def grapheme_to_phoneme(text, g2p, lexicon=None): """Converts grapheme to phoneme""" phones = [] words = filter(None, re.split(r"(['(),:;.\-\?\!\s+])", text)) for w in words: if lexicon is not None and w.lower() in lexicon: phones += lexicon[w.lower()] else: phones += list(filter(lambda p: p != " ", g2p(w))) return phones
2bb5195a323aa712b2725851fdde64b8e38856f0
11,380
def mean_log_cosh_error(pred, target): """ Determine mean log cosh error. f(y_t, y) = sum(log(cosh(y_t-y)))/n where, y_t = predicted value y = target value n = number of values :param pred: {array}, shape(n_samples,) predicted values. :param target: {array}, shape(n_samples,) target values. :return: mean log cosh error. """ error = pred - target return np.mean(np.log(np.cosh(error)))
85fd6c3d582e7bc41271e3212d43c5cfea8bcf7e
11,381
def check_columns(board: list): """ Check column-wise compliance of the board for uniqueness (buildings of unique height) and visibility (top-bottom and vice versa). Same as for horizontal cases, but aggregated in one function for vertical case, i.e. columns. >>> check_columns(['***21**', '412453*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*1***']) False >>> check_columns(['***21**', '412453*', '423145*', '*543215', \ '*35214*', '*41232*', '*2*1***']) False >>> check_columns(['***21**', '412553*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*1***']) False >>> check_columns(['***22**', '412453*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*1***']) False >>> check_columns(['***21**', '412453*', '423145*', '*543215', \ '*35214*', '*41532*', '*2*4***']) False """ return check_uniqueness_in_rows(get_board_columns(board), False) and \ check_horizontal_visibility(get_board_columns(board), False)
85fd1f02b392c6b6219ce989f7439ec0140b9fa2
11,383
import numpy import pathlib import tqdm import pandas import warnings def extract_header(mjds, path, keywords, dtypes=None, split_dbs=False, is_range=False): """Returns a `~pandas.DataFrame` with header information. For a list or range of MJDs, collects a series of header keywords for database files and organises them in a `~pandas.DataFrame` sorted by MJD and frame number. Parameters ---------- mjds : list The list of MJDs to extract. If the lenght of ``mjds`` is two and ``is_range=True``, all the MJDs between both values will be extracted. path : str The path to the database file. keywords : list A list of strings with the header keywords to extract. dtypes : list, optional A list of types to cast the keyword values. split_dbs : bool, optional If True, assumes that the DB is split into multiple files, one for each MJD. In that case, the path for each file is assumed to be ``path`` with the ``_{MJD}`` suffix. is_range : bool, optional If True, assumes that ``mjds`` are the extremes of a range of MJDs. """ mjds = numpy.atleast_1d(mjds) path = pathlib.Path(path) keywords = [key.lower() for key in keywords] if dtypes: assert len(dtypes) == len(keywords), 'inconsistent lenghts of keywords and dtypes' assert mjds.ndim == 1, 'invalid number of dimensions in mjds' if is_range: assert len(mjds) == 2, 'when is_range=True, mjds must be a list of lenght 2' mjds = numpy.arange(mjds[0], mjds[1] + 1) if not split_dbs: assert path.exists() database.init(str(path)) assert database.connect(), 'cannot connect to database' dataframes = [] with tqdm.trange(len(mjds)) as tt: for mjd in mjds: tt.set_description(str(mjd)) if split_dbs: suffix = path.suffix database_mjd = str(path).replace(suffix, f'_{mjd}{suffix}') if not pathlib.Path(database_mjd).exists(): tt.update() continue database.init(str(database_mjd)) assert database.connect(), 'cannot connect to database' Header = playhouse.reflection.Introspector.from_database( database).generate_models()['header'] fields = [Frame.mjd, Frame.frame] failed = any([not hasattr(Header, keyword) for keyword in keywords]) if failed: tt.update() continue for keyword in keywords: fields.append(getattr(Header, keyword)) data = Header.select(*fields).join(Frame, on=(Frame.pk == Header.frame_pk)).tuples() dataframes.append(pandas.DataFrame(list(data), columns=(['mjd', 'frame'] + keywords))) tt.update() dataframe = pandas.concat(dataframes) if dtypes: failed = False for ii, key in enumerate(keywords): try: dataframe[key] = dataframe[key].astype(dtypes[ii]) except ValueError as ee: warnings.warn(f'failed to apply astype: {ee!r}', exceptions.GuiderQAUserWarning) failed = True if not failed: dataframe = dataframe[dataframe > -999.] dataframe = dataframe.set_index(['mjd', 'frame']) dataframe.sort_index(inplace=True) return dataframe
65934d9b5e9c1e6eb639709a16e6e93c145b57e7
11,384
import pytz from datetime import datetime async def get_time(): """获取服务器时间 """ tz = pytz.timezone('Asia/Shanghai') return { 'nowtime': datetime.now(), 'utctime': datetime.utcnow(), 'localtime': datetime.now(tz) }
282eb1136713df8045c6ad5f659042484fe4ec8b
11,385
def health_check(): """Attempt to ping the database and respond with a status code 200. This endpoint is verify that the server is running and that the database is accessible. """ response = {"service": "OK"} try: postgres.session.query(text("1")).from_statement(text("SELECT 1")).all() response["database"] = "OK" except Exception as e: app.logger.error(e) response["database"] = "ERROR" try: mongo.connection.server_info() response["document_store"] = "OK" except Exception as e: app.logger.error(e) response["document_store"] = "ERROR" return response
cd47815ada53281f2b13542dd8cad93398be5203
11,386
def find_ad_adapter(bus): """Find the advertising manager interface. :param bus: D-Bus bus object that is searched. """ remote_om = dbus.Interface( bus.get_object(constants.BLUEZ_SERVICE_NAME, '/'), constants.DBUS_OM_IFACE) objects = remote_om.GetManagedObjects() for o, props in objects.items(): if constants.LE_ADVERTISING_MANAGER_IFACE in props: return o return None
6b5f49a5908948a54f99438a38865293fca51cc7
11,387
def leaky_relu(x, slope=0.2): """Leaky Rectified Linear Unit function. This function is expressed as :math:`f(x) = \max(x, ax)`, where :math:`a` is a configurable slope value. Args: x (~chainer.Variable): Input variable. slope (float): Slope value :math:`a`. Returns: ~chainer.Variable: Output variable. """ return LeakyReLU(slope)(x)
cf7624309543e24c70832249116b74d56c26d1f9
11,388
def GetConfig(user_config): """Decide number of vms needed to run oldisim.""" config = configs.LoadConfig(BENCHMARK_CONFIG, user_config, BENCHMARK_NAME) config['vm_groups']['default']['vm_count'] = (FLAGS.oldisim_num_leaves + NUM_DRIVERS + NUM_ROOTS) return config
b04380fe6dbc84ef4c353dd34354581fa69aac89
11,389
import re def gen_answer(question, passages): """由于是MLM模型,所以可以直接argmax解码。 """ all_p_token_ids, token_ids, segment_ids = [], [], [] for passage in passages: passage = re.sub(u' |、|;|,', ',', passage) p_token_ids, _ = tokenizer.encode(passage, maxlen=max_p_len + 1) q_token_ids, _ = tokenizer.encode(question, maxlen=max_q_len + 1) all_p_token_ids.append(p_token_ids[1:]) token_ids.append([tokenizer._token_start_id]) token_ids[-1] += ([tokenizer._token_mask_id] * max_a_len) token_ids[-1] += [tokenizer._token_end_id] token_ids[-1] += (q_token_ids[1:] + p_token_ids[1:]) segment_ids.append([0] * len(token_ids[-1])) token_ids = sequence_padding(token_ids) segment_ids = sequence_padding(segment_ids) probas = model.predict([token_ids, segment_ids]) results = {} for t, p in zip(all_p_token_ids, probas): a, score = tuple(), 0. for i in range(max_a_len): idxs = list(get_ngram_set(t, i + 1)[a]) if tokenizer._token_end_id not in idxs: idxs.append(tokenizer._token_end_id) # pi是将passage以外的token的概率置零 pi = np.zeros_like(p[i]) pi[idxs] = p[i, idxs] a = a + (pi.argmax(),) score += pi.max() if a[-1] == tokenizer._token_end_id: break score = score / (i + 1) a = tokenizer.decode(a) if a: results[a] = results.get(a, []) + [score] results = { k: (np.array(v)**2).sum() / (sum(v) + 1) for k, v in results.items() } return results
536880c1318cc193be19561183e652c7668eb09b
11,391
def compile(function_or_sdfg, *args, **kwargs): """ Obtain a runnable binary from a Python (@dace.program) function. """ if isinstance(function_or_sdfg, dace.frontend.python.parser.DaceProgram): sdfg = dace.frontend.python.parser.parse_from_function( function_or_sdfg, *args, **kwargs) elif isinstance(function_or_sdfg, SDFG): sdfg = function_or_sdfg else: raise TypeError("Unsupported function type") return sdfg.compile(**kwargs)
7504344e8e9df5a395e51af1211db286188f3fcb
11,392
import re def is_untweeable(html): """ I'm not sure at the moment what constitutes untweeable HTML, but if we don't find DVIS in tiddlywiki, that is a blocker """ # the same regex used in tiddlywiki divs_re = re.compile( r'<div id="storeArea"(.*)</html>', re.DOTALL ) return bool(divs_re.search(html))
face6c6d30b6e26ffa3344ed8e42ed7d44cf2ea5
11,393
from typing import Optional def create_1m_cnn_model(only_digits: bool = False, seed: Optional[int] = 0): """A CNN model with slightly under 2^20 (roughly 1 million) params. A simple CNN model for the EMNIST character recognition task that is very similar to the default recommended model from `create_conv_dropout_model` but has slightly under 2^20 parameters. This is useful if the downstream task involves randomized Hadamard transform, which requires the model weights / gradients / deltas concatednated as a single vector to be padded to the nearest power-of-2 dimensions. This model is used in https://arxiv.org/abs/2102.06387. When `only_digits=False`, the returned model has 1,018,174 trainable parameters. For `only_digits=True`, the last dense layer is slightly smaller. Args: only_digits: If True, uses a final layer with 10 outputs, for use with the digits only EMNIST dataset. If False, uses 62 outputs for the larger dataset. seed: A random seed governing the model initialization and layer randomness. Returns: A `tf.keras.Model`. """ data_format = 'channels_last' initializer = tf.keras.initializers.GlorotUniform(seed=seed) model = tf.keras.models.Sequential([ tf.keras.layers.Conv2D( 32, kernel_size=(3, 3), activation='relu', data_format=data_format, input_shape=(28, 28, 1), kernel_initializer=initializer), tf.keras.layers.MaxPool2D(pool_size=(2, 2), data_format=data_format), tf.keras.layers.Conv2D( 64, kernel_size=(3, 3), activation='relu', data_format=data_format, kernel_initializer=initializer), tf.keras.layers.Dropout(0.25), tf.keras.layers.Flatten(), tf.keras.layers.Dense( 128, activation='relu', kernel_initializer=initializer), tf.keras.layers.Dropout(0.5), tf.keras.layers.Dense( 10 if only_digits else 62, activation=tf.nn.softmax, kernel_initializer=initializer), ]) return model
87353f8bd8e3b3d7602ad3dcd92b717b2590285b
11,394
def _check_index(target_expr, index_expr): """ helper function for making sure that an index is valid :param target_expr: the target tensor :param index_expr: the index :return: the index, wrapped as an expression if necessary """ if issubclass(index_expr.__class__, _Expression): index = index_expr else: index = _ConstScalar(index_expr) if index.proto_expr.dtype is lang.UNDEFINED_TYPE: raise TypeError('Can only index with a scalar.') if type(index) is _ConstScalar: if target_expr.size <= index.value() or index.value() < 0: raise IndexError('Index out of bounds.') return index
96d5bf6d6d19bfca0de30ea9915a38237cf9c80f
11,395
def create_access_token(user: UserModel, expires_delta: timedelta = None) -> str: """ Create an access token for a user :param user: CTSUser -> The user :param expires_delta: timedelta -> The expiration of the token. If not given a default will be used :return: str -> A token """ load_all_config() to_encode = user.dict() if not expires_delta: expires_delta = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) return __generate_jwt_token(to_encode, expires_delta)
d5ba53f0ecc7e7755988ad2540e4cd4c520b30dd
11,396
def is_async_mode(): """Tests if we're in the async part of the code or not.""" async def f(): """Unasync transforms async functions in sync functions.""" return None obj = f() if obj is None: return False obj.close() # prevent unawaited coroutine warning return True
8e515efc767f75c4b90486089f0d8a7203da59d7
11,397
def remove_arm(frame): """ Removes the human arm portion from the image. """ ##print("Removing arm...") # Cropping 15 pixels from the bottom. height, width = frame.shape[:2] frame = frame[:height - 15, :] ##print("Done!") return frame
99b998da87f1aa2eca0a02b67fc5adc411603ee4
11,398
def cumulative_spread(array, x): """ >>> import numpy as np >>> a = np.array([1., 2., 3., 4.]) >>> cumulative_spread(a, 0.) array([0., 0., 0., 0.]) >>> cumulative_spread(a, 5.) array([1., 2., 2., 0.]) >>> cumulative_spread(a, 6.) array([1., 2., 3., 0.]) >>> cumulative_spread(a, 12.) array([1., 2., 3., 4.]) """ # This is probably inefficient. cumulative_effect = np.cumsum(array) - array b = x - cumulative_effect return np.fmin(array, np.fmax(0, b))
c6966a97945f30cce6a794325091a31716a36e54
11,399
def GetIdentifierStart(token): """Returns the first token in an identifier. Given a token which is part of an identifier, returns the token at the start of the identifier. Args: token: A token which is part of an identifier. Returns: The token at the start of the identifier or None if the identifier was not of the form 'a.b.c' (e.g. "['a']['b'].c"). """ start_token = token previous_code_token = GetPreviousCodeToken(token) while (previous_code_token and ( previous_code_token.IsType(JavaScriptTokenType.IDENTIFIER) or IsDot(previous_code_token))): start_token = previous_code_token previous_code_token = GetPreviousCodeToken(previous_code_token) if IsDot(start_token): return None return start_token
6b3ad9fb9d43411fc7df147ace872f75c70b5d11
11,400
def load_spec(filename): """ loads the IDL spec from the given file object or filename, returning a Service object """ service = Service.from_file(filename) service.resolve() return service
6dfea85635d3b610ee998999397fc92fd516933c
11,401
import torch def load_model(file_path, *, epoch, model, likelihood, mll, optimizer, loss): """モデルの保存関数 Parameters ---------- file_path : str モデルの保存先のパスとファイル名 epoch : int 現在のエポック数 model : :obj:`gpytorch.models` 学習済みのモデルのオブジェクト likelihood : :obj:`gpytorch.likelihoods` 学習済みのlikelihoodsのオブジェクト mll : :obj:`gpytorch.mlls` 学習済みのmllsのオブジェクト optimizer : :obj:`torch.optim` 学習済みのoptimのオブジェクト loss : list 現在のエポックまでの経過loss Returns ------- epoch : int 現在のエポック数 model : :obj:`gpytorch.models` 学習済みのモデルのオブジェクト likelihood : :obj:`gpytorch.likelihoods` 学習済みのlikelihoodsのオブジェクト mll : :obj:`gpytorch.mlls` 学習済みのmllsのオブジェクト optimizer : :obj:`torch.optim` 学習済みのoptimのオブジェクト loss : list 現在のエポックまでの経過loss """ temp = torch.load(file_path) epoch = temp['epoch'] model.load_state_dict(temp['model']) likelihood.load_state_dict(temp['likelihood']) mll.load_state_dict(temp['mll']) optimizer.load_state_dict(temp['optimizer']) loss = temp['loss'] return epoch, model, likelihood, mll, optimizer, loss
ccc7f221164d89ed29326f720becd29e3442c52b
11,403
import re def valid_account_id(log, account_id): """Validate account Id is a 12 digit string""" if not isinstance(account_id, str): log.error("supplied account id {} is not a string".format(account_id)) return False id_re = re.compile(r'^\d{12}$') if not id_re.match(account_id): log.error("supplied account id '{}' must be a 12 digit number".format(account_id)) return False return True
30f3aa9547f83c4bea53041a4c79ba1242ae4754
11,404
import numpy def prod(a, axis=None, dtype=None, out=None): """ Product of array elements over a given axis. Parameters ---------- a : array_like Elements to multiply. axis : None or int or tuple of ints, optional Axis or axes along which a multiply is performed. The default (`axis` = `None`) is perform a multiply over all the dimensions of the input array. `axis` may be negative, in which case it counts from the last to the first axis. .. versionadded:: 1.7.0 If this is a tuple of ints, a multiply is performed on multiple axes, instead of a single axis or all the axes as before. dtype : dtype, optional The type of the returned array and of the accumulator in which the elements are summed. The dtype of `a` is used by default unless `a` has an integer dtype of less precision than the default platform integer. In that case, if `a` is signed then the platform integer is used while if `a` is unsigned then an unsigned integer of the same precision as the platform integer is used. out : ndarray, optional Array into which the output is placed. By default, a new array is created. If `out` is given, it must be of the appropriate shape (the shape of `a` with `axis` removed, i.e., ``numpy.delete(a.shape, axis)``). Its type is preserved. See `doc.ufuncs` (Section "Output arguments") for more details. Returns ------- protuct_along_axis : ndarray An array with the same shape as `a`, with the specified axis removed. If `a` is a 0-d array, or if `axis` is None, a scalar is returned. If an output array is specified, a reference to `out` is returned. Examples -------- >>> np.prod([0.5, 1.5]) 2.0 >>> np.prod([0.5, 0.7, 0.2, 1.5], dtype=np.int32) 1 >>> np.prod([[0, 1], [0, 5]]) 6 >>> np.prod([[0, 1], [0, 5]], axis=0) array([0, 6]) >>> np.prod([[0, 1], [0, 5]], axis=1) array([1, 5]) If the accumulator is too small, overflow occurs: >>> np.ones(128, dtype=np.int8).prod(dtype=np.int8) -128 """ if not bhary.check(a) and not bhary.check(out): return numpy.prod(a, axis=axis, dtype=dtype, out=out) else: if dtype is not None: a = array_create.array(a, dtype=dtype) return ufuncs.multiply.reduce(a, axis=axis, out=out)
c33a506847b13924aa903b5daeece0312cc29c8f
11,405
import random def sample_pagerank(corpus, damping_factor, n): """ Return PageRank values for each page by sampling `n` pages according to transition model, starting with a page at random. Return a dictionary where keys are page names, and values are their estimated PageRank value (a value between 0 and 1). All PageRank values should sum to 1. """ # Initialize dict with all pages with count 0 pr_sample = dict([(page, 0) for page in corpus]) sample_page = None # Iterate over n samples and increment page each time it is selected for i in range(n): if sample_page: transition_dist = transition_model(corpus, sample_page, damping_factor) sample_page = random.choices(list(transition_dist.keys()), weights=list(transition_dist.values()), k=1)[0] else: sample_page = random.choice(list(pr_sample.keys())) # Record sample selection for each time it is chosen pr_sample[sample_page] += 1 # Apply overall percentage by dividing each page count by n for page in pr_sample: pr_sample[page] /= n return pr_sample
32c89d7669718c714663e66a926bb27f9c219c38
11,406
def guess_layout_cols_lr(mr, buf, alg_prefix, layout_alg_force=None, verbose=False): """ Assume bits are contiguous in columns wrapping around at the next line Least significant bit at left Can either start in very upper left of bit colum and go right Or can start in upper right of bit colum and go left Related permutations are handled by flipx, rotate, etc """ # Must be able to divide input txtw, _txth = mr.txtwh() if txtw % mr.word_bits() != 0: verbose and "guess_layout_cols_lr: bad width" return bit_cols = txtw // mr.word_bits() # upper left start moving right def ul_oi2cr(offset, maski): bitcol = offset % bit_cols col = maski * bit_cols + bitcol row = offset // bit_cols return (col, row) name = "cols-right" if layout_alg_force is None or layout_alg_force == name: yield try_oi2cr(mr, ul_oi2cr, buf), alg_prefix + name # upper right start moving left def ur_oi2cr(offset, maski): bitcol = bit_cols - 1 - offset % bit_cols col = maski * bit_cols + bitcol row = offset // bit_cols return (col, row) name = "cols-left" if layout_alg_force is None or layout_alg_force == name: yield try_oi2cr(mr, ur_oi2cr, buf), alg_prefix + name # Used in TMS320C15 # even bits start from left side, odd bits from right # Basically alternating cols-right and cols-left # they move towards each other and then start again on the next line if mr.word_bits() % 2 == 0: def squeeze_lr_oi2cr(offset, maski): left_bit = maski & 0xFFFE if maski % 2 == 0: # cols-right bitcol = offset % bit_cols else: # cols-left (offset by left_bit) bitcol = 2 * bit_cols - 1 - offset % bit_cols col = left_bit * bit_cols + bitcol row = offset // bit_cols return (col, row) name = "squeeze-lr" if layout_alg_force is None or layout_alg_force == name: yield try_oi2cr(mr, squeeze_lr_oi2cr, buf), alg_prefix + name
dbbbf68ee251fb50c413648e97c9957ed7c086ec
11,407
def decrease(rse_id, account, files, bytes, session=None): """ Decreases the specified counter by the specified amount. :param rse_id: The id of the RSE. :param account: The account name. :param files: The amount of files. :param bytes: The amount of bytes. :param session: The database session in use. """ return increase(rse_id=rse_id, account=account, files=-files, bytes=-bytes, session=session)
2ad193e5f50c0bcb19f0d796c7f8b9da115a1f2d
11,408
def get_import_error(import_error_id, session): """ Get an import error """ error = session.query(ImportError).filter(ImportError.id == import_error_id).one_or_none() if error is None: raise NotFound("Import error not found") return import_error_schema.dump(error)
37444be97de3c4fa97fba60d87f469c428011db1
11,409
def roll_dice(): """ simulate roll dice """ results = [] for num in range(times): result = randint(1, sides) results.append(result) return results
9a8442ff777c8c03146bcb9a0f8a2dc19e87a195
11,411
def _read_calib_SemKITTI(calib_path): """ :param calib_path: Path to a calibration text file. :return: dict with calibration matrices. """ calib_all = {} with open(calib_path, 'r') as f: for line in f.readlines(): if line == '\n': break key, value = line.split(':', 1) calib_all[key] = np.array([float(x) for x in value.split()]) # reshape matrices calib_out = {} calib_out['P2'] = calib_all['P2'].reshape(3, 4) # 3x4 projection matrix for left camera calib_out['Tr'] = np.identity(4) # 4x4 matrix calib_out['Tr'][:3, :4] = calib_all['Tr'].reshape(3, 4) return calib_out
2d71146ce79ce39309930bb8a452c185c35c3061
11,412
import torch def _bias_act_cuda(dim=1, act='linear', alpha=None, gain=None, clamp=None): """Fast CUDA implementation of `bias_act()` using custom ops. """ # Parse arguments. assert clamp is None or clamp >= 0 spec = activation_funcs[act] alpha = float(alpha if alpha is not None else spec.def_alpha) gain = float(gain if gain is not None else spec.def_gain) clamp = float(clamp if clamp is not None else -1) # Lookup from cache. key = (dim, act, alpha, gain, clamp) if key in _bias_act_cuda_cache: return _bias_act_cuda_cache[key] # Forward op. class BiasActCuda(torch.autograd.Function): @staticmethod def forward(ctx, x, b): # pylint: disable=arguments-differ ctx.memory_format = torch.channels_last if x.ndim > 2 and x.stride()[1] == 1 else torch.contiguous_format x = x.contiguous(memory_format=ctx.memory_format) b = b.contiguous() if b is not None else _null_tensor y = x if act != 'linear' or gain != 1 or clamp >= 0 or b is not _null_tensor: y = _plugin.bias_act(x, b, _null_tensor, _null_tensor, _null_tensor, 0, dim, spec.cuda_idx, alpha, gain, clamp) ctx.save_for_backward( x if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor, b if 'x' in spec.ref or spec.has_2nd_grad else _null_tensor, y if 'y' in spec.ref else _null_tensor) return y @staticmethod def backward(ctx, dy): # pylint: disable=arguments-differ dy = dy.contiguous(memory_format=ctx.memory_format) x, b, y = ctx.saved_tensors dx = None db = None if ctx.needs_input_grad[0] or ctx.needs_input_grad[1]: dx = dy if act != 'linear' or gain != 1 or clamp >= 0: dx = BiasActCudaGrad.apply(dy, x, b, y) if ctx.needs_input_grad[1]: db = dx.sum([i for i in range(dx.ndim) if i != dim]) return dx, db # Backward op. class BiasActCudaGrad(torch.autograd.Function): @staticmethod def forward(ctx, dy, x, b, y): # pylint: disable=arguments-differ ctx.memory_format = torch.channels_last if dy.ndim > 2 and dy.stride()[1] == 1 else torch.contiguous_format dx = _plugin.bias_act(dy, b, x, y, _null_tensor, 1, dim, spec.cuda_idx, alpha, gain, clamp) ctx.save_for_backward( dy if spec.has_2nd_grad else _null_tensor, x, b, y) return dx @staticmethod def backward(ctx, d_dx): # pylint: disable=arguments-differ d_dx = d_dx.contiguous(memory_format=ctx.memory_format) dy, x, b, y = ctx.saved_tensors d_dy = None d_x = None d_b = None d_y = None if ctx.needs_input_grad[0]: d_dy = BiasActCudaGrad.apply(d_dx, x, b, y) if spec.has_2nd_grad and (ctx.needs_input_grad[1] or ctx.needs_input_grad[2]): d_x = _plugin.bias_act(d_dx, b, x, y, dy, 2, dim, spec.cuda_idx, alpha, gain, clamp) if spec.has_2nd_grad and ctx.needs_input_grad[2]: d_b = d_x.sum([i for i in range(d_x.ndim) if i != dim]) return d_dy, d_x, d_b, d_y # Add to cache. _bias_act_cuda_cache[key] = BiasActCuda return BiasActCuda
44559520faf06fbf9b6f17ac1b29b829840e7f38
11,413
from typing import Mapping def root_nodes(g: Mapping): """ >>> g = dict(a='c', b='ce', c='abde', d='c', e=['c', 'z'], f={}) >>> sorted(root_nodes(g)) ['f'] Note that `f` is present: Isolated nodes are considered both as root and leaf nodes both. """ nodes_having_parents = set(chain.from_iterable(g.values())) return set(g) - set(nodes_having_parents)
67c2043053f82a9a17f148c57bbf4d2501530f99
11,414
def _GetRemoteFileID(local_file_path): """Returns the checked-in hash which identifies the name of file in GCS.""" hash_path = local_file_path + '.sha1' with open(hash_path, 'rb') as f: return f.read(1024).rstrip()
4a06dcdd30e379891fe3f9a5b3ecc2c4fd1a98ed
11,415
def stress_stress( bond_array_1, c1, etypes1, bond_array_2, c2, etypes2, sig, ls, r_cut, cutoff_func ): """2-body multi-element kernel between two partial stress components accelerated with Numba. Args: bond_array_1 (np.ndarray): 2-body bond array of the first local environment. c1 (int): Species of the central atom of the first local environment. etypes1 (np.ndarray): Species of atoms in the first local environment. bond_array_2 (np.ndarray): 2-body bond array of the second local environment. c2 (int): Species of the central atom of the second local environment. etypes2 (np.ndarray): Species of atoms in the second local environment. sig (float): 2-body signal variance hyperparameter. ls (float): 2-body length scale hyperparameter. r_cut (float): 2-body cutoff radius. cutoff_func (Callable): Cutoff function. Return: float: Value of the 2-body kernel. """ kernel_matrix = np.zeros((6, 6)) ls1 = 1 / (2 * ls * ls) ls2 = 1 / (ls * ls) ls3 = ls2 * ls2 sig2 = sig * sig for m in range(bond_array_1.shape[0]): ri = bond_array_1[m, 0] e1 = etypes1[m] for n in range(bond_array_2.shape[0]): e2 = etypes2[n] # check if bonds agree if (c1 == c2 and e1 == e2) or (c1 == e2 and c2 == e1): rj = bond_array_2[n, 0] r11 = ri - rj D = r11 * r11 s1 = 0 for d1 in range(3): ci = bond_array_1[m, d1 + 1] B = r11 * ci fi, fdi = cutoff_func(r_cut, ri, ci) for d2 in range(d1, 3): coordinate_1 = bond_array_1[m, d2 + 1] * ri s2 = 0 for d3 in range(3): cj = bond_array_2[n, d3 + 1] A = ci * cj C = r11 * cj fj, fdj = cutoff_func(r_cut, rj, cj) for d4 in range(d3, 3): coordinate_2 = bond_array_2[n, d4 + 1] * rj force_kern = force_helper( A, B, C, D, fi, fj, fdi, fdj, ls1, ls2, ls3, sig2 ) kernel_matrix[s1, s2] += ( force_kern * coordinate_1 * coordinate_2 ) s2 += 1 s1 += 1 return kernel_matrix / 4
c832b6951774eff3b37dd3a674be74ad917409df
11,416
def is_color_rgb(color): """Is a color in a valid RGB format. Parameters ---------- color : obj The color object. Returns ------- bool True, if the color object is in RGB format. False, otherwise. Examples -------- >>> color = (255, 0, 0) >>> is_color_rgb(color) True >>> color = (1.0, 0.0, 0.0) >>> is_color_rgb(color) True >>> color = (1.0, 0, 0) >>> is_color_rgb(color) False >>> color = (255, 0.0, 0.0) >>> is_color_rgb(color) False >>> color = (256, 0, 0) >>> is_color_rgb(color) False """ if isinstance(color, (tuple, list)): if len(color) == 3: if all(isinstance(c, float) for c in color): if all(c >= 0.0 and c <= 1.0 for c in color): return True elif all(isinstance(c, int) for c in color): if all(c >= 0 and c <= 255 for c in color): return True return False
46b8241d26fa19e4372587ffebda3690972c3395
11,417
def edit_post_svc(current_user, id, content): """ Updates post content. :param current_user: :param id: :param content: :return: """ post = single_post_svc(id) if post is None or post.user_id != current_user: return None post.content = content db.session.commit() return True
a17b632f402ef3f915bf06bde86ab0ff40956177
11,418
from re import M def free_free_absorp_coefPQ(n_e,n_i,T,f): """Returns a physical quantity for the free-free absorption coefficient given the electron density, ion density, kinetic temperature and frequency as physical quantities. From Shklovsky (1960) as quoted by Kraus (1966).""" value = 9.8e-13 * n_e.inBaseUnits().value * n_i.inBaseUnits().value \ * M.pow(T.inBaseUnits().value,-1.5) * M.pow(f.inBaseUnits().value,-2) \ * (19.8 + M.log(M.pow(T.inBaseUnits().value,1.5)/f.inBaseUnits().value)) return P.pq(value,'1/m')
17a09bf20f4363be4f273694168df2cf0eee8b38
11,419
def pixel_gain_mode_statistics(gmaps): """returns statistics of pixels in defferent gain modes in gain maps gr0, gr1, gr2, gr3, gr4, gr5, gr6 = gmaps """ arr1 = np.ones_like(gmaps[0], dtype=np.int32) return [np.sum(np.select((gr,), (arr1,), default=0)) for gr in gmaps]
b9c6b4c601724105d381e77f7c293e0bd00f3ba8
11,420
def run_parallel(ds1, ds2): """ Run the calculation using multiprocessing. :param ds1: list with points :param ds2: list with points :return: list of distances """ pool = mp.Pool(processes=mp.cpu_count()) result = pool.starmap(euclidian_distance, [(p1, p2) for p1 in ds1 for p2 in ds2]) pool.close() return result
e8a6b0124db1948ab72b9081863cdfe77a75e08d
11,421
import re def to_latin(name): """Convert all symbols to latin""" symbols = (u"іїєабвгдеёжзийклмнопрстуфхцчшщъыьэюяІЇЄАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ", u"iieabvgdeejzijklmnoprstufhzcss_y_euaIIEABVGDEEJZIJKLMNOPRSTUFHZCSS_Y_EUA") tr = {ord(a): ord(b) for a, b in zip(*symbols)} translated_name = name.translate(tr) translated_name = re.sub("[^A-Za-z0-9]", "_", translated_name) return translated_name
06a0d535fa7a74feea33e58815da2792a6026def
11,422