content
stringlengths
39
14.9k
sha1
stringlengths
40
40
id
int64
0
710k
def build_evaluation_from_config_item(configuration_item, compliance_type, annotation=None): """Form an evaluation as a dictionary. Usually suited to report on configuration change rules. Keyword arguments: configuration_item -- the configurationItem dictionary in the invokingEvent compliance_type -- either COMPLIANT, NON_COMPLIANT or NOT_APPLICABLE annotation -- an annotation to be added to the evaluation (default None) """ eval_ci = {} if annotation: eval_ci['Annotation'] = annotation eval_ci['ComplianceResourceType'] = configuration_item['resourceType'] eval_ci['ComplianceResourceId'] = configuration_item['resourceId'] eval_ci['ComplianceType'] = compliance_type eval_ci['OrderingTimestamp'] = configuration_item['configurationItemCaptureTime'] return eval_ci
05769fc549acdcec7ed611abeff5f0b4f695e57e
699,335
def splitbycharset(txt, charset): """Splits a string at the first occurrence of a character in a set. Args: txt: Text to split. chars: Chars to look for (specified as string). Returns: (char, before, after) where char is the character from the character set which has been found as first; before and after are the substrings before and after it. If none of the characters had been found in the text, char and after are set to the empty string and before to the entrire string. """ for firstpos, char in enumerate(txt): if char in charset: break else: return '', txt, '' return txt[firstpos], txt[:firstpos], txt[firstpos+1:]
c23577eb96c9621909acaa816e8791e95dbf493d
699,340
def process_meta_review(meta_review): """ Do something with the meta-review JSON! This is where you would: 1. Translate meta_review["ty_id"] to your own hotel ID, dropping any unmapped hotels 2. Traverse the JSON structure to find the data you are interested in, documented at http://api.trustyou.com/hotels/documentation.html 3. Store data in your own database, to run reports, or serve them to a live website Here, for demonstration purposes, we print a little custom summary sentence. """ ty_id = meta_review["ty_id"] trust_score = meta_review.get("summary", {}).get("score") badges = meta_review.get("badge_list", []) def strip_markup(text): """ Badge texts contain some formatting hints. Remove them for display on the terminal. """ return (text .replace("<strong class=\"label\">", "") .replace("</strong>", "") .replace("<span class=\"hotel-type\">", "") .replace("</span>", "") .replace("<strong>", "") ) badge_texts = list( strip_markup(badge["text"]) for badge in badges[1:] # skip the overall badge, which is always in first place ) sentence = "Hotel {ty_id} has a score of {trust_score}, and got awarded these badges: {badge_texts}".format( ty_id=ty_id, trust_score=trust_score, badge_texts=(", ".join(badge_texts) or "No badges!") ) print(sentence)
681ace9b9685f4bfd284ac6e41efde12bafbb1b9
699,341
def find_natural_number(position: int) -> tuple: """Return natural number at specified position and number its a part of.""" num_range = "" counter = 0 while len(str(num_range)) < position: counter += 1 num_range += str(counter) return int(num_range[-1]), counter
62aff0c400ac007fc67dafd25eb4cacf63262105
699,342
def camel_case(snake_case: str) -> str: """Converts snake case strings to camel case Args: snake_case (str): raw snake case string, eg `sample_text` Returns: str: camel cased string """ cpnts = snake_case.split("_") return cpnts[0] + "".join(x.title() for x in cpnts[1:])
b3080a3e3520209581cbd381ffaff24045343115
699,343
def identify_contentType(url): """ Given a URL for a content, it identifies the type of the content :param url(str): URL :returns: Type of the content """ extensions = ['mp3', 'wav', 'jpeg', 'zip', 'jpg', 'mp4', 'webm', 'ecar', 'wav', 'png'] if ('youtu.be' in url) or ('youtube' in url): return "youtube" elif url.endswith('pdf'): return "pdf" elif any(url.endswith(x) for x in extensions): return "ecml" else: return "unknown"
720a9ea9adaab547309f61b6858b0eb19ddebafe
699,349
def stack(x, filters, num_blocks, block_fn, use_bias, stride1=2, name=None): """A set of stacked residual blocks. Arguments: x: input tensor. filters: integer, filters of the bottleneck layer in a block. use_bias: boolean, enables or disables all biases in conv layers. num_blocks: integer, blocks in the stacked blocks. block_fn: a function of a block to stack. stride1: default 2, stride of the first layer in the first block. name: string, stack label. Returns: Output tensor for the stacked blocks. """ x = block_fn(x, filters, conv_shortcut=True, stride=stride1, use_bias=use_bias, name=f'{name}_block1') for i in range(2, num_blocks + 1): x = block_fn(x, filters, use_bias=use_bias, name=f'{name}_block{i}') return x
1ed366778a5abba4e05c070da05e3c87cbd92560
699,351
def pid_info(output_line): """ Take a line of 'ps -o pid,comm' output and return the PID number and name. The line looks something like: 9108 orterun or 10183 daos_server Need both items. Return a tuple (name, pid) Note: there could be leading spaces on the pid. """ info = output_line.lstrip().split() try: return info[1], info[0] except Exception as e: print("Unable to retrieve PID info from {}".format(output_line)) return "", None
479c51e562b7bbeb7e812fad4b2cb1f771e2e830
699,354
from typing import List from typing import Tuple def two_columns(pairs: List[Tuple]) -> str: """ Join pairs (or more) of strings to a string. :param pairs: List of tuples of strings :return: String separated by newlines """ return '\n'.join([' '.join(map(str, t)) for t in pairs])
810fdab52b4641c32f54c6adc772f8352b8f2ae6
699,357
def get_record_as_json(cur, tablename, row_id): """ Get a single record from the database, by id, as json. """ # IMPORTANT NOTE: Only use this function in trusted input. Never on data # being created by users. The table name is not escaped. q = """ SELECT row_to_json(new_with_table) FROM (SELECT {t}.*, '{t}' AS tablename FROM {t}) new_with_table WHERE id=%s;""".format( t=tablename, ) cur.execute(q, (row_id,)) return cur.fetchone()[0]
00521ae582a013f97b77494944e0f6e04069ed05
699,358
def segno(x): """ Input: x, a number Return: 1.0 if x>0, -1.0 if x<0, 0.0 if x==0 """ if x > 0.0: return 1.0 elif x < 0.0: return -1.0 elif x == 0.0: return 0.0
5caccfa037b2972755958f647f009660aefae59d
699,361
def speed_2_pace(speed): """Convert speed in km/hr to pace in s/km""" return 60*60/speed
25379049e98622ec5888461a9f6455be399d5f5a
699,364
from pathlib import Path def get_dictionaries(base: Path) -> list[tuple[str, list[Path]]]: """Make a list of available dictionaries and the interesting files. :param base: The Apple Dictionaries root directory. :return: A list of tuples of name, files for each dictionary. """ all_dicts = sorted( ( ( dic.stem, [ f for f in (dic / "Contents" / "Resources").iterdir() if f.suffix != ".lproj" ], ) for dic_path in Path(base).iterdir() if dic_path.is_dir() for dic in (dic_path / "AssetData").iterdir() ), key=lambda x: x[0], ) return [(name, files) for name, files in all_dicts if files]
98068ecb847aa6975cc8dc7eed59b8948316f191
699,366
def generate_recipient_from(nhais_cypher): """ Generates the recipient cypher. This value can be deduced from the nhais_cypher provided. The nhais cypher can be 2 to 3 characters is length. If it is 2 characters in length it will append "01" to generate the recipient cypher If it is 3 characters in length it will append "1" to generate the recipient cypher :param nhais_cypher: The nhais cypher provided. Should be 2-3 characters in length :return: The recipient cypher """ recipient = '' if len(nhais_cypher) == 3: recipient = nhais_cypher + '1' elif len(nhais_cypher) == 2: recipient = nhais_cypher + "01" return recipient
ac29a09f246fc38b43301cc1b00a4056fc49e203
699,367
def _convert_color(color): """Convert a 24-bit color to 16-bit. The input `color` is assumed to be a 3-component list [R,G,B], each with 8 bits for color level. This method will translate that list of colors into a 16-bit number, with first 5 bits indicating R component, last 5 bits indicating B component, and remaining 6 bits in the middle indicating G component. i.e., 16-bit color -> (5 bits, 6 bits, 5 bits) -> (R,G,B). """ for i in color: if i not in range(256): raise ValueError("Valid color value for R, G, B is 0 - 255.") red, green, blue = color return ((blue & 0xF8) << 8) | ((green & 0xFC) << 3) | ((red & 0xF8) >> 3)
6635e30d574288146c5ff07bf3d0d1661cd33b97
699,368
def list_get(lst, index, default=None): """ A safety mechanism for accessing uncharted indexes of a list. Always remember: safety first! :param lst: list :param index: int :param default: A default value :return: Value of list at index -or- default value """ assert type(lst) == list, "Requires a list type" return_value = default try: return_value = lst[index] except IndexError: pass return return_value
41ca83d6a9b0ba66858617b48dcb6c43ca5a6a54
699,371
def iterate_items(collection, *args, **kwargs): """ iterates over the items of given object. :param type collection: collection type to be used to iterate over given object's items. :rtype: iterator[tuple[object, object]] """ return iter(collection.items(*args, **kwargs))
49fde9f9c027ff1fc64a57ee67b06c91033f8755
699,372
from typing import Tuple def is_multi_class(output_shape: Tuple[int, ...]) -> bool: """Checks if output is multi-class.""" # If single value output if len(output_shape) == 1: return False return True
66726be66cce6f837b40287b75c547d28d709a74
699,374
def cradmin_instance_url(context, appname, viewname, *args, **kwargs): """ Template tag implementation of :meth:`cradmin_legacy.crinstance.BaseCrAdminInstance.reverse_url`. Examples: Reverse the view named ``"edit"`` within the app named ``"pages"``: .. code-block:: htmldjango {% load cradmin_legacy_tags %} <a href='{% cradmin_instance_url appname="pages" viewname="edit" %}'> Edit </a> Reverse a view with keyword arguments: .. code-block:: htmldjango {% load cradmin_legacy_tags %} <a href='{% cradmin_instance_url appname="pages" viewname="list" mode="advanced" orderby="name" %}'> Show advanced pages listing ordered by name </a> """ request = context['request'] return request.cradmin_instance.reverse_url( appname=appname, viewname=viewname, args=args, kwargs=kwargs)
9cea000ff75b68d536796cbcc323fef1b0a7059b
699,375
import torch def get_discretized_transformation_matrix(matrix, discrete_ratio, downsample_rate): """ Get disretized transformation matrix. Parameters ---------- matrix : torch.Tensor Shape -- (B, L, 4, 4) where B is the batch size, L is the max cav number. discrete_ratio : float Discrete ratio. downsample_rate : float/int downsample_rate Returns ------- matrix : torch.Tensor Output transformation matrix in 2D with shape (B, L, 2, 3), including 2D transformation and 2D rotation. """ matrix = matrix[:, :, [0, 1], :][:, :, :, [0, 1, 3]] # normalize the x,y transformation matrix[:, :, :, -1] = matrix[:, :, :, -1] \ / (discrete_ratio * downsample_rate) return matrix.type(dtype=torch.float)
fd6ab95dcbb6fca9cab6b35fd5e20998fc12472b
699,378
import yaml def represent_ordered_dict(dumper, data): """ Serializes ``OrderedDict`` to YAML by its proper order. Registering this function to ``yaml.SafeDumper`` enables using ``yaml.safe_dump`` with ``OrderedDict``s. """ return dumper.represent_mapping(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, data.items())
f8c83dd3b3ecf94077b7b465334ffa84df7e16a8
699,385
def get_dot_size(val, verbose=False): """ Get the size of the marker based on val :param val: the value to test :param verbose: more output :return: the size of the marker in pixels """ markersizes = [6, 9, 12, 15, 18] # there should be one less maxmakervals than markersizes and then we use markersizes[-1] for anything larger maxmarkervals = [10, 20, 30, 40] for i,m in enumerate(maxmarkervals): if val <= m: return markersizes[i] return markersizes[-1]
aa84c98a3cb78822dd02a9062f9f9a325907b310
699,387
import six def _tuplify_version(version): """ Coerces the version string (if not None), to a version tuple. Ex. "1.7.0" becomes (1, 7, 0). """ if version is None: return version if isinstance(version, six.string_types): version = tuple(int(x) for x in version.split(".")) assert len(version) <= 4, version assert (1, 3) <= version, version assert all(isinstance(x, six.integer_types) for x in version), version return version
97575c813ce585e7e928b129e67196dcece5db0a
699,388
from typing import Type from typing import Callable from typing import Any def is_type(tipe: Type) -> Callable[[Any], bool]: """ :param tipe: A Type :return: A predicate that checks if an object is an instance of that Type """ def predicate(value: Any) -> bool: """ :param value: An object :return: Whether the object is an instance of the exprected Type """ return isinstance(value, tipe) predicate.__name__ = f'_{is_type.__name__}_{tipe}' return predicate
2b4be636675216c810f9e14f70fe8a5647552e3f
699,394
def strip_constants(df, indices): """Remove columns from DF that are constant input factors. Parameters ---------- * df : DataFrame, of input parameters used in model run(s). * indices : list, of constant input factor index positions. Returns ---------- * copy of `df` modified to exclude constant factors """ df = df.copy() const_col_names = df.iloc[:, indices].columns df = df.loc[:, ~df.columns.isin(const_col_names)] return df
5a68d9beaa39cb2651ccd995af20d25165ccb03e
699,397
def input_details(interpreter, key): """Returns input details by specified key.""" return interpreter.get_input_details()[0][key]
b06bd5278fcc5d95da387cb506ac9b9f443d9f27
699,401
def format_date( date_obj ): # date_obj is a datetime.date object """Returns a formatted date string given a date object. If the day is the first of the month, then the day is dropped, eg: format_date ( datetime.date(2013, 04, 12)) returns 2013-04-12 format_date ( datetime.date(2013, 4, 1)) returns 2013-04 """ if date_obj.day == 1: full_date = date_obj.isoformat() return full_date[0:7] else: return date_obj.isoformat()
bfcddc9cbd4228084a0a4c5e6736be28a90d520e
699,404
from typing import Dict from typing import Any def _make_pod_podannotations() -> Dict[str, Any]: """Generate pod annotation. Returns: Dict[str, Any]: pod annotations. """ annot = { "annotations": { "k8s.v1.cni.cncf.io/networks": '[\n{\n"name" : "internet-network",' '\n"interface": "eth1",\n"ips": []\n}\n]' } } return annot
94ab8b66c5cf63546f15cb8fef6e1fbc4aa3cb49
699,406
def merge_result(docker_list: dict, result_dict: dict = {}, max_entries_per_docker: int = 5) -> dict: """Returns a python dict of the merge result Args: :type docker_list: ``dict`` :param docker_list: dictionary representation for the docker image used by integration or script :type result_dict: ``dict`` :param result_dict: dictionary representation for the docker image and the integration/scripts belongs to it merge the current result to it :type max_entries_per_docker: ``int`` :param max_entries_per_docker: max number of integration or script to show per docker image entry Returns: :return: dict as {'docker_image':['integration/scripts', 'integration/scripts',...]} :rtype: dict """ result = result_dict or {} for integration_script, docker_image in docker_list.items(): if integration_script in ['CommonServerUserPowerShell', 'CommonServerUserPython']: continue if docker_image in result: if len(result[docker_image]) < max_entries_per_docker: result[docker_image].append(integration_script) else: result[docker_image] = [integration_script] return result
7cfd2708e15eb65c09e32cf0c08a360f780aacb8
699,408
def _major_minor(version): """Given a string of the form ``X.Y.Z``, returns ``X.Y``.""" return ".".join(version.split(".")[:2])
8ca52bd0324bb0445ab3c5b9b44124c0f627f635
699,412
def is_lock_valid(transfer, block_number): """ True if the lock has not expired. """ return block_number <= transfer.expiration
186c48c8a81458a9ff25891f5afa380f07dcbede
699,413
def set_overlay(background, overlay, pos=(0,0)): """ Function to overlay a transparent image on background. :param background: input color background image :param overlay: input transparent image (BGRA) :param pos: position where the image to be set. :return: result image """ h,w,_ = overlay.shape rows,cols,_ = background.shape y,x = pos[0],pos[1] for i in range(h): for j in range(w): if x+i >= rows or y+j >= cols: continue alpha = float(overlay[i][j][3]/255.0) background[x+i][y+j] = alpha*overlay[i][j][:3]+(1-alpha)*background[x+i][y+j] return background
ae9b8be9193e04ede7649ff9cab2ad4a94c4876a
699,415
def format_line(entries, sep=' | ', pads=None, center=False): """ Format data for use in a simple table output to text. args: entries: List of data to put in table, left to right. sep: String to separate data with. pad: List of numbers, pad each entry as you go with this number. center: Center the entry, otherwise left aligned. """ line = '' align = '^' if center else '' if pads: pads = [align + str(pad) for pad in pads] else: pads = [align for ent in entries] ents = [] for ind, ent in enumerate(entries): fmt = '{:%s}' % pads[ind] ents += [fmt.format(str(ent))] line = sep.join(ents) return line.rstrip()
c5dfd312f8f13a54943fe18e254a6d8836d4460a
699,417
def int_or_none(x): """ A helper to allow filtering by an integer value or None. """ if x.lower() in ("null", "none", ""): return None return int(x)
f7a99fd637b5f5e2f4519034b36d03128279726c
699,423
import platform def supports_posix() -> bool: """Check if the current machine supports basic posix. Returns: bool: True if the current machine is MacOSX or Linux. """ return platform.system().lower() in ( "darwin", "linux", )
527bb8570e0493deec01aadafdf929e7315b27c0
699,426
import torch def compute_reconstruction_error(vae, data_loader, **kwargs): """ Computes log p(x/z), which is the reconstruction error. Differs from the marginal log likelihood, but still gives good insights on the modeling of the data, and is fast to compute. """ # Iterate once over the data and computes the reconstruction error log_lkl = {} for tensors in data_loader: loss_kwargs = dict(kl_weight=1) _, _, losses = vae(tensors, loss_kwargs=loss_kwargs) for key, value in losses._reconstruction_loss.items(): if key in log_lkl: log_lkl[key] += torch.sum(value).item() else: log_lkl[key] = 0.0 n_samples = len(data_loader.indices) for key, value in log_lkl.items(): log_lkl[key] = log_lkl[key] / n_samples log_lkl[key] = -log_lkl[key] return log_lkl
ee4fa35002e0f43d6482ae7f9ccfc7b7b1282db7
699,427
def _whbtms(anchor): """Return width, height, x bottom, and y bottom for an anchor (window).""" w = anchor[2] - anchor[0] + 1 h = anchor[3] - anchor[1] + 1 x_btm = anchor[0] + 0.5 * (w - 1) y_btm = anchor[1] + 1.0 * (h - 1) return w, h, x_btm, y_btm
0b4d65ad8a9dca2753ee703ad47764a1cb88f50e
699,428
def _compute_land_only_mask(ds, lsm_min=0.8): """Computes a mask for cells that are considered to be over the land. The lsm fraction is above lsm_min. Here, lsm is the land-sea mask as a fraction (0 is all water, 1 is all land).""" da_mask = ds.lsm > lsm_min da_mask.attrs[ "long_name" ] = f"Land only (land-sea mask > {lsm_min} [{ds.lsm.units}])" return da_mask
23b682a216031abac3e90989d130f7b3de9abf7c
699,432
def check_datasets(datasets): """Check that datasets is a list of (X,y) pairs or a dictionary of dataset-name:(X,y) pairs.""" try: datasets_names = [dataset_name for dataset_name, _ in datasets] are_all_strings = all([isinstance(dataset_name, str) for dataset_name in datasets_names]) are_unique = len(list(datasets_names)) == len(set(datasets_names)) if are_all_strings and are_unique: return datasets else: raise ValueError("The datasets' names should be unique strings.") except: raise ValueError("The datasets should be a list of (dataset name:(X,y)) pairs.")
e02771dd7d2df3d9e716141ba2ada92408a2b14e
699,433
import requests import json def get_card_updated_data(scryfall_id) -> str: """Gets updated data from scryfall Args: scryfall_id ([type]): [description] Returns: json: result from scryfalls card api ref: https://scryfall.com/docs/api/cards/id ex scryfall_id="e9d5aee0-5963-41db-a22b-cfea40a967a3" """ r = requests.get( f"https://api.scryfall.com/cards/{scryfall_id}", ) if r.status_code == 200: return json.loads(r.text) raise Exception("Could not download os save card image")
2a0f1a9c65cbe7e173543e8a3d4b03fd364e2ae6
699,435
def get_candidate_file_name( monotonous: bool, agg_point: bool, both: bool = False, ) -> str: """Get canonical filename for candidate set sizes.""" if both: return f"candidate_sizes{'_mono' if monotonous else ''}_k_point" else: return f"candidate_sizes{'_mono' if monotonous else ''}_{'_point' if agg_point else '_k'}"
85b27f7767fd495a46459553b96160691a3dbeda
699,438
def square_of_sum(limit): """ Returns the square of the sum of all integers in the range 1 up to and including limit. """ return sum([i for i in range(limit + 1)]) ** 2
503048c7b175d10dce20ff9d2f9435be4fbe1c35
699,439
import re def is_valid_regex(regex): """Helper function to determine whether the provided regex is valid. Args: regex (str): The user provided regex. Returns: bool: Indicates whether the provided regex was valid or not. """ try: re.compile(regex) return True except (re.error, TypeError): return False
4c544168f2b1894e7cc7c7804342f923287022b5
699,441
def normalize_medical_kind(shape, properties, fid, zoom): """ Many medical practices, such as doctors and dentists, have a speciality, which is indicated through the `healthcare:speciality` tag. This is a semi-colon delimited list, so we expand it to an actual list. """ kind = properties.get('kind') if kind in ['clinic', 'doctors', 'dentist']: tags = properties.get('tags', {}) if tags: speciality = tags.get('healthcare:speciality') if speciality: properties['speciality'] = speciality.split(';') return (shape, properties, fid)
dbf75799624cbe119c4c3a74c8814d0a979d828e
699,443
def _get_tws(sel_cim_data): """Return terrestrial water storage.""" return sel_cim_data.TWS_tavg
2b8405a245d39466ef2b47463d88518cc3b5bedf
699,444
def merge_arrays(*lsts: list): """Merges all arrays into one flat list. Examples: >>> lst_abc = ['a','b','c']\n >>> lst_123 = [1,2,3]\n >>> lst_names = ['John','Alice','Bob']\n >>> merge_arrays(lst_abc,lst_123,lst_names)\n ['a', 'b', 'c', 1, 2, 3, 'John', 'Alice', 'Bob'] """ merged_list = [] [merged_list.extend(e) for e in lsts] return merged_list
f2dd78a9e2d31347d72e1e904c0f2c6e30b37431
699,449
def is_within_range(num, lower_bound: int, upper_bound: int) -> bool: """ check if a number is within a range bounded by upper and lower bound :param num: target number needs to be checked against :param lower_bound: exclusive lower bound :param upper_bound: exclusive upper bound :return: True if number is within this range, False otherwise """ num = int(num) if upper_bound < lower_bound: raise ValueError("bounds are incorrect") return lower_bound < num < upper_bound
325f4084a88254ec2f29dd28749b8709de394078
699,452
from typing import Optional from typing import Tuple def _shape_param_to_id_str(shape_param: Optional[Tuple[Optional[int], ...]]) -> str: """Convert kernel input shape parameter used in `test_call.py` and `conftest.py` into a human readable representation which is used in the pytest parameter id.""" if shape_param is None: return "None" shape_strs = tuple("indim" if dim is None else str(dim) for dim in shape_param) if len(shape_strs) == 1: return f"({shape_strs[0]},)" return f"({', '.join(shape_strs)})"
ba73efa0693217a32ba42754af36204631c4200d
699,453
def getbox(xcenter, ycenter, size=500): """ A function to compute coordinates of a bounding box. Arguments: - xcenter: int, x position of the center of the box. - ycenter: int, y position of the center of the box. - size: int, size of the side of the box. Returns: - box: list of tuple of int, (x, y) coordinates of the sides of the box. """ xo = xcenter - int(size / 2) yo = ycenter - int(size / 2) xe = xcenter + int(size / 2) ye = ycenter + int(size / 2) horizonhaut = [(x, yo) for x in range(xo, xe)] horizonbas = [(x, ye) for x in range(xo, xe)] verticalgauche = [(xo, y) for y in range(yo, ye)] verticaldroite = [(xe, y) for y in range(yo, ye)] box = horizonbas + horizonhaut + verticaldroite + verticalgauche return box
6e8030f113a13775365fcd715be46690849154f3
699,460
from typing import List def get_entity_attributes(entity: dict) -> List[str]: """Get a list with the attributes of the entity. Args: entity(:obj:`dict`): entity. Returns: list: containing the attributes. """ keys = entity.keys() not_attributes = ["id", "type"] attributes = [attr for attr in keys if attr not in not_attributes] return attributes
a5482a679ff5060d2deb26d7af6f4dc7fe394bf5
699,461
def fahrenheitToRankie(fahrenheit:float, ndigits = 2)->float: """ Convert a given value from Fahrenheit to Rankine and round it to 2 decimal places. Wikipedia reference: https://en.wikipedia.org/wiki/Fahrenheit Wikipedia reference: https://en.wikipedia.org/wiki/Rankine_scale """ return round(float(fahrenheit)+ 459.7, ndigits)
feea06edfbc800fbb4da6a3a128b2a89f07966ed
699,462
def connect(H, G, Gout=None, Hin=None): """ Connect outputs Gout of G to inputs Hin of H. The outputs and inputs of the connected system are arranged as follows: - remaining outputs of G get lower, the outputs of H the higher indices - inputs of G get the lower, remaining inputs of H the higher indices connect(H, G) is equivalent to H * G. """ if issubclass(type(H), type(G)): try: connection = H.__connect__(G, Gout, Hin) except AttributeError: connection = G.__rconnect__(H, Gout, Hin) else: try: connection = G.__rconnect__(H, Gout, Hin) except AttributeError: connection = H.__connect__(G, Gout, Hin) return(connection)
c5a6bbf86ec9da5daf006a5e1dc3de1f8140e45f
699,463
def factorial(x): """Return the factorial of a given number.""" if x == 1: return 1 else: return factorial(x-1) * x
a1c3adacf122c1bec57bbbfd246f07bf627febcd
699,465
from pathlib import Path def is_file_suffix(filename, suffixes, check_exist=True): """ is_file + check for suffix :param filename: pathlike object :param suffixes: tuple of possible suffixes :param check_exist: whether to check the file's existence :return: bool """ if check_exist and not Path(filename).is_file(): return False return str(filename).endswith(suffixes)
e1e81eb0c39c991586097882c728535829acf415
699,467
import shutil def cmd_exists(cmd): """Returns True if a binary exists on the system path""" return shutil.which(cmd) is not None
0d43181532b9b71cb06b6a5d1f207bbb19899129
699,468
import requests def get_swapi_resource(url, params=None): """This function initiates an HTTP GET request to the SWAPI service in order to return a representation of a resource. The function defines two parameters, the resource url (str) and an optional params (dict) query string of key:value pairs may be provided as search terms (e.g., {'search': 'yoda'}). If a match is obtained from a search, be aware that the JSON object that is returned will include a list property named 'results' that contains the resource(s) matched by the search query term(s). Parameters: resource (str): a url that specifies the resource. params (dict): optional dictionary of querystring arguments. This parameter should have a default value of None. Returns: dict: dictionary representation of the decoded JSON. """ if params: response = requests.get(url, params=params).json() else: response = requests.get(url).json() return response
3a5de57fc498da1e25de4f2b3e61cae8508ad7c7
699,469
def assertify(text): """Wraps text in the (assert ).""" return '(assert ' + text + ')'
da7af0fe5d27759d8cef4589843796bee8e74383
699,470
def bubble_sort(items): """Sort given items by swapping adjacent items that are out of order, and repeating until all items are in sorted order. Running time: O(n**2) because it passes through n/2 (on average) elements n-1 times, which simplifies to n elements n times, n**2 Memory usage: O(1), as only a boolean and two integers are declared """ # Take up to n-1 passes for j in range(len(items) - 1): # Bool for checking if items were swapped swapped = False # Last item after each pass is always sorted and can be ignored for i in range(len(items) - 1 - j): # Swap items if the current is greater than the next if items[i] > items[i + 1]: items[i], items[i + 1] = items[i + 1], items[i] swapped = True # If there were no swaps, list is already sorted if not swapped: return items return items
88748e0d552f0d08e228049f12268e34aed4907b
699,473
def human_list(_list) -> str: """Convert a list of items into 'a, b or c'""" last_item = _list.pop() result = ", ".join(_list) return "%s or %s" % (result, last_item)
04ee703d1878ac7602ba33aaf1831ccc188ee9e2
699,474
def ccall_except_check(x): """ >>> ccall_except_check(41) 42 >>> ccall_except_check(-2) -1 >>> ccall_except_check(0) Traceback (most recent call last): ValueError """ if x == 0: raise ValueError return x+1
f4a877f63a189b39fea477af218438de2e6c2a78
699,479
def input_prompt(prompt): """ Get user input :param prompt: the prompt to display to the user """ return input(prompt)
b780278c37f048d1ea61f36af0947b683c5f9b9c
699,481
def safeintorbignumber(value): """safely converts value to integer or 10M""" try: return int(value) except ValueError: return 10000000
de665dc11ba27c6846412b706cf833e46dc26758
699,482
def isNumber(s): """ Tests whether an input is a number Parameters ---------- s : string or a number Any string or number which needs to be type-checked as a number Returns ------- isNum : Bool Returns True if 's' can be converted to a float Returns False if converting 's' results in an error Examples -------- >>> isNum = isNumber('5') >>> isNum True >>> isNum = isNumber('s') >>> isNum False """ try: float(s) return True except ValueError: return False
bd1bae27814ddca22c39d6411df3581e8116c324
699,484
def read_epi_params(item_basename): """Read all the necessary EPI parameters from text files with the given basename. Args: item_basename (str): The basename for all the files we need to read. In particular the following files should exist: - basename + '.read_out_time.txt' (with the read out time) - basename + '.phase_enc_dir.txt' (with the phase encode direction, like AP, PA, LR, RL, SI, IS, ...) Returns: dict: A dictionary for use in the nipype workflow 'all_peb_pipeline'. It contains the keys: - read_out_time (the read out time of the scan in seconds) - enc_dir (the phase encode direction, converted to nipype standards (x, -x, y, -y, ...)) """ with open(item_basename + '.read_out_times.txt', 'r') as f: read_out_time = float(f.read()) with open(item_basename + '.phase_enc_dir.txt', 'r') as f: phase_encoding = f.read() phase_enc_dirs_translate = {'AP': 'y-', 'PA': 'y', 'LR': 'x-', 'RL': 'x', 'SD': 'x-', 'DS': 'x', 'SI': 'z-', 'IS': 'z', 'HF': 'z-', 'FH': 'z'} return {'read_out_time': read_out_time, 'enc_dir': phase_enc_dirs_translate[phase_encoding]}
3af788073607df214c447f2b87606b2d3e1638fd
699,487
def filled_int(val, length): """ Takes a value and returns a zero padded representation of the integer component. :param val: The original value. :param length: Minimum length of the returned string :return: Zero-padded integer representation (if possible) of string. Original string used if integer conversion fails """ try: converted_val = int(val) except ValueError: converted_val = val return str(converted_val).zfill(length)
55da47570ab03c5964f3af167bb8a4f27656a660
699,488
import pickle def _load_batch(fpath, label_key='labels'): """Internal utility for parsing CIFAR data. Arguments: fpath: path the file to parse. label_key: key for label data in the retrieve dictionary. Returns: A tuple `(data, labels)`. """ with open(fpath, 'rb') as f: d = pickle.load(f, encoding='bytes') # decode utf8 d_decoded = {} for k, v in d.items(): d_decoded[k.decode('utf8')] = v d = d_decoded data = d['data'] labels = d[label_key] data = data.reshape(data.shape[0], 3, 32, 32) return data, labels
4311566594ac6f0f6c9573bdb3ccf162205991ae
699,491
def velocity(estimate, actual, times=60): """Calculate velocity. >>> velocity(2, 160, times=60) 0.75 >>> velocity(3, 160, times=60) 1.125 >>> velocity(3, 160, times=80) 1.5 """ return (estimate*times)/(actual*1.)
ffdb12c7aea05f9fc8aa9e354e8db2320cbf431a
699,496
from pathlib import Path def _node_does_not_exist(node_path): """ Determine whether module already exists for node :param node_path: full path to node module :return: bool; True if node does not exist; False if it does exist """ try: # noinspection PyArgumentList Path(node_path).resolve() except FileNotFoundError: return True else: return False
242f9895cb6e7ef4441b6d76b013cbdc88f8de45
699,499
def indent(s, depth): # type: (str, int) -> str """ Indent a string of text with *depth* additional spaces on each line. """ spaces = " "*depth interline_separator = "\n" + spaces return spaces + interline_separator.join(s.split("\n"))
69d509761cc6ab2f861f8b8c7fe7097ce8deff13
699,502
def prior_transform(u): """Flat prior between -10. and 10.""" return 10. * (2. * u - 1.)
4dd488a76a08361f1c7d833eaef96a7dfdf51ca6
699,503
def ensure_components(model_tracer_list): """If a CO2 flavor is detected for a model, ensure all flavors are present.""" co2_components = {'CO2', 'CO2_OCN', 'CO2_LND', 'CO2_FFF'} models = set(m for m, t in model_tracer_list) new_list = [] for model in models: m_tracers = set(t for m, t in model_tracer_list if m == model) if m_tracers.intersection({'CO2_LND+CO2_FFF'}): new_list.extend((model, t) for t in co2_components.union(m_tracers)) else: new_list.extend([(model, t) for t in m_tracers]) return new_list
8cb7f4e14f51718c8db75779ea02f6a73917323d
699,506
def subtraction(a, b): """subtraction: subtracts b from a, return result c""" a = float(a) b = float(b) c = b - a return c
0115222efc08588a12a6fbc1965441b83a7eaff0
699,510
import time def sec_to_datetime(timestamp): """ Convert secondes since epoch to a date and time """ return time.strftime("%d/%m/%Y %H:%M:%S %Z", time.localtime(timestamp))
e1e72e2e9e34259fcf2e2d3fcd6a6598dc77e3ae
699,511
def contains_failure(lines): """Check if any line starts with 'FAILED'.""" for line in lines: if line.startswith('FAILED'): return True return False
c3a74373f351a946e7d8f9d9497c8ee9af32282e
699,512
def Jaccard3d(a, b): """ This will compute the Jaccard Similarity coefficient for two 3-dimensional volumes Volumes are expected to be of the same size. We are expecting binary masks - 0's are treated as background and anything else is counted as data Arguments: a {Numpy array} -- 3D array with first volume b {Numpy array} -- 3D array with second volume Returns: float """ if len(a.shape) != 3 or len(b.shape) != 3: raise Exception(f"Expecting 3 dimensional inputs, got {a.shape} and {b.shape}") if a.shape != b.shape: raise Exception(f"Expecting inputs of the same shape, got {a.shape} and {b.shape}") ba = (a > 0).astype(int) bb = (b > 0).astype(int) n = (ba + bb == 2).sum() magna = ba.sum() magnb = bb.sum() return (n / (magna + magnb - n))
0c5e7be04f596736ab0184b2799708350691c240
699,516
def imputation(matrix, nan_filling): """ takes in matrix dataframe and value for filling in NaNs for imputation Parameters: matrix dataframe, NaN filling value Returns: imputed matrix dataframe """ matrix.fillna(nan_filling, inplace=True) return matrix
a6981e54f6228e9ebfcbb6ea65e5305f50a327ca
699,521
import pkg_resources def is_version_greater_equal(version1, version2): """Returns True if version1 is greater or equal than version2 else False""" return (pkg_resources.parse_version(version1) >= pkg_resources.parse_version(version2))
0618f18c22121d954ae156af7bb6eff80236ae29
699,524
def get_config(config, group): """Return the tuple of song_data, log_data and output_data paths. Arguments: config -- ConfigParser object used to extract data values group -- Top-level grouping of config values (AWS or LOCAL)""" group = group.upper() return config[group]['SONG_DATA'], config[group]['LOG_DATA'], config[group]['OUTPUT_DATA']
62af332b29e0a901c14143bd8b77834229ce0013
699,525
import asyncio def run_coro(coro): """Runs a co-routing in the default event loop and retuns it result.""" return asyncio.get_event_loop().run_until_complete(coro)
62f109ef4440ecb2807640ff91b27f07e91d8f9f
699,530
def buildaff(ulx: float, uly: float, pixelres: float) -> tuple: """ Build a gdal GeoTransform tuple Args: ulx: projected geo-spatial upper-left x reference coord uly: projected geo-spatial upper-left y reference coord pixelres: pixel resolution Returns: affine tuple """ return ulx, pixelres, 0, uly, 0, -pixelres
43e593050a6b3ebef876f4347d3df787e2a49795
699,534
def parse_search_result_data(api_response): """ Parse the search result data from the given raw json by following the response style of tokopedia Arg: - api_response (list): list of products Returns: - product_list (list): list of compiled product properties """ product_list = [] for resp in api_response: product_results = resp.get('data').get('ace_search_product_v4').get('data').get('products') # Standard tokopedia response style for product in product_results: product_dict = dict( product_name=product.get('name'), product_image_link=product.get('imageUrl'), product_price=product.get('price'), product_rating=product.get('rating'), product_average_rating=product.get('ratingAverage'), product_merchant=product.get('shop').get('name'), product_target_url=product.get('url') # Going to be used to crawl further into the product page itself, to extract description ) product_list.append(product_dict) return product_list
ee1314589e1599f2d4a58523077abc8a7f270f88
699,535
import re def parse_show_spanning_tree_mst_config(raw_result): """ Parse the 'show spanning-tree mst-config' command raw output. :param str raw_result: vtysh raw result string. :rtype: dict :return: The parsed result of the show spanning-tree \ mst-config command in a dictionary of the form: :: { 'mst_config_id': '70:72:cf:d9:2c:f6', 'mst_config_revision': '8' 'no_instances': '2', 'instance_vlan': {'1': ['1','2'], '2': ['3','4']} } """ mst_conf_re = ( r'\s*MST\s*config\s*ID\s*:\s*(?P<mst_config_id>[^ ]+)\s*\n' r'\s*MST\s*config\s*revision\s*:' r'\s*(?P<mst_config_revision>[0-9]+)\s*\n' r'\s*MST\s*config\s*digest\s*:\s*(?P<mst_digest>[^ ]+)\s*\n' r'\s*Number\s*of\s*instances\s*:\s*(?P<no_instances>[0-9]+)\s*\n' ) instance_re = ( r'(?P<instance>^[0-9]+)\s*(?P<vlan>.+)\s*' ) error = [ r'No\s*record\s*found\.', r'\s*Spanning-tree\s*is\s*disabled' ] instance = {} result = {} for error_str in error: re_result = re.search(error_str, raw_result) if (re_result): result['error'] = str(raw_result) return result re_result = re.search(mst_conf_re, raw_result) assert re_result result = re_result.groupdict() for line in raw_result.splitlines(): re_result = re.search(instance_re, line) if re_result: partial = re_result.groupdict() instance[partial['instance']] = partial['vlan'].split(',') result['instance_vlan'] = instance return result
2f07e13ff7f79e4c15e0fe5111cbc18fb638dae8
699,538
def read_sql_file(filename, encoding='utf-8') -> str: """Read SQL file, remove comments, and return a list of sql statements as a string""" with open(filename, encoding=encoding) as f: file = f.read() statements = file.split('\n') return '\n'.join(filter(lambda line: not line.startswith('--'), statements))
bd29c1080b2fd95d690b4696bf63c92932616964
699,540
def scenegraphLocationString(dataPacket): """ Given a datapacket, return a string representing its location in the scenegraph. (::UUID:OUTPUT) """ return "::"+str(dataPacket.sourceNode.uuid)+":"+dataPacket.sourceOutputName
027a69984acac4454e27a149ad822864751a0983
699,541
def get_directive_type(directive): """Given a dict containing a directive, return the directive type Directives have the form {'<directive type>' : <dict of stuff>} Example: {'#requirement': {...}} --> '#requirement' """ keys = list(directive.keys()) if len(keys) != 1: raise ValueError('Expected directive dict to contain a single key: {}'.format(directive)) return keys[0]
584c1f22fc120815e79c781fc7ace69940c0f651
699,544
def u8(x: int) -> bytes: """ Encode an 8-bit unsigned integer. """ assert 0 <= x < 256 return x.to_bytes(1, byteorder='little')
c23bb4b6ea6bb610da5c3ecd281129e0bcc40bb7
699,547
def evaluate_poly(poly, x): """ Computes the polynomial function for a given value x. Returns that value. Example: >>> poly = (0.0, 0.0, 5.0, 9.3, 7.0) # f(x) = 7x^4 + 9.3x^3 + 5x^2 >>> x = -13 >>> print evaluate_poly(poly, x) # f(-13) = 7(-13)^4 + 9.3(-13)^3 + 5(-13)^2 180339.9 poly: tuple of numbers, length > 0 x: number returns: float """ eval_of_poly = 0.0 for idx, val in enumerate(poly): eval_of_poly += (val * (x ** idx)) return eval_of_poly
2705dbdaa937c564454078dc2cbc8dd4a9bd56e8
699,551
def split(string_to_split, separator): """Returns the list of strings divided by the separator.""" return string_to_split.split(separator)
c96d4ed6e3128617925c7d52c19d607cbfe1ece1
699,554
def _find_biggest_value(list): """ Get the intex of the largest value in list of values :return: -1 if list empty, otherwise index of biggest value """ if len(list) < 1: return -1 max = 0 for idx, val in enumerate(list): if val > list[max]: max = idx return max
e4c4267ac2bfe73ad3bdb11433935805f4859e95
699,555
def inline(s, fmt): """Wrap string with inline escape""" return "`\u200B{}\u200B`".format(fmt.format(s))
3f07a4f55e60c763a10956c9ac52314b6958eca8
699,557
def _compute_cultural_score_building(building_geometry, historical_elements_gdf, historical_elements_gdf_sindex, score = None): """ Compute pragmatic for a single building. It supports the function "pragmatic_meaning" Parameters ---------- buildings_geometry: Polygon building_land_use: string historical_elements_gdf_sindex: Rtree spatial index score: string Returns ------- float """ possible_matches_index = list(historical_elements_gdf_sindex.intersection(building_geometry.bounds)) # looking for possible candidates in the external GDF possible_matches = historical_elements_gdf.iloc[possible_matches_index] pm = possible_matches[possible_matches.intersects(building_geometry)] if (score is None): cs = len(pm) # score only based on number of intersecting elements elif len(pm) == 0: cs = 0 else: cs = pm[score].sum() # otherwise sum the scores of the intersecting elements return cs
743be39a3c100f53787df8195298c43affac8b4d
699,561
import requests def get_json_from_url(url): """Retrieve JSON from a URL, raising on failure.""" response = requests.get(url) response.raise_for_status() return response.json()
c88b36ff6d4911aaa6d4115b5c054fbab2f3051f
699,568
def is_param(arg): """Returns whether the passed argument is a list or dictionary of params.""" return isinstance(arg, tuple) and arg[0] == "params"
bedb4745f8fc7095e235be588ad53c28db9fb4d8
699,569
def evaluate_numeric_condition(target, reveal_response): """ Tests whether the reveal_response contains a numeric condition. If so, it will evaluate the numeric condition and return the results of that comparison. :param target: the questions value being tested against :param reveal_response: the numeric condition that will be evaluated against :return: boolean result of numeric condition evaluation or None if there is no numeric condition to evaluate. """ if target == '': # cannot evaluate if answer is blank return None if reveal_response.startswith('>='): return float(target) >= float(reveal_response[2:]) elif reveal_response.startswith('<='): return float(target) <= float(reveal_response[2:]) elif reveal_response.startswith('=='): return float(target) == float(reveal_response[2:]) elif reveal_response.startswith('<'): return float(target) < float(reveal_response[1:]) elif reveal_response.startswith('>'): return float(target) > float(reveal_response[1:]) return None
1eeb170635e5fb0ac5fd379af885a7a0222fb722
699,570
import hashlib def checksum(filepath, hcnstrctr=hashlib.md5, enc="utf-8"): """Compute the checksum of given file, `filepath` :raises: OSError, IOError """ return hcnstrctr(open(filepath).read().encode(enc)).hexdigest()
a0a6c576ef9f22de106834088f69cbbc2b3c4bd0
699,573
def increment(x): """increments input by one""" return x+1
416451d93765ee148de9b69bd3e1af0e846d6fb5
699,575
def flatten(list_like, recursive=True): """ Flattens a list-like datastructure (returning a new list). """ retval = [] for element in list_like: if isinstance(element, list): if recursive: retval += flatten(element, recursive=True) else: retval += element else: retval.append(element) return retval
ad343decfa9e8ae949af303fc3f1a52179464009
699,579
def intents_to_string(intents, queryset=False): """ Args: intents: [{"action": "/application/json/view"}, ...] OR [models.Intent] (if queryset=True) Returns: ['<intent.action', ...] """ if queryset: new_intents = [i.action for i in intents] else: new_intents = [i['action'] for i in intents] return str(sorted(new_intents))
55e9350d2db63de474f46836e02ae32297e2c170
699,581
import re def greek_to_english(string): """ Converts all greek letters to the corresponding english letters. Useful for creating song slugs from greek song titles. """ GREEK_MAP = { 'α':'a', 'β':'b', 'γ':'g', 'δ':'d', 'ε':'e', 'ζ':'z', 'η':'h', 'θ':'th', 'ι':'i', 'κ':'k', 'λ':'l', 'μ':'m', 'ν':'n', 'ξ':'ks', 'ο':'o', 'π':'p', 'ρ':'r', 'σ':'s', 'τ':'t', 'υ':'y', 'φ':'f', 'χ':'x', 'ψ':'ps', 'ω':'w', 'ά':'a', 'έ':'e', 'ί':'i', 'ό':'o', 'ύ':'y', 'ή':'h', 'ώ':'w', 'ς':'s', 'ϊ':'i', 'ΰ':'y', 'ϋ':'y', 'ΐ':'i', 'Α':'A', 'Β':'B', 'Γ':'G', 'Δ':'D', 'Ε':'E', 'Ζ':'Z', 'Η':'H', 'Θ':'Th', 'Ι':'I', 'Κ':'K', 'Λ':'L', 'Μ':'M', 'Ν':'N', 'Ξ':'Ks', 'Ο':'O', 'Π':'P', 'Ρ':'R', 'Σ':'S', 'Τ':'T', 'Υ':'Y', 'Φ':'F', 'Χ':'X', 'Ψ':'Ps', 'Ω':'W', 'Ά':'A', 'Έ':'E', 'Ί':'I', 'Ό':'O', 'Ύ':'Y', 'Ή':'H', 'Ώ':'W', 'Ϊ':'I', 'Ϋ':'Y' } s = "".join(GREEK_MAP.keys()) result = '' for piece in re.compile('[%s]|[^%s]+' % (s,s)).findall(string): if piece in GREEK_MAP: result += GREEK_MAP[piece] else: result += piece return result.replace('oy', 'ou').replace('OY', 'OU').replace('Oy', 'Ou')
5c4752b1a1d08b0b37acc3f0e0c884d775eae637
699,582
def anum(self, num="", type_="", xhot="", yhot="", **kwargs): """Specifies the annotation number, type, and hot spot (GUI). APDL Command: /ANUM Parameters ---------- num Annotation number. ANSYS automatically assigns the lowest available number. You cannot assign a higher number if a lower number is available; ANSYS will substitute the lowest available number in place of any user-specified higher number. type\_ Annotation internal type number. If TYPE = DELE, delete annotation NUM. 1 - Text 2 - Block text (not available in GUI) 3 - Dimensions 4 - Lines 5 - Rectangles 6 - Circles 7 - Polygons 8 - Arcs 9 - Wedges, pies 11 - Symbols 12 - Arrows 13 - Bitmap xhot X hot spot (-1.0 < X < 2.0). Used for menu button item delete. yhot Y hot spot (-1.0 < Y < 1.0). Used for menu button item delete. Notes ----- This is a command generated by the GUI and will appear in the log file (Jobname.LOG) if annotation is used. This command is not intended to be typed in directly in an ANSYS session (although it can be included in an input file for batch input or for use with the /INPUT command). Type 13 (bitmap) annotation applies user defined bitmaps defined using the FILE option of the /TXTRE command. This command is valid in any processor. """ command = f"/ANUM,{num},{type_},{xhot},{yhot}" return self.run(command, **kwargs)
be3acd32deffcd31a3a83758b64d0d6950bbd791
699,583