content
stringlengths
39
14.9k
sha1
stringlengths
40
40
id
int64
0
710k
from typing import Mapping def UpdateDict( target, override ): """Apply the updates in |override| to the dict |target|. This is like dict.update, but recursive. i.e. if the existing element is a dict, then override elements of the sub-dict rather than wholesale replacing. e.g. UpdateDict( { 'outer': { 'inner': { 'key': 'oldValue', 'existingKey': True } } }, { 'outer': { 'inner': { 'key': 'newValue' } }, 'newKey': { 'newDict': True }, } ) yields: { 'outer': { 'inner': { 'key': 'newValue', 'existingKey': True } }, 'newKey': { newDict: True } } """ for key, value in override.items(): current_value = target.get( key ) if not isinstance( current_value, Mapping ): target[ key ] = value elif isinstance( value, Mapping ): target[ key ] = UpdateDict( current_value, value ) else: target[ key ] = value return target
a07a3d7989e227ff1759271248777e167b7e5467
699,096
def dss_target(request): """ This is a parameterized fixture. Its value will be set with the different DSS target (DSS7, DSS8 ...) that are specified in the configuration file. It returns the value of the considered DSS target for the test. Here it is only used by other fixtures, but one could use it as a test function parameter to access its value inside the test function. Args: request: The object to introspect the “requesting” test function, class or module context Returns: The string corresponding to the considered DSS target for the test to be executed """ return request.param
0aa9f85160280032dfdea872b7c9a147a5717523
699,098
def gym_size(gym): """Returns the size of the gym.""" return len(gym)
b31a46a7b56e973da8dfa0cac9950fad14b48622
699,101
def is_call_id_in_video_state(log, ad, call_id, video_state): """Return is the call_id is in expected video_state Args: log: logger object ad: android_device object call_id: call id video_state: valid VIDEO_STATE Returns: True is call_id in expected video_state; False if not. """ return video_state == ad.droid.telecomCallVideoGetState(call_id)
d0da323a21a23d461fc2aec06ac5d0bebac7cbef
699,103
def _extract_spots_outside_foci(cell_cyt_mask, spots_out_foci): """ Extract spots detected outside foci, in a specific cell. Parameters ---------- cell_cyt_mask : np.ndarray, bool Binary mask of the cell with shape (y, x). spots_out_foci : np.ndarray, np.int64 Coordinate of the spots detected outside foci, with shape (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus a default index (-1 for mRNAs spotted outside a foci). Returns ------- spots_out_foci_cell : np.ndarray, np.int64 Coordinate of the spots detected outside foci in the cell, with shape (nb_spots, 4). One coordinate per dimension (zyx coordinates) plus the index of the foci. """ # get coordinates of rna outside foci mask_spots_to_keep = cell_cyt_mask[spots_out_foci[:, 1], spots_out_foci[:, 2]] spots_out_foci_cell = spots_out_foci[mask_spots_to_keep] return spots_out_foci_cell
d4e06d9ad14ced3b8984b71c32d9d3b1e0cebaae
699,104
def extract_image_number(filename: str, from_file: bool) -> int: """ finds the number of the image from the original images of LITIV 2014 dataset. :param filename: name of the image file. :param from_file: filename is read from a ground-truth file or not. :return: number. """ number = filename[-8:-4] if from_file: number = filename[-9:-5] if not number.isdigit(): number = number[-3:] if not number.isdigit(): number = number[-2:] return int(number)
e55431beffb02959907106a01596310812ba7363
699,107
def calculateNetIncome(gross, state): """ Calculate the net income after federal and state tax :param gross: Gross Income :param state: State Name :return: Net Income """ state_tax = {'LA': 10, 'SA': 0, 'NY': 9} # Calculate net income after federal tax net = gross - (gross * .10) # Calculate net income after state tax if state in state_tax: net = net - (gross * state_tax[state]/100) print("Your net income after all the heavy taxes is: " + str(net)) return net else: print("State not in the list") return None
915528d8bfd15c18003eaeb8f6b3f1e8ad5565a0
699,110
def field_size(field_label): """ Helper function to determine the size of a binary table field Parameters ---------- field_label : PVLModule The field label Returns ------- int : The size of the one entry in bytes """ data_sizes = { 'Integer' : 4, 'Double' : 8, 'Real' : 4, 'Text' : 1 } return data_sizes[field_label['Type']] * field_label['Size']
afaff70bc18d4d9d023fb7c89d45560f1a691bcf
699,111
def leading_by(agents, player): """Determine difference between player's score and closest opponent.""" scores = [a.score() for a in agents] player_score = scores[player] scores.sort() if player_score == scores[-1]: return player_score - scores[-2] else: return player_score - scores[-1]
e97aa0a1109bb2ba5f276f34030ea1f93022046f
699,113
def mk_seealso( function_name: str, role: str = "func", prefix: str = "\n\n", module_location: str = ".", ) -> str: """ Returns a sphinx `seealso` pointing to a function. Intended to be used for building custom fitting model docstrings. .. admonition:: Usage example for a custom fitting model :class: dropdown, tip See the usage example at the end of the :class:`~ResonatorModel` source-code: .. literalinclude:: ../quantify_core/analysis/fitting_models.py :pyobject: ResonatorModel Parameters ---------- function_name name of the function to point to role a sphinx role, e.g. :code:`"func"` prefix string preceding the `seealso` module_location can be used to indicate a function outside this module, e.g., :code:`my_module.submodule` which contains the function. Returns ------- : resulting string """ return f"{prefix}.. seealso:: :{role}:`~{module_location}{function_name}`\n"
0165599829e8edd3f75adcda9402069066a0381a
699,115
def mock_xibo_api(mocker): """Return a mock XiboApi.""" return mocker.MagicMock()
8c2ad1566ad716d9fb4dd680a624e59f89950a0a
699,117
def get_corpus_archive_name(cycle: int) -> str: """Returns a corpus archive name given a cycle.""" return 'corpus-archive-%04d.tar.gz' % cycle
3068ce88bd85f2c21819da697a2b1147f547c509
699,118
import re def extract_airlines_from_flight_text(flight_text): """ :param flight_text: Raw flight text string, e.g., "3:45 PM – 8:15 PM+1\nUnited\n13h 30m\nSFO–PVG\nNonstop\n$4,823", "12:51 PM – 4:50 PM+1\nDelta\nChina Southern\n12h 59m\nSEA–PVG\nNonstop\n$4,197", "2:10 AM – 1:25 PM+1\nSeparate tickets booked together\nEVA Air, Spring\n20h 15m\nSEA–PVG\n1 stop\n6h 15m TPE\n$1,194" :return: A list of airlines, e.g., ["United"], ["Delta", "China Southern"], ["EVA Air", "Spring"] """ airlines = [] # We escape flight_text.split("\n")[0] which indicates flight time range. for airline_candidate in flight_text.split("\n")[1:]: if airline_candidate == "Separate tickets booked together": continue if re.match(r"(\d+h )?\d+m", airline_candidate): # The flight time length indicates the end of airline info. break airlines.extend(airline_candidate.split(",")) return airlines
188f040c15e62f4eace72cb90ef74825c4b803fc
699,120
def get_inputs(inputs, mask=None): """Extract and normalize the arrays from inputs""" gmax = inputs[0][:,:,1].max() o = inputs[0][:,:,0]/gmax n = inputs[1][:,:,0]/gmax return o,n
329dfce70d65dec8d5f177239b7f88c977519867
699,121
def formatTime(t): """Check if hour, minute, second variable has format hh, mm or ss if not change format. :param t: string time hh, mm or ss :return: string time in correct format eg. hh=02 instead of hh=2 """ if len(t) < 2: t = "0" + t return t
8011fc25a001964af1f1e0b0cb4e54f7d7aec721
699,123
def remove_signature(message): """Remove the 3 Letter signature and the '/' found at the beginning of a valid message""" return message[1:]
a802dc5abfea09e05fad51936dd76e17719900e7
699,126
import textwrap def get_comment_from_location(location): """Return comment text from location. Args: location: descriptor_pb2.SourceCodeInfo.Location instance to get comment from. Returns: Comment as string. """ return textwrap.dedent(location.leading_comments or location.trailing_comments)
d86213ddee50128c8363d2a31a740c5677244612
699,128
def get_name(test): """Gets the name of a test. PARAMETERS: test -- dict; test cases for a question. Expected to contain a key 'name', which either maps to a string or a iterable of strings (in which case the first string will be used) RETURNS: str; the name of the test """ if type(test['name']) == str: return test['name'] return test['name'][0]
e9d5a5013b062077c499e0351786819c9bd6bd90
699,131
def check_if_points_escape_box(u, box_boundaries): """ Determine if points u in 2D plane have escaped from box_boundaries limits. Parameters ---------- u : ndarray, shape(n, 2), Points in plane. box_boundaries : list of 2 tuples of floats, Values are interpreted as [[x_min,x_max], [y_min, y_max]]. Returns ------- u_indices : ndarray of bools, shape(n, 2), True/False for points inside/outside the box_boundaries respectively. """ x, y = u.T # Escape condition box_x_min, box_x_max = box_boundaries[0] box_y_min, box_y_max = box_boundaries[1] u_indices = (x >= box_x_min) & (x <= box_x_max) & (y >= box_y_min) & (y <= box_y_max) return u_indices
41b04b72821bc39f387c7557be1b11f14e65c71d
699,132
from typing import Any import random def assign_new_ids(items: dict[str, Any]) -> list[str]: """ Assigns new IDs to any item ID that starts with "NEW:" or is an empty string. Will modify the dict in place. Will return a list of new item IDs assigned. """ new_items = [] for item_id in items: if item_id in ('', 'NEW') or item_id.startswith('NEW:'): new_items.append(item_id) for i, item_id in enumerate(new_items): item_range = (10 ** (max(len(str(len(items))), 5) + 1)) - 1 item_range_l = len(str(item_range)) new_id: str = '' while not new_id or new_id in items: new_id = str(random.randint(0, item_range)).zfill(item_range_l) items[new_id] = items.pop(item_id) new_items[i] = new_id return new_items
4fb3466566f0fd9981e1c99cb429da629c843dab
699,133
def isatty(stream): """Check if a stream is attached to a console. Args: stream (:obj:`io.IOBase`): Stream to check. Returns: :obj:`bool` """ return stream.isatty() if hasattr(stream, "isatty") else False
4ec38e35413f0f8af76da5e2681f5502acf3d61e
699,134
def egcd(a, b): """ Calculate the extended Euclidean algorithm. ax + by = gcd(a,b) Args: a (int): An integer. b (int): Another integer. Returns: int: Greatest common denominator. int: x coefficient of Bezout's identity. int: y coefficient of Bezout's identity. """ if a == 0: return (b, 0, 1) else: g, y, x = egcd(b % a, a) return (g, x - (b // a) * y, y)
87b35ff4e28529d1de2a6fb0063b69cee5dfec74
699,137
def old(sym): """ Return the "old" version of symbol "sym", that is, the one representing "sym" in the pre_state. """ return sym.prefix('old_')
4cc24bd0448195ee1c373106679177ce428e5937
699,139
def _remove_stopwords(line, nlp): """ Helper function for removing stopwords from the given text line. """ line_nlp = nlp(line) line_tokens = [tok.text for tok in line_nlp] filtered_line = list() # Filter for tok in line_tokens: lexeme = nlp.vocab[tok] if not lexeme.is_stop: filtered_line.append(tok) return ' '.join(filtered_line)
58932dc254874ea7a9e93e7e8d7fbf9f306f740b
699,144
from typing import Dict def dict_from_text_file(fpath: str) -> Dict[str, float]: """Parse a two-column CSV file into a dictionary of string keys and float values. Will fail an assertion if the second column contains values which are not valid floats. Args: fpath (str): Path to file to parse. Returns: Dict[str, float]: Dictionary of string keys and float values. """ out_dict: Dict[str, float] = {} with open(fpath, "r") as fp: for line in fp: comps = list(map(lambda elem: elem.strip(), line.strip().split(","))) assert(len(comps) == 2) key = comps[0] val = comps[1] out_dict[key] = float(val) return out_dict
5baf29832e0a44c8131a97168cde796757c05bfa
699,146
import posixpath def get_fuzzer_benchmark_covered_regions_filestore_path( fuzzer: str, benchmark: str, exp_filestore_path: str) -> str: """Returns the path to the covered regions json file in the |filestore| for |fuzzer| and |benchmark|.""" return posixpath.join(exp_filestore_path, 'coverage', 'data', benchmark, fuzzer, 'covered_regions.json')
f999a81c53d961a2ed38a7941d7dd6912dae9621
699,148
def breakdown(data): """Break down each row into context-utterance pairs. Each pair is labeled to indicate truth (1.0) vs distraction (0.0). Output is a native array with format : [context, utterance, label]""" output = [] for row in data: context = row[0] ground_truth_utterance = row[1] output.append([list(context), ground_truth_utterance, 1.0]) for i in range(2,11): output.append([list(context), row[i], 0.0]) return output
613cc8ca3d65d8eb22631114a88a934f67f37867
699,149
def string_escape(text: str) -> str: """Escape values special to javascript in strings. With this we should be able to use something like: elem.evaluateJavaScript("this.value='{}'".format(string_escape(...))) And all values should work. """ # This is a list of tuples because order matters, and using OrderedDict # makes no sense because we don't actually need dict-like properties. replacements = ( ('\\', r'\\'), # First escape all literal \ signs as \\. ("'", r"\'"), # Then escape ' and " as \' and \". ('"', r'\"'), # (note it won't hurt when we escape the wrong one). ('\n', r'\n'), # We also need to escape newlines for some reason. ('\r', r'\r'), ('\x00', r'\x00'), ('\ufeff', r'\ufeff'), # https://stackoverflow.com/questions/2965293/ ('\u2028', r'\u2028'), ('\u2029', r'\u2029'), ) for orig, repl in replacements: text = text.replace(orig, repl) return text
f85d02527f3a9fdb9373f2359c2fce86b86a5a89
699,150
def check_permutation(str1, str2): """ 1.2 Check Permutation: Given two strings, write a method to decide if one is a permutation of the other. Complexity: O(n) time, O(n) space """ h = {} for c in str1: if c not in h: h[c] = 0 h[c] += 1 for c in str2: if c not in h: return False h[c] -= 1 for (_, count) in h.items(): if count != 0: return False return True
4da48752e963c05115b3255b03749e8579a9f8ff
699,151
def climb_stairs(n: int) -> int: """ Args: n: number of steps of staircase Returns: Distinct ways to climb a n step staircase Raises: AssertionError: n not positive integer """ fmt = "n needs to be positive integer, your input {}" assert isinstance(n, int) and n > 0, fmt.format(n) if n == 1: return 1 dp = [0] * (n + 1) dp[0], dp[1] = (1, 1) for i in range(2, n + 1): dp[i] = dp[i - 1] + dp[i - 2] return dp[n]
71ac88a1f475e8fe2da8e525f7924e289dbf28e4
699,152
import codecs def raw_buffered_line_counter(path, encoding="utf-8", buffer_size=1024 * 1024): """ Fast way to count the number of lines in a file. :param Path path: Path to file. :param str encoding: Encoding used in file. :param int buffer_size: Size of buffer for loading. :return: int """ # Open file f = codecs.open(str(path), encoding=encoding, mode="r") # Reader generator def _reader_generator(reader): b = reader(buffer_size) while b: yield b b = reader(buffer_size) # Reader used file_read = f.raw.read # Count lines line_count = sum(buf.count(b'\n') for buf in _reader_generator(file_read)) + 1 return line_count
700135dc1a5b5bf4a807469e34f56213d7b1265a
699,155
def consider_trip_number(trip_strategy, total_trips, trip_num): """Determines if the vehicle should charge given trip strategy and current trip :param int trip_strategy: a toggle that determines if should charge on any trip or only after last trip (1-anytrip number, 2-last trip) :param int total_trips: total trips that the vehicle makes :param int trip_num: the trip number of the current trip :return: (*bool*) -- boolean that represents if the vehicle should charge """ if trip_strategy == 1: return True elif trip_strategy == 2: return total_trips == trip_num
b2fe3a43b95fead4ebf65981cfba39857d1bee3c
699,157
import pathlib def as_pathlib(path): """ Converts the supplied path to an pathlib.Path object :param path: The path to convert :return: The path converted to pathlib.Path """ return pathlib.Path(path)
88129771be8c3277320c813502efbcfee6abdc84
699,158
import re def remove_non_alpha_numeric(input_string): """ return string by removing non alpha numric characters from it """ return re.sub(r'\W+', '', input_string)
fc7b203e4937a7a5a80f0d3dc9a2d7bca5de6b45
699,159
def extract_text(tweet): """Gets the full text from a tweet if it's short or long (extended).""" def get_available_text(t): if t['truncated'] and 'extended_tweet' in t: # if a tweet is retreived in 'compatible' mode, it may be # truncated _without_ the associated extended_tweet #eprint('#%s' % t['id_str']) return t['extended_tweet']['full_text'] else: return t['full_text'] if 'full_text' in t else t['text'] if 'retweeted_status' in tweet: rt = tweet['retweeted_status'] return 'RT @%s: %s' % (rt['user']['screen_name'], extract_text(rt)) if 'quoted_status' in tweet: qt = tweet['quoted_status'] return get_available_text(tweet) + " --> " + extract_text(qt) return get_available_text(tweet)
41660b71e3b020bc25309821b46471e88d79aa49
699,163
def search_linearf(a, x): """ Returns the index of x in a if present, None elsewhere. """ for i in range(len(a)): if a[i] == x: return i return None
949cb93218381a1a45002be03c6b8ca4d00092bf
699,164
def gamma_corr(clip, gamma): """ Gamma-correction of a video clip """ def fl(im): corrected = 255 * (1.0 * im / 255) ** gamma return corrected.astype("uint8") return clip.fl_image(fl)
d98d411c63d932b068d80bef63d42289cb0d8468
699,166
def connected_components(graph): """ Given an undirected graph (a 2d array of indices), return a set of connected components, each connected component being an (arbitrarily ordered) array of indices which are connected either directly or indirectly. """ def add_neighbors(el, seen=[]): ''' Find all elements which are connected to el. Return an array which includes these elements and el itself. ''' #seen stores already-visited indices if seen == []: seen = [el] #iterate through the neighbors (x) of el for x in graph[el]: if x not in seen: seen.append(x) #Recursively find neighbors of x add_neighbors(x, seen) return seen #Create a list of indices to iterate through unseen = list(range(len(graph))) sets = [] i = 0 while (unseen != []): #x is the index we are finding the connected component of x = unseen.pop() sets.append([]) #Add neighbors of x to the current connected component for y in add_neighbors(x): sets[i].append(y) #Remove indices which have already been found if y in unseen: unseen.remove(y) i += 1 return sets
e8299cc024dd27414a287ee0afa302ea64c18b68
699,167
import math import torch def loglinspace(a, b, n=100, **kwargs): """Like :meth:`torch.linspace`, but spread the values out in log space, instead of linear space. Different from :meth:`torch.logspace`""" return math.e**torch.linspace(math.log(a), math.log(b), n, **kwargs)
ea456462a0d029f1ada1c4a9e40c9377b86e815d
699,170
def _query_pkey(query, args): """Append 'query' and 'args' into a string for use as a primary key to represent the query. No risk of SQL injection as memo_dict will simply store memo_dict['malicious_query'] = None. """ return query + '.' + str(args)
d524697af247879f6aca5fa3918d80199b6148d5
699,177
from typing import Dict def alias(alias: str) -> Dict[str, str]: """Select a single alias.""" return {"alias": alias}
9321f00118658dc74fbc9704f1ea0e4a33e1f7aa
699,181
def max_digits(x): """ Return the maximum integer that has at most ``x`` digits: >>> max_digits(4) 9999 >>> max_digits(0) 0 """ return (10 ** x) - 1
3f0ffdfbbb3fdaec8e77889b3bfa14c9b9829b2e
699,184
def to_numpy(t): """ If t is a Tensor, convert it to a NumPy array; otherwise do nothing """ try: return t.numpy() except: return t
3ac3ef0efd9851959f602d42e7f38bdd7e5da21a
699,185
import json def _jsonToDict(json_file): """Reads in a JSON file and converts it into a dictionary. Args: json_file (str): path to the input file. Returns: (dict) a dictionary containing the data from the input JSON file. """ with open(json_file, 'r') as fid: dout = json.loads(fid.read()) return dout
6e4b5996d6aaf2982012c6c2f135d7876ee5b3ca
699,195
def _matches_app_id(app_id, pkg_info): """ :param app_id: the application id :type app_id: str :param pkg_info: the package description :type pkg_info: dict :returns: True if the app id is not defined or the package matches that app id; False otherwise :rtype: bool """ return app_id is None or app_id in pkg_info.get('apps')
4d6cd0d652a2751b7a378fd17d5ef7403cfdc075
699,196
def quad_pvinfo(tao, ele): """ Returns dict of PV information for use in a DataMap """ head = tao.ele_head(ele) attrs = tao.ele_gen_attribs(ele) device = head['alias'] d = {} d['bmad_name'] = ele d['pvname_rbv'] = device+':BACT' d['pvname'] = device+':BDES' d['bmad_factor'] = -1/attrs['L']/10 d['bmad_attribute'] = 'b1_gradient' return d
b35e04d78d419673afbc0711f9d454e01bc1dd5d
699,198
from typing import Callable from typing import Set from typing import Type def is_quorum(is_slice_contained: Callable[[Set[Type], Type], bool], nodes_subset: set): """ Check whether nodes_subset is a quorum in FBAS F (implicitly is_slice_contained method). """ return all([ is_slice_contained(nodes_subset, v) for v in nodes_subset ])
4a4af3af8ca5a3f969570ef3537ae75c17a8015c
699,202
from re import match def extrakey(key): """Return True if key is not a boring standard FITS keyword. To make the data model more human readable, we don't overwhelm the output with required keywords which are required by the FITS standard anyway, or cases where the number of headers might change over time. This list isn't exhaustive. Parameters ---------- key : :class:`str` A FITS keyword. Returns ------- :class:`bool` ``True`` if the keyword is not boring. Examples -------- >>> extrakey('SIMPLE') False >>> extrakey('DEPNAM01') False >>> extrakey('BZERO') True """ # don't drop NAXIS1 and NAXIS2 since we want to document which is which if key in ('BITPIX', 'NAXIS', 'PCOUNT', 'GCOUNT', 'TFIELDS', 'XTENSION', 'SIMPLE', 'EXTEND', 'COMMENT', 'HISTORY', 'EXTNAME', ''): return False # Table-specific keywords if match(r'T(TYPE|FORM|UNIT|COMM|DIM)\d+', key) is not None: return False # Compression-specific keywords if match(r'Z(IMAGE|TENSION|BITPIX|NAXIS|NAXIS1|NAXIS2|PCOUNT|GCOUNT|TILE1|TILE2|CMPTYPE|NAME1|VAL1|NAME2|VAL2|HECKSUM|DATASUM)', key) is not None: return False # Dependency list if match(r'DEP(NAM|VER)\d+', key) is not None: return False return True
d4c36c3a5408d7056e55d5e67ebebe0b960e5b72
699,206
def P(N_c, N_cb, e_t, t, A, N_bb): """ Returns the points :math:`P_1`, :math:`P_2` and :math:`P_3`. Parameters ---------- N_c : numeric Surround chromatic induction factor :math:`N_{c}`. N_cb : numeric Chromatic induction factor :math:`N_{cb}`. e_t : numeric Eccentricity factor :math:`e_t`. t : numeric Temporary magnitude quantity :math:`t`. A : numeric Achromatic response :math:`A` for the stimulus. N_bb : numeric Chromatic induction factor :math:`N_{bb}`. Returns ------- tuple Points :math:`P`. Examples -------- >>> N_c = 1.0 >>> N_cb = 1.00030400456 >>> e_t = 1.1740054728519145 >>> t = 0.149746202921 >>> A = 23.9394809667 >>> N_bb = 1.00030400456 >>> P(N_c, N_cb, e_t, t, A, N_bb) # doctest: +ELLIPSIS (30162.8908154..., 24.2372054..., 1.05) """ P_1 = ((50000 / 13) * N_c * N_cb * e_t) / t P_2 = A / N_bb + 0.305 P_3 = 21 / 20 return P_1, P_2, P_3
82e444ca0e7563f061b69daedd82ff3fc771f190
699,208
import re def trim_http(url :str) -> str: """ Discard the "http://" or "https://" prefix from an url. Args: url: A str containing an URL. Returns: The str corresponding to the trimmed URL. """ return re.sub("https?://", "", url, flags = re.IGNORECASE)
472e71a646de94a1ad9b84f46fc576ed5eb5a889
699,214
def remove_recorders(osi): """Removes all recorders""" return osi.to_process('remove', ['recorders'])
c63f23a031a5c957fd8667fc5be87fbd96b26a1e
699,221
from typing import Match def gen_ruby_html(match: Match) -> str: """Convert matched ruby tex code into plain text for bbs usage \ruby{A}{B} -> <ruby><rb>A</rb><rp>(</rp><rt>B</rt><rp>)</rp></ruby> Also support | split ruby \ruby{椎名|真昼}{しいな|まひる} -> <ruby><rb>椎名</rb><rp>(</rp><rt>しいな</rt><rp>)</rp><rb>真昼</rb><rp>(</rp><rt>まひる</rt><rp>)</rp></ruby> """ return ''.join('<ruby><rb>{}</rb><rp>(</rp><rt>{}</rt><rp>)</rp></ruby>'.format(*pair) for pair in zip(match['word'].split('|'), match['ruby'].split('|')))
bd603b67a61812152f7714f3a13f48cac41db277
699,224
import random import string def randomstring(size=20): """Create a random string. Args: None Returns: result """ # Return result = ''.join( random.SystemRandom().choice( string.ascii_uppercase + string.digits) for _ in range(size)) return result
64ecd935130f6308367d02a5d699ea05c906cbb2
699,228
def has_seven(k): """Returns True if at least one of the digits of k is a 7, False otherwise. >>> has_seven(3) False >>> has_seven(7) True >>> has_seven(2734) True >>> has_seven(2634) False >>> has_seven(734) True >>> has_seven(7777) True """ if k % 10 == 7: return True elif k < 10: return False else: return has_seven(k // 10)
8c0b7b02e36247b3685a6a0142ebd81dd63e220c
699,229
def get_grid_size(grid): """Return grid edge size.""" if not grid: return 0 pos = grid.find('\n') if pos < 0: return 1 return pos
9ff60184bb0eed7e197d015d8b330dcf615b4008
699,233
def index() -> str: """ Static string home page """ return "Hello, Python!!!"
7bf6b684e8404d0b2d52bb7578e1f44e37bdf565
699,236
def get_unique_coords(df, lat_field, lon_field): """ Takes in a dataframe and extract unique fields for plotting. Uses dataframe group by to reduce the number of rows that need to be plotted, returns the lat and lon fields """ unique = df.groupby([lat_field, lon_field]).size().reset_index() lat, lon= unique[lat_field].values, unique[lon_field].values return lat, lon
3914e59a9263e07a18833135b0d30a3e5b1d4ce6
699,237
def unhex(value): """Converts a string representation of a hexadecimal number to its equivalent integer value.""" return int(value, 16)
0a8c297a93f484c8a1143511ef8511521c887a78
699,239
def filter_errors(seq, errors): """Helper for filter_keys. Return singleton list of error term if only errors are in sequence; else return all non-error items in sequence. Args seq: list of strings errors: dict representing error values Returns List of filtered items. """ key_err, val_err = errors['key'], errors['val'] key_err_str, val_err_str = errors['key_str'], errors['val_str'] return ([key_err_str] if set(seq) == set([key_err]) else [val_err_str] if set(seq) == set([val_err]) else [s for s in seq if s not in (key_err, val_err)])
93f44cd933e48974c393da253b7f37057ea7de19
699,244
def _offset(x, y, xoffset=0, yoffset=0): """Return x + xoffset, y + yoffset.""" return x + xoffset, y + yoffset
a6c88b2ee3172e52f7a538d42247c0fdc16352f8
699,245
def filter_to_be_staged(position): """Position filter for Experiment.filter() to include only worms that still need to be stage-annotated fully.""" stages = [timepoint.annotations.get('stage') for timepoint in position] # NB: all(stages) below is True iff there is a non-None, non-empty-string # annotation for each stage. return not all(stages) or stages[-1] != 'dead'
df771b0856c91c8663ad06cacf86bf3389df04c5
699,246
def leja_growth_rule(level): """ The number of samples in the 1D Leja quadrature rule of a given level. Most leja rules produce two point quadrature rules which have zero weight assigned to one point. Avoid this by skipping from one point rule to 3 point rule and then increment by 1. Parameters ---------- level : integer The level of the quadrature rule Return ------ num_samples_1d : integer The number of samples in the quadrature rule """ if level == 0: return 1 return level+2
b93fe05a3bf9b8c016b92a00078dce8ef156a8c4
699,248
def nastran_replace_inline(big_string, old_string, new_string): """Find a string and replace it with another in one big string. In ``big_string`` (probably a line), find ``old_string`` and replace it with ``new_string``. Because a lot of Nastran is based on 8-character blocks, this will find the 8-character block currently occupied by ``old_string`` and replace that entire block with ``new_string``. big_string, old_string, new_string: str """ index = big_string.find(old_string) block = index / 8 return big_string[:8*block] + new_string.ljust(8) + \ big_string[8*block+8:]
f9955d40a74fc57674e79dd6aeea3872ffc2c87d
699,249
import re def does_support_ssl(ip): """Check if IP supports SSL. Has aba sequence outside of the bracketed sections and corresponding bab sequence inside bracketed section. Examples: - aba[bab]xyz supports SSL (aba outside square brackets with corresponding bab within square brackets). - xyx[xyx]xyx does not support SSL (xyx, but no corresponding yxy). - aaa[kek]eke supports SSL (eke in supernet with corresponding kek in hypernet; the aaa sequence is not related, because the interior character must be different). - zazbz[bzb]cdb supports SSL (zaz has no corresponding aza, but zbz has a corresponding bzb, even though zaz and zbz overlap). """ regex = r'''(\w)(\w)\1 # aba sequence [a-z]* # separating characters (\[[a-z]+\][a-z]+)* # zero or more bracketed sections # followed by characters \[[a-z]*\2\1\2[a-z]*\] # bracketed bab ''' regex2 = r'''\[[a-z]*(\w)(\w)\1[a-z]*\] # bracketed aba ([a-z]+\[[a-z]+\])* # zero or more bracketed sections [a-z]* # separating characters \2\1\2 # bab sequence ''' has_sequence = (re.search(regex, ip, re.VERBOSE) or re.search(regex2, ip, re.VERBOSE)) if has_sequence: return has_sequence.group(1) != has_sequence.group(2) return False
f46dda13d53717352fe27446d9fa3d0292d75c26
699,250
import six import json def meta_serialize(metadata): """ Serialize non-string metadata values before sending them to Nova. """ return dict((key, (value if isinstance(value, six.string_types) else json.dumps(value)) ) for (key, value) in metadata.items())
a2ef8762c9d1b3d78dc401996392df0985c1c226
699,251
def keep_merge(walkers, keep_idx): """Merge a set of walkers using the state of one of them. Parameters ---------- walkers : list of objects implementing the Walker interface The walkers that will be merged together keep_idx : int The index of the walker in the walkers list that will be used to set the state of the new merged walker. Returns ------- merged_walker : object implementing the Walker interface """ weights = [walker.weight for walker in walkers] # but we add their weight to the new walker new_weight = sum(weights) # create a new walker with the keep_walker state new_walker = type(walkers[0])(walkers[keep_idx].state, new_weight) return new_walker
b029bd14cab4aec2cdf8edf27a9d63c2ffbbe61e
699,253
def is_nan(var) -> bool: """ Simple check if a variable is a numpy NaN based on the simple check where (nan is nan) gives True but (nan == nan) gives False """ return not var == var
0f91829f9b5ee3dfb22944d956066069b4a3f606
699,259
def load_instances(model, primary_keys): """Load model instances preserving order of keys in the list.""" instance_by_pk = model.objects.in_bulk(primary_keys) return [instance_by_pk[pk] for pk in primary_keys]
21f26f66047fc2b2871f77447035ba15fbf78fa7
699,260
def GetHotlistRoleName(effective_ids, hotlist): """Determines the name of the role a member has for a given hotlist.""" if not effective_ids.isdisjoint(hotlist.owner_ids): return 'Owner' if not effective_ids.isdisjoint(hotlist.editor_ids): return 'Editor' if not effective_ids.isdisjoint(hotlist.follower_ids): return 'Follower' return None
0c03460d3e4190d4964a60a2753d31e1732b6e44
699,263
from unittest.mock import Mock from unittest.mock import patch def mock_gateway_fixture(gateway_id): """Mock a Tradfri gateway.""" def get_devices(): """Return mock devices.""" return gateway.mock_devices def get_groups(): """Return mock groups.""" return gateway.mock_groups gateway_info = Mock(id=gateway_id, firmware_version="1.2.1234") def get_gateway_info(): """Return mock gateway info.""" return gateway_info gateway = Mock( get_devices=get_devices, get_groups=get_groups, get_gateway_info=get_gateway_info, mock_devices=[], mock_groups=[], mock_responses=[], ) with patch("homeassistant.components.tradfri.Gateway", return_value=gateway), patch( "homeassistant.components.tradfri.config_flow.Gateway", return_value=gateway ): yield gateway
6404cb18ce9dd0e97b33958958d7851ee5739bed
699,264
from typing import Any def function_sig_key( name: str, arguments_matter: bool, skip_ignore_cache: bool, *args: Any, **kwargs: Any, ) -> int: """Return a unique int identifying a function's call signature If arguments_matter is True then the function signature depends on the given arguments If skip_ignore_cache is True then the ignore_cache kwarg argument is not counted in the signature calculation """ function_sig = name if arguments_matter: for arg in args: function_sig += str(arg) for argname, value in kwargs.items(): if skip_ignore_cache and argname == 'ignore_cache': continue function_sig += str(value) return hash(function_sig)
bfec647db5d819fb87cf3a227927acd5cd6dda10
699,267
import time def date_file_name(name): """Generate file name with date suffix.""" time_str = time.strftime("%Y%m%d-%H%M%S") return name + "_" + time_str
40e37e2a5dbc0208421f797bc2ae349414b05e4e
699,271
def compute_efficiency_gap(partition): """ Input is a gerrychain.Partition object with voteshare and population data. It is assumed that `add_population_data` and `add_voteshare_data` have been called on the given partition's GeoDataFrame. Returns the efficiency gap of the districting plan from the GOP perspective: (gop_wasted_votes - dem_wasted_votes) / total_votes. Reference: Stephanopoulos and McGhee. "Partisan gerrymandering and the efficiency gap." 2015. """ k = len(partition.parts) gop_wasted_votes = 0 dem_wasted_votes = 0 for i in range(1, k + 1): gop_votes = partition['gop_votes'][i] dem_votes = partition['dem_votes'][i] if gop_votes > dem_votes: gop_wasted_votes += gop_votes - 0.5 * (gop_votes + dem_votes) dem_wasted_votes += dem_votes else: gop_wasted_votes += gop_votes dem_wasted_votes += dem_votes - 0.5 * (gop_votes + dem_votes) # Using total population as a proxy for total_votes for simplicity total_votes = partition.graph.data.population.sum() return (gop_wasted_votes - dem_wasted_votes) / total_votes
2982fe1b2f570c8eca27fade8915e9b117397cd1
699,272
import requests import json def updateData(url): """ Returns the symbol and the price of an asset. Parameters ----------- url: url used for information retrieval Returns ----------- tuple (symbol name, symbol price) """ res = requests.get(url); text = res.text; text = text[5:]; jsonData = json.loads(text); symbolName = jsonData["PriceUpdate"][0][0][0][17][1]; symbolPrice = jsonData["PriceUpdate"][0][0][0][17][4]; print('{0} - {1}'.format(symbolName, symbolPrice)); return (symbolName, symbolPrice);
b458dee9da7700f5c4f82a182724bba007c7a05f
699,273
def has_phrase(message: str, phrases: list): """ returns true if the message contains one of the phrases e.g. phrase = [["hey", "world"], ["hello", "world"]] """ result = False for i in phrases: # if message contains it i = " ".join(i) if i in message: result = True return result
f56fcc261e21c538f1f23b811e14ae29d92f3038
699,276
def check_output(solution: str, output: str) -> bool: """Check if program's output is correct. Parameters ---------- solution Sample output taken from BOJ. output Output from program run. Returns ------- bool True if correct, False if wrong. """ solution_lines = [x.rstrip() for x in solution.rstrip().split("\n")] output_lines = [x.rstrip() for x in output.rstrip().split("\n")] return all([x == y for x, y in zip(solution_lines, output_lines)])
66d35952d892842bd1b47329bfa7b77e0a878a51
699,278
from typing import Sequence def bit_array_to_int(bit_array: Sequence[int]) -> int: """ Converts a bit array into an integer where the right-most bit is least significant. :param bit_array: an array of bits with right-most bit considered least significant. :return: the integer corresponding to the bitstring. """ output = 0 for bit in bit_array: output = (output << 1) | bit return output
d902a8e3db7b65ad348ef86cbfac371361aedd58
699,279
import math def euclidean_distance(p1, p2): """Calculate the euclidean distance of two 2D points. >>> euclidean_distance({'x': 0, 'y': 0}, {'x': 0, 'y': 3}) 3.0 >>> euclidean_distance({'x': 0, 'y': 0}, {'x': 0, 'y': -3}) 3.0 >>> euclidean_distance({'x': 0, 'y': 0}, {'x': 3, 'y': 4}) 5.0 """ return math.sqrt((p1["x"] - p2["x"]) ** 2 + (p1["y"] - p2["y"]) ** 2)
8cdc0e0534b2ed9272832fc0f977b9aa0e594c65
699,281
import zlib def zlib_handler(method): """ Prepare hash method and seed depending on CRC32/Adler32. :param method: "crc32" or "adler32". :type method: str """ hashfunc = zlib.crc32 if method == "crc32" else zlib.adler32 seed = 0 if method == "crc32" else 1 return hashfunc, seed
46e9d91e5ebe92f3b5b24f138ae693368128ce09
699,283
def delete_container(client, resource_group_name, name, **kwargs): """Delete a container group. """ return client.delete(resource_group_name, name)
d69c3fbd89ce684942af4980ca9931908b12db6a
699,289
def unmatched_places(w, open, close): """ Given a word ``w`` and two letters ``open`` and ``close`` to be treated as opening and closing parentheses (respectively), return a pair ``(xs, ys)`` that encodes the positions of the unmatched parentheses after the standard parenthesis matching procedure is applied to ``w``. More precisely, ``xs`` will be the list of all ``i`` such that ``w[i]`` is an unmatched closing parenthesis, while ``ys`` will be the list of all ``i`` such that ``w[i]`` is an unmatched opening parenthesis. Both lists returned are in increasing order. EXAMPLES:: sage: from sage.combinat.tableau import unmatched_places sage: unmatched_places([2,2,2,1,1,1],2,1) ([], []) sage: unmatched_places([1,1,1,2,2,2],2,1) ([0, 1, 2], [3, 4, 5]) sage: unmatched_places([], 2, 1) ([], []) sage: unmatched_places([1,2,4,6,2,1,5,3],2,1) ([0], [1]) sage: unmatched_places([2,2,1,2,4,6,2,1,5,3], 2, 1) ([], [0, 3]) sage: unmatched_places([3,1,1,1,2,1,2], 2, 1) ([1, 2, 3], [6]) """ lw = len(w) places_open = [] places_close = [] for i in range(lw): letter = w[i] if letter == open: places_open.append(i) elif letter == close: if places_open == []: places_close.append(i) else: places_open.pop() return places_close, places_open
cfd2a50c50cecc6fcc08d4fd95df56ad503fa4d2
699,290
def _clip(n: float) -> float: """ Helper function to emulate numpy.clip for the specific use case of preventing math domain errors on the acos function by "clipping" values that are > abs(1). e.g. _clip(1.001) == 1 _clip(-1.5) == -1 _clip(0.80) == 0.80 """ sign = n / abs(n) if abs(n) > 1: return 1 * sign else: return n
78308e70a405b3b3d94827c00705e8842b242cde
699,291
import math def line_intersect(pt1, pt2, ptA, ptB): """ Taken from https://www.cs.hmc.edu/ACM/lectures/intersections.html this returns the intersection of Line(pt1,pt2) and Line(ptA,ptB) returns a tuple: (xi, yi, valid, r, s), where (xi, yi) is the intersection r is the scalar multiple such that (xi,yi) = pt1 + r*(pt2-pt1) s is the scalar multiple such that (xi,yi) = pt1 + s*(ptB-ptA) valid == 0 if there are 0 or inf. intersections (invalid) valid == 1 if it has a unique intersection ON the segment """ DET_TOLERANCE = 0.00000001 # the first line is pt1 + r*(pt2-pt1) # in component form: x1, y1 = pt1 x2, y2 = pt2 dx1 = x2 - x1 dy1 = y2 - y1 # the second line is ptA + s*(ptB-ptA) x, y = ptA xB, yB = ptB dx = xB - x dy = yB - y # we need to find the (typically unique) values of r and s # that will satisfy # # (x1, y1) + r(dx1, dy1) = (x, y) + s(dx, dy) # # which is the same as # # [ dx1 -dx ][ r ] = [ x-x1 ] # [ dy1 -dy ][ s ] = [ y-y1 ] # # whose solution is # # [ r ] = _1_ [ -dy dx ] [ x-x1 ] # [ s ] = DET [ -dy1 dx1 ] [ y-y1 ] # # where DET = (-dx1 * dy + dy1 * dx) # # if DET is too small, they're parallel # DET = (-dx1 * dy + dy1 * dx) if math.fabs(DET) < DET_TOLERANCE: return (0, 0, 0, 0, 0) # now, the determinant should be OK DETinv = 1.0 / DET # find the scalar amount along the "self" segment r = DETinv * (-dy * (x - x1) + dx * (y - y1)) # find the scalar amount along the input line s = DETinv * (-dy1 * (x - x1) + dx1 * (y - y1)) # return the average of the two descriptions xi = (x1 + r * dx1 + x + s * dx) / 2.0 yi = (y1 + r * dy1 + y + s * dy) / 2.0 return (xi, yi, 1, r, s)
73ffd9674302f3be7b0edd9cdddd95df198919cb
699,295
def render_icon(icon): """ Render a Bootstrap glyphicon icon """ return '<span class="glyphicon glyphicon-{icon}"></span>'.format(icon=icon)
4fcc501cbea07d3dbe99f35f63dc39c8f629c4c4
699,296
import binascii def hex_to_bytes(hex_repn: str) -> bytes: """ Convert a hexidecimal string representation of a block of bytes into a Pyton bytes object. This function is the inverse of bytes_to_hex. hex_to_bytes('F803') -> b'\xf8\x03' """ return binascii.unhexlify(hex_repn)
2c456a353e1cce75998d1b2dd9b077af962ee41d
699,297
import re def get_text_url_base(content): """Return base URL to full text based on the content of the landing page. Parameters ---------- content : str The content of the landing page for an rxiv paper. Returns ------- str or None The base URL if available, otherwise None. """ match = re.match('(?:.*)"citation_html_url" content="([^"]+).full"', content, re.S) if match: return match.groups()[0] return None
c679e9e1e8b074f7fea3aaf9eb256542e20a4d7d
699,298
def calculateMatchValue(incompleteObject, knownObject): """Calculate an integer match value, scoring +1 for each match""" matchvalue = 0 for catkey, catval in incompleteObject.items(): if knownObject[catkey] == catval: matchvalue += 1 return matchvalue
bd0efa089fa9edc2e290a46ca7e18b3d22bd1594
699,299
def get_contents_dir(node): """Return content signatures and names of all our children separated by new-lines. Ensure that the nodes are sorted.""" contents = [] for n in sorted(node.children(), key=lambda t: t.name): contents.append('%s %s\n' % (n.get_csig(), n.name)) return ''.join(contents)
147d26ae5fca9540a081feef495dfa4bb0fca8eb
699,302
def two_way_merge(array1, array2): """ Given two sorted arrays, merge them into a single sorted array. This is a very simple operation but is a precursor to k-way merge. We compare each element at the beginning of each array and remove smaller one and add it to the merged array. If one of the arrays run out of elements, we just copy rest of the other array into the merged array and return. Time Complexity: O(n) - Since we only need to do one comparison operation per element. Auxiliary Space: O(n) - We will store the final sorted data in an array of size O(n), which is the combined length of the given arrays. If you want to see the fully animated video explanation, it is here: https://www.youtube.com/watch?v=Xo54nlPHSpg :param array1: A sorted array of values. :param array2: Another sorted array of values. :return: A single sorted array. """ longer_arr_len = len(array1) + len(array2) merged_arr = [] for i in range(longer_arr_len): if len(array1) == 0: merged_arr += array2 break if len(array2) == 0: merged_arr += array1 break if array1[0] < array2[0]: merged_arr.append(array1.pop(0)) else: merged_arr.append(array2.pop(0)) return merged_arr
6d1a4779634809b7ff63159928af668596f5c00e
699,304
def wavelength_to_energy(wavelength: float): """Conversion from photon wavelength (angstroms) to photon energy (eV)""" return 1.2398 / wavelength * 1e4
fc067b9fd9cae68103742e8998b6aa0117d906d0
699,306
import threading def concurrent_map(func, data): """ Similar to the bultin function map(). But spawn a thread for each argument and apply `func` concurrently. Note: unlike map(), we cannot take an iterable argument. `data` should be an indexable sequence. """ N = len(data) result = [None] * N # wrapper to dispose the result in the right slot def task_wrapper(i): result[i] = func(data[i]) threads = [threading.Thread(target=task_wrapper, args=(i,)) for i in range(N)] for t in threads: t.start() for t in threads: t.join() return result
5fb482055699087ca7f7b3b95b7d8c425894882f
699,308
def van_vleck_weisskopf(νeval, ν, γ, δ): """Complex Van Vleck-Weisskopf line shape function. νeval GHz frequency at which line shape is evaluated ν GHz center frequency of line γ GHz width parameter of line δ - overlap parameter of line Returned value is unitless. """ term1 = (1. - 1j*δ)/(ν - νeval - 1j*γ) term2 = (1. + 1j*δ)/(ν + νeval + 1j*γ) return νeval * (term1 - term2)
f2f221196fbe911d4582cfc74bf260bb87ce7db0
699,310
import re def is_valid_username(field): """ Checks if it's an alphanumeric + underscore, lowercase string, at least two characters long, and starts with a letter, ends with alphanumeric """ return re.match(r"[a-z][0-9a-z_]*[a-z0-9]$", field) is not None
b4c870951715e103d58d1187703276dbb21e84cf
699,313
def select_number(list_of_numbers): """The player select *one* number of a list of numbers""" answer = "" while ((not answer.isdecimal()) or int(answer) not in list_of_numbers): answer = input("Please type selected number and press ENTER: ") return int(answer)
af91b18508ff361b0524a551949aac7d93f9afc6
699,324
def cast(s): """ Function which clarifies the implicit type of strings, a priori coming from csv-like files. Example ------- >>> cast('1') 1 >>> cast('1.') 1.0 >>> cast('1E+0') 1.0 >>> cast('1E+1') 10.0 >>> cast('one') 'one' >>> cast('One') 'one' """ s = str(s) try: float(s) if '.' in s or 'E' in s: return float(s) else: return int(s) except: return s.lower()
5e2c9b3b913a733608cab614ae0f08421e489196
699,326
def is_macosx_sdk_path(path): """ Returns True if 'path' can be located in an OSX SDK """ return (path.startswith('/usr/') and not path.startswith('/usr/local')) or path.startswith('/System/')
59b60fa00bf6dd10cf207e6421ea3e4828de5b9c
699,327
import math def _mean_standard(dist): """Find the mean and standard deviation.""" # In the dist dictionary, the key is the value of the metric and # the value is the number of times it appears. So, the sample # value is the key and the number of samples for the value is the # value in dist for that key. total_samples = sum(dist.values()) total_values = sum(key*value for key, value in dist.items()) mean = total_values/total_samples std_squared = sum((value/total_samples) * (key - mean)**2 for key, value in dist.items()) std = math.sqrt(std_squared) return mean, std
3d90807a619b6fe090571a3f07db807e60c3849c
699,328
def shift2d(x,w,a,b): """Shift a 2d quadrature rule to the box defined by the tuples a and b""" xs=[[a[0]],[a[1]]]+x*[[b[0]-a[0]],[b[1]-a[1]]] ws=w*(b[0]-a[0])*(b[1]-a[1]) return xs,ws
84c2090cc0e1689a79aa2c7fa40fb399bc03f535
699,329
def effective_kernel(kernel_shape, dilations): """ Args: kernel_shape: tuple[int] representing the kernel shape in each given dimension. dilations: tuple[int] representing the dilation of the kernel in each given dimension. Must be the same length as kernel_shape, and is assumed to give the dimensions in the same order as kernel_shape Returns: tuple[int] representing the effective shape of the kernel in each given dimension, with each dimension in the order given, taking into account dilation. See http://deeplearning.net/software/theano/tutorial/conv_arithmetic.html#dilated-convolutions Note that a dilation of 1 is equivalent to having no dilation. """ if len(kernel_shape) != len(dilations): raise ValueError( "kernel_shape ({}) and dilations ({}) must be the same length".format( len(kernel_shape), len(dilations) ) ) return [(k - 1) * d + 1 for k, d in zip(kernel_shape, dilations)]
a955d185c924514bf981c2512a8e78646d523144
699,333
def int_from_32bit_array(val): """Converts an integer from a 32 bit bytearray :param val: the value to convert to an int :type val: int :rtype: int """ rval = 0 for fragment in bytearray(val): rval <<= 8 rval |= fragment return rval
ca2f32c7eac6f42aeed688510fa57e717edfacdf
699,334