content stringlengths 42 6.51k |
|---|
def replace_self(name1, str1, str2):
"""replace"""
return name1.replace(str1, str2) |
def process_instruction(instruction, line, accumulator):
"""Process operation from single instruction."""
operations = {
'nop': lambda l, diff: (line + 1, accumulator),
'acc': lambda l, diff: (line + 1, accumulator + diff),
'jmp': lambda l, diff: (line + diff, accumulator),
}
ope... |
def parser_rar_over_ip_Descriptor(data,i,length,end):
"""\
parser_rar_over_ip_Descriptor(data,i,length,end) -> dict(parsed descriptor elements).
This descriptor is not parsed at the moment. The dict returned is:
{ "type": "rar_over_ip", "contents" : unparsed_descriptor_contents }
(Defin... |
def mhz_to_freq_khz(mhz):
"""
Convert MHz to exact frequency in kHz
"""
return {
14: 14100,
18: 18110,
21: 21150,
24: 24930,
28: 28200
}[mhz] |
def user_defined_descriptions(path):
"""Returns a dict consisting of (unicode_char, description) tuples"""
try:
lines = [line.rstrip() for line in open(path).readlines()]
return dict([x.split(maxsplit=1) for x in lines])
except FileNotFoundError:
return dict() |
def compare(initial, candidate):
"""
Compares two shingles sequence and returns similarity value.
:param initial: initial sentence shingles sequence
:param candidate: compared sentence shingles sequence
:return: similarity value
"""
matches = 0
for shingle in initial:
if shingle ... |
def human_join(iterable, delim=', ', *, final='and'):
"""Joins an iterable in a human-readable way.
The items are joined such that the last two items will be joined with a
different delimiter than the rest.
"""
seq = tuple(iterable)
if not seq:
return ''
return f"{delim.join(seq[:-... |
def serialise(entry):
"""Serialise an entry."""
if not entry:
return None
ret = entry._asdict()
ret["type"] = entry.__class__.__name__
if ret["type"] == "Transaction":
ret["payee"] = entry.payee or ""
if entry.tags:
ret["narration"] += " " + " ".join(["#" + t for ... |
def per_device_batch_size(batch_size, num_gpus):
"""For multi-gpu, batch-size must be a multiple of the number of GPUs.
Note that this should eventually be handled by DistributionStrategies
directly. Multi-GPU support is currently experimental, however,
so doing the work here until that feature is in pl... |
def get_count(sentence):
"""
Return the number (count) of vowels in the given string.
We will consider a, e, i, o, u as vowels for this Kata (but not y).
The input string will only consist of lower case letters and/or spaces.
"""
vowels = ['a', 'e', 'i', 'o', 'u']
count = 0
for ch in s... |
def cross_product(a, b):
"""Computes cross product between two vectors"""
return (
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0]
) |
def _iendswith(string, suffix):
"""Check if string ends with suffix."""
return string.lower().endswith(suffix) |
def _node_match(node_a_attr, node_b_attr):
"""
Compares attributes of the nodes for equality.
:param node_a_attr: Attributes of first node.
:param node_b_attr: Attributes of second node.
:return: True is equal - otherwise False
"""
if node_a_attr == node_b_attr:
return True... |
def set_payload(email: str, password: str) -> dict:
"""Defines payload for the request to the FH Kiel.
Parameters
----------
email : str
email of the user
password : str
password of the user
Returns
-------
dict
Body with all key/value pairs for the request.
... |
def num_odd(n, m, indices):
"""returns the number of odds
after indices flips"""
# initialize variables
row, col = [False] * n, [False] * m
# iterate through indices
for r, c in indices:
row[r] ^= True
col[c] ^= True
return sum(rows ^ colm for rows in row for colm in col) |
def lis(arr):
"""
Time Complexity: O(n^2)
Space Complexity: O(n)
"""
n = len(arr)
dp = [1 for i in range(n)]
for i in range(1, n):
for j in range(i):
if arr[i] > arr[j] and dp[i] < dp[j] + 1:
dp[i] = dp[j] + 1
longest_subsequence_len = None
for ... |
def dedup(objects):
""" De-duplicate list of objects based on dbId key"""
new = []
seen = {}
for object in objects:
dbId = object['dbId']
if dbId in seen:
continue
seen[dbId] = 1
new.append(object)
return new |
def sequence_minus(seq1, seq2):
"""Calculate difference of two sequences.
Result contains the elements from first sequence that are not
present in second sequence, in original order. Works even
if sequence elements are not hashable.
"""
result = list(seq1)
for item in seq2:
try:
... |
def get_id(item):
"""Return id of an item if it's a dict"""
if type(item) == dict and "id" in item:
return item["id"]
else:
return item |
def get_left_child(iIndex):
"""
Given an index it returns it's left child's index.
"""
return 2 * iIndex + 1 |
def build_reaction_page_url(article_id, max_total_likes):
"""
>>> build_reaction_page_url(123, 5000000)
'https://mbasic.facebook.com/ufi/reaction/profile/browser/fetch/?\
limit={0}&total_count=5000000&ft_ent_identifier=123'
"""
# Not replacing limit={0} on purpose
return \
"https://mbasi... |
def do_duration(seconds):
"""Convert a numeric duration in seconds into a human-readable string."""
hours, seconds = divmod(seconds, 3600)
minutes, seconds = divmod(seconds, 60)
if hours:
return '%dh%dm' % (hours, minutes)
if minutes:
return '%dm%ds' % (minutes, seconds)
else:
... |
def is_valid_bst(node, value_min, value_max):
"""
Traverses tree depth first in order
Note the tree may be a subtree of a larger tree.
The method may be called recursively.
Tree does not have to be "balanced", may have more levels than necessary.
Duplicate values are not allowed.
https://e... |
def subPt(ptA, ptB):
"""Substract two vectors"""
return ptA[0] - ptB[0], ptA[1] - ptB[1] |
def quantile_5_95(values):
"""
Returns 5% and 95% quantiles.
"""
values = sorted(values)
size = len(values)
idx5 = int(round(size * 0.05)) - 1
idx95 = int(round(size * 0.95)) - 1
if idx5 == 0:
raise ValueError("Sample size too small: %s" % len(values))
return values[idx5], va... |
def append_error(params, err):
"""
:param params:
:param err:
:return:
"""
dict_items = params.copy()
if err:
stack = None
if hasattr(err, "stack"):
stack = err.stack
error = {"errorName": str(type(err).__name__), "errorMessage": str(err), "stackTrace": s... |
def is_an_iter(x):
"""
this function identifies iterables that are not strings
"""
return hasattr(x, '__iter__') |
def merge(line):
""" Merges a single row or column given as line.
Returns a new list with merged values.
"""
result_vals = [0 for num in line]
for num in line:
# Push all non-zero values to the front
if num != 0:
if 0 in result_vals:
first_zero = ... |
def get_next(result):
"""Get next item in the result set. """
return next(iter(result)) |
def coin_change(x, R):
"""Coin change
:param x: table of non negative values
:param R: target value
:returns bool: True if there is a non negative linear combination of x that has value R
:complexity: O(n*R)
"""
b = [False] * (R + 1)
b[0] = True
for xi in x:
for s in range(x... |
def new_canvas(dimension, value='0'):
"""Produce a blank canvas."""
return [[value] * dimension for _ in range(0, dimension)] |
def normalize_coefficients(n, D):
"""
:param n: integer dimension of the original space
:param D: dictionary in the form returned by forward_no_normalization(v):
:return: corresponding dictionary with the coefficients noramlized
>>> expected = {(2, 0): -0.7071067811865476, (0, 0): 5.0, (1, 0): -2.0,... |
def _del_nulls(kwargs):
"""Delete keys that are ``None`` or ``'null'`` for kwargs.
"""
null_keys = [k for (k, v) in kwargs.items() if v is None or v is 'null']
for k in null_keys:
del(kwargs[k])
return kwargs |
def and_fault(a, b, out, fault):
"""Returns True if AND(a, b) == out and fault == 0 or AND(a, b) != out and fault == 1."""
if (a and b) == out:
return fault == 0
else:
return fault == 1 |
def broadcasted_shape(*shapes):
"""
Computes the resulting broadcasted shape for a given set of shapes.
Uses the broadcasting rules of NumPy. Raises an exception if the shapes do
not broadcast.
"""
dim = 0
for a in shapes:
dim = max(dim, len(a))
S = ()
for i in range(-dim,0... |
def _loc_info(loc):
"""Parse info from location string."""
info = {}
tup = loc.split(',')
if len(tup) < 5:
info['id_lu'] = tup[0].split('.')
return info
info['id_lu'] = tup[2].split('.')
info['tgt'] = tup
return info |
def is_boolean(value, arg_name, logger=None):
"""
Verifies whether a parameter is correctly defined as boolean.
:param value: value of the parameter
:param arg_name: str, parameter name
:param logger: logger instance
:return: boolean, True if value is a boolean, False other... |
def get_type_pieces(type_str):
"""
Given a full type string, returns (module, name, ver)
- Given "KBaseNarrative.Narrative-4.0"
- Returns ("KBaseNarrative", "Narrative", "4.0")
"""
(full_name, type_version) = type_str.split('-')
(type_module, type_name) = full_name.split('.')
return (t... |
def find_which_schedule_this_belongs_to(schedule_array, sample_val):
"""
Takes a sample and determines with schedule this belongs to.
Note: A schedule is task * task sized
:param sample_val: an int
:return: schedule num
"""
for i, each_array in enumerate(schedule_array):
if each_arra... |
def _check_filesys_for_guess2(ini_zma_fs, zma_locs=(0,)):
""" Check if the filesystem for any TS structures at the input
level of theory
"""
guess_zmas = []
if ini_zma_fs is not None:
if ini_zma_fs[-1].file.zmatrix.exists(zma_locs):
geo_path = ini_zma_fs[-1].file.zmatrix.exi... |
def is_dict_like(obj):
"""Try to figure if the given obj gives a dict-like interface"""
return all(hasattr(obj, method_name)
for method_name in ["__getitem__", "__iter__", "get", "keys"]) |
def __isabbreviation(abbrev, item):
"""Return True if first char of 'abbrev' and 'item' match and all chars of 'abbrev' occur in 'item' in this order.
@param abbrev : Case sensitive string.
@param item : Case sensitive string.
@return : True if 'abbrev' is an abbreviation of 'item'.
"""
if not a... |
def count_iterations(alist):
"""
Counts the number of times value 'x' occurs in a list
"""
x = {}
for i in alist:
if i in x:
x[i] += 1
else:
x[i] = 1
return x |
def generate_q_gram_matrix(string1, string2, q_value):
"""
Generate a vector of q-gram occurences in two strings given a
window size of q.
Parameters
----------
string1 : str
string to calculate distance from
string2 : str
string to calculate distance to
q_value : int
... |
def did_not_run(departure):
"""Return True if did not depart. False, otherwise."""
return not departure[1] |
def MOTP_frame(pairs_num, distance, frame_id, gt_num, hp_num):
"""calculate MOTP of a frame
params
pairs_num: mapping pairs num for one frame
distance:
frame_id: id of frame which is processing
gt_num: object num of ground truth
hp_num: object num of hypothesis
-----------
... |
def _module_dir(lock_filename):
"""Returns module dir from a full 'lock_filename' path.
Args:
lock_filename: Name of the lock file, ends with .lock.
Raises:
ValueError: if lock_filename is ill specified.
"""
if not lock_filename.endswith(".lock"):
raise ValueError(
"Lock file name (%s) h... |
def as_text(value):
"""Returns the string representation of given value
Arguments:
value {any} -- Value to get the string representation for
Returns:
stringified text {String} -- String representation of given value
"""
return "" if value is None else str(value) |
def primeFactors(n):
""" This function returns a list of prime factors for n
--param
n : integer
--return
list : prime factors of n
"""
if n < 2:
return []
elif n in {2,3}:
return [(n,1)]
else:
factors = []
exponent = 0
while n % 2 == 0:
... |
def removeprefix(text, prefix):
"""Removes a prefix from a string.
If the string starts with the prefix string, return string[len(prefix):].
Otherwise, returns the original string. This function has been added in
Python3.9 as the builtin `str.removeprefix`, but is defined here to support
previous v... |
def _get_namespace(sensor):
"""get sensor namespace
:param sensor: namespace of the sensor, e.g. bio.bpm, activities.steps
"""
parts = sensor.split(".")
if len(parts) < 2:
return None, sensor
return ".".join(parts[0:-1]), parts[-1] |
def is_valid_ip(ip_addr: str) -> bool:
"""Returns true if the string represents a valid IPv4 address.
Args:
ip_addr: The IP address being qualified
Returns:
True if it has 4 parts separated by `.` with each part in range 0..255
"""
if not(isinstance(ip_addr, str)):
... |
def modo_api_versions(url, request):
"""Simulate versions check."""
return {
"status_code": 200,
"content": [
{"name": "modoboa", "version": "9.0.0", "url": ""},
]
} |
def build_deltastrs(addcount, delcount):
"""build a string of `+`s and `-`s representing a delta"""
strlen = 79
changed = addcount + delcount
if changed > strlen:
if addcount > 0:
addcount = round(strlen / changed * addcount)
if delcount > 0:
delcount = round(strl... |
def cleanup_current_branch_output(branch_list: list) -> list:
"""cleanups the way git outputs the current branch
for example: git branch --list
some-branch
* develop
branch-list = ['some-branch', '* develop']
The asterisks is attached to the current branch, and we want to remove
... |
def sec_url(period):
""" Create url link to SEC Financial Statement Data Set """
url = "".join([
"https://www.sec.gov/files/dera/data/financial-statement-data-sets/",
period,
".zip"
])
# handle weird path exception of SEC
if period == "2020q1":
url = "".join([
... |
def merged_production_mix(non_renewables_mix: dict, renewables_mix: dict) -> dict:
"""Merges production mix data from different sources. Hydro comes from two
different sources that are added up."""
production_mix = {
"biomass": renewables_mix["biomass"],
"solar": renewables_mix["solar"],
... |
def GetPartitionsByType(partitions, typename):
"""Given a partition table and type returns the partitions of the type.
Partitions are sorted in num order.
Args:
partitions: List of partitions to search in
typename: The type of partitions to select
Returns:
A list of partitions of the type
"""
... |
def nearest(variable, items):
"""
Returns the nearest value of a variable inside a list
Used to find the nearest
"""
return min(items, key=lambda x: abs(x - variable)) |
def alternate(nums):
"""
In worst case, requires (1 / 2) * (N ^ 2 + 3 * N - 2) invocations of less-than.
In best case requires N.
"""
for v in nums:
v_is_largest = True
for num in nums:
if v < num:
v_is_largest = False
break
if v_is... |
def _round(value: float, places=2) -> str:
"""Rounds a value to the given number of decimal places."""
fstring = "{:.%gg}" % places # pylint: disable=consider-using-f-string
return fstring.format(value) |
def int_to_format(value, target_format):
"""Convert int to specified format"""
if target_format == float:
ret = float(value)
elif target_format == str:
ret = str(value)
else:
ret = value
return ret |
def create_scatter_legend(axi, color_labels, class_names, show=False,
**kwargs):
"""Generate a legend for a scatter plot with class labels.
Parameters
----------
axi : object like :class:`matplotlib.axes.Axes`
The axes we will add the legend for.
color_labels : dic... |
def parse_list_of_list_from_string(a_string):
"""
This parses a list of lists separated string. Each list is separated by a colon
Args:
a_string (str): This creates a list of lists. Each sub list is separated by colons and the sub list items are separated by commas. So `1,2,3:4,5` would produce [ [... |
def sanitize(text):
"""
remove all spacial characters from text
:param text: input text
:return: clean text
"""
meta_characters = ["\\", "^", "$", "{", "}", "[",
"]", "(", ")", ".", "*", "+",
"?", "|", "<", ">", "-", "&",
"/",... |
def pig_it(text):
"""Removes first letter of an original word and returns a new word with original word's first letter at end with addition of 'ay'."""
pyg = 'ay'
text_var = text.split()
each_word = []
for item in text_var:
if len(item) > 0 and item.isalpha():
each_word.append(item... |
def is_set(var):
"""
is this a set
"""
return isinstance(var, (set)) |
def volume_prisma(area_dasar: float, tinggi: float) -> float:
"""
kalkulasi dari volume prisma
referensi
https://en.wikipedia.org/wiki/Prism_(geometry)
>>> volume_prisma(10, 2)
20.0
>>> volume_prisma(11, 1)
11.0
"""
return float(area_dasar * tinggi) |
def canonical_entity_name(entity):
"""Convert entity names to their canonical form.
Some entities (notably project-<team>-) have more than one name, for
example the project-owners-<project_id> entities are called
project-owners-<project_number> internally. This function
:param entity:str convert t... |
def _sp_print_stderr(m: str) -> str:
"""Return the subprocess cmd to print `m` to stderr."""
return 'python -c "import sys; print(\'{}\', file=sys.stderr)"'.format(m) |
def trim_suffix(text, suffix):
"""Strip a suffix from text, if it appears (otherwise return text unchanged)"""
if not text.endswith(suffix):
return text
return text[: len(text) - len(suffix)] |
def build_mapping(*items, cls=dict):
"""
builds a dict from pairs passed, each 2 values are interpreted as (key, value)
"""
# check that it's an even length
assert len(items) & 1 != 1, 'length of items must be even in build_dict(...)'
return cls(zip(items[::2], items[1::2])) |
def is_namedtuple(value):
"""Whether the value is a namedtuple instance.
Args:
value (Object):
Returns:
``True`` if the value is a namedtuple instance.
"""
return isinstance(value, tuple) and hasattr(value, '_fields') |
def std_dev(list_of_nums):
"""
Returns standard deviation values for a list of numbers
:param list_of_nums: a list of numbers
:return: standard deviation val
"""
length = len(list_of_nums)
mean = sum(list_of_nums)/length
std_dev = (sum([(num - mean)**2 for num in list_of_nums])/length)*... |
def parse_period(period):
"""
Parse a 'period' out to it's two parts
>>> parse_period('minute-15')
('minute', 15)
>>> parse_period('day')
('day', 1)
"""
unit = period.split('-')[0]
quantity = int((period.split('-') + ['1'])[1])
return (unit, quantity) |
def _flatten(l, ltypes=(list, tuple)):
"""
Return a flatten list from a list like [1,2,[4,5,1]]
"""
ltype = type(l)
l = list(l)
i = 0
while i < len(l):
while isinstance(l[i], ltypes):
if not l[i]:
l.pop(i)
i -= 1
break
... |
def calculate_rc_lowpass_filter(data, time_constant, time_interval):
"""
This code can be found at https://en.wikipedia.org/wiki/Low-pass_filter
:param data:
:param time_constant:
:param time_interval:
:return:
"""
result = [0] * len(data)
alpha = time_interval / (time_constant +... |
def get_generic_type(obj):
"""Get the generic type of an object if possible, or runtime class otherwise.
Examples::
class Node(Generic[T]):
...
type(Node[int]()) == Node
get_generic_type(Node[int]()) == Node[int]
get_generic_type(Node[T]()) == Node[T]
get_gen... |
def _esc(code):
"""Get an ANSI color code based on a color number."""
return '\033[{}m'.format(code) |
def test_line(line):
"""returns true lines. Not comments or blank line"""
if not line.strip():
return False # if the last line is blank
if line.startswith("#"):
return False # comment line
if line.startswith(" # "): # swarm result file
return False # comment line
if li... |
def _extract_spectrum_mpi(version_buffer_str):
"""
Parses the typical Spectrum MPI library version message, eg:
Open MPI v4.0.1, package: Spectrum MPI Distribution, ident: 4.0.1, repo rev: v4.0.1, Mar 26, 2019
"""
return version_buffer_str.split("v", 1)[1].split(",", 1)[0] |
def intersect(L1, L2):
"""
1. first nested loop takes len(L1)*len(L2) steps
2. second loop takes at most len(L1) steps
3. Latter term overwhelmed by form term
4. O(len(L1)*len(L2))
"""
tmp = []
for e1 in L1:
for e2 in L2:
if e1 == e2:
tmp.append(e1)
... |
def highest_mortality(hurricanes):
"""Find the highest mortality hurricane and the number of deaths it caused."""
max_mortality_cane = 'Cuba I'
max_mortality = 0
for cane in hurricanes:
if hurricanes[cane]['Deaths'] > max_mortality:
max_mortality_cane = cane
max_mortality = hurricanes[cane]['Dea... |
def extrapolate_wind_speed(height_in, height_out, wind_speed):
"""
:param height_in: m, Height data was recorded at
:param height_out: m, Height desired
:param wind_speed: m/s, Array of wind speeds recorded at height_in
:return:
"""
shear_exponent = .144444
extrapolated_wind_speed = [x ... |
def fuzzy_equal(d1, d2, precision=0.1):
"""
Compare two objects recursively (just as standard '==' except floating point
values are compared within given precision.
Based on https://gist.github.com/durden/4236551, modified to handle lists
"""
if len(d1) != len(d2):
print("Length of obj... |
def get_cui_if_exists(field_ids: list, remapped_cuis: dict):
"""
Given a list of IDs present in a SemMedDB SUBJECT_CUI or OBJECT_CUI field, this function returns the CUI, if one
exists (sometimes only NCBIGene IDs are present).
"""
first_id = field_ids[0]
if first_id.upper().startswith('C'):
... |
def gmres_params(n_krylov=40, max_restarts=20, tol_coef=0.01):
"""
Bundles parameters for the GMRES linear solver. These control the
expense of finding the left and right environment Hamiltonians.
PARAMETERS
----------
n_krylov (int): Size of the Krylov subspace.
max_restarts (int): Maximum... |
def to_time (wmi_time):
"""
Convenience wrapper to take a WMI datetime string of the form
yyyymmddHHMMSS.mmmmmm+UUU and return a 9-tuple containing the
individual elements, or None where string contains placeholder
stars.
@param wmi_time The WMI datetime string in yyyymmddHHMMSS.mmmmmm+UUU format... |
def change_char_list(lista, rep):
"""The strings of a list by replacling some parts.
Parameters
----------
lista: list
the list of strings that we want to transform.
rep: dict
the replace dictionary.
Returns
-------
new_lista: list
the list of transformed string... |
def heat_equation_no_density(Cu, Cth, Ck, c1=0.26, c2=0.07, c3=0.10):
"""
Heat production equation from Beamish and Busby (2016)
density is the density of the
Cu: weight of uranium in ppm
Cth: weight of thorium in ppm
Ck: weight of potassium in %
Returns: Radioactive heat producti... |
def is_implicit_newline(raw):
"""should we add a newline to templates starting with *, #, :, ;, {|
see: http://meta.wikimedia.org/wiki/Help:Newlines_and_spaces#Automatic_newline_at_the_start
"""
sw = raw.startswith
for x in ('*', '#', ':', ';', '{|'):
if sw(x):
return True
re... |
def enumerate_combinations(iterable, length):
"""
Enumerate all combinations of iterable elements of a given length
:param iterable: An iterable, such as a list or tuple
:param length: An integer specifying the length of the combination
:return: A set
"""
answer_set = set([()])
for dummy... |
def cross(o, a, b):
"""Cross-product for vectors o-a and o-b
"""
xo, yo = o
xa, ya = a
xb, yb = b
return (xa - xo)*(yb - yo) - (ya - yo)*(xb - xo) |
def populate_pictures(query, dictree, picpath):
"""
populates pictures in an existing dictree for the shelters it contains
"""
for p in query:
if p.shelter_id in dictree:
if p.is_main_picture == True:
if not dictree[p.shelter_id]["Identification"]["Cover"]:
... |
def original_production_volume(dataset, default=None):
"""Get original (i.e. before activity link subtractions) production volume of reference product exchange.
Returns ``default`` (default value is ``None``) if no or multiple
reference products, or if reference product doesn't have a production
volume... |
def _html_tag(tag, contents, attr_string=''):
"""Wraps 'contents' in an HTML element with an open and closed 'tag', applying the 'attr_string' attributes. """
return '<' + tag + attr_string + '>' + contents + '</' + tag + '>' |
def chunks(lst, n):
"""Yield successive n-sized chunks from lst."""
return [lst[x:x+n] for x in range(0, len(lst), n)] |
def is_fp_closed(obj):
"""
Checks whether a given file-like object is closed.
:param obj:
The file-like object to check.
"""
try:
# Check for our own base response class.
return obj.complete
except AttributeError:
pass
try:
# Check via the official f... |
def append_slash(url, append=True):
"""Append a slash to a URL, checking if it already has one."""
if url.endswith("/"):
if append:
return url
else:
return url[:-1]
else:
if append:
return url + "/"
else:
return url |
def get_author(author_list: list) -> str:
"""Parse ChemRxiv dump entry to extract author list
Args:
author_list (list): List of dicts, one per author.
Returns:
str: ;-concatenated author list.
"""
return '; '.join([a['full_name'] for a in author_list]) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.