Datasets:

---

bigcode

/

python-stack-v1-functions-filtered-sc2-subset

like 1

Follow

BigCode 1.18k

def hex_to_b64(hex_str): """Convert Hex string to Base64 string.""" arr = bytearray.fromhex(hex_str) decoded = ''.join([chr(c) for c in arr]) b64_str = decoded.encode('base64').strip() return b64_str

f2fd5f3de60638df19f1b477ea005549c6c43b35

def normalize(string: str) -> str: """[removes spaces and stuff in string] Args: string (str): [any string] Returns: str: [string without spaces or -_] """ string = string.replace(' ', '') string = string.replace('-', '') string = string.replace('_', '') return string.lower()

57079531dde1bb6e424cf748d895981177890517

def detach_virtual_disk_spec(client_factory, device, destroy_disk=False): """Builds spec for the detach of an already existing Virtual Disk from VM. """ virtual_device_config = client_factory.create( 'ns0:VirtualDeviceConfigSpec') virtual_device_config.operation = "remove" if destroy_disk: virtual_device_config.fileOperation = "destroy" virtual_device_config.device = device return virtual_device_config

007b21df2c17a676d4c4b2a7b6f41c91aedc6a78

def lowerBackslash(r, c): """ >>> lowerBackslash(6, 3) [(6, 3), (7, 4), (8, 5)] >>> lowerBackslash(2, 2) [(2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8)] >>> lowerBackslash(1, 8) [(1, 8)] >>> lowerBackslash(1, 1) [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8)] """ lower_x = range(r, 9, 1) lower_y = range(c, 9, 1) return zip(lower_x, lower_y)

8269b34c71651df32a79f111f18d2a28350807dd

def line_to_cols(raw_col_vals: str): """Transform a raw text line of column names into a list of column names Args: raw_line (str): String from textfile Returns: A list of the column names in order """ change_case = [ "RA", "DEC", "Ra", "Dec", "X", "Y", "ID", "iD", "Id", "A", "B", "THETA", "Theta", ] # make ra and dec lowercase for ease of access raw_cols = list(map(lambda s: s.lower() if s in change_case else s, raw_col_vals,)) # if header line starts with a '#' exclude it if raw_cols[0] == "#": return raw_cols[1:] else: return raw_cols

a63eb03e051bf7e4a6a719022de907afc709f41c

def test_sympy_parents(sympy_cls: str, parents: tuple) -> bool: """ Returns True if 'sympy_cls' is in 'bases'. False, otherwise. """ return any([sympy_cls in str(parent) for parent in parents])

ad99314e0119e4b5465e052f1b8d2824cc8a994e

import copy def merge_targets(pac_to_super, pac_to_unstuck, pac_to_normal): """ Merges the targets dictionaries into a single one. """ pac_targets = {} if pac_to_super is not None: pac_targets = copy.deepcopy(pac_to_super) if pac_to_unstuck is not None: pac_targets.update(pac_to_unstuck) if pac_to_normal is not None: pac_targets.update(pac_to_normal) return pac_targets

9648d626841dde0cac0bd70b39a24699a9804f0e

def dynamics(state, time, config, intervention=None): """State dynamics for the Chen et al. opioid epidemic model. Parameters ---------- state: np.ndarray or tuple or list Instantenous system state time: float Time to evaluate the derivative config: whynot.simulators.opioid.Config Configuration parameters for the dynamics intervention: whynot.simulators.opioid.Intervention (Optional) Parameters specifying when/how to update the dynamics Returns ------- ds_dt: np.ndarray Derivative of the state with respect to time, evaluated at state and time. """ # In the opioid simulator, if there is an intervention, # it is applied for every time step of the dynamics (since # interventions are specified on TimeVaryingParams which internally track # the year). if intervention: config = config.update(intervention) nonmedical_users, oud_users, illicit_users = state # Update non-medical opioid use cases nonmedical_increase = config.nonmedical_incidence[time] nonmedical_decrease = nonmedical_users * ( config.nonmedical_exit + config.nonmedical_overdose + config.nonmedical_to_oud + config.nonmedical_to_illicit ) nonmedical_delta = nonmedical_increase - nonmedical_decrease # Update opioid use disorder cases oud_increase = config.nonmedical_to_oud * nonmedical_users oud_decrease = oud_users * ( config.oud_exit[time] + config.oud_overdose[time] + config.oud_to_illicit[time] ) oud_delta = oud_increase - oud_decrease # Update illicit opiate use cases illicit_increase = config.illicit_incidence[time] + ( config.oud_to_illicit[time] * oud_users + config.nonmedical_to_illicit * nonmedical_users ) illicit_decrease = illicit_users * ( config.illicit_exit + config.illicit_overdose[time] ) illicit_delta = illicit_increase - illicit_decrease return [nonmedical_delta, oud_delta, illicit_delta]

fb67d294539b22425233ad7078e4f771aa22d93d

def tar_entry_size(filesize): """Get the space a file of the given size will actually require in a TAR. The entry has a 512-byte header followd by the actual file data, padded to a multiple of 512 bytes if necessary. Args: filesize (int): File size in bytes Returns: int: Bytes consumed in a TAR archive by this file. Examples: :: >>> tar_entry_size(1) 1024 >>> tar_entry_size(511) 1024 >>> tar_entry_size(512) 1024 >>> tar_entry_size(513) 1536 """ # round up to next multiple of 512 return 512 + filesize + ((512 - filesize) % 512)

be5720f23561201344eba0c46afd0215134c4eda

def get_mean(dataframe, column, by=None): """ Return mean values of column x (optionally grouped) :param dataframe: Data :type dataframe: pandas.Dataframe :param column: Column name :type column: str :param by: Column names by which to group. :type by: str|list :return: mean value, optionally for each group. :rtype: numpy.float64|pandas.Series """ if by is None: means = dataframe[column].mean() else: means = dataframe.groupby(by, observed=True)[column].mean() return means

6c4181bf28971a3b0053c1bcad88f75565819a78

def tune(scale, acc_rate): """ Tunes the scaling parameter for the proposal distribution according to the acceptance rate over the last tune_interval: Rate Variance adaptation ---- ------------------- <0.001 x 0.1 <0.05 x 0.5 <0.2 x 0.9 >0.5 x 1.1 >0.75 x 2 >0.95 x 10 """ # Switch statement if acc_rate < 0.001: # reduce by 90 percent scale *= 0.1 elif acc_rate < 0.05: # reduce by 50 percent scale *= 0.5 elif acc_rate < 0.2: # reduce by ten percent scale *= 0.9 elif acc_rate > 0.95: # increase by factor of ten scale *= 10.0 elif acc_rate > 0.75: # increase by double scale *= 2.0 elif acc_rate > 0.5: # increase by ten percent scale *= 1.1 return scale

d0af4f5e6a7f4b02aed2b269d7f3b1db9e58409d

import torch def calculate_accuracy(output, target): """ Top-1 classification accuracy. """ with torch.no_grad(): batch_size = output.shape[0] prediction = torch.argmax(output, dim=1) return torch.sum(prediction == target).item() / batch_size

569a66bf755eb36e83d516e5507b0cc0f36a4c01

import time def rfc822date(timeinfo=None,local=1): """ Format an RFC-2822 compliant date string. @param timeinfo: (optional) A sequence as returned by C{time.localtime()} or C{time.gmtime()}. Default is now. @param local: (optional) Indicates if the supplied time is local or universal time, or if no time is given, whether now should be local or universal time. Default is local, as suggested (SHOULD) by rfc-2822. @returns: A string representing the time and date in RFC-2822 format. """ if not timeinfo: if local: timeinfo = time.localtime() else: timeinfo = time.gmtime() if local: if timeinfo[8]: # DST tz = -time.altzone else: tz = -time.timezone (tzhr, tzmin) = divmod(abs(tz), 3600) if tz: tzhr *= int(abs(tz)/tz) (tzmin, tzsec) = divmod(tzmin, 60) else: (tzhr, tzmin) = (0,0) return "%s, %02d %s %04d %02d:%02d:%02d %+03d%02d" % ( ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'][timeinfo[6]], timeinfo[2], ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'][timeinfo[1] - 1], timeinfo[0], timeinfo[3], timeinfo[4], timeinfo[5], tzhr, tzmin)

fa1a78a099e73e13384711f613854fa9968a43b7

def get_error_point(view, error): """Get the error text point. lxml uses 1-based line and column numbers but ST wants them 0-based, so subtract 1 from both.""" return view.text_point(error.line - 1, error.column - 1)

a2284225f7d3db4d3d0e6a9470f6db53698ac1d8

def get_filename_pair(filename): """ Given one *.spar/*.sdat filename, returns tuple with both filenames It doesn't matter if the filename is a fully qualified path or not. - one assumption, the extension are either all caps or all lower """ spar_filename = sdat_filename = filename[:-3] if filename[-1:].isupper(): sdat_filename += 'DAT' spar_filename += 'PAR' else: sdat_filename += 'dat' spar_filename += 'par' return (spar_filename, sdat_filename)

1d3a33ba68e14d9217e5e2a7833258d9c94f1667

def write_vec_string(vec, prec): """Write data vector into string.""" o = "[" for (n, v) in enumerate(vec): o += f"{v:.{prec}f}" if n < len(vec) - 1: o += "," return o + "]"

195b8a458362b61b689568f71f87b7c03dc911a8

def dEds(s, P, Q): """ we have: E = P/Q therefore: dEds = E' = (P'Q - Q'P) / Q^2 input P, Q: two polynomials that depend on L s: the independent (scaling) variable """ Pp = P.deriv(1)(s) Qp = Q.deriv(1)(s) return (Pp*Q(s) - Qp*P(s)) / Q(s)**2

1a36fa62ec91969bc8925780061a5d195db9a8f8

def get_tokens(node, index): """ Get the tokens from the leaf node Args: node: leaf node index: 0-token, 1-final, 2-sentence, 3-beat, 4-pos """ sen = [] while node: words = node.wordid[index][0].tolist() for w in words[::-1]: sen.append(w) node = node.prevNode return sen[::-1]

b33a4d9ff2dcdd66e4c6ef8e9477e57ce0a7278e

import math def exp_pdf(value, rate): """ Returns the probability density for an exponential distribution with an intensity of rate, evaluated at value. """ return float(rate) * math.exp(-1.0 * rate * value)

a50625b216fdbd492c7aff725f965b9085a3201a

import math def negative_binomial(x, k, p): """ Evaluate the negative binomial distribution b*(x; k, p) as defined in the textbook. Equivalent to finding the probability of coin flip x to be the k-th head when the probability of getting a head on any one coin flip is p. Found with the equation (x-1)C(k-1) * p^k * (1 - p)^(x - k) """ return math.comb(x - 1, k - 1) * (p ** k) * ((1 - p) ** (x - k))

c4b2d923cafdb95142cafe40c1f4248278f06323

def _get_noise_id(tr): """ Get trace id for noise type data. e.g., 'starttime-endtime' :param tr: an obspy trace :return str event_id: noise id """ starttime = tr.stats.starttime endtime = tr.stats.endtime event_id = "-".join([starttime.strftime("%Y%m%d%H%M%S"), endtime.strftime("%Y%m%d%H%M%S")]) return event_id

16960810091e2ae6daa512eb8ccfe8f79c15e960

def root_app(expr): """Returns the pair (r, args) such that expr = r(*args) Arguments: - `expr`: an expression """ root = expr args = [] while root.is_app(): args.append(root.arg) root = root.fun #The arguments were collected in reverse order args.reverse() return (root, args)

500c3626cb777af28c4e58832d3ceb98751c873b

def zeropad(splitver, idx, padlen): """ Zero-pad an element of an OS/radio version to a certain length. :param splitver: OS/radio version, but split into quarters. :type splitver: list(str) :param idx: Index of splitver which must be checked. :type idx: int :param padlen: Length to pad to. :type padlen: int """ if len(splitver[idx]) < padlen: splitver[idx] = splitver[idx].rjust(padlen, "0") return splitver

ab8358a753096501471986ed90a1cf76a2c811df

def get_ssl_subject_alt_names(ssl_info): """ Return the Subject Alt Names """ altNames = '' subjectAltNames = ssl_info['subjectAltName'] index = 0 for item in subjectAltNames: altNames += item[1] index += 1 if index < len(subjectAltNames): altNames += ', ' return altNames

ce38761c452d9704bdbe3309bdfa1bb46eb9a92a

def has_no_e(w): """ Check if 'e' char is present in a given string. Return True is it is not or Flalse otherwise. """ for l in w: if l == 'e': return False return True

2bfa3257e2b2616026dd1a5770da3ef51e93ec09

def circumcircle(u, v, w): """find the center/radius of circumcircle of triangle uvw""" vu, wv, uw = (u - v), (v - w), (w - u) d = 2 * ((u - v).crs(v - w)).dot((u - v).crs(v - w)) a = (v - w).dot(v - w) * (u - v).dot(u - w) / d b = (u - w).dot(u - w) * (v - u).dot(v - w) / d c = (u - v).dot(u - v) * (w - u).dot(w - v) / d o = u * a + v * b + w * c r = (u - o).mag() return o, r

ee824a1ccc96663d1e347057938b1a6fc4da80ac

def jefferson(votes, seats): """Apportion seats using the Jefferson method. Known also as the D'Hondt method or Hagenbach-Bischoff method. :param list votes: a list of vote counts :param int seats: the number of seats to apportion """ allocated = [0] * len(votes) while sum(allocated) < seats: quotients = [1.0 * vote / (allocated[idx] + 1) for idx, vote in enumerate(votes)] idx_max = quotients.index(max(quotients)) allocated[idx_max] += 1 return allocated

acc249637b0f244a0f1ff08c8c2091a713de46bb

def MAVS(data1, data2): """ Mean Absolute Value Slope: the difference between MAVs in adjacent segments. Parameters ---------- data1: array-like 2D matrix of shape (time, data) data2: array-like 2D matrix of shape (time, data) of subsequent segment to x1 Returns ------- MAVSlope: 1D numpy array containing MAV for adjacent signals Reference --------- Hudgins, B., Parker, P., & Scott, R. N. (1993). A new strategy for multifunction myoelectric control. IEEE Transactions on Bio-Medical Engineering, 40(1), 82–94. """ MAV1Data = sum(abs(data1))/len(data1) MAV2Data = sum(abs(data2))/len(data2) MAVSlope = MAV2Data - MAV1Data return MAVSlope

c721d1d1cf0bdf633307d80a52c8497c58e0bd8d

def getImageOffset(img, pos, box=(156, 156)): """ Determine the required image offset Params: img -- The PIL Image object pos -- The (x,y) postion box -- The bounding box (x,y) position Returns: A tuple containg the offset coordinates (j,k) """ x_offset = max((box[0] - img.size[0]) / 2, 0) y_offset = max((box[1] - img.size[1]) / 2, 0) j = pos[0] + x_offset k = pos[1] + y_offset return (j, k)

972e6929bab13c25aad1c26d7e21511439b7b479

import time def elapsed(since): """Return the number of minutes elapsed since a time.""" return (time.time() - since) / 60

6e2b131e66fc153b96feea0ec8b0f8193d98b5cd

def node_restore_all(self, flag=0) : """ Restores a all device from the configuration in ISY args : flag 0 or 1 Flag : 0 = All shall be restored from the configuration files in ISY 1 = Does not regenerate groups/scenes - good for testing raise: IsyResponseError : if Error in ISY responce """ return self.soapcomm("RestoreDevices", flag=flag)

ef7f63ee26b9e08e23e3ac26971729e008322858

def convert_list(in_list): """Converts a list of strings to a printable list of object names""" return ''.join(('[', ','.join(in_list), ']'))

2d13f19baf2966df024aba0a212b2047e78626e0

import string import random def gen_random_string(n=24): """Returns a random n-length string, suitable for a password or random secret""" # RFC 3986 section 2.3. unreserved characters (no special escapes required) char_set = string.ascii_letters + string.digits + "-._~" return "".join(random.choices(char_set, k=n))

b3bd49ed5b89d886aefa7431b62d85b6f5ff1c60

def idn(x): """ Identity function (for use with getMapParams) """ return x

5cd80ee1531dc28434cd4ea5ba3d43e350e338fc

def job_as_parameter(f): """A decorator for job handlers that take the job as a parameter.""" f.job_as_parameter = True return f

5cb27b65cde8054c0ea8c192cb105afb6f6b6f33

def load_quotes(quotes_file) -> tuple: """Load quotes from file, return tuple of quotes.""" with open(quotes_file, 'r') as f: build_quote = [] quotes = [] for line in f: if line.isspace(): quotes.append(''.join(build_quote).strip()) build_quote = [] build_quote.append(line.replace("\n", "").strip() + " ") return tuple(quotes)

e649806b6adc861c05f787e719d442bea54686cf

import re def replace_uuid(msg): """ Replace UUID in `msg` with ``UUID``. """ pattern = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}' return re.sub(pattern, 'UUID', msg)

f5dbf51133aa28ef74d98e0d98c85faa71dcc080

def union_boxes(box_a, box_b): """ Merges two rectangles. Args: box_a <tuple> : First rectangle (x, y, w, h) box_b <tuple> : Second rectangle (x, y, w, h) Returns: merged_box <tuple> : Merged rectangle (x, y, w, h) """ ax1, ay1, aw, ah = box_a ax2, ay2 = ax1+aw-1, ay1+ah-1 bx1, by1, bw, bh = box_b bx2, by2 = bx1+bw-1, by1+bh-1 x1 = min(ax1, bx1) y1 = min(ay1, by1) x2 = max(ax2, bx2) y2 = max(ay2, by2) merged_box = [x1, y1, x2-x1+1, y2-y1+1] return merged_box

cfe2ab4d604eded90b905a4b837afe8156b2484f

def add_base_args(parser): """Add the base nerf arguments to the parser Args: parser (ArgumentParser): the current ArgumentParser. Returns: ArgumentParser: the modified ArgumentParser for call chaining """ parser.add_argument( "--perturb", type=float, default=1.0, help="set to 0. for no jitter, 1. for jitter", ) parser.add_argument( "--raw_noise_std", type=float, default=0.0, help="std dev of noise added to regularize sigma_a output, 1e0 recommended", ) return parser

490bae7816769b6c7970eea7f1a8f054fac049ed

def mulmatvec3x3(m, vect): """ This function returns a 3D vector which consists of the 3D input vector multiplied by a 3x3 matrix. :rtype: double iterable :return: 3D vector :type m: double iterable :param m: The matrix to multiply :type vect: double iterable :param vect: The vector - in the format[x,y,z] (or [x,y,z,0] for affine transformations in an homogeneous space) """ r = [0.0, 0.0, 0.0] r[0] = vect[0] * m[0][0] + vect[1] * m[1][0] + vect[2] * m[2][0] r[1] = vect[0] * m[0][1] + vect[1] * m[1][1] + vect[2] * m[2][1] r[2] = vect[0] * m[0][2] + vect[1] * m[1][2] + vect[2] * m[2][2] return r

9385eb0d14c2ee1bb6e80870c2c8f4a82b8d9ce7

def pysolr_formatter(credentials): """ Returns formatted Solr credentials for a pysolr-Solr connection. Args: credentials (dict): The credentials dictionary from the relationships. Returns: (string) A formatted pysolr credential. """ return "http://{0}:{1}/{2}".format(credentials['ip'], credentials['port'], credentials['path'])

f36aa9c56998f6d0e8c800182e1a3dfae40f441c

def setCopy( set ): """(shallow) copy a set""" return set[:]

5ccfcf3729d7bd77c173d9ba2aa90911e7c3fe25

def rgb255(r, g, b): """Define an RGB color with three values 0..255.""" return (r/255, g/255, b/255)

505c012f53f99258c9ae19ff9afb398c436b8262

def equivalent(list1, list2): """ Checks if two (possibly nested) lists are equivalent. Recursive. Args: list1, list2 (lists): The lists to compare Returns: bool: Whether the lists are equivalent """ # Base case if not isinstance(list1, list) and not isinstance(list2, list): return type(list1) == type(list2) and list1 == list2 # Exit case elif not isinstance(list1, list) or not isinstance(list2, list) or len(list1) != len(list2): return False # Recursive case else: for i in range(len(list1)): if not equivalent(list1[i], list2[i]): return False # Looks redundant, but it isn't. We need to check for each. # If we got through everything else. Will only happen in list cases. return True

136f2b63d35d473c9f53bd142045d8faf6b890f1

import torch def get_IoU(predictions: torch.Tensor, labels: torch.Tensor, threshold: float = 0.5): """Code inspired by https://www.kaggle.com/iezepov/fast-iou-scoring-metric-in-pytorch-and-numpy """ eps = 1e-6 # assert N x H x W if len(predictions.shape) != 3: predictions.unsqueeze_(0) if len(labels.shape) != 3: labels.unsqueeze_(0) outputs = (predictions > threshold).int() labels = labels.int() # Will be zero if Truth=0 or Prediction=0 intersection = (outputs & labels).float().sum((1, 2)) # Will be zero if both are union = (outputs | labels).float().sum((1, 2)) # We smooth our devision to avoid 0/0 iou = (intersection + eps) / (union + eps) return iou.mean()

e0189c98a09033f4ff80cedf9b638432c272edc8

def split_into_formatters(compound): """Split a possibly compound format string into segments. >>> split_into_formatters('bold_underline_bright_blue_on_red') ['bold', 'underline', 'bright_blue', 'on_red'] """ merged_segs = [] # These occur only as prefixes, so they can always be merged: mergeable_prefixes = ['on', 'bright', 'on_bright'] for s in compound.split('_'): if merged_segs and merged_segs[-1] in mergeable_prefixes: merged_segs[-1] += '_' + s else: merged_segs.append(s) return merged_segs

00c3a5d314638047b4b53ed72bc27c3f1b8a00f1

def get_idx(prefix, itf): """ Gets the index of an interface string >>> get_idx('et', 'et12') 12 >>> get_idx('ap', 'ap32') 32 """ return int(itf[len(prefix) :])

0a4b1e49ad6c0a7e9a2a9ae1903480a3bf73d70e

def restrict_available_forage(available_forage, management_threshold): """Reduce forage available for grazing. The management threshold specifies the biomass that must be left after herbivore offtake. Calculate the forage available for offtake by herbivores according to its relative availability, restricting it to be below the management threshold if necessary. Parameters: available_forage (list): list of class FeedType, where each FeedType is characterized by its standing biomass and biomass available to herbivores for offtake management_threshold (float): biomass (kg/ha) required to be left standing after offtake by herbivores Returns: modified available_forage, a list of class FeedType """ sum_biomass = 0. for feed_type in available_forage: sum_biomass += feed_type.biomass actually_available = max(sum_biomass - management_threshold, 0) for feed_type in available_forage: feed_type.biomass_avail = ( feed_type.rel_availability * actually_available) return available_forage

dbac8561dd00b8a477117580c151e7fd73e15dee

def _get_roi_from_rect(rect): """ Returns the ROI from a rectangle, the rectangle can have the top and bottom flipped. :param rect: Rect to get roi from :return: x, y, width, height of ROI """ x_min = min(rect.topLeft().x(), rect.bottomRight().x()) y_min = min(rect.topLeft().y(), rect.bottomRight().y()) x_max = max(rect.topLeft().x(), rect.bottomRight().x()) y_max = max(rect.topLeft().y(), rect.bottomRight().y()) return x_min, y_min, x_max, y_max

fba34bcedb68bfa90ae9700df5b23f3b7450b9b3

def serialize_forma(analysis, type): """Convert the output of the forma250 analysis to json""" return { 'id': None, 'type': type, 'attributes': { 'areaHa': analysis.get('area_ha', None), 'areaHaLoss': analysis.get('area_ha_loss', None), 'alertCounts': analysis.get('alert_counts', None) } }

bc3b9d835e9477823554cfef1deb95d552a01741

def compute_runtime(length, buffer): """ Takes a length as a time delta and a buffer in seconds Returns number of miliseconds equal to length - buffer """ return (length.total_seconds() - buffer)*1000

4e139340ff48904a737936dcd54d087f60755bea

def is_ignored_file(f): """Check if this file has to be ignored. Ignored files includes: - .gitignore - OS generated files - text editor backup files - XCF image files (Gimp) """ return f == '.gitignore' or f == '.DS_Store' or f == '.DS_Store?' or \ f == '.Spotlight-V100' or f == '.Trashes' or f == 'ehthumbs.db' or f == 'Thumbs.db' or \ f.startswith("._") or f.endswith(".swp") or f.endswith(".bak") or f.endswith("~") or \ f.endswith(".xcf")

9ccea4940cce382d2166c86f40c45f6ce1c892b7

def item_path(item, program): """ More recent versions of Sublime Merge use a recent list that contains state for the repository instead of just a path; this determines, based on an item and the program in use, what the path inside it is. """ if program == "merge" and isinstance(item, dict): return item.get("path") return item

becb47d451d834b410b6ad4a85ba7f76df8b24ba

def time_diff(t0, t1): """ Args: :t0: start time in seconds :t1: end time in seconds Returns: string with time difference (i.e. t1-t0) """ minutes, seconds = divmod(t1 - t0, 60) hours, minutes = divmod(minutes, 60) return "%d hours, %d minutes, %d seconds" % (hours, minutes, seconds)

9b1c179fbec8fa0b9dc5143cf3316b061bf5d5c8

import math def floor(theNumber): """Returns math.floor(theNumber).""" return math.floor(theNumber)

69119eac9bcc21ed0cdb78a8f90b2441093a4e03

async def redirect(request): """Handler to do redirects using HTTP status code 307. The url to redirect to must be given with a query parameter: http://localhost/redirect?url=http://example.com """ url = request.querydict.get("url", "") if url: return 307, {"location": url}, "Redirecting" else: return 500, {}, "specify the URL using a query param"

f87fa1e67765e3d4ffcfdc77609d658c274128af

def trim_hidden(inputs, hidden): """ In the case where the last batch is smaller than batch_size, we will need to keep only the first N hidden states, where N is the number of samples in the last batch Args: inputs: the inputs in the last batch size hidden: the hidden state produced by the penultimate batch Returns: hidden the trimmed hidden state """ batch_size = inputs.size(0) if isinstance(hidden, tuple): hidden_size = hidden[0].size(1) else: hidden_size = hidden.size(1) # do nothing if batch_size == hidden_size: return hidden # trim the hidden state to the remaining samples in the batch if isinstance(hidden, tuple): hidden = (hidden[0][:, :batch_size, :].contiguous(), hidden[1][:, :batch_size, :].contiguous()) else: hidden = hidden[:, :batch_size, :].contiguous() return hidden

c7230872edf3f0c65aa0c166bd6692cbe9567d29

def has_number(input_str): """Returns true if input_str contains any numbers.""" return any(char.isdigit() for char in input_str)

9e01cd258dc648da3a554a444f2b7aaee33691f3

import shlex def repr_command(argv): """Represent an argument array as a string. Args: argv: The arguments of the command. Returns: A string which could be pasted into a shell for execution. """ return ' '.join(shlex.quote(str(arg)) for arg in argv)

23406785a208d35db8730345e8fa4074e854d3ad

def get_url_for_alert(alert, alerts): """ Gets the url slug for an alert (given the global alerts object obtained from `Alerts.load()`.) Note: The alert must be public to have a url slug. Will return a date string in the style '3-jun-2021', unless there were already alerts that day, in which case it'll append a 1-indexed counter on to the end eg '3-jun-2021-2'. Note that the first alert of the day never has a count. """ alerts_on_this_day = sorted([ other_alert for other_alert in alerts.public if other_alert.starts_at_date.as_local_date == alert.starts_at_date.as_local_date ]) if not alerts_on_this_day: raise ValueError(f'Alert {alert.id} is not public so does not have a URL') # if this is the first alert of the day (or the only alert of the day), then don't include a counter if alert == alerts_on_this_day[0]: return alert.starts_at_date.as_url # count through the alerts that day til we find this one, so we know for i, other_alert in enumerate(alerts_on_this_day[1:], start=2): if alert == other_alert: return f'{alert.starts_at_date.as_url}-{i}' raise ValueError(f'Couldnt find alert {alert.id} in public alerts for day')

7f3468f8f07dcdcb4f7c23d76b37c519f5fa9639

def interpret(block: str): """ Interprets an element block, breaking it into element and number of that element. :param block: string block describing an element :return: composition dictionary :rtype: dict """ if block[0].isdigit() is True: # if isotope number is encountered return {block: 1} else: ele = block[0] i = 0 num = '' while i < len(block) - 1: i += 1 if block[i].isdigit() is True: # add digits num += block[i] else: ele += block[i] if num == '': num = 1 else: num = int(num) return {ele: num}

24a8ee49488099ce86be3518565510778429170a

def get_tuple_fragmentation_fn(pegasus_graph): """ Returns a fragmentation function that is specific to pegasus_graph. This fragmentation function, fragment_tuple(..), takes in a list of Pegasus qubit coordinates and returns their corresponding K2,2 Chimera fragment coordinates. Details on the returned function, fragment_tuple(list_of_pegasus_coordinates): Each Pegasus qubit is split into six fragments. If edges are drawn between adjacent fragments and drawn between fragments that are connected by an existing Pegasus coupler, we can see that a K2,2 Chimera graph is formed. The K2,2 Chimera graph uses a coordinate system with an origin at the upper left corner of the graph. y: number of vertical fragments from the top-most row x: number of horizontal fragments from the left-most column u: 1 if it belongs to a horizontal qubit, 0 otherwise r: fragment index on the K2,2 shore Parameters ---------- pegasus_graph: networkx.graph A pegasus graph Returns ------- fragment_tuple(pegasus_coordinates): a function A function that accepts a list of pegasus coordinates and returns a list of their corresponding K2,2 Chimera coordinates. """ horizontal_offsets = pegasus_graph.graph['horizontal_offsets'] vertical_offsets = pegasus_graph.graph['vertical_offsets'] # Note: we are returning a fragmentation function rather than fragmenting the pegasus # coordinates ourselves because: # (1) We don't want the user to have to deal with Pegasus horizontal/vertical offsets directly. # (i.e. Don't want fragment_tuple(pegasus_coord, vertical_offset, horizontal_offset)) # (2) We don't want the user to have to pass entire Pegasus graph each time they want to # fragment some pegasus coordinates. # (i.e. Don't want fragment_tuple(pegasus_coord, pegasus_graph)) def fragment_tuple(pegasus_coords): fragments = [] for u, w, k, z in pegasus_coords: # Determine offset offset = horizontal_offsets if u else vertical_offsets offset = offset[k] # Find the base (i.e. zeroth) Chimera fragment of this pegasus coordinate fz0 = (z*12 + offset) // 2 #first fragment's z-coordinate fw = (w*12 + k) // 2 #fragment w-coordinate fk = k&1 #fragment k-index base = [fw, 0, u, fk] if u else [0, fw, u, fk] # Generate the six fragments associated with this pegasus coordinate for fz in range(fz0, fz0 + 6): base[u] = fz fragments.append(tuple(base)) return fragments return fragment_tuple

eba885f8e87289f46f91c7b23831b209d88fd61a

def price_table_to_price_mapping(table): """Convert price table to a dict mapping from region to instance type to instance info """ region_price_mapping = {} for region_table in table['config']['regions']: types = {} for type_category in region_table['instanceTypes']: for size in type_category['sizes']: types[size['size']] = size region_price_mapping[region_table['region']] = types return region_price_mapping

d39887b82be8ae37a20d73c830e7ef724553600e

def find_x_overlap(rect1, rect2): """ Return left_x and width of overlapping x of two rects """ r1left = rect1['left_x'] r1right = r1left + rect1['width'] r2left = rect2['left_x'] r2right = r2left + rect2['width'] highest_start_point = r1left if r1left >= r2left else r2left lowest_end_point = r1right if r1right <= r2right else r2right if highest_start_point < lowest_end_point: return highest_start_point, lowest_end_point - highest_start_point else: return None

8773615aa2316defd63bf479bc5b9efdfee0974b

import requests import json def isdisambiguation(pagename): """Given a wikipedia page name, returns True if that page is a disambiguation page and False otherwise :param pagename: The name of a wikipedia page :type pagename: String :return: True if pagename is the name of a wikipedia page in the 'All disambiguation pages' category, otherwise False :rtype: Boolean """ pagenamehyphen = pagename.replace(' ', '_') query = requests.get(f'https://en.wikipedia.org/w/api.php?action=query&format=json&titles={pagenamehyphen}&prop=categories') data = json.loads(query.text) for category in data['query']['pages'][next(iter(data['query']['pages'].keys()))]['categories']: catname = category['title'] if catname == "Category:All disambiguation pages": return True return False

466d481523b4e86a4562644798047a9a4544cab9

def __get_inline_formfield_for_dbfield(inline, field, widget): """ Gets the new formfield_for_dbfield function for an inline """ old_formfield_for_dbfield = inline.formfield_for_dbfield def formfield_for_dbfield(db_field, **kwargs): if db_field.name == field: kwargs['widget'] = widget return old_formfield_for_dbfield(db_field, **kwargs) return formfield_for_dbfield

e07808c19409e178301ba5758b765c1d39c068f6

def cuadrado(num): """ (num) -> num Calcula el cuadrado del numero >>> cuadrado(2) 4 >>> cuadrado(-2) 4 >>> cuadrado(0) 0 :param num: int or float el numero a elevar al cuadrado :return: num el resultado de elevar num al cuadrado """ return num ** 2

a4f16640f01cf8fb225f031229dff07f33832fc5

import re def valid_height_cm(height_string): """ Check if height is valid in cm """ match = re.match(r"^(\d*)(cm)$", height_string) if match: height_cm = int(match.group(1)) if 150 <= height_cm and height_cm <= 193: return True return False

23a7d35ad7fa1153134339df80c06093226f5562

def is_eof(line): """readline only ever returns an empty line at EOF""" return line == ""

0e9d8524a4ce08d8810d72d9d18c24f40a5f6257

import torch def init_net(net, init_type='normal', init_gain=0.02, gpu_ids=[]): """Initialize a network: 1. register CPU/GPU device (with multi-GPU support); 2. initialize the network weights Parameters: net (network) -- the network to be initialized init_type (str) -- the name of an initialization method: normal | xavier | kaiming | orthogonal gain (float) -- scaling factor for normal, xavier and orthogonal. gpu_ids (int list) -- which GPUs the network runs on: e.g., 0,1,2 Return an initialized network. """ if len(gpu_ids) > 0: assert(torch.cuda.is_available()) net.to(gpu_ids[0]) net = torch.nn.DataParallel(net, gpu_ids) # multi-GPUs # init_weights(net, init_type, init_gain=init_gain) return net

dc6fdba712c2f31aa19f6ba75338a6ad58bfc642

def get_id(record): """Get the ID from a record. Args: record A record returned by AWS. Returns: The ID of the subnet. """ return record["SubnetId"]

a977b55441b4d707bbf221aeae722a3d84809fa4

import math def sph2cart(theta, phi, r=1): """Converts spherical coords to cartesian""" x = r * math.sin(theta) * math.cos(phi) y = r * math.sin(theta) * math.sin(phi) z = r * math.cos(theta) vect = [x, y, z] return vect

cf793f0a81baefa80c96863d1b765fdd8d30b637

def tapisize(fieldKeyName): """Transforms a string into a Tapis query parameter """ return fieldKeyName.lower()

cc8032a6cc9e822193430134bb33da8aef74cf06

def less_equals(x): """Less than or equal operator. >>> less_equals(1)(1) True >>> less_equals(1)(3) False """ def less_equals(y): return y <= x return less_equals

52b6caef10b9e9edbcb54bf17c82afdc8ef26aad

def seq_sign_changes(arr, i): """ Checks whether a sequence's i'th element has different sign from the i+1'th element """ return arr[i]*arr[i+1] < 0

08190728804232e4abe2042267fb18b29bee6eac

def remove_empty(s): """\ Remove empty strings from a list. >>> a = ['a', 2, '', 'b', ''] >>> remove_empty(a) [{u}'a', 2, {u}'b'] """ while True: try: s.remove('') except ValueError: break return s

98778e4cc90f11b9b74ac6d26b203cbfc958fd7b

def find_multiple(x, n): """Takes integers x and n. Returns the smallest multiple of n, m where m >= x. """ while n < x: n = n << 1 return n

5c4c7291b591aac8154ab4fee97e375c582376ad

import torch def _get_sfm_calibration_matrix( N, device, focal_length, principal_point, orthographic: bool = False, image_size=None, ) -> torch.Tensor: """ Returns a calibration matrix of a perspective/orthograpic camera. Args: N: Number of cameras. focal_length: Focal length of the camera in world units. principal_point: xy coordinates of the center of the principal point of the camera in pixels. orthographic: Boolean specifying if the camera is orthographic or not image_size: (Optional) Specifying the image_size = (imwidth, imheight). If not None, the camera parameters are assumed to be in screen space and are transformed to NDC space. The calibration matrix `K` is set up as follows: .. code-block:: python fx = focal_length[:,0] fy = focal_length[:,1] px = principal_point[:,0] py = principal_point[:,1] for orthographic==True: K = [ [fx, 0, 0, px], [0, fy, 0, py], [0, 0, 1, 0], [0, 0, 0, 1], ] else: K = [ [fx, 0, px, 0], [0, fy, py, 0], [0, 0, 0, 1], [0, 0, 1, 0], ] Returns: A calibration matrix `K` of the SfM-conventioned camera of shape (N, 4, 4). """ if not torch.is_tensor(focal_length): focal_length = torch.tensor(focal_length, device=device) if focal_length.ndim in (0, 1) or focal_length.shape[1] == 1: fx = fy = focal_length else: fx, fy = focal_length.unbind(1) if not torch.is_tensor(principal_point): principal_point = torch.tensor(principal_point, device=device) px, py = principal_point.unbind(1) if image_size is not None: if not torch.is_tensor(image_size): image_size = torch.tensor(image_size, device=device) imwidth, imheight = image_size.unbind(1) # make sure imwidth, imheight are valid (>0) if (imwidth < 1).any() or (imheight < 1).any(): raise ValueError( "Camera parameters provided in screen space. Image width or height invalid." ) half_imwidth = imwidth / 2.0 half_imheight = imheight / 2.0 fx = fx / half_imwidth fy = fy / half_imheight px = -(px - half_imwidth) / half_imwidth py = -(py - half_imheight) / half_imheight K = fx.new_zeros(N, 4, 4) K[:, 0, 0] = fx K[:, 1, 1] = fy if orthographic: K[:, 0, 3] = px K[:, 1, 3] = py K[:, 2, 2] = 1.0 K[:, 3, 3] = 1.0 else: K[:, 0, 2] = px K[:, 1, 2] = py K[:, 3, 2] = 1.0 K[:, 2, 3] = 1.0 return K

b741cb888038fcc71ceafd86b18a203682ca21d7

from typing import OrderedDict import json def load(infile): """Return a dictionary of settings from the given file.""" with open(infile, 'rb') as file: settings = OrderedDict(json.load(file)) return settings

a901df13bf70511617723e9cb2a65eaf24a14297

def str_to_regex(string): """Convert a string to a regex pattern with special treatment of an empty string.""" if string: return string return "a^" # This pattern should never match

6f7868d7a1b47d1e0a6b50cd6a53d0e398170af9

def is_subset_of_dicts(src_dict, dest_dict): """Check is all items of one dictionary 'src_dict' is subset of items of another dictionary 'dest_dict', where 'src_dict' should has same or less length then 'dest_dict'. Examples: ({"b": 2, "a": 1}, {"a": 1, "b": 2, "c": 4}) = True ({"a": 1, "b": 2, "c": 4}, {"b": 2, "a": 1}) = False """ return all(item in dest_dict.iteritems() for item in src_dict.iteritems())

993991d1322bf7da0ae0972aa454992f6f9e7ce6

import re def simple_preproc(text): """ replace digits with 0 and lowercase text """ return re.sub(r"\d", "0", text.lower())

d6e400ac50059c85976f5dc4ff3c62a2defc4f5e

def tile_to_quadkey(z, x, y): """Transform tile coordinates to a Bing quadkey. Slippy map tiles cache numeration starts from 0 level with one tile. On 1 level four tiles etc Bing uses quadkey tile coordinates, so minimal cache level is 1 (four tiles). Single tile at zero level not addressed. https://docs.microsoft.com/en-us/bingmaps/articles/bing-maps-tile-system https://github.com/buckhx/QuadKey/blob/master/quadkey/tile_system.py Examples -------- >>> tile_to_quadkey(1,0,0) '0' >>> tile_to_quadkey(4, 9, 5) '1203' >>> tile_to_quadkey(16, 38354, 20861) '1203010313232212' Paramaters ---------- :param int z: starts from zero :return: Quadkey string :rtype: str """ quadkey = "" for i in range(z): bit = z - i digit = ord('0') mask = 1 << (bit - 1) if (x & mask) != 0: digit += 1 if (y & mask) != 0: digit += 2 quadkey += chr(digit) return quadkey

d438360e986bdf317f2e8672a16ebbe40ce12d38

import click def format(text): """Format all OK,FAIL,PR,REPO words :param text: word :type text: string :raises Exception: Unknown text :return: formated click style text :rtype: string """ text = text.lower() if text == "ok": return click.style('OK', fg='green', bold=True) elif text == "fail": return click.style('FAIL', fg='red', bold=True) elif text == "pr": return click.style('PR', bold=True) elif text == "repo": return click.style('REPO', bold=True) else: raise Exception("Unkown text")

2ac991685f3b70615ba9ef253724f200f4c8e79e

import torch def sparse2tensor(sparse_data): """Convert sparse csr matrix to pytorch tensor.""" return torch.FloatTensor(sparse_data.toarray())

1688204cf6b2da4424c5c00dc4dae056c2625208

def tobin(deci_num, len=32): """ Given a decimal number, returns a string bitfield of length = len Example: given deci_num = 1 and len = 10, it return 0000000001 """ bitstr = "".join(map(lambda y: str((deci_num >> y) & 1), range(len - 1, -1, -1))) return bitstr

d505a3ad247e4c5508a97f71898617cfcfd8cca5

def format_byte(size: int, decimal_places: int = 3): """ Formats a given size and outputs a string equivalent to B, KB, MB, or GB """ if size < 1e03: return f"{round(size, decimal_places)} B" if size < 1e06: return f"{round(size / 1e3, decimal_places)} KB" if size < 1e09: return f"{round(size / 1e6, decimal_places)} MB" return f"{round(size / 1e9, decimal_places)} GB"

3265fe250e6e7b0ce4178356b4ff079a7a1609ef

def get_params_autogen(term): """Sets the parameters for the API call for the initial user-entered term""" params = { "action": "parse", "prop": "links", "page": term, "format": "json", } # Parameter set to query the Wikipedia page for a given term and retrieve up to 250 links to other articles - # namespace 0 - from that page in JSON format. return params

c5a49a114b153d129e9427db59c479c2b2341333

def inplace_buffer_merge(buffer, data, timesteps, model): """ Merges the new text from the current frame with the previous text contained in the buffer. The alignment is based on a Longest Common Subsequence algorithm, with some additional heuristics leveraging the notion that the chunk size is >= the context window. In case this assumptio is violated, the results of the merge will be incorrect (or at least obtain worse WER overall). """ # If delay timesteps is 0, that means no future context was used. Simply concatenate the buffer with new data. if timesteps < 1: buffer += data return buffer # If buffer is empty, simply concatenate the buffer and data. if len(buffer) == 0: buffer += data return buffer # Concat data to buffer buffer += data return buffer

f5ef530c5e9c1b0bc3bc3f92ac41d157ef834b4b

import decimal def convert_decimal_to_int(obj): """ Amazon DynamoDB returns numbers in Python Decimal format, which are converted to float by the JSON serializer. This function instead converts them to int. Pass this function to the `json.dumps` function for custom conversion. :param obj: The current object being deserialized. :return: When obj is a Decimal, return it as an int. """ if isinstance(obj, decimal.Decimal): return int(obj)

bf28e3538bbf0a95c5492492169dd4f5df43d9fd

def get_current_connections(session): """Retrieves open connections using the the given session""" # Use Show process list to count the open sesions. res = session.sql("SHOW PROCESSLIST").execute() rows = res.fetch_all() connections = {} for row in rows: if row.get_string('User') not in connections: connections[row.get_string('User')] = [row.get_string('Host')] else: connections[row.get_string('User')].append(row.get_string('Host')) return connections

13db61d46cff29c757316b5f577aa7f8df60eb82

def checkCriteria(criteria, failed = False): """ This function is an input exclusive function that returns a True or False """ if failed == False: # gathers the input from the user resp = input('Would you like ' + criteria + ' to be enabled: ').lower() # returns the necessary end result until specifications are met if resp == 'yes' or resp == 'y': return True elif resp == 'no' or resp == 'n': return False else: return checkCriteria(criteria, True) else: # gathers the input from the user resp = input('Please put only yes/y or no/n: ').lower() # returns the necessary end result until specifications are met if resp == 'yes' or resp == 'y': return True elif resp == 'no' or resp == 'n': return False else: return checkCriteria(criteria, True)

1bd22460796b6581a6a334977cd4dedaf2da80fa

def find_water_volume_blocked_in_towers(towers): """ Solution for finding water volume occupied in towers of different heights. Assumed that, width of tower is 1 unit. :param towers: list of tower heights :return: unit water occupied """ res = 0 n = len(towers) for_idx = 0 # traverse forward while (for_idx < n): j = for_idx + 1 sel_towers = [] while (j < n and towers[for_idx] >= towers[j]): sel_towers.append(towers[j]) j += 1 if j < n: for t_h in sel_towers: res += abs(towers[for_idx] - t_h) for_idx = j back_idx = n - 1 # traverse backward while(back_idx > -1): j = back_idx - 1 sel_towers = [] while (j > -1 and towers[back_idx] >= towers[j]): sel_towers.append(towers[j]) j -= 1 if j > -1: for t_h in sel_towers: res += abs(towers[back_idx] - t_h) back_idx = j return res

fbfdc0fe4745a9e7e163e0b7152d6a143147a7de

def strip_integer_in_string(name): """Strip interger from string""" i = 0 for i in range(len(name) - 1, - 1, -1): if not name[i].isdigit(): i += 1 break return name[0:i]

8cc8cf784dd231e40844d1087f0681ae53fe9af8

import torch def svm_loss(x, y): """ Computes the loss and gradient using for multiclass SVM classification. Inputs: - x: Input data, of shape (N, C) where x[i, j] is the score for the jth class for the ith input. - y: Vector of labels, of shape (N,) where y[i] is the label for x[i] and 0 <= y[i] < C Returns a tuple of: - loss: Scalar giving the loss - dx: Gradient of the loss with respect to x """ N = x.shape[0] correct_class_scores = x[torch.arange(N), y] margins = (x - correct_class_scores[:, None] + 1.0).clamp(min=0.) margins[torch.arange(N), y] = 0. loss = margins.sum() / N num_pos = (margins > 0).sum(dim=1) dx = torch.zeros_like(x) dx[margins > 0] = 1. dx[torch.arange(N), y] -= num_pos.to(dx.dtype) dx /= N return loss, dx

5f36dc353c4f6e26b7ae89e5996018ae0f5effb3

def count_sheeps(arrayOfSheeps: list) -> int: """ Consider an array of sheep where some sheep may be missing from their place. We need a function that counts the number of sheep present in the array (true means present). Hint: Don't forget to check for bad values like null/undefined :param arrayOfSheeps: :return: """ return 0 if arrayOfSheeps is None \ else arrayOfSheeps.count(True)

b229315fd9bcc6e7ec566d926d86893e9501b03a

import string def str_to_key(str1:str) -> str: """Convert a string to a string usable as a key""" # Remove any trailing white space str1 = str1.strip() # Add underscore if 1st character is a number if str1[0].isdigit(): str1 = '_' + str1 # Replace any non-letters with '_' _strings = [t if t in string.ascii_letters + string.digits else '_' for t in str1] ans = "".join(_strings) return ans

6bf67c7d8856126d34af9898ab0d29f34bd57b88

def get_params(model): """Retrieves list of all the named parameters in a model. Arguments: model::torch.nn.Module- Ideally the deep learning model, but can be a set of layers/layer too. Returns: param_list::list- List of all the named parameters in the model. """ return [(name, params) for name, params in model.named_parameters() if params.requires_grad]

0ed9b604e7215c82f813ee962018fee7c0d0b450

def get_os_data_from_box_title(box_title: str) -> tuple: """ Gets OS name and version from a properly formatted box title. Returns: (str, str): OS name, OS version """ # Split box title into [os name, os version] box_title_elements = box_title.split(" v") return box_title_elements[0], box_title_elements[1]

a103a4c5690d8a7c544741671a8e6221618bda94

def biopdbresid_to_pdbresseq(biopdb_residueid,ignore_insertion_codes=False): """ Give a Bio.PDB Residue id tupe (hetatm, resseqnum, icode), return the PDB residue sequence number string consisting of the sequence number and the insertion code, if not blank. Parameters: biopdb_residueid - tuple (hetatm, resseqnum, icode) from Residue.get_id() ignore_insertion_codes - If True, a hack to make it work with PMML (only) which does not report insertion codes unlike DSSP and STRIDE Return value: string residue PDB sequence number e.g. '60' or '60A'. """ # Residue.get_id() gives tuple (hetatm, resseqnum, icode) res_seq = str(biopdb_residueid[1]) if not ignore_insertion_codes: if biopdb_residueid[2] != ' ': res_seq += biopdb_residueid[2] return res_seq

4bb023feb7bbca24f514e041a657752f34d533e0