content
stringlengths 39
9.28k
| sha1
stringlengths 40
40
| id
int64 8
710k
|
|---|---|---|
def _format_list_items(list_items):
"""Generate an indented string out of a list of items."""
list_string = ''
if list_items:
for item in list_items:
list_string = list_string + " '" + item + "',\n"
list_string = "[\n {}\n]".format(list_string.strip()[:-1])
else:
list_string = '[]'
return list_string | dd677277650e5d3105c01f6636518b8bbd2a1bff | 22,216 |
def organization_analytics_by_voter_doc_template_values(url_root):
"""
Show documentation about organizationAnalyticsByVoter
"""
required_query_parameter_list = [
{
'name': 'organization_we_vote_id',
'value': 'string', # boolean, integer, long, string
'description': 'An organization\'s unique We Vote id.',
},
{
'name': 'organization_api_pass_code',
'value': 'string', # boolean, integer, long, string
'description': 'An organization\'s unique pass code for retrieving this data. '
'Not needed if organization is signed in.',
},
{
'name': 'voter_device_id',
'value': 'string', # boolean, integer, long, string
'description': 'Not needed if organization_api_pass_code is used.',
},
{
'name': 'api_key',
'value': 'string (from post, cookie, or get (in that order))', # boolean, integer, long, string
'description': 'The unique key provided to any organization using the WeVoteServer APIs',
},
]
optional_query_parameter_list = [
{
'name': 'election_id',
'value': 'integer', # boolean, integer, long, string
'description': 'Limit the results to just this election',
},
{
'name': 'external_voter_id',
'value': 'string', # boolean, integer, long, string
'description': 'Limit the results to just this voter',
},
{
'name': 'voter_we_vote_id',
'value': 'string', # boolean, integer, long, string
'description': 'Limit the results to just this voter',
},
]
potential_status_codes_list = [
# {
# 'code': 'VALID_VOTER_DEVICE_ID_MISSING',
# 'description': 'Cannot proceed. A valid voter_device_id parameter was not included.',
# },
# {
# 'code': 'VALID_VOTER_ID_MISSING',
# 'description': 'Cannot proceed. A valid voter_id was not found.',
# },
]
try_now_link_variables_dict = {
}
api_response = '{\n' \
' "status": string,\n' \
' "success": boolean,\n' \
' "organization_we_vote_id": string,\n' \
' "election_list": list\n' \
' [\n' \
' "election_id": string,\n' \
' "election_name": string,\n' \
' "election_date": string,\n' \
' "election_state": string,\n' \
' ],\n' \
' "voter_list": list\n' \
' [\n' \
' "external_voter_id": string (Unique ID from organization),\n' \
' "voter_we_vote_id": string (the voter\'s we vote id),\n' \
' "elections_visited: list,\n' \
' [\n' \
' "election_id": string (the election if within we vote),\n' \
' "support_count": integer (COMING SOON),\n' \
' "oppose_count: integer (COMING SOON),\n' \
' "friends_only_support_count": integer (COMING SOON),\n' \
' "friends_only_oppose_count: integer (COMING SOON),\n' \
' "friends_only_comments_count": integer (COMING SOON),\n' \
' "public_support_count": integer (COMING SOON),\n' \
' "public_oppose_count: integer (COMING SOON),\n' \
' "public_comments_count": integer (COMING SOON),\n' \
' ],\n' \
' ],\n' \
'}'
template_values = {
'api_name': 'organizationAnalyticsByVoter',
'api_slug': 'organizationAnalyticsByVoter',
'api_introduction':
"A list of voter-specific analytics about either a) one of your member's, or b) all of your members "
"based on the variables you send with the request. These analytics come from visits to organization's "
"custom URL, and not the main WeVote.US site.",
'try_now_link': 'apis_v1:organizationAnalyticsByVoterView',
'try_now_link_variables_dict': try_now_link_variables_dict,
'url_root': url_root,
'get_or_post': 'GET',
'required_query_parameter_list': required_query_parameter_list,
'optional_query_parameter_list': optional_query_parameter_list,
'api_response': api_response,
'api_response_notes':
"",
'potential_status_codes_list': potential_status_codes_list,
}
return template_values | 77dc6a9ce0e6cb3416f3eb75aed6302e8002fa23 | 91,665 |
def _get_interval_amount(recur_ent, money):
"""
Get the Salary Amount Based on a Recurring Period of Time
param recur_ent (str): 'yearly', 'monthly', 'weely', 'daily', 'hourly'
param money (float): Hourly Salary of an employee
"""
intv_mult = {"yearly": 12*4*5*8, "monthly": 4*5*8, "weekly": 5*8, "daily": 8, "hourly": 1}
return round(intv_mult[recur_ent] * money, 2) | deed695b780edd9cb6f17e5465b1f522c649f6fb | 368,010 |
from typing import List
def _convert_tags_bio2plain(bio_tag_list: List[str]) -> List[str]:
"""
retrieve plain tags by removing bio prefixes
Args:
bio_tag_list: e.g. ['O', 'B-ORG', 'I-ORG']
Returns:
tag_list: e.g. ['O', 'ORG', 'ORG']
"""
return [elem.split("-")[-1] for elem in bio_tag_list] | d6419ed4f61fa4d46c6464b330cdeb17a37f58d1 | 209,279 |
def get_folder_overall_status(path, file_statuses, all_statuses):
"""Returns a 3-tuple of an IndexStatus, WorktreeStatus and MergeStatus,
chosen based on the most severe of the corresponding statuses of the
files. file_statuses should be a set of status tuples for individual
files."""
if file_statuses:
index_statuses, worktree_statuses, merge_statuses = zip(*file_statuses)
index_status = max(index_statuses)
worktree_status = max(worktree_statuses)
merge_status = max(merge_statuses)
else:
# No files listed. Maybe the directory, or a parent directory, is listed:
index_status, worktree_status, merge_status = all_statuses.get_status(path)
return index_status, worktree_status, merge_status | b46a969c3f7d9f3c3e3145489b087a609767b636 | 495,978 |
from typing import List
from typing import Dict
from typing import Any
def convert_list_to_comma_separated_string(values: List[Dict[str, Any]], key: str) -> str:
"""
Retrieve values of an attribute in comma separated manner from response to populate human readable output
:param: values: list of attributes fetched from response
:param: key: key to consider the value for
:return: a string containing values of passed attribute in comma separated manner
"""
value_list = set()
for value in values:
value_list.add(value.get(key, ''))
return ', '.join(value_list) | 833254f3d95849016ee049fe4e76ee47db64e04a | 617,021 |
def find_deltas(arr):
"""
Creates a new array that is the differences between consecutive elements in
a numeric series. The new array is len(arr) - 1
"""
return [j-i for i, j in zip(arr[:-1], arr[1:])] | fbd91938be06a62228a74422f4f4f86395b0080a | 590,225 |
def convert_lut_init_to_hex(val: str) -> str:
"""Converts EDIF decimal and hexadecimal notation to hexadecimal for SpDE.
Args:
val (str): value in decimal or hexadecimal notation (i.e. ``16'hABCD``)
Returns:
str: string containing only hexadecimal number, without ``0x`` prefix
(i.e. "ABCD")
"""
if "'" not in val:
return str(format(int(val), 'x')).upper()
else:
return str(val.split("'h")[1]).upper() | b4a8e2ecfb186ec7383f2902b7462bff1d6acc43 | 390,861 |
def getattr_recursive(variable, attribute):
"""
Get attributes recursively.
"""
if '.' in attribute:
top, remaining = attribute.split('.', 1)
return getattr_recursive(getattr(variable, top), remaining)
else:
return getattr(variable, attribute) | e91401be53c287f392a123ec3a88a19c0f4b8095 | 70,238 |
def has_active_network_in_vlan(vlan):
"""Check if there are any other active network in the vlan this is used
because some equipments remove all the L3 config when applying some
commands, so they can only be applyed at the first time or to remove
interface vlan configuration
:param vlan: vlan object
:returns: True of False
"""
networksv4 = vlan.networkipv4_set.filter(active=True)
networksv6 = vlan.networkipv6_set.filter(active=True)
if networksv4 or networksv6:
return True
return False | ab38e73ebbd402463d03b6f8d7ca3d918e970879 | 600,450 |
import random
def generate_problems(number_of_problems=2, maximum_integer=50, problem_type='Addition', number_of_pages=1):
"""
Generates random example math problems in latex format for practicing Addition, Subtraction, or Multiplication
:param number_of_problems: defines how many problems to generate
:param maximum_integer: defines the maximum integer possible during the generation of problems
:param problem_type: type of problems to generate. options are Addition, Subtraction, or Multiplication
:return: contents of the latex document as a string
"""
operator = {'Addition': r'+',
'Subtraction': r'-',
'Multiplication': r'\times'}
lines = [r'\documentclass{article}',
r'\usepackage{amsmath}',
r'\usepackage{amsfonts}',
r'\usepackage{amssymb}',
r'\pagenumbering{gobble}',
r'\usepackage{multicol}',
r'\begin{document}']
for index, page in enumerate(range(number_of_pages)):
lines.append(r'{\Large ' + ' {} '.format(problem_type) + r' practice version 0.1\par}')
lines.append(r'{\large using max integer = ' + str(maximum_integer) + r'\par}')
lines.append(r'\begin{multicols}{2}')
lines.append(r'\begin{large}')
lines.append(r'\begin{enumerate}')
for _ in range(number_of_problems):
lines.append(r'\item')
lines.append(r'\begin{tabular}{lr}')
int_1 = random.randint(1, maximum_integer)
int_2 = random.randint(1, maximum_integer)
if int_1 < int_2:
int_2, int_1 = int_1, int_2
int_1_string = ' '.join(iter(str(int_1)))
int_2_string = ' '.join(iter(str(int_2)))
lines.append(r' & ' + int_1_string + r'\\')
if problem_type == 'Mixed':
lines.append(operator[random.choice(['Addition', 'Subtraction', 'Multiplication'])] + r'& ' + int_2_string + r'\\')
elif problem_type == 'Mixed Addition Subtraction':
lines.append(operator[random.choice(['Addition', 'Subtraction'])] + r'& ' + int_2_string + r'\\')
else:
lines.append(operator[problem_type] + r'& ' + int_2_string + r'\\')
lines.append(r'\hline')
lines.append(r' & \\')
lines.append(r'\end{tabular}')
lines.append(r'\vspace*{50px}')
lines.append(r'\end{enumerate}')
lines.append(r'\end{large}')
lines.append(r'\end{multicols}')
# generate the next set of problems on a new page for student i
if index != number_of_pages:
lines.append(r'\newpage')
lines.append(r'\end{document}')
return '\n'.join(lines) | 42220b90b46adf823fc0649b569d850f4a653305 | 140,495 |
def within_range(val, vrange):
""" Check if a value is within a range.
**Parameters**\n
val: numeric
Value to check within range.
vrange: tuple/list
Range of values.
"""
if (val >= vrange[0] and val <= vrange[-1]) or (val <= vrange[0] and val >= vrange[-1]):
return True
else:
return False | 44b4089b581b07c91c56f289ac46d357b2fc87cc | 567,711 |
def normalize(x):
"""
Helper function for normalizing the inputs.
Normalization is an affine transformation such that the minimal element of x maps to 0, and maximal element of x
maps to 1
Args:
x (``np.ndarray``): the array to be normalized
Returns:
``np.ndarray``: a normalized array such that the minimum is 0 and the maximum is 1
"""
return (x - x.min()) / (x.max() - x.min()) | 62c18aeecaf0672fa1c73e380c96723e8373510f | 574,933 |
def valid_sequence(sequences):
"""
Function that iterates through all protein sequences and validates that
each sequence is made up of valid canonical amino acid letters. If no
invalid values are found then None will be returned. If invalid letters
are found in the sequence, the sequence index and the index of the value
in the sequence will be appened to a dict.
Parameters
----------
sequences : list/np.ndarray
list or array of protein sequences.
Returns
-------
None or invalid_indices : None/list
if no invalid values found in the protein sequences, None returned. if
invalid values found, list of dicts returned in the form
{sequence index: invalid value in sequence index}.
"""
#if input is string, cast to a list so it is iterable
if isinstance(sequences,str):
sequences = [sequences]
# sequences = np.array(sequences).reshape((-1,1))
#valid canonical amino acid letters
valid_amino_acids = ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L', 'M',\
'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y','-']
invalid_indices = []
#iterate through all sequences, validating that there are no invalid values
# present in the sequences, if there are then append to list of invalid indices
try:
for seq in range(0,len(sequences)):
for aa in range(0,len(sequences[seq])):
if (sequences[seq][aa] not in valid_amino_acids):
invalid_indices.append({'Sequence #'+str(seq) : 'Index #'+str(aa)})
except:
print('Error parsing sequences in datasets.')
#if no invalid values found in sequences return None, else return list of
# dicts containing invalid index and invalid values
if invalid_indices == []:
return None
else:
return invalid_indices | 15974e8428857c988b971f12c9a666990d951d6f | 543,701 |
def calculate_dis_travelled(speed, time):
"""Calculate the distance travelled(in Km) in a give amount of time(s)."""
return (speed * time) / 3600.0 | 6f71e362109c930ca1e8a9ebd1a4cea9944da23d | 266,819 |
def autolabel(ax, rects, xpos='center'):
"""
Attach a text label above each bar in *rects*, displaying its heightt.
*xpos* indicates which side to place the text w.r.t. the center of
the bar. It can be one of the following {'center', 'right', 'left'}.
"""
xpos = xpos.lower() # normalize the case of the parameter
ha = {'center': 'center', 'right': 'left', 'left': 'right'}
offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off
for rect in rects:
heightt = rect.get_heightt()
ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*heightt, '{}'.format(heightt), ha=ha[xpos], va='bottom')
return ax | 49d8ed659491ac87bbffb12c8be6001bbd7cd541 | 541,725 |
def parse_print_dur(print_dur):
"""
Parse formatted string containing print duration to total seconds.
>>> parse_print_dur(" 56m 47s")
3407
"""
h_index = print_dur.find("h")
hours = int(print_dur[h_index - 2 : h_index]) if h_index != -1 else 0
m_index = print_dur.find("m")
minutes = int(print_dur[m_index - 2 : m_index]) if m_index != -1 else 0
s_index = print_dur.find("s")
seconds = int(print_dur[s_index - 2 : s_index]) if s_index != -1 else 0
return hours * 60 * 60 + minutes * 60 + seconds | 7b1a29f31ba38e7d25b4dca9600d4be96a1da3ac | 7,797 |
import re
def _remove_whitespace(string):
"""Return a version of the input string with whitespace removed"""
whitespace_re = re.compile(r"\s+")
return whitespace_re.sub('', string) | 0da9083b1f4d4e4c8cb4a375b2e70cd3b70a4564 | 26,422 |
def get_ptr_from_memory_pointer(mem_ptr):
"""
Access the value associated with one of the attributes 'device_ptr', 'device_pointer', 'ptr'.
"""
attributes = ('device_ptr', 'device_pointer', 'ptr')
for attr in attributes:
if hasattr(mem_ptr, attr):
return getattr(mem_ptr, attr)
message = f"Memory pointer objects should have one of the following attributes specifying the device pointer: {attributes}"
raise AttributeError(message) | 1aa2ffdd3522632984230896506d0ce3ae9d0b07 | 444,761 |
def unique_records(df):
"""Checks that each date and FIPs combination is unique."""
return df[['date', 'fips']].drop_duplicates().shape[0] == df.shape[0] | 418d1b81b3333df6ac0b1e288a44f95539c07347 | 524,705 |
def parse_logs(response):
"""Parse the Docker logs into stdout and stderr string lists"""
# Parse each line into a log, skip the empty lines
lines = list(filter(None, response.text.split('\n')))
stdout_logs = []
stderr_logs = []
for line in lines:
# Byte format documentation
# https://docs.docker.com/engine/api/v1.40/#operation/ContainerAttach
log_bytes = bytes(line, 'utf8')
stream_type = log_bytes[0]
log_message = line[8:]
if stream_type == 0:
print('Warning: Received a stdin log?')
elif stream_type == 1:
stdout_logs.append(log_message)
elif stream_type == 2:
stderr_logs.append(log_message)
return [stdout_logs, stderr_logs] | 006c7258477c20ecd96df2490155e8615d6313a3 | 282,956 |
def set_axes_vis(p, xlabel, ylabel):
""" Set the visibility of axes"""
if not xlabel: p.xaxis.visible = False
if not ylabel: p.yaxis.visible = False
return p | 2a2632b1c041b4957bf08280eeffea9bbc2977f0 | 109,317 |
def has_index_together_changed(old_model_sig, new_model_sig):
"""Returns whether index_together has changed between signatures."""
old_meta = old_model_sig['meta']
new_meta = new_model_sig['meta']
old_index_together = old_meta.get('index_together', [])
new_index_together = new_meta['index_together']
return list(old_index_together) != list(new_index_together) | b286c460ae06f8cca53326f46766a77c7c1b073c | 337,256 |
def parse_speed(as_str: str) -> float:
"""Parses a speed in N.NNx format"""
return float(as_str.rstrip("x")) | 9855df3a53df20cd6a3ed196e5f77ade06fac888 | 264,387 |
def add_route_parts_into(failure, into):
"""
Adds route parts into the given list.
Parameters
----------
failure : ``FailureBase``
The parent failure to get route of.
into : `list` of `str`
A list to put the string parts into.
Returns
-------
into : `list` of `str`
"""
case = failure.handle.case
into.append(case.import_route)
into.append('.')
into.append(case.name)
return into | e8612711cce19b10ef67c3b8f3231481af24652b | 525,444 |
def tryint(x):
"""
Used by numbered string comparison (to protect against unexpected letters in version number).
:param x: possible int.
:return: converted int or original value in case of ValueError.
"""
try:
return int(x)
except ValueError:
return x | 22c8cc0d57254040fb32a2111054dcbd68bcafe9 | 458,004 |
def clean_string(text: str):
"""Replace MS Office Special Characters from a String as well as double whitespace
Args:
text (str):
Returns:
str: Cleaned string
"""
result = ' '.join(text.split())
result = result.replace('\r', '').replace('.', '').replace(
'\n', ' ').replace(u'\xa0', u' ').replace(u'\xad', u'-').rstrip().lstrip()
return result | 64990c668e7aa8507ed9c0bfa79ce8941d54b89e | 61,249 |
def _get_bin_width(stdev, count):
"""Return the histogram's optimal bin width based on Sturges
http://www.jstor.org/pss/2965501
"""
w = int(round((3.5 * stdev) / (count ** (1.0 / 3))))
if w:
return w
else:
return 1 | 77d818db7be992703ddab959d1054a261b39f6dc | 369,354 |
import random
def random_choice(gene):
"""
Randomly select a object, such as strings, from a list. Gene must have defined `choices` list.
Args:
gene (Gene): A gene with a set `choices` list.
Returns:
object: Selected choice.
"""
if not 'choices' in gene.__dict__:
raise KeyError("'choices' not defined in this gene, please include a list values!")
return random.choice(gene.choices) | 8a01a2039a04262aa4fc076bdd87dbf760f45253 | 2,817 |
def selection_sort(A, show_progress=False):
"""
The selection sort algorithm sorts an array by repeatedly
finding the minimum element (considering ascending order)
from unsorted part and putting it at the beginning.
The algorithm maintains two subarrays in a given array.
1) The subarray which is already sorted.
2) Remaining subarray which is unsorted.
In every iteration of selection sort, the minimum element
(considering ascending order) from the unsorted subarray
is picked and moved to the sorted subarray.
"""
#Iterate the array as many times as there are items-1
for k in range(len(A)-1):
if show_progress:
print(A)
#Reference value for comparison
ref = k
#Find the smallest item of the array and put it in the front
for i in range(k+1, len(A)):
if A[i] < A[ref]:
ref = i
A[ref], A[k] = A[k], A[ref]
if show_progress:
print(A)
return A | c9ad4903bd2231557bccadd9352db89442634854 | 133,487 |
def hex_str_to_bytes_str(hex_str):
"""Converts the hex string to bytes string.
:type hex_str: str
:param hex_str: The hex tring representing trace_id or span_id.
:rtype: str
:returns: string representing byte array
"""
return bytes(bytearray.fromhex(hex_str)) | 5dc712fa9f42902feef25b2dbca0e524c192b8de | 421,513 |
import re
def word_substitute(expr, substitutions):
"""
Applies a dict of word substitutions.
The dict ``substitutions`` consists of pairs ``(word, rep)`` where each
word ``word`` appearing in ``expr`` is replaced by ``rep``. Here a 'word'
means anything matching the regexp ``\\bword\\b``.
Examples
--------
>>> expr = 'a*_b+c5+8+f(A)'
>>> print(word_substitute(expr, {'a':'banana', 'f':'func'}))
banana*_b+c5+8+func(A)
"""
for var, replace_var in substitutions.items():
expr = re.sub(f"\\b{var}\\b", str(replace_var), expr)
return expr | 9800d0909769621d08b5831f0b9ebb9a315dbce2 | 381,882 |
def dip_percent_value(price: float, percent: float) -> float:
"""Return the value of the current price if it dips a certain percent
Args:
price: The price to check a dip percentage against
percent: the dip percentage we care about
Returns:
dip_price: A float containing the price if we hit our dip target
"""
dip_price = price * (1 - percent / 100)
return round(dip_price, 2) | 2b5a179f2ba7ed8a8dc64c5515855d869f4058b9 | 345,763 |
def is_public_function(function_name):
"""
Determine whether the Vim script function with the given name is a public
function which should be included in the generated documentation (for
example script-local functions are not included in the generated
documentation).
"""
is_global_function = ':' not in function_name and function_name[0].isupper()
is_autoload_function = '#' in function_name and not function_name[0].isupper()
return is_global_function or is_autoload_function | f807a159d66978426604ae9cad382505be55b2b7 | 607,124 |
def check_characters(text):
"""
Method used to check the digit and special
character in a text.
Parameters:
-----------------
text (string): Text to clean
Returns:
-----------------
characters (dict): Dictionary with digit
and special characters
"""
numerical, special = [[] for i in range(2)]
for i in range(len(text)):
if text[i].isalpha():
pass
elif text[i].isdigit():
# adding only unique characters
numerical = list(set(numerical + [text[i]]))
elif not text[i].isspace():
# adding only unique characters
special = list(set(special + [text[i]]))
characters = {
"numerical": numerical,
"special": special
}
return characters | c90f04849e0d40095e7eca00aaef98d4991749a3 | 553,158 |
import math
def torsion_angle(c1, c2, c3, c4):
"""
float <- torsion_angle(a, b, c, d)
returns the torsion angle in degrees between 3D pts a,b,c,d
"""
v1 = (c1[0]-c2[0], c1[1]-c2[1], c1[2]-c2[2])
v2 = (c2[0]-c3[0], c2[1]-c3[1], c2[2]-c3[2])
v3 = (c3[0]-c4[0], c3[1]-c4[1], c3[2]-c4[2])
p = (v2[1]*v1[2] - v1[1]*v2[2],
v1[0]*v2[2] - v2[0]*v1[2],
v2[0]*v1[1] - v1[0]*v2[1])
q = (v3[1]*v2[2] - v2[1]*v3[2],
v2[0]*v3[2] - v3[0]*v2[2],
v3[0]*v2[1] - v2[0]*v3[1])
n = 1.0 / math.sqrt( p[0]*p[0] + p[1]*p[1] + p[2]*p[2] )
p = (p[0]*n, p[1]*n, p[2]*n )
n = 1.0 / math.sqrt( q[0]*q[0] + q[1]*q[1] + q[2]*q[2] )
q = (q[0]*n, q[1]*n, q[2]*n )
xtheta = p[0]*q[0] + p[1]*q[1] + p[2]*q[2]
if xtheta > 1.0: xtheta = 1.0
if xtheta < -1.0: xtheta = -1.0
theta = math.acos(xtheta) * 57.29578
absth = math.fabs(theta)
if absth < 0.001:
return 0.0
elif math.fabs(absth - 180.0) < 0.001:
return 180.0
s = v1[0]*q[0] + v1[1]*q[1] + v1[2]*q[2]
if s < 0.0:
theta = 360.0 - theta
if theta > 180.0:
theta = theta - 360.0
return theta | 32eb380fd8e4d0645481ab816a32e01144fb3c7b | 22,101 |
def count_bits(n):
"""Count number of ones in binary representation of decimal number."""
bits = 0 if n == 0 else 1
while n > 1:
bits += n % 2
n //= 2
return bits | 8acdeb6380cde0b0191de9b283af3d40d7388d39 | 170,517 |
def _congruent(a: int, b: int, n: int) -> bool:
"""
Returns true if a is congruent to b modulo n.
"""
assert type(a) is int
return (a % n) == (b % n) | 73e9ded677a042792f6458cff7ceffb5932b532c | 105,050 |
async def some_async_function(value):
"""A demo async function. Does not do any actual I/O."""
return value | 9324669acd9955095e12c28acc09cf0b7d68d767 | 22,613 |
def order_validation(order):
"""
Validate the order. If it's under 2 then raise a ValueError
"""
if order < 2:
raise ValueError("An order lower than two is not allowed.")
else:
return order | ee9f9c64c30a9625246d5e139c94a53d144270db | 37,247 |
import torch
def get_pyg_edge_index(graph, both_dir=True):
"""
Get edge_index for an instance of torch_geometric.data.Data.
Args:
graph: networkx Graph
both_dir: boolean; whether to include reverse edge from graph
Return:
torch.LongTensor of edge_index with size [2, num_edges]
"""
sources = []
targets = []
for edge in graph.edges:
sources.append(edge[0])
targets.append(edge[1])
if both_dir:
sources.append(edge[1])
targets.append(edge[0])
return torch.LongTensor([sources, targets]) | d0300a93a6e4a68302d04dfa8b646b92c7ac256b | 660,279 |
def token_is(token_type):
"""Return a callable object that returns whether a token is of the
given type `token_type`."""
def token_is_type(token):
"""Return whether a token is of a certain type or not."""
token = token[0]
while token is not token_type and token.parent:
token = token.parent
return token is token_type
return token_is_type | 7f27c887a909180154cd4520286afdad88e18fb1 | 327,344 |
def emplace_kv(dictionary: dict, k, v) -> dict:
"""
Returns input dict with added k:v pair, overwriting if k already exists
"""
return {**dictionary, k: v} | 191343ec1d588efb377e0c0a06ebc5544a2a8f84 | 122,367 |
def other_invoiceitem(faker):
"""Returns a dict for an `InvoiceItem` with `vat` = 0."""
full_item_dict = {
"service": faker.sentence(nb_words=2),
"qty": 1.0,
"unit_price": 1.0,
"vat": 0.0,
"description": faker.sentence(nb_words=5),
}
return full_item_dict | 5afd003360a455e553bfbc97fa4d72233bc2e4cf | 254,720 |
import json
def get_wordpools() -> dict: # Reads the json file and returns a dictionary containing the wordpools. Internal function
"""
Get the wordpools
@return: A dictionary containing the information of the wordpools
"""
with open('data/wordpools.json') as file:
wordpool_dict = json.load(file)
return wordpool_dict | b0a5ca50846487f3f68adcbb3e23440b2f2062c1 | 510,604 |
def lista_para_texto(lista):
"""
Transforma uma lista de palavras em texto.
Parâmetros:
----------
lista : List
- Lista de palavras.
Retorno:
----------
texto : String
- O texto contento todas as palavras da lista.
"""
texto = ""
for palavra in lista:
texto += palavra + " "
return texto.strip() | 67feba7d09a98837834ec2cdf71786b6df906bdb | 480,323 |
def _cliffs_delta(x, y):
"""
Calculates Cliff's delta.
"""
delta = 0
for x_val in x:
result = 0
for y_val in y:
if y_val > x_val:
result -= 1
elif x_val > y_val:
result += 1
delta += result / len(y)
if abs(delta) < 10e-16:
# due to minor rounding errors
delta = 0
else:
delta = delta / len(x)
return delta | 9748f6a5608ae4c74a122ba9256c77dc1f5a08ae | 516,527 |
import math
def similarity(di, dj):
"""Cos similarity.
usage:
>>> a = {0:2, 1:1, 2:1}
>>> b = {0:1, 2:1}
>>> print round(similarity(a, b), 5)
0.86603
"""
inds = set(di.keys()) & set(dj.keys())
s = len(set(di.keys()) & set(dj.keys()))
if s == 0:
return 0.0
up = sum([di[k] * dj[k] for k in inds])
m = sum([di[k] ** 2 for k in di]) * sum([dj[k] ** 2 for k in dj])
#alpha = min(s / 6.0, 1.0)
alpha = 1.0
return float(up) / math.sqrt(m) * alpha | f1347b55a47150ba177b50e1668557b77f78a8e8 | 584,094 |
def _compare_two_tensor_shapes(t1, t2):
"""Compare tensor shapes."""
if t1.shape.as_list() != t2.shape.as_list():
raise RuntimeError("Compare shape fail: base {} {} vs gc {} {}".format(t1.name, t1.shape.as_list(), t2.name, t2.shape.as_list()))
return True | 69b27bcbc8524886b1709abb8eb17f030e3016a0 | 68,599 |
def _find_startswith(x, s):
"""Finds the index of a sequence that starts with s or returns -1.
"""
for i, elem in enumerate(x):
if elem.startswith(s):
return i
return -1 | d36bbc4b6005a1ee6f84f3f2dc51504564c6a147 | 180,685 |
def filter_active_particles(particles):
"""Filter active particles from particles dict."""
return {particle_number: particle
for particle_number, particle in particles.items()
if particle['active']} | 68e7d028e4f8cc94fc003af0eff5bfaa90f451a4 | 654,562 |
def _calculate_to_transitions(trans_probs):
"""Calculate which 'to transitions' are allowed for each state
This looks through all of the trans_probs, and uses this dictionary
to determine allowed transitions. It converts this information into
a dictionary, whose keys are destination states and whose values are
lists of source states from which the destination is reachable via a
transition.
"""
transitions = dict()
for from_state, to_state in trans_probs:
try:
transitions[to_state].append(from_state)
except KeyError:
transitions[to_state] = [from_state]
return transitions | c56b17cd05def3117eebd0d93fc644bbf324fc76 | 417,055 |
def be32toh(buf):
# named after the c library function
"""Convert big-endian 4byte int to a python numeric value."""
out = (ord(buf[0]) << 24) + (ord(buf[1]) << 16) + \
(ord(buf[2]) << 8) + ord(buf[3])
return out | bf87b8e4b42036fbb5e2526d53bc9469e66d3579 | 430,269 |
import math
def include_integer(low, high):
"""Check if the range [low, high) includes integer."""
def _in_range(num, low, high):
"""check if num in [low, high)"""
return low <= num < high
if _in_range(math.ceil(low), low, high) or _in_range(math.floor(high), low, high):
return True
return False | 74bf89e314e3319bfb0b034c41ed78668442523d | 511,222 |
def is_256_bit_imm(n):
"""Is n a 256-bit number?"""
return type(n) == int and n >= 0 and 1 << 256 > n | eebc31bb8d9f53c98f9d930a4c6b2d70d4050dc0 | 149,400 |
import re
def regex_match(key1, key2):
"""determines whether key1 matches the pattern of key2 in regular expression."""
res = re.match(key2, key1)
if res:
return True
else:
return False | 76e3ff2ff8359078f0f17698043f24c0164392b3 | 158,000 |
def same_position(oldmethod):
"""Decorate `oldmethod` to also compare the `_v_pos` attribute."""
def newmethod(self, other):
try:
other_pos = other._v_pos
except AttributeError:
return False # not a column definition
return self._v_pos == other._v_pos and oldmethod(self, other)
newmethod.__name__ = oldmethod.__name__
newmethod.__doc__ = oldmethod.__doc__
return newmethod | 15752f5f397d45cab0aa750679e8f6fd6665b713 | 278,212 |
def union_crops(crop1, crop2):
"""Union two (x1, y1, x2, y2) rects."""
x11, y11, x21, y21 = crop1
x12, y12, x22, y22 = crop2
return min(x11, x12), min(y11, y12), max(x21, x22), max(y21, y22) | f32d15fbc8a30c3b431899c08cb7f7549108edf4 | 492,121 |
def get_uid(vobject_component):
"""UID value of an item if defined."""
return vobject_component.uid.value if hasattr(vobject_component, "uid") else None | 3a86bbb96df0ac03e3a6c9b5c4f74e4e1e7bfad0 | 209,275 |
def is_app_code(code):
"""
Checks whether a code is part of the app range
:param int code: input code
:return: if `code` is in the app range or not
:rtype: bool
"""
return 0 < code < 0x10 | 69b86297d6d7b85cf3e22a725bb10ea32c2bbdea | 550,132 |
import re
def is_line_all_header_1_or_2(line):
"""Returns True if the given line is all '=' or all '-'."""
match_obj = re.search("^[=]+$", line.rstrip())
if match_obj:
return True
match_obj = re.search("^[\\-]+$", line.rstrip())
if match_obj:
return True
return False | b0d1788f63b866a91f3b19ab26723aedba0ae008 | 343,249 |
def url_of_link(link):
"""
Extract the url of the link
Parameters
----------
link : WebElement
The link to inspect
Returns
----------
url: str
The url of the given link
"""
return link.get_attribute("href") | dcdd3ea4ecee84e1726e21ba574ea7be64f48459 | 271,664 |
def score_ap_from_ranks_1(ranks, nres):
""" Compute the average precision of one search.
ranks = ordered list of ranks of true positives
nres = total number of positives in dataset
"""
# accumulate trapezoids in PR-plot
ap = 0.0
# All have an x-size of:
recall_step = 1.0 / nres
for ntp, rank in enumerate(ranks):
# y-size on left side of trapezoid:
# ntp = nb of true positives so far
# rank = nb of retrieved items so far
if rank == 0:
precision_0 = 1.0
else:
precision_0 = ntp / float(rank)
# y-size on right side of trapezoid:
# ntp and rank are increased by one
precision_1 = (ntp + 1) / float(rank + 1)
ap += (precision_1 + precision_0) * recall_step / 2.0
return ap | ad249838201c7ad1eb61f3b0b348a6e9db773563 | 616,773 |
def azLimit(az):
"""Limits azimuth to +/- 180"""
azLim = (az + 180) % 360
if azLim < 0:
azLim = azLim + 360
return azLim - 180 | 628a8c70f96039da1981ec79cffb115c1abddaa3 | 541,575 |
from datetime import datetime
def str2datetime(s):
"""
Function that transforms a string datetime to a datetime object.
Args:
s: String datetime.
Returns:
A datetime object.
"""
return datetime.strptime(s, '%Y-%m-%d %H:%M:%S.%f') | 1f8519d7b06be372bfc17f57ddf4d7237460b32f | 189,835 |
def snake_to_camel(snake_case_string: str) -> str:
"""
Takes in a `snake_case` string and returns a `camelCase` string.
:params str snake_case_string: The snake_case string to be converted
into camelCase.
:returns: camelCase string
:rtype: str
"""
initial, *temp = snake_case_string.split("_")
return "".join([initial.lower(), *map(str.title, temp)]) | 4ef8fa72580739dbedfbac5bf9f95247f5ea69c3 | 14,481 |
import socket
def connect(host, port):
"""Connection
Args:
host(str): destination hostname
port(int): destination port
Returns:
the created socket
"""
# IPv4 address family over TCP
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((host, port))
print('Socket status after connection %s' % (s))
return s | 94aa6040a55489eb22e84f82809632e8c4c469ee | 575,660 |
def tsv2table(text):
"""Parse a "tsv" (tab separated value) string into a list of lists
of strings (a "table").
The input text is tabulated using tabulation characters to separate
the fields of a row and newlines to separate columns.
The output lines are padded with '' values to ensure that all lines
have the same length.
Note that only '\n' is acceptable as the newline character. Other
special whitespace characters will be left untouched.
"""
rows = text.split('\n')
# 'splitlines' can't be used as it loses trailing empty lines.
table_data = []
max_len = 0
for row in rows:
line = row.split('\t')
l = len(line)
if l > max_len:
max_len = l
table_data.append((line, l))
result = []
for line, l in table_data:
if l < max_len:
line += ['']*(max_len - l)
result.append(line)
return result | 6f62a20882495ebfce71f3baa3121203dcc80f13 | 219,213 |
def is_valid_cubic_coord(x, y, z):
"""
Tests if the cubic coordinates sum to 0, a property of this hex
coordinate system.
"""
return (x + y + z) == 0 | eb0f1eb42c2d8f0ccb3e09fddcd5992c4d9eeac7 | 310,721 |
def minmaxrescale(x, a=0, b=1):
"""
Performs a MinMax Rescaling on an array `x` to a generic range :math:`[a,b]`.
"""
xresc = (b - a) * (x - x.min()) / (x.max() - x.min()) + a
return xresc | 114b8f3f67338be432af82ab36769618c3140c51 | 667,072 |
import select
def _is_readable(socket):
"""Return True if there is data to be read on the socket."""
timeout = 0
(rlist, wlist, elist) = select.select(
[socket.fileno()], [], [], timeout)
return bool(rlist) | 79b258987171e3a5e4d3bab51a9b8c9a59e2415e | 24,922 |
import string
import random
def ctx_id_factory() -> str:
"""A factory method to give ctx id as 8 chars random string"""
chars = string.ascii_letters + string.digits
return ''.join(random.choice(chars) for _ in range(8)) | 8dd4a2e8ea1575a3b53901892ab0d4f4430ab5e9 | 387,140 |
def is_palindrome(word):
"""
Checks if the given word is a palindrome or not. A palindrome is string
that reads the same if reversed like "madam" or "anna".
Parameters
----------
word: str
The word to be checked if it's a palindrome or not.
Returns
-------
bool:
A boolean verifying if the given word is a palindrome. `True` indicates
the given word is a palindrome. `False` indicates it's not.
Raises
------
AssertionError:
If the given word isn't a `str` object.
Example
-------
>>> is_palindrome("madam")
True
>>> is_palindrome("anna")
True
>>> is_palindrome("apple")
False
>>> is_palindrome("")
True
"""
assert type(word) == str
for i in range(len(word) // 2):
if word[i] != word[len(word) - 1 - i]:
return False
return True | 3fb0f7f58db56a27de6ce6375c6d7b68a6d525dd | 123,788 |
def observatory_from_string(string):
"""If "jwst" or "hst" is in `string`, return it, otherwise return None."""
if "jwst" in string:
return "jwst"
elif "hst" in string:
return "hst"
else:
return None | 217cc3cf3c5b802799c0db73563f6d11b7ab4c4d | 16,035 |
def double_with_docstring(arg):
"""Return 2 * arg."""
return 2 * arg | 73a5bab13a8599ab06a51bb1ae8f386990b679fd | 528,097 |
def prefix(txt, pref):
"""
Place a prefix in front of the text.
"""
return str(pref) + str(txt) | e9b4efd78f9132f7855cccba84c8a2d4b58ae8bb | 699,912 |
def process_one_file(k, a, filename):
"""Return a set of species over thresholds."""
with open(filename) as f:
f.readline()
species = set()
for line in f:
tkns = [tkn.strip() for tkn in line.split('\t')]
abund, _, _, kmers, _, _, _, rank, taxa_name = tkns
if rank != 'species':
continue
if float(abund) >= a and int(kmers) >= k:
species.add(taxa_name)
return species | ec00bf57d67c9fe0b1b54e9644e32415da7855fc | 638,493 |
from functools import reduce
def count(l):
"""Count the number of elements in an iterator. (consumes the iterator)"""
return reduce(lambda x,y: x+1, l) | c30519261dbd6e02cd41d4df07607087cb7a6374 | 32,698 |
from typing import List
def validate_sequences_length(sequences: List[list]):
"""Returns True if all lists in `sequences` are the same length. Else returns False."""
for param in sequences:
if len(param) != len(sequences[0]):
return False
return True | f6279b894f29713f69b793e198385c4186e29846 | 520,979 |
def sum_counts(fname, R1=False):
"""Collect the sum of all reads for all samples from a summary count file (e.g. from collect_counts)"""
count = 0
with open(fname, 'r') as infh:
for line in infh:
l = line.split()
if R1:
if l[2] == "R1":
count += float(l[3])
else:
count += float(l[3])
return count | 6ce7e156e1100f3106836e0b34caf6750baa18e1 | 10,544 |
def _stupidize_dict(mydict):
"""Convert a dictionary to a list of ``{key: ..., value: ...}``"""
return [
{'key': key, 'value': value} for key, value in mydict.iteritems()
] | 1601d468f4387397eaa09fbd71b2c6cd0ae66915 | 195,361 |
def transitive_deps(lib_map, node):
"""Returns a list of transitive dependencies from node.
Recursively iterate all dependent node in a depth-first fashion and
list a result using a topological sorting.
"""
result = []
seen = set()
start = node
def recursive_helper(node):
if node is None:
return
for dep in node.get("deps", []):
if dep not in seen:
seen.add(dep)
next_node = lib_map.get(dep)
recursive_helper(next_node)
if node is not start:
result.insert(0, node["name"])
recursive_helper(node)
return result | b2c5b6170a734b0e5ea2d0f40daf084739b0b65d | 66,789 |
def null_distance_results(string1, string2, max_distance):
"""Determines the proper return value of an edit distance function
when one or both strings are null.
**Args**:
* string_1 (str): Base string.
* string_2 (str): The string to compare.
* max_distance (int): The maximum distance allowed.
**Returns**:
-1 if the distance is greater than the max_distance, 0 if the\
strings are equivalent (both are None), otherwise a positive number\
whose magnitude is the length of the string which is not None.
"""
if string1 is None:
if string2 is None:
return 0
else:
return len(string2) if len(string2) <= max_distance else -1
return len(string1) if len(string1) <= max_distance else -1 | 39a59478db858283d533ca0db69e2aaed4625945 | 542,782 |
def oct_to_decimal(oct_string: str) -> int:
"""
Convert a octal value to its decimal equivalent
>>> oct_to_decimal("12")
10
>>> oct_to_decimal(" 12 ")
10
>>> oct_to_decimal("-45")
-37
>>> oct_to_decimal("2-0Fm")
Traceback (most recent call last):
...
ValueError: Non-octal value was passed to the function
>>> oct_to_decimal("")
Traceback (most recent call last):
...
ValueError: Empty string was passed to the function
>>> oct_to_decimal("19")
Traceback (most recent call last):
...
ValueError: Non-octal value was passed to the function
"""
oct_string = str(oct_string).strip()
if not oct_string:
raise ValueError("Empty string was passed to the function")
is_negative = oct_string[0] == "-"
if is_negative:
oct_string = oct_string[1:]
if not oct_string.isdigit() or not all(0 <= int(char) <= 7 for char in oct_string):
raise ValueError("Non-octal value was passed to the function")
decimal_number = 0
for char in oct_string:
decimal_number = 8 * decimal_number + int(char)
if is_negative:
decimal_number = -decimal_number
return decimal_number | ef933850d533c499b126d024d1cae1f86944248e | 34,209 |
def valid(bo, pos, num):
"""
Returns if the attempted move is valid
:param bo: 2d list of ints
:param pos: (row, col)
:param num: int
:return: bool
"""
# Check row
for i in range(0, len(bo)):
if bo[pos[0]][i] == num and pos[1] != i:
return False
# Check Col
for i in range(0, len(bo)):
if bo[i][pos[1]] == num and pos[1] != i:
return False
# Check box
box_x = pos[1]//3
box_y = pos[0]//3
for i in range(box_y*3, box_y*3 + 3):
for j in range(box_x*3, box_x*3 + 3):
if bo[i][j] == num and (i,j) != pos:
return False
return True | 3a7efec63644b0835019edcfd7c5fdcfe95dc5f3 | 502,149 |
def line_intersects_segment(line, line_segment):
"""Returns the intersection the Line and LineSegment or None if they do
not intersect.
This function is useful for splitting polygons by a straight line.
"""
linesegform = line_segment.to_line()
if line.is_parallel_to(linesegform):
return None
else:
p = line.intersection(linesegform)
# Is the intersection on the line_segment?
if line_segment.between(p):
return p
else:
return None | 90739c66a3fa9abd0d360fdaf1807a3c27713f0a | 639,686 |
import math
def find_line_through_point(center, theta, length):
"""Find the coordinates of the start and end of a line passing through the
point center, at an angle theta to the x coordinate, extending a distance
length from the center."""
r = length
cx, cy = center
xo = int(r * math.sin(theta))
yo = int(r * math.cos(theta))
line_start = cx, cy
line_end = cx + xo, cy + yo
return line_start, line_end | 4595b5d6b2975bae33633586165dfb759dcd0c38 | 474,080 |
import copy
def min_specializations(h,domains,x):
"""Implement a function min_specializations(h, domains, x)
for a hypothesis h and an example x. The argument
domains is a list of lists, in which the i-th
sub-list contains the possible values of feature i.
The function should return all minimal specializations
of h with respect to domains which are not fulfilled by x."""
specializations = []
for i,element in enumerate(h):
if element == "?":
possible_values = copy.deepcopy(domains[i])
possible_values.remove(x[i])
for val in possible_values:
temp_h = list(h)
temp_h[i] = val
specializations.append(tuple(temp_h))
else:
temp_h = list(h)
temp_h[i] = "T"
specializations.append(tuple(temp_h))
return specializations | fb0205ca1a25aa31bcc9ebb4eefbacbd2dce8800 | 688,401 |
def rescale_layout(Y, scale=1):
"""Return scaled position array to (-scale, scale) in all axes.
The function acts on NumPy arrays which hold position information.
Each position is one row of the array. The dimension of the space
equals the number of columns. Each coordinate in one column.
To rescale, the mean (center) is subtracted from each axis separately.
Then all values are scaled so that the largest magnitude value
from all axes equals `scale` (thus, the aspect ratio is preserved).
The resulting NumPy Array is returned (order of rows unchanged).
Parameters
----------
Y : numpy array
positions to be scaled. Each row is a position.
scale : number (default: 1)
The size of the resulting extent in all directions.
Returns
-------
Y : numpy array
Scaled positions. Each row is a position.
"""
# Find max length over all dimensions
lim = 0 # max coordinate for all axes
for i in range(Y.shape[1]):
Y[:, i] -= Y[:, i].mean()
lim = max(Y[:, i].max(), lim)
# rescale to (-scale, scale) in all directions, preserves aspect
if lim > 0:
for i in range(Y.shape[1]):
Y[:, i] *= scale / lim
return Y | 97d297663a2848e469e021aa1e371535eda6636e | 652,860 |
def LinInterp2(a, b, alpha):
"""Return the point alpha of the way from a to b."""
beta = 1 - alpha
return (beta * a[0] + alpha * b[0], beta * a[1] + alpha * b[1]) | e4aa1738d1f846f484eb071c5f04326f2b94c2e9 | 338,076 |
def get_fabric_ip_networks(cfmclient, fabric_uuid=None):
"""
Get a list of IP networks from the Composable Fabric.
:param cfmclient:
:param fabric_uuid: UUID of fabric
:return: list of IP address dict objects
:rtype: list
"""
path = 'v1/fabric_ip_networks'
if fabric_uuid:
path += '/{}'.format(fabric_uuid)
return cfmclient.get(path).json().get('result') | 7e9e5cbc5da247e8048c57a2aef18e887090a9c4 | 640,022 |
def has_single_count(metadata):
"""
Return True if the metadata dictionary has a single value for a "count" key.
Written to improve readability, since this is used a lot in the annotation functions.
"""
return metadata.get("count") is not None and not isinstance(metadata["count"], list) | d4f639364e125d4880905e0a204f60e0b25f91ee | 434,361 |
def update_log_level(logger, level):
"""Update the logging level.
Args:
logger (:class:`logging.Logger`): Logger to update.
level (Union[str, int]): Level given either as a string corresponding
to ``Logger`` levels, or their corresponding integers, ranging
from 0 (``NOTSET``) to 50 (``CRITICAL``). For convenience,
values can be given from 0-5, which will be multiplied by 10.
Returns:
:class:`logging.Logger`: The logger for chained calls.
"""
if isinstance(level, str):
# specify level by level name
level = level.upper()
elif isinstance(level, int):
# specify by level integer (0-50)
if level < 10:
# for convenience, assume values under 10 are 10-fold
level *= 10
else:
return
try:
# set level for the logger and all its handlers
logger.setLevel(level)
for handler in logger.handlers:
handler.setLevel(level)
except (TypeError, ValueError) as e:
logger.error(e, exc_info=True)
return logger | dede5ee698f4831853df7c98bd9927ebc86acfe1 | 645,285 |
def cubes_intersect(a, b):
"""
Find if two cubes intersect w/ each other
:param a: cube a, tuple of min, max tuple of coords
:param b: cube a, tuple of min, max tuple of coords
:return: bool, if cubes intersect
"""
for i, j, k, l in zip(a[0], a[1], b[0], b[1]):
if i >= l or k >= j:
return False
return True | 8566f69a18285a98bb539bedd539184d29005ce3 | 252,213 |
def hash_response(r):
"""Hashes a request into a unique name."""
return "{}:{}:{}".format(r.method, r.uri, r.body) | a55915f6c201a54e1afa6a2ed214228b1feac279 | 97,624 |
def getFormat(path):
"""
Returns the file format of the translation. One of: gettext, xlf, properties and txt
"""
if path:
if path.endswith(".po"):
return "gettext"
elif path.endswith(".xlf"):
return "xlf"
elif path.endswith(".properties"):
return "property"
elif path.endswith(".txt"):
return "txt"
return None | 11bcd8b5bc153e0b94ab699db6a051856f344220 | 498,751 |
import re
def _event_id_func(desc, event_id, trig_shift_by_type, dropped_desc):
"""Get integers from string description.
This function can be passed as event_id to events_from_annotations
function.
Parameters
----------
desc : str
The description of the event.
event_id : dict
The default mapping from desc to integer.
trig_shift_by_type: dict | None
The names of marker types to which an offset should be added.
If dict, the keys specify marker types (case is ignored), so that the
corresponding value (an integer) will be added to the trigger value of
all events of this type. If the value for a key is in the dict is None,
all markers of this type will be ignored. If None (default), no offset
is added, which may lead to different marker types being mapped to the
same event id.
dropped_desc : list
Used to log the dropped descriptions.
Returns
-------
trigger : int | None
The integer corresponding to the specific event. If None,
then a proper integer cannot be found and the event is typically
ignored.
"""
mtype, mdesc = desc.split('/')
found = False
if (mdesc in event_id) or (mtype == "New Segment"):
trigger = event_id.get(mdesc, None)
found = True
else:
try:
# Match any three digit marker value (padded with whitespace).
# In BrainVision Recorder, the markers sometimes have a prefix
# depending on the type, e.g., Stimulus=S, Response=R,
# Optical=O, ... Note that any arbitrary stimulus type can be
# defined. So we match any single character that is not
# forbidden by BrainVision Recorder: [^a-z$%\-@/\\|;,:.\s]
marker_regexp = r'^[^a-z$%\-@/\\|;,:.\s]{0,1}([\s\d]{2}\d{1})$'
trigger = int(re.findall(marker_regexp, mdesc)[0])
except IndexError:
trigger = None
if mtype.lower() in trig_shift_by_type:
cur_shift = trig_shift_by_type[mtype.lower()]
if cur_shift is not None:
trigger += cur_shift
else:
# The trigger has been deliberately shifted to None. Do not
# add this to "dropped" so we do not warn about something
# that was done deliberately. Just continue with next item.
trigger = None
found = True
if trigger is None and not found:
dropped_desc.append(desc)
return trigger | 46c22ac4c05770c4d6fadbc9a858267d248d484a | 486,015 |
def _normalize_version_number(version):
"""Turn a version representation into a tuple."""
# trim the v from a 'v2.0' or similar
try:
version = version.lstrip('v')
except AttributeError:
pass
# if it's an integer or a numeric as a string then normalize it
# to a string, this ensures 1 decimal point
try:
num = float(version)
except Exception:
pass
else:
version = str(num)
# if it's a string (or an integer) from above break it on .
try:
return tuple(map(int, version.split(".")))
except Exception:
pass
# last attempt, maybe it's a list or iterable.
try:
return tuple(map(int, version))
except Exception:
pass
raise TypeError("Invalid version specified: %s" % version) | 817bb95e2465fe4fdef293a6e5bc6f87a8145e80 | 618,019 |
def flip_edges(adj, edges):
"""
Flip the edges in the graph (A_ij=1 becomes A_ij=0, and A_ij=0 becomes A_ij=1).
Parameters
----------
adj : sp.spmatrix, shape [n, n]
Sparse adjacency matrix.
edges : np.ndarray, shape [?, 2]
Edges to flip.
Returns
-------
adj_flipped : sp.spmatrix, shape [n, n]
Sparse adjacency matrix with flipped edges.
"""
adj_flipped = adj.copy().tolil()
if len(edges) > 0:
adj_flipped[edges[:, 0], edges[:, 1]] = 1 - adj[edges[:, 0], edges[:, 1]]
return adj_flipped | 0e163616ddb645e636424d673500f07aedabf336 | 695,466 |
def calcModDuration(duration, freq, ytm):
""" Calculates the Modified Duration """
tmp = 1 + (ytm / freq)
return duration / tmp | 9ceb9c72c3d1b5b28b8ff86ab271a238d5ae962e | 97,724 |
Subsets and Splits