content stringlengths 42 6.51k |
|---|
def increase_config(config, amount=1):
"""Generate a new configuration that applies the given configuration
more aggressively.
"""
out = []
for ident, param in config:
if param:
out.append((ident, param + amount))
else:
out.append((ident, param))
return tu... |
def intify(obj):
"""
Takes an object that is a recursive composition of primitive types, lists and dictionaries, and returns an
equivalent object where every `float` number that is actually an integer is replaced with the corresponding
:obj:`int`.
Args:
obj: an object as specified.
Ret... |
def parse_textarea_ids_or_names(textarea_contents):
"""
Prepares text to go through format_records().
Note that textarea_contents is going to be a unicode type as flask builds it
that way. Output is plain bytes (str type) as the rest of our code
does not assume unicode types.
Parameters
... |
def hex_fig(n, uppercase=True):
"""
Return the hexadecimal figure of `n`.
:param n: 0 <= int < 16
:param uppercase: bool
:return: str (one character from 0123456789ABCDEF or 0123456789abcdef)
"""
assert isinstance(n, int), type(n)
assert 0 <= n < 16
assert isinstance(uppercase, boo... |
def verify_spacer(reads, umis, spacer_seq):
"""Returns true if spacer is present."""
for read in reads:
for umi in umis:
if umi in read:
if not read.split(umi)[1].startswith(spacer_seq):
return False
return True |
def _get_category(dataset):
"""Get the category from available layer information"""
category = [k for k in dataset['keywords']
if k.startswith('category:')]
if not category:
return "Other"
else:
return category[0].split(":")[1] |
def get_type(a):
"""
Extract a's type. First, try to extract a's class name. If this
is unsuccessful, return type(a).
The session below illustrates differences between type(a) nad
get_type(a) for standard classes, instances of user-defined classes,
and class objects (new style and classic class... |
def group_by_first(pairs):
"""Return a list of pairs that relates each unique key in [key, value]
pairs to a list of all values that appear paired with that key.
Arguments:
pairs -- a sequence of pairs
>>> example = [ [1, 2], [3, 2], [2, 4], [1, 3], [3, 1], [1, 2] ]
>>> group_by_first(example)... |
def gen_mlsag_assert(pk, xx, kLRki, mscout, index, dsRows):
"""
Conditions check for gen_mlsag_ext.
:param pk:
:param xx:
:param kLRki:
:param mscout:
:param index:
:param dsRows:
:return:
"""
cols = len(pk)
if cols <= 1:
raise ValueError("Cols == 1")
if index... |
def get_message(line, emote):
"""
Returns the message.
Args:
line (binary): Line which we parse.
emote (bool): Flag to determine if there is a emote in the line.
"""
_line = str(line)
# `i` and `j` are indexes for where we can fetch the username. If a
# emote is invloved it... |
def d_get_delta_time(timebase_scale=1.0, i_ns=120):
"""Given the DS1054Z timebase scale, calculate the delta time between samples"""
return (12. * float(timebase_scale)) / float(i_ns) |
def fix_name(team_name):
"""Expand team names from the values in JSON"""
if 'wings' in team_name:
team_name = 'Red Wings'
elif 'jackets' in team_name:
team_name = 'Blue Jackets'
elif 'leafs' in team_name:
team_name = 'Maple Leafs'
elif 'knights' in team_name:
team_nam... |
def astype(value, types=None):
"""Return argument as one of types if possible."""
if value[0] in '\'"':
return value[1:-1]
if types is None:
types = int, float, str
for typ in types:
try:
return typ(value)
except (ValueError, TypeError, UnicodeEncodeError):
... |
def selection_sort(items):
"""
Sort items with a selection sort.
"""
for index, item in enumerate(items):
current_smallest = index
for search_index in range(index + 1, len(items)):
if items[search_index] < items[current_smallest]:
current_smallest = search_ind... |
def viewkeys(obj, **kwargs):
"""
Function for iterating over dictionary keys with the same set-like
behaviour on Py2.7 as on Py3.
Passes kwargs to method."""
func = getattr(obj, "viewkeys", None)
if not func:
func = obj.keys
return func(**kwargs) |
def get_absolute_import_name(dir_path: str, import_name: str) -> str:
"""Joins a relative import path with an import name."""
return f'{dir_path}:{import_name}' |
def autocomplete(term, search_terms) -> str:
"""
Validate search term and return complete name, e.g. autocomplete('subj') == 'subject'
"""
term = term.lower()
# Check if term already complete
if term in search_terms:
return term
full_key = (x for x in search_terms if x.lower().starts... |
def rgb_int_to_float(color):
"""
Turns an integer color in 0-255 range into a 0-1 float range
:param color: tuple(int, int, int, int), color in 0-255 range
:return: tuple(float, float, float, float) color in 0-1 range
"""
return tuple([color_channel / 255.0 for color_channel in color]) |
def dms_to_decimal(degrees, minutes, seconds, sign=' '):
"""Convert degrees, minutes, seconds into decimal degrees.
>>> dms_to_decimal(10, 10, 10)
10.169444444444444
>>> dms_to_decimal(8, 9, 10, 'S')
-8.152777777777779
"""
return (-1 if sign[0] in 'SWsw' else 1) * (
float(degrees) ... |
def remove_nones(X):
""" Removes all Nones from a list and replaces them by zero """
return [[[0. if v is 'None' else v for v in d] for d in data] for data in X] |
def pyx_is_cplus(path):
"""
Inspect a Cython source file (.pyx) and look for comment line like:
# distutils: language = c++
Returns True if such a file is present in the file, else False.
"""
for line in open(path, 'rt'):
if line.startswith('#') and '=' in line:
splitted = ... |
def leaf_name_to_bacterial_phylum(leaf_name: str) -> str:
"""
'ASV_0053; d__Bacteria; p__Bacteroidetes; c__Bacteroidia; o__Bacteroidales' -> 'Bacteroidetes'
"""
if '__Bacteria;' not in leaf_name:
return 'Unassigned'
if '; p__' not in leaf_name:
return 'Unassigned'
else:
... |
def build_etrans_dct(spc_dct_i):
""" Build an energy transfer dict from a spc dct
"""
etrans_dct = {}
mass = spc_dct_i.get('mass', None)
if mass is not None:
etrans_dct['mass'] = mass
ljpar = spc_dct_i.get('lj', None)
if ljpar is not None:
etrans_dct['lj'] = ljpar
ed... |
def uri_sort_key(uri):
"""return a sort key for the given URI, based on whether it represents the primary work in the record"""
if uri.startswith('http://urn.fi/URN:NBN:fi:bib:me:'):
priority = int(uri[-2:]) # last two digits are 00 for the primary work, 01+ for other works mentioned
else:
p... |
def test_no_conflict(N):
"""A 1-SAT problem that requires N variables to all be true"""
return [[i+1] for i in range(N)] |
def _is_barcode_gc_compatible(barcode, min_gc=0.20, max_gc=0.80):
"""check GC content
"""
gc_count = barcode.count("G") + barcode.count("C")
gc_fract = gc_count / float(len(barcode))
if gc_fract < min_gc:
return False
if gc_fract > max_gc:
return False
return True |
def get_publication_year(raw):
"""
Extract publication year.
@param raw: json object of a Libris edition
@type raw: dictionary
"""
publication = raw["mainEntity"].get("publication")
primary = [x for x in publication if
x["@type"] == "PrimaryPublication"]
if primary:
... |
def Luhn (number):
""" function Luhn validates a number against the Luhn checksum formula
- function call: Luhn (number)
number has to be an integer, digits only
- output: True | False
source: https://en.wikipedia.org/wiki/Luhn_algorithm
Press q to exit. """
result = False
... |
def _combine(**kw):
"""
Combine two table dictionaries used in a join to produce a single dictionary
that can be used in formatting.
"""
result = {}
for tableRole, tableDictionary in kw.items():
result.update([("%s:%s" % (tableRole, k), v)
for k, v in tableDictiona... |
def pivot_index(row):
"""
Returns the index of pivot in a row
"""
counter = 0
for element in row:
if element != float(0):
return counter
counter += 1
return counter |
def capitalize(s):
"""
Capitalize a string - only first letter
Args:
s (string): The input string to be capitalized.
Returns:
(string): The capitalized string.
"""
return s[0:1].upper() + s[1:] |
def abbr_fqdn(origin: str, name: str, *, prefix: str = '') -> str:
"""Abbreviate fully-qualified Python name, by removing origin.
``app.origin`` is the package where the app is defined,
so if this is ``examples.simple``::
>>> app.origin
'examples.simple'
>>> abbr_fqdn(app.origin, '... |
def unitify(quantity, unit):
"""Format an amount with units specifier handling options plural 's'"""
return '{} {}'.format(quantity, unit if quantity == 1 else unit + 's') |
def divmod_min(a, b):
"""
return q,r such that a = qb + r, with minimum |r|
"""
q, r = divmod(a, b)
# we will want to adjust r if
# (|r| > |b/2|), which is equivalent to checking
# (|2r| > |b|),
# (|r| > |b| - |r|)
# then using the fact that for python,
# divmod will g... |
def is_false(v, chk_none: bool = True) -> bool:
"""
**Warning:** Unless you specifically need to verify a value is Falsey, it's usually safer to
check for truth :py:func:`.is_true` and invert the result, i.e. ``if not is_true(v)``
Check if a given bool/str/int value is some form of ``False``:
... |
def clean_up_command_output(raw_command_data):
""" clean up command output
restructures the registered output data """
# initialize vrf command output
vrf_command_output = []
# skip if no data available in the raw command data
if 'results' not in raw_command_data:
return vrf_command_ou... |
def _get_mod97_value(to_check, characters=None, mod=97):
"""Method that calculates a check digit based on the formula used for the mod97
check digit method. This method replaces all non-numeric values in the string with
two digits (i.e. A=10, B=11, etc) and then calculates a modulus of this value.
"""
... |
def convert_standard_datestamp(entry):
"""Set date and time attributes based on a standard date stamp"""
# Get the date stamp (without year)
months = {'Jan': '01', 'Feb': '02', 'Mar': '03',
'Apr': '04', 'May': '05', 'Jun': '06',
'Jul': '07', 'Aug': '08', 'Sep': '09',
'Oct... |
def is_new_style(cls):
"""
Python 2.7 has both new-style and old-style classes. Old-style classes can
be pesky in some circumstances, such as when using inheritance. Use this
function to test for whether a class is new-style. (Python 3 only has
new-style classes.)
"""
return hasattr(... |
def rel_index(elem, lst, default=None):
"""`lst.index(elem) / len(lst)` with fallback."""
try:
return lst.index(elem) / len(lst)
except ValueError:
if default == None:
raise
return default |
def invalid_request_body_with_non_existent_client(valid_staff_model):
"""
A fixture for creating a request body with non-existent client id.
Args:
valid_staff_model (Model): a valid staff model created by a fixture.
"""
return {
'title': 'Improve customer care services',
'de... |
def TBool(val):
"""Checks if the given value is a boolean.
"""
return isinstance(val, bool) |
def clean_string(s):
"""
Get a string into a canonical form - no whitespace at either end,
no newlines, no double-spaces.
"""
return s.strip().replace("\n", " ").replace(" ", " ") |
def parse_shader_error( error ):
"""Parses a single GLSL error and extracts the line number and error
description.
Line number and description are returned as a tuple.
GLSL errors are not defined by the standard, as such,
each driver provider prints their own error format.
Nvidia print using ... |
def mid_point(x1, y1, x2, y2):
"""
mid_point will find the mid point of a line segment when four coordinates are given.
It will return the mid point as a tuple.
:param x1: x-coordinate of left vertex
:param y1: y-coordinate of left vertex
:param x2: x-coordinate of right vertex
:param y2: y... |
def get_by_py_path(py_path):
"""
Imports and returns a python callable.
Keyword arguments:
py_path -- callable to load
"""
parts = py_path.split('.')
module = ".".join(parts[:-1])
m = __import__(module)
for comp in parts[1:]:
m = getattr(m, comp)
return m |
def elfhash(s):
"""
:param string: bytes
>>> import base64
>>> s = base64.b64encode(b'hello world')
>>> elfhash(s)
224648685
"""
hash = 0
x = 0
for c in s:
hash = (hash << 4) + c
x = hash & 0xF0000000
if x:
hash ^= (x >> 24)
hash &... |
def normalized2KITTI(box):
"""
convert Bbox format
:param box: [X, Y, width, height]
:return: [xmin, ymin, xmax, ymax]
"""
o_x, o_y, o_width, o_height = box
xmin = int(o_x)
ymin = int(o_y)
xmax = int(o_x + o_width)
ymax = int(o_y + o_height)
return [xmin, ymin, xmax, ymax] |
def basename(fullyqualname: str) -> str:
"""Remove a name's namespace, so it can be used in a __qualname__.
It may seem wrong that the fully qualified PHP name is used as __name__,
and the unqualified PHP name is used as __qualname__, but Python's
qualified names shouldn't include the module name.
... |
def parse_gav(gav, defaults=(None, None, None)):
"""Parses the given GAV as a tuple.
gav
the GAV to parse. It must be a string with two colons separating the
GAV parts.
defaults
a triple of default coordinates to return if a part from the input is
missing
Returns:
... |
def fib(n: int):
"""Recursive function for fibonacci sequence."""
if n < 2:
return n
else:
return fib(n - 1) + fib(n - 2) |
def is_ascending(numbers):
"""Returns whether the given list of numbers is in ascending order."""
for i in range(len(numbers) - 1):
if numbers[i+1] < numbers[i]:
return False
return True |
def list_uniq(seq, key=None):
"""
Removes duplicate elements from a list while preserving the order of the rest.
>>> uniq([9,0,2,1,0])
[9, 0, 2, 1]
The value of the optional `key` parameter should be a function that
takes a single argument and returns a key to test the uniquene... |
def get_reader_pairs(reader):
"""
Return the set of alphabetically-sorted word (str) tuples
in `reader`
"""
return {tuple(sorted([w1, w2])): score for w1, w2, score in reader()} |
def relu(x):
"""
:math:`f(x) =` x if x is greater then y else 0
(See https://en.wikipedia.org/wiki/Rectifier_(neural_networks).)
"""
return x if x > 0. else 0. |
def _deduplicate_names(names):
"""Ensure there are no duplicates in ``names``
This is done by iteratively adding ``_<N>`` to the name for increasing N
until the name is unique.
"""
new_names = []
existing_names = set()
for name in names:
base_name = name + '_'
i = 1
... |
def values_dict(items):
"""Given a list of (key, list) values returns a dictionary where
single-element lists have been replaced by their sole value.
"""
return {k: v[0] if len(v) == 1 else v for k, v in items} |
def is_xfailed(xfail_args, compatible_version, platform, swift_branch):
"""Return whether the specified platform/swift_branch is xfailed."""
xfail = xfail_args['compatibility'].get(compatible_version, {})
if '*' in xfail:
return xfail['*'].split()[0]
if '*' in xfail.get('branch', {}):
re... |
def get_severity(data):
"""Convert level value to severity"""
if data == "warning":
return "Medium"
if data == "error":
return "Critical"
return "Info" |
def output_mode_adv(session, Type='Int32', RepCap='', AttrID=1150051, buffsize=0, action=['Get', '']):
"""[Advance Output Mode <int32>]
Sets/Gets the output mode, which may be Arbitrary Waveform, Arbitrary Sequence, or Advanced Sequence.
In Arbitrary Waveform mode, the generator outputs a single waveform. ... |
def sig_stars(p):
"""Return a R-style significance string corresponding to p values."""
if p < 0.001:
return "***"
elif p < 0.01:
return "**"
elif p < 0.05:
return "*"
elif p < 0.1:
return "."
return "" |
def strippedtxt(what, allowed=[]):
""" strip control characters from txt. """
txt = []
for i in what:
if ord(i) > 31 or (allowed and i in allowed): txt.append(i)
try: res = ''.join(txt)
except: res = u''.join(txt)
return res |
def expand_curie_to_uri(curie, context_info):
"""Expand curie to uri based on the context given
parmas
======
curie: curie to be expanded (e.g. bts:BiologicalEntity)
context_info: jsonld context specifying prefix-uri relation (e.g. {"bts":
"http://schema.biothings.io/"})
"""
# as sugges... |
def update_object(obj, path, callback=None):
"""
Traverse a data structure ensuring all nodes exist.
obj: expected to be a dictionary
path: string with dot-separated path components
callback: optional callback function (described below)
When update_object reaches the parent of the leaf node, i... |
def get_ngrams(text, n):
"""Returns all ngrams that are in the text.
Inputs:
text: string
n: int
Returns:
list of strings (each is a ngram)
"""
tokens = text.split()
return [
" ".join(tokens[i : i + n]) for i in range(len(tokens) - (n - 1))
] |
def social_optimum_cd(alpha, c):
"""
Cobb-Douglas utility social optimum
"""
if alpha > 1 - c:
return 1 / (1 - alpha)
else:
return 1 / c |
def get_char_indexes(arg_string, target):
"""list all instances of char in string | str --> list(int)"""
indexes = [index for index, char in enumerate(arg_string)
if char == target]
return indexes |
def trust_compatibility_score(h1_output_labels, h2_output_labels, expected_labels):
"""
The fraction of instances labeled correctly by both h1 and h2
out of the total number of instances labeled correctly by h1.
Args:
h1_output_labels: A list of the labels outputted by the model h1.
h2_... |
def is_apriori(Ck_item, Lksub1):
"""
Judge whether a frequent candidate k-itemset satisfy Apriori property.
Args:
Ck_item: a frequent candidate k-itemset in Ck which contains all frequent
candidate k-itemsets.
Lksub1: Lk-1, a set which contains all frequent candidate (k-1)-i... |
def canAddExtension(somefile, extension):
"""Ensures the given extension can even be used."""
return (((somefile is None) or (extension is None)) is False) |
def check_string_is_empty(string):
"""name
check string empty or not
Args:
Returns:
"""
if string == '':
return True
return False |
def datasets_to_str(datasets):
"""
This function prints out all existing datasets in the JSON format.
The output can then be copied & pasted to set the value of 'DATASETS'
in crab.datasets.
"""
import json
return str(json.dumps(datasets, indent=4, sort_keys=True)) |
def canvas2px(coord, dmn, dpi):
"""
Convert matplotlib canvas coordinate to pixels
"""
return int(round(coord * dmn * dpi)) |
def unique_everseen(items):
"""Returns only the first occurrence of the items in a list.
Equivalent to unique_everseen from the package more-itertools."""
from collections import OrderedDict
return list(OrderedDict.fromkeys(items)) |
def _get_opcode_length(op):
"""
Get length of operand bytes.
"""
while not op[-1]:
# encountered bug for the following
# 00 04 31 add byte ptr [rcx + rsi], al
if len(op) == 1:
break
op.pop()
return len(op) |
def get_param_path(cache_dir, method, data_fn, prop_missing, max_num_feature,
feature_selection):
"""Get path of pickled parameters."""
return (
'{}/{}_datafn={}_propmiss={}_maxfeat={}_featselect={}_param.pkl'.format(
cache_dir, method, data_fn, prop_missing, max_num_featu... |
def sort_uniq(seq):
"""
Sort sequence.
Args:
seq: the sequence of the data
Returns:
sequence with sorted order and no duplicates
"""
def _check_list(x):
if isinstance(x, list):
return True
else:
return False
seen = {}
result = [... |
def get_machines(request):
"""Returns the available machines that jobs can run on
Keyword arguments:
request - Django HttpRequest
"""
return {"localhost": {}} |
def interpolation(list, idx1, idx2, ratio):
"""Return the interpolation between list[idx1] and list[idx2] of vector "list".
Args:
list (vector) : List of values
idx1 : the index of the first value in the list
idx2 : the index of the second value in the list
ratio : the distance ... |
def string(integer,len_str_out):
"""
From a given integer, return an string of length len_str_out completed by zero
Example:
ut.string(1,3)-->'001'
"""
str_zero='0'
str_int=str(integer)
len_int=len(str_int)
if len_str_out-len_int<0:
print('****ERROR: length of string too shor... |
def get_images_helper(request, images):
"""
Helper method for gathering an object's list of images and formatting them along with their
corresponding types.
Parameters:
request : Request object from the serializer instance.
images : Queryset of image objects connected to the Object
... |
def get_bytes_from_gb(size_in_gb):
"""Convert size from GB into bytes."""
return size_in_gb * (1024 * 1024 * 1024) |
def _normalise_and_validate_contact_urn(contact_urn):
"""
Normalises and validates the given URN.
Fails with an AssertionError if the given URN is invalid.
:param contact_urn: URN to de-identify.
:type contact_urn: str
:return: Normalised contact urn.
:rtype: str
"""
if contact_urn... |
def convert_resnet_state_dict(src_dict):
"""Return the correct mapping of tensor name and value
Mapping from the names of torchvision model to our resnet conv_body and box_head.
"""
dst_dict = {}
for k, v in src_dict.items():
toks = k.split('.')
if k.startswith('layer'):
... |
def gp_tuple_to_dict(gp_tuple):
"""Convert a groupings parameters (gp) tuple into a dict suitable
to pass to the ``grouping_parameters`` CompoundTemplate.__init__
kwarg.
"""
params = [{'min': 1}, {'max': 1}, {'name': None}, {'possible_types': None},
{'is_separator': False}, {'inner_sep... |
def get_constr( module_str, start, end ):
"""Extract and return the constructor string from module_str[start:end];
also return the first position past the constructor string."""
constr_start = start
# Remove leading spaces
while module_str[ constr_start ] == ' ':
constr_start += 1
if module_str.find( '... |
def lays_in(a, b):
""" Does cube a completely lay in cube b? """
a_from, a_to = a
b_from, b_to = b
return (all(b <= a for a, b in zip(a_from, b_from)) and
all(a <= b for a, b in zip(a_to, b_to))) |
def _contains_acquire_instruction(experiments):
""" Return True if the list of experiments contains an Acquire instruction
Parameters:
experiments (list): list of schedules
Returns:
True or False: whether or not the schedules contain an Acquire command
Raises:
"""
for exp in exp... |
def b2s(a):
"""
Converts bytes to str
"""
return "".join(list(map(chr, a))) |
def check_description(description, check_term=' and '):
"""
Check if the first argument contains the 2nd argument
:param description: str
:param check_term: str
:return: bool
"""
if description.find(check_term) >= 0:
return True
return False |
def save_file(filename, content, header="", writemode="w"):
"""Save specified string contents to a file with the specified filename.
[description]
Arguments:
filename {[type]} -- [description]
content {[type]} -- [description]
Keyword Arguments:
writemode {str} -- Changes the ... |
def fontName2FamilyName(name):
"""For now take the chunk up till "-" in the filename and ignore the family
name as set in the font.info Also make sure that the extension is removed,
if the font has no "-" it isn't name. Relay-Medium_Italic.ufo becomes
Relay. ThisFont.ufo becomes ThisFont."""
return ... |
def windows_only_packages(pkgs):
"""Find out which packages are windows only"""
res = set()
for p in pkgs:
for name, info in p.items():
if info.get("OS_type", "").lower() == "windows":
res.add(name)
return res |
def dict_splicer(plot_dict,Ld,Lx):
"""Dictionary constructor for plotting
Base-level function used by most other plotting functions to construct a list of dictionaries,
each containing the passed arguments to the underlying plotting calls for each different dataset.
Parameters
----------
plot_dict : dict
Co... |
def filter_dict(pred, d) :
"""Return a subset of the dictionary d, consisting only of the keys that satisfy pred(key)."""
ret = {}
for k in d :
if pred(k) :
ret[k] = d[k]
return ret |
def _get_a0(nshell, ncomponent):
"""Return the first mass number in the given shell
:param nshell: shell (0=s, 1=p, 2=sd, ...)
:param ncomponent: 1 -> neutrons, 2 -> protons & neutrons
"""
return int((nshell+2) * (nshell+1) * nshell/3 * ncomponent) |
def get_index_of_most_important_sentences(weighted_sums, num_vectors):
""" Finds and returns the index of the two sentences with the highest weighted sum """
largest_sum_index, second_largest_sum_index = 0, 0
largest_sum, second_largest_sum = 0, 0
for i in range(num_vectors):
current_sum = weigh... |
def transform_part_info(data):
"""Transform the participants annotation JSON, into one that has names as keys."""
new_data={}
for part_id, part in data.items():
if 'Name' in part and part['Name'].strip():
name=part['Name'].strip()
del part['Name']
new_part={}
... |
def buildRowBorder(start, middle, end, spacer, dateWidth, editorWidths, editorIds):
"""
Create a row border line.
:param start: The character to use at the start
:param middle: The character to use for each middle column
:param end: The character to use at the end
:param spacer: The character to... |
def XOR(x,y,z):
""" Bitwise XOR """
y = int(x, 2)^int(y, 2)^int(z, 2)
return bin(y)[2:].zfill(len(x)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.