text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create(fs, channels):
"""Allocates and initializes a decoder state""" |
result_code = ctypes.c_int()
result = _create(fs, channels, ctypes.byref(result_code))
if result_code.value is not 0:
raise OpusError(result_code.value)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def packet_get_bandwidth(data):
"""Gets the bandwidth of an Opus packet.""" |
data_pointer = ctypes.c_char_p(data)
result = _packet_get_bandwidth(data_pointer)
if result < 0:
raise OpusError(result)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def packet_get_nb_channels(data):
"""Gets the number of channels from an Opus packet""" |
data_pointer = ctypes.c_char_p(data)
result = _packet_get_nb_channels(data_pointer)
if result < 0:
raise OpusError(result)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def packet_get_nb_frames(data, length=None):
"""Gets the number of frames in an Opus packet""" |
data_pointer = ctypes.c_char_p(data)
if length is None:
length = len(data)
result = _packet_get_nb_frames(data_pointer, ctypes.c_int(length))
if result < 0:
raise OpusError(result)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def packet_get_samples_per_frame(data, fs):
"""Gets the number of samples per frame from an Opus packet""" |
data_pointer = ctypes.c_char_p(data)
result = _packet_get_nb_frames(data_pointer, ctypes.c_int(fs))
if result < 0:
raise OpusError(result)
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def decode(decoder, data, length, frame_size, decode_fec, channels=2):
"""Decode an Opus frame Unlike the `opus_decode` function , this function takes an additional parameter `channels`, which indicates the number of channels in the frame """ |
pcm_size = frame_size * channels * ctypes.sizeof(ctypes.c_int16)
pcm = (ctypes.c_int16 * pcm_size)()
pcm_pointer = ctypes.cast(pcm, c_int16_pointer)
# Converting from a boolean to int
decode_fec = int(bool(decode_fec))
result = _decode(decoder, data, length, pcm_pointer, frame_size, decode_fec)
if result < 0:
raise OpusError(result)
return array.array('h', pcm).tostring() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def diff(old_html, new_html, cutoff=0.0, plaintext=False, pretty=False):
"""Show the differences between the old and new html document, as html. Return the document html with extra tags added to show changes. Add <ins> tags around newly added sections, and <del> tags to show sections that have been deleted. """ |
if plaintext:
old_dom = parse_text(old_html)
new_dom = parse_text(new_html)
else:
old_dom = parse_minidom(old_html)
new_dom = parse_minidom(new_html)
# If the two documents are not similar enough, don't show the changes.
if not check_text_similarity(old_dom, new_dom, cutoff):
return '<h2>The differences from the previous version are too large to show concisely.</h2>'
dom = dom_diff(old_dom, new_dom)
# HTML-specific cleanup.
if not plaintext:
fix_lists(dom)
fix_tables(dom)
# Only return html for the document body contents.
body_elements = dom.getElementsByTagName('body')
if len(body_elements) == 1:
dom = body_elements[0]
return minidom_tostring(dom, pretty=pretty) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def adjusted_ops(opcodes):
""" Iterate through opcodes, turning them into a series of insert and delete operations, adjusting indices to account for the size of insertions and deletions. [('delete', 0, 1, 0, 0), ('delete', 1, 2, 1, 1)] [('insert', 0, 0, 0, 1), ('insert', 2, 2, 2, 3)] [('delete', 1, 3, 1, 1), ('insert', 1, 1, 1, 2)] [('delete', 1, 2, 1, 1), ('insert', 1, 1, 1, 2)] [('delete', 0, 1, 0, 0), ('insert', 1, 1, 1, 2)] [('insert', 0, 0, 0, 1), ('delete', 2, 3, 2, 2)] """ |
while opcodes:
op = opcodes.pop(0)
tag, i1, i2, j1, j2 = op
shift = 0
if tag == 'equal':
continue
if tag == 'replace':
# change the single replace op into a delete then insert
# pay careful attention to the variables here, there's no typo
opcodes = [
('delete', i1, i2, j1, j1),
('insert', i2, i2, j1, j2),
] + opcodes
continue
yield op
if tag == 'delete':
shift = -(i2 - i1)
elif tag == 'insert':
shift = +(j2 - j1)
new_opcodes = []
for tag, i1, i2, j1, j2 in opcodes:
new_opcodes.append((
tag,
i1 + shift,
i2 + shift,
j1,
j2,
))
opcodes = new_opcodes |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_opcodes(matching_blocks):
"""Use difflib to get the opcodes for a set of matching blocks.""" |
sm = difflib.SequenceMatcher(a=[], b=[])
sm.matching_blocks = matching_blocks
return sm.get_opcodes() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def match_blocks(hash_func, old_children, new_children):
"""Use difflib to find matching blocks.""" |
sm = difflib.SequenceMatcher(
_is_junk,
a=[hash_func(c) for c in old_children],
b=[hash_func(c) for c in new_children],
)
return sm |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_nonmatching_blocks(matching_blocks):
"""Given a list of matching blocks, output the gaps between them. Non-matches have the format (alo, ahi, blo, bhi). This specifies two index ranges, one in the A sequence, and one in the B sequence. """ |
i = j = 0
for match in matching_blocks:
a, b, size = match
yield (i, a, j, b)
i = a + size
j = b + size |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def merge_blocks(a_blocks, b_blocks):
"""Given two lists of blocks, combine them, in the proper order. Ensure that there are no overlaps, and that they are for sequences of the same length. """ |
# Check sentinels for sequence length.
assert a_blocks[-1][2] == b_blocks[-1][2] == 0 # sentinel size is 0
assert a_blocks[-1] == b_blocks[-1]
combined_blocks = sorted(list(set(a_blocks + b_blocks)))
# Check for overlaps.
i = j = 0
for a, b, size in combined_blocks:
assert i <= a
assert j <= b
i = a + size
j = b + size
return combined_blocks |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_comments(xml):
""" Remove comments, as they can break the xml parser. See html5lib issue #122 ( http://code.google.com/p/html5lib/issues/detail?id=122 ). '' '' '<p>stuffstuff</p>' """ |
regex = re.compile(r'<!--.*?-->', re.DOTALL)
return regex.sub('', xml) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_newlines(xml):
r"""Remove newlines in the xml. If the newline separates words in text, then replace with a space instead. '<p>para one</p><p>para two</p>' '<p>line one line two</p>' 'one 1' 'hey! more text!' """ |
# Normalize newlines.
xml = xml.replace('\r\n', '\n')
xml = xml.replace('\r', '\n')
# Remove newlines that don't separate text. The remaining ones do separate text.
xml = re.sub(r'(?<=[>\s])\n(?=[<\s])', '', xml)
xml = xml.replace('\n', ' ')
return xml.strip() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_insignificant_text_nodes(dom):
""" For html elements that should not have text nodes inside them, remove all whitespace. For elements that may have text, collapse multiple spaces to a single space. """ |
nodes_to_remove = []
for node in walk_dom(dom):
if is_text(node):
text = node.nodeValue
if node.parentNode.tagName in _non_text_node_tags:
nodes_to_remove.append(node)
else:
node.nodeValue = re.sub(r'\s+', ' ', text)
for node in nodes_to_remove:
remove_node(node) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_child(parent, child_index):
""" Get the child at the given index, or return None if it doesn't exist. """ |
if child_index < 0 or child_index >= len(parent.childNodes):
return None
return parent.childNodes[child_index] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_location(dom, location):
""" Get the node at the specified location in the dom. Location is a sequence of child indices, starting at the children of the root element. If there is no node at this location, raise a ValueError. """ |
node = dom.documentElement
for i in location:
node = get_child(node, i)
if not node:
raise ValueError('Node at location %s does not exist.' % location) #TODO: line not covered
return node |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def check_text_similarity(a_dom, b_dom, cutoff):
"""Check whether two dom trees have similar text or not.""" |
a_words = list(tree_words(a_dom))
b_words = list(tree_words(b_dom))
sm = WordMatcher(a=a_words, b=b_words)
if sm.text_ratio() >= cutoff:
return True
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def insert_or_append(parent, node, next_sibling):
""" Insert the node before next_sibling. If next_sibling is None, append the node last instead. """ |
# simple insert
if next_sibling:
parent.insertBefore(node, next_sibling)
else:
parent.appendChild(node) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wrap(node, tag):
"""Wrap the given tag around a node.""" |
wrap_node = node.ownerDocument.createElement(tag)
parent = node.parentNode
if parent:
parent.replaceChild(wrap_node, node)
wrap_node.appendChild(node)
return wrap_node |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def wrap_inner(node, tag):
"""Wrap the given tag around the contents of a node.""" |
children = list(node.childNodes)
wrap_node = node.ownerDocument.createElement(tag)
for c in children:
wrap_node.appendChild(c)
node.appendChild(wrap_node) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def unwrap(node):
"""Remove a node, replacing it with its children.""" |
for child in list(node.childNodes):
node.parentNode.insertBefore(child, node)
remove_node(node) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def full_split(text, regex):
""" Split the text by the regex, keeping all parts. The parts should re-join back into the original text. ['word'] """ |
while text:
m = regex.search(text)
if not m:
yield text
break
left = text[:m.start()]
middle = text[m.start():m.end()]
right = text[m.end():]
if left:
yield left
if middle:
yield middle
text = right |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def multi_split(text, regexes):
""" Split the text by the given regexes, in priority order. Make sure that the regex is parenthesized so that matches are returned in re.split(). Splitting on a single regex works like normal split. 'one| |two| |three' Splitting on digits first separates the digits from their word 'one|234|five| |678' Splitting on words first keeps the word with digits intact. 'one234five| |678' """ |
def make_regex(s):
return re.compile(s) if isinstance(s, basestring) else s
regexes = [make_regex(r) for r in regexes]
# Run the list of pieces through the regex split, splitting it into more
# pieces. Once a piece has been matched, add it to finished_pieces and
# don't split it again. The pieces should always join back together to form
# the original text.
piece_list = [text]
finished_pieces = set()
def apply_re(regex, piece_list):
for piece in piece_list:
if piece in finished_pieces:
yield piece
continue
for s in full_split(piece, regex):
if regex.match(s):
finished_pieces.add(s)
if s:
yield s
for regex in regexes:
piece_list = list(apply_re(regex, piece_list))
assert ''.join(piece_list) == text
return piece_list |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def match_length(self):
""" Find the total length of all words that match between the two sequences.""" |
length = 0
for match in self.get_matching_blocks():
a, b, size = match
length += self._text_length(self.a[a:a+size])
return length |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run_edit_script(self):
""" Run an xml edit script, and return the new html produced. """ |
for action, location, properties in self.edit_script:
if action == 'delete':
node = get_location(self.dom, location)
self.action_delete(node)
elif action == 'insert':
parent = get_location(self.dom, location[:-1])
child_index = location[-1]
self.action_insert(parent, child_index, **properties)
return self.dom |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_nesting(dom, tag_name):
""" Unwrap items in the node list that have ancestors with the same tag. """ |
for node in dom.getElementsByTagName(tag_name):
for ancestor in ancestors(node):
if ancestor is node:
continue
if ancestor is dom.documentElement:
break
if ancestor.tagName == tag_name:
unwrap(node)
break |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sort_nodes(dom, cmp_func):
""" Sort the nodes of the dom in-place, based on a comparison function. """ |
dom.normalize()
for node in list(walk_dom(dom, elements_only=True)):
prev_sib = node.previousSibling
while prev_sib and cmp_func(prev_sib, node) == 1:
node.parentNode.insertBefore(node, prev_sib)
prev_sib = node.previousSibling |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def merge_adjacent(dom, tag_name):
""" Merge all adjacent tags with the specified tag name. Return the number of merges performed. """ |
for node in dom.getElementsByTagName(tag_name):
prev_sib = node.previousSibling
if prev_sib and prev_sib.nodeName == node.tagName:
for child in list(node.childNodes):
prev_sib.appendChild(child)
remove_node(node) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def distribute(node):
""" Wrap a copy of the given element around the contents of each of its children, removing the node in the process. """ |
children = list(c for c in node.childNodes if is_element(c))
unwrap(node)
tag_name = node.tagName
for c in children:
wrap_inner(c, tag_name) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def save(self, *args, **kwargs):
""" Save object to the database. Removes all other entries if there are any. """ |
self.__class__.objects.exclude(id=self.id).delete()
super(SingletonModel, self).save(*args, **kwargs) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_magicc_region_to_openscm_region_mapping(inverse=False):
"""Get the mappings from MAGICC to OpenSCM regions. This is not a pure inverse of the other way around. For example, we never provide "GLOBAL" as a MAGICC return value because it's unnecesarily confusing when we also have "World". Fortunately MAGICC doesn't ever read the name "GLOBAL" so this shouldn't matter. Parameters inverse : bool If True, return the inverse mappings i.e. MAGICC to OpenSCM mappings Returns ------- dict Dictionary of mappings """ |
def get_openscm_replacement(in_region):
world = "World"
if in_region in ("WORLD", "GLOBAL"):
return world
if in_region in ("BUNKERS"):
return DATA_HIERARCHY_SEPARATOR.join([world, "Bunkers"])
elif in_region.startswith(("NH", "SH")):
in_region = in_region.replace("-", "")
hem = "Northern Hemisphere" if "NH" in in_region else "Southern Hemisphere"
if in_region in ("NH", "SH"):
return DATA_HIERARCHY_SEPARATOR.join([world, hem])
land_ocean = "Land" if "LAND" in in_region else "Ocean"
return DATA_HIERARCHY_SEPARATOR.join([world, hem, land_ocean])
else:
return DATA_HIERARCHY_SEPARATOR.join([world, in_region])
# we generate the mapping dynamically, the first name in the list
# is the one which will be used for inverse mappings
_magicc_regions = [
"WORLD",
"GLOBAL",
"OECD90",
"ALM",
"REF",
"ASIA",
"R5ASIA",
"R5OECD",
"R5REF",
"R5MAF",
"R5LAM",
"R6OECD90",
"R6REF",
"R6LAM",
"R6MAF",
"R6ASIA",
"NHOCEAN",
"SHOCEAN",
"NHLAND",
"SHLAND",
"NH-OCEAN",
"SH-OCEAN",
"NH-LAND",
"SH-LAND",
"SH",
"NH",
"BUNKERS",
]
replacements = {}
for magicc_region in _magicc_regions:
openscm_region = get_openscm_replacement(magicc_region)
# i.e. if we've already got a value for the inverse, we don't want to overwrite
if (openscm_region in replacements.values()) and inverse:
continue
replacements[magicc_region] = openscm_region
if inverse:
return {v: k for k, v in replacements.items()}
else:
return replacements |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def convert_magicc_to_openscm_regions(regions, inverse=False):
""" Convert MAGICC regions to OpenSCM regions Parameters regions : list_like, str Regions to convert inverse : bool If True, convert the other way i.e. convert OpenSCM regions to MAGICC7 regions Returns ------- ``type(regions)`` Set of converted regions """ |
if isinstance(regions, (list, pd.Index)):
return [_apply_convert_magicc_to_openscm_regions(r, inverse) for r in regions]
else:
return _apply_convert_magicc_to_openscm_regions(regions, inverse) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def convert_magicc7_to_openscm_variables(variables, inverse=False):
""" Convert MAGICC7 variables to OpenSCM variables Parameters variables : list_like, str Variables to convert inverse : bool If True, convert the other way i.e. convert OpenSCM variables to MAGICC7 variables Returns ------- ``type(variables)`` Set of converted variables """ |
if isinstance(variables, (list, pd.Index)):
return [
_apply_convert_magicc7_to_openscm_variables(v, inverse) for v in variables
]
else:
return _apply_convert_magicc7_to_openscm_variables(variables, inverse) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_magicc6_to_magicc7_variable_mapping(inverse=False):
"""Get the mappings from MAGICC6 to MAGICC7 variables. Note that this mapping is not one to one. For example, "HFC4310", "HFC43-10" and "HFC-43-10" in MAGICC6 both map to "HFC4310" in MAGICC7 but "HFC4310" in MAGICC7 maps back to "HFC4310". Note that HFC-245fa was mistakenly labelled as HFC-245ca in MAGICC6. In reality, they are not the same thing. However, the MAGICC6 labelling was merely a typo so the mapping between the two is one-to-one. Parameters inverse : bool If True, return the inverse mappings i.e. MAGICC7 to MAGICC6 mappings Returns ------- dict Dictionary of mappings """ |
# we generate the mapping dynamically, the first name in the list
# is the one which will be used for inverse mappings
magicc6_simple_mapping_vars = [
"KYOTO-CO2EQ",
"CO2I",
"CO2B",
"CH4",
"N2O",
"BC",
"OC",
"SOx",
"NOx",
"NMVOC",
"CO",
"SF6",
"NH3",
"CF4",
"C2F6",
"HFC4310",
"HFC43-10",
"HFC-43-10",
"HFC4310",
"HFC134a",
"HFC143a",
"HFC227ea",
"CCl4",
"CH3CCl3",
"HFC245fa",
"Halon 1211",
"Halon 1202",
"Halon 1301",
"Halon 2402",
"Halon1211",
"Halon1202",
"Halon1301",
"Halon2402",
"CH3Br",
"CH3Cl",
"C6F14",
]
magicc6_sometimes_hyphen_vars = [
"CFC-11",
"CFC-12",
"CFC-113",
"CFC-114",
"CFC-115",
"HCFC-22",
"HFC-23",
"HFC-32",
"HFC-125",
"HFC-134a",
"HFC-143a",
"HCFC-141b",
"HCFC-142b",
"HFC-227ea",
"HFC-245fa",
]
magicc6_sometimes_hyphen_vars = [
v.replace("-", "") for v in magicc6_sometimes_hyphen_vars
] + magicc6_sometimes_hyphen_vars
magicc6_sometimes_underscore_vars = [
"HFC43_10",
"CFC_11",
"CFC_12",
"CFC_113",
"CFC_114",
"CFC_115",
"HCFC_22",
"HCFC_141b",
"HCFC_142b",
]
magicc6_sometimes_underscore_replacements = {
v: v.replace("_", "") for v in magicc6_sometimes_underscore_vars
}
special_case_replacements = {
"FossilCO2": "CO2I",
"OtherCO2": "CO2B",
"MCF": "CH3CCL3",
"CARB_TET": "CCL4",
"MHALOSUMCFC12EQ": "MHALOSUMCFC12EQ", # special case to avoid confusion with MCF
}
one_way_replacements = {"HFC-245ca": "HFC245FA", "HFC245ca": "HFC245FA"}
all_possible_magicc6_vars = (
magicc6_simple_mapping_vars
+ magicc6_sometimes_hyphen_vars
+ magicc6_sometimes_underscore_vars
+ list(special_case_replacements.keys())
+ list(one_way_replacements.keys())
)
replacements = {}
for m6v in all_possible_magicc6_vars:
if m6v in special_case_replacements:
replacements[m6v] = special_case_replacements[m6v]
elif (
m6v in magicc6_sometimes_underscore_vars and not inverse
): # underscores one way
replacements[m6v] = magicc6_sometimes_underscore_replacements[m6v]
elif (m6v in one_way_replacements) and not inverse:
replacements[m6v] = one_way_replacements[m6v]
else:
m7v = m6v.replace("-", "").replace(" ", "").upper()
# i.e. if we've already got a value for the inverse, we don't
# want to overwrite it
if (m7v in replacements.values()) and inverse:
continue
replacements[m6v] = m7v
if inverse:
return {v: k for k, v in replacements.items()}
else:
return replacements |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def convert_magicc6_to_magicc7_variables(variables, inverse=False):
""" Convert MAGICC6 variables to MAGICC7 variables Parameters variables : list_like, str Variables to convert inverse : bool If True, convert the other way i.e. convert MAGICC7 variables to MAGICC6 variables Raises ------ ValueError If you try to convert HFC245ca, or some variant thereof, you will get a ValueError. The reason is that this variable was never meant to be included in MAGICC6, it was just an accident. See, for example, the text in the description section of ``pymagicc/MAGICC6/run/HISTRCP_HFC245fa_CONC.IN``: Returns ------- ``type(variables)`` Set of converted variables """ |
if isinstance(variables, (list, pd.Index)):
return [
_apply_convert_magicc6_to_magicc7_variables(v, inverse) for v in variables
]
else:
return _apply_convert_magicc6_to_magicc7_variables(variables, inverse) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_pint_to_fortran_safe_units_mapping(inverse=False):
"""Get the mappings from Pint to Fortran safe units. Fortran can't handle special characters like "^" or "/" in names, but we need these in Pint. Conversely, Pint stores variables with spaces by default e.g. "Mt CO2 / yr" but we don't want these in the input files as Fortran is likely to think the whitespace is a delimiter. Parameters inverse : bool If True, return the inverse mappings i.e. Fortran safe to Pint mappings Returns ------- dict Dictionary of mappings """ |
replacements = {"^": "super", "/": "per", " ": ""}
if inverse:
replacements = {v: k for k, v in replacements.items()}
# mapping nothing to something is obviously not going to work in the inverse
# hence remove
replacements.pop("")
return replacements |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def convert_pint_to_fortran_safe_units(units, inverse=False):
""" Convert Pint units to Fortran safe units Parameters units : list_like, str Units to convert inverse : bool If True, convert the other way i.e. convert Fortran safe units to Pint units Returns ------- ``type(units)`` Set of converted units """ |
if inverse:
return apply_string_substitutions(units, FORTRAN_SAFE_TO_PINT_UNITS_MAPPING)
else:
return apply_string_substitutions(units, PINT_TO_FORTRAN_SAFE_UNITS_MAPPING) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run_evaluate(self) -> None: """ Overrides the base evaluation to set the value to the evaluation result of the value expression in the schema """ |
result = None
self.eval_error = False
if self._needs_evaluation:
result = self._schema.value.evaluate(self._evaluation_context)
self.eval_error = result is None
if self.eval_error:
return
# Only set the value if it conforms to the field type
if not self._schema.is_type_of(result):
try:
result = self._schema.type_object(result)
except Exception as err:
logging.debug('{} in casting {} to {} for field {}. Error: {}'.format(
type(err).__name__, result, self._schema.type,
self._schema.fully_qualified_name, err))
self.eval_error = True
return
try:
result = self._schema.sanitize_object(result)
except Exception as err:
logging.debug('{} in sanitizing {} of type {} for field {}. Error: {}'.format(
type(err).__name__, result, self._schema.type, self._schema.fully_qualified_name,
err))
self.eval_error = True
return
self.value = result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set(self, key: Any, value: Any) -> None: """ Sets the value of a key to a supplied value """ |
if key is not None:
self[key] = value |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def increment(self, key: Any, by: int = 1) -> None: """ Increments the value set against a key. If the key is not present, 0 is assumed as the initial state """ |
if key is not None:
self[key] = self.get(key, 0) + by |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def insert(self, index: int, obj: Any) -> None: """ Inserts an item to the list as long as it is not None """ |
if obj is not None:
super().insert(index, obj) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_dattype_regionmode(regions, scen7=False):
""" Get the THISFILE_DATTYPE and THISFILE_REGIONMODE flags for a given region set. In all MAGICC input files, there are two flags: THISFILE_DATTYPE and THISFILE_REGIONMODE. These tell MAGICC how to read in a given input file. This function maps the regions which are in a given file to the value of these flags expected by MAGICC. Parameters regions : list_like The regions to get THISFILE_DATTYPE and THISFILE_REGIONMODE flags for. scen7 : bool, optional Whether the file we are getting the flags for is a SCEN7 file or not. Returns ------- dict Dictionary where the flags are the keys and the values are the value they should be set to for the given inputs. """ |
dattype_flag = "THISFILE_DATTYPE"
regionmode_flag = "THISFILE_REGIONMODE"
region_dattype_row = _get_dattype_regionmode_regions_row(regions, scen7=scen7)
dattype = DATTYPE_REGIONMODE_REGIONS[dattype_flag.lower()][region_dattype_row].iloc[
0
]
regionmode = DATTYPE_REGIONMODE_REGIONS[regionmode_flag.lower()][
region_dattype_row
].iloc[0]
return {dattype_flag: dattype, regionmode_flag: regionmode} |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_region_order(regions, scen7=False):
""" Get the region order expected by MAGICC. Parameters regions : list_like The regions to get THISFILE_DATTYPE and THISFILE_REGIONMODE flags for. scen7 : bool, optional Whether the file we are getting the flags for is a SCEN7 file or not. Returns ------- list Region order expected by MAGICC for the given region set. """ |
region_dattype_row = _get_dattype_regionmode_regions_row(regions, scen7=scen7)
region_order = DATTYPE_REGIONMODE_REGIONS["regions"][region_dattype_row].iloc[0]
return region_order |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_special_scen_code(regions, emissions):
""" Get special code for MAGICC6 SCEN files. At the top of every MAGICC6 and MAGICC5 SCEN file there is a two digit number. The first digit, the 'scenfile_region_code' tells MAGICC how many regions data is being provided for. The second digit, the 'scenfile_emissions_code', tells MAGICC which gases are in the SCEN file. The variables which are part of ``PART_OF_SCENFILE_WITH_EMISSIONS_CODE_1`` are the emissions species which are expected when scenfile_emissions_code is 1. Similarly, ``PART_OF_SCENFILE_WITH_EMISSIONS_CODE_0`` defines the emissions species which are expected when scenfile_emissions_code is 0. Having these definitions allows Pymagicc to check that the right set of emissions has been provided before writing SCEN files. Parameters region : list_like Regions to get code for. emissions : list-like Emissions to get code for. Raises ------ ValueError If the special scen code cannot be determined. Returns ------- int The special scen code for the regions-emissions combination provided. """ |
if sorted(set(PART_OF_SCENFILE_WITH_EMISSIONS_CODE_0)) == sorted(set(emissions)):
scenfile_emissions_code = 0
elif sorted(set(PART_OF_SCENFILE_WITH_EMISSIONS_CODE_1)) == sorted(set(emissions)):
scenfile_emissions_code = 1
else:
msg = "Could not determine scen special code for emissions {}".format(emissions)
raise ValueError(msg)
if set(regions) == set(["WORLD"]):
scenfile_region_code = 1
elif set(regions) == set(["WORLD", "OECD90", "REF", "ASIA", "ALM"]):
scenfile_region_code = 2
elif set(regions) == set(["WORLD", "R5OECD", "R5REF", "R5ASIA", "R5MAF", "R5LAM"]):
scenfile_region_code = 3
elif set(regions) == set(
["WORLD", "R5OECD", "R5REF", "R5ASIA", "R5MAF", "R5LAM", "BUNKERS"]
):
scenfile_region_code = 4
try:
return scenfile_region_code * 10 + scenfile_emissions_code
except NameError:
msg = "Could not determine scen special code for regions {}".format(regions)
raise ValueError(msg) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pull_cfg_from_parameters_out(parameters_out, namelist_to_read="nml_allcfgs"):
"""Pull out a single config set from a parameters_out namelist. This function returns a single file with the config that needs to be passed to MAGICC in order to do the same run as is represented by the values in ``parameters_out``. Parameters parameters_out : dict, f90nml.Namelist The parameters to dump namelist_to_read : str The namelist to read from the file. Returns ------- :obj:`f90nml.Namelist` An f90nml object with the cleaned, read out config. Examples -------- """ |
single_cfg = Namelist({namelist_to_read: {}})
for key, value in parameters_out[namelist_to_read].items():
if "file_tuning" in key:
single_cfg[namelist_to_read][key] = ""
else:
try:
if isinstance(value, str):
single_cfg[namelist_to_read][key] = value.strip(" \t\n\r").replace(
"\x00", ""
)
elif isinstance(value, list):
clean_list = [v.strip(" \t\n\r").replace("\x00", "") for v in value]
single_cfg[namelist_to_read][key] = [v for v in clean_list if v]
else:
assert isinstance(value, Number)
single_cfg[namelist_to_read][key] = value
except AttributeError:
if isinstance(value, list):
assert all([isinstance(v, Number) for v in value])
single_cfg[namelist_to_read][key] = value
else:
raise AssertionError(
"Unexpected cause in out parameters conversion"
)
return single_cfg |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def pull_cfg_from_parameters_out_file( parameters_out_file, namelist_to_read="nml_allcfgs" ):
"""Pull out a single config set from a MAGICC ``PARAMETERS.OUT`` file. This function reads in the ``PARAMETERS.OUT`` file and returns a single file with the config that needs to be passed to MAGICC in order to do the same run as is represented by the values in ``PARAMETERS.OUT``. Parameters parameters_out_file : str The ``PARAMETERS.OUT`` file to read namelist_to_read : str The namelist to read from the file. Returns ------- :obj:`f90nml.Namelist` An f90nml object with the cleaned, read out config. Examples -------- """ |
parameters_out = read_cfg_file(parameters_out_file)
return pull_cfg_from_parameters_out(
parameters_out, namelist_to_read=namelist_to_read
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_generic_rcp_name(inname):
"""Convert an RCP name into the generic Pymagicc RCP name The conversion is case insensitive. Parameters inname : str The name for which to get the generic Pymagicc RCP name Returns ------- str The generic Pymagicc RCP name Examples -------- "rcp26" """ |
# TODO: move into OpenSCM
mapping = {
"rcp26": "rcp26",
"rcp3pd": "rcp26",
"rcp45": "rcp45",
"rcp6": "rcp60",
"rcp60": "rcp60",
"rcp85": "rcp85",
}
try:
return mapping[inname.lower()]
except KeyError:
error_msg = "No generic name for input: {}".format(inname)
raise ValueError(error_msg) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def join_timeseries(base, overwrite, join_linear=None):
"""Join two sets of timeseries Parameters base : :obj:`MAGICCData`, :obj:`pd.DataFrame`, filepath Base timeseries to use. If a filepath, the data will first be loaded from disk. overwrite : :obj:`MAGICCData`, :obj:`pd.DataFrame`, filepath Timeseries to join onto base. Any points which are in both `base` and `overwrite` will be taken from `overwrite`. If a filepath, the data will first be loaded from disk. join_linear : tuple of len(2) A list/array which specifies the period over which the two timeseries should be joined. The first element is the start time of the join period, the second element is the end time of the join period. In the join period (excluding the start and end times), output data will be a linear interpolation between (the annually interpolated) `base` and `overwrite` data. If None, no linear join will be done and any points in (the annually interpolated) `overwrite` data will simply overwrite any points in `base`. Returns ------- :obj:`MAGICCData` The joint timeseries. The resulting data is linearly interpolated onto annual steps """ |
if join_linear is not None:
if len(join_linear) != 2:
raise ValueError("join_linear must have a length of 2")
if isinstance(base, str):
base = MAGICCData(base)
elif isinstance(base, MAGICCData):
base = deepcopy(base)
if isinstance(overwrite, str):
overwrite = MAGICCData(overwrite)
elif isinstance(overwrite, MAGICCData):
overwrite = deepcopy(overwrite)
result = _join_timeseries_mdata(base, overwrite, join_linear)
return MAGICCData(result) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_scen_file( filepath, columns={ "model": ["unspecified"], "scenario": ["unspecified"], "climate_model": ["unspecified"], }, **kwargs ):
""" Read a MAGICC .SCEN file. Parameters filepath : str Filepath of the .SCEN file to read columns : dict Passed to ``__init__`` method of MAGICCData. See ``MAGICCData.__init__`` for details. kwargs Passed to ``__init__`` method of MAGICCData. See ``MAGICCData.__init__`` for details. Returns ------- :obj:`pymagicc.io.MAGICCData` ``MAGICCData`` object containing the data and metadata. """ |
mdata = MAGICCData(filepath, columns=columns, **kwargs)
return mdata |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_openscm_var_from_filepath(filepath):
""" Determine the OpenSCM variable from a filepath. Uses MAGICC's internal, implicit, filenaming conventions. Parameters filepath : str Filepath from which to determine the OpenSCM variable. Returns ------- str The OpenSCM variable implied by the filepath. """ |
reader = determine_tool(filepath, "reader")(filepath)
openscm_var = convert_magicc7_to_openscm_variables(
convert_magicc6_to_magicc7_variables(reader._get_variable_from_filepath())
)
return openscm_var |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _find_nml(self):
""" Find the start and end of the embedded namelist. Returns ------- (int, int) start and end index for the namelist """ |
nml_start = None
nml_end = None
for i in range(len(self.lines)):
if self.lines[i].strip().startswith("&"):
nml_start = i
if self.lines[i].strip().startswith("/"):
nml_end = i
assert (
nml_start is not None and nml_end is not None
), "Could not find namelist within {}".format(self.filepath)
return nml_end, nml_start |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_data(self, stream, metadata):
""" Extract the tabulated data from the input file. Parameters stream : Streamlike object A Streamlike object (nominally StringIO) containing the table to be extracted metadata : dict Metadata read in from the header and the namelist Returns ------- (pandas.DataFrame, dict) The first element contains the data, processed to the standard MAGICCData format. The second element is th updated metadata based on the processing performed. """ |
ch, metadata = self._get_column_headers_and_update_metadata(stream, metadata)
df = self._convert_data_block_and_headers_to_df(stream)
return df, metadata, ch |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_variable_from_filepath(self):
""" Determine the file variable from the filepath. Returns ------- str Best guess of variable name from the filepath """ |
try:
return self.regexp_capture_variable.search(self.filepath).group(1)
except AttributeError:
self._raise_cannot_determine_variable_from_filepath_error() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_header(self, header):
""" Parse the header for additional metadata. Parameters header : str All the lines in the header. Returns ------- dict The metadata in the header. """ |
metadata = {}
for line in header.split("\n"):
line = line.strip()
for tag in self.header_tags:
tag_text = "{}:".format(tag)
if line.lower().startswith(tag_text):
metadata[tag] = line[len(tag_text) + 1 :].strip()
return metadata |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _read_data_header_line(self, stream, expected_header):
"""Read a data header line, ensuring that it starts with the expected header Parameters stream : :obj:`StreamIO` Stream object containing the text to read expected_header : str, list of strs Expected header of the data header line """ |
pos = stream.tell()
expected_header = (
[expected_header] if isinstance(expected_header, str) else expected_header
)
for exp_hd in expected_header:
tokens = stream.readline().split()
try:
assert tokens[0] == exp_hd
return tokens[1:]
except AssertionError:
stream.seek(pos)
continue
assertion_msg = "Expected a header token of {}, got {}".format(
expected_header, tokens[0]
)
raise AssertionError(assertion_msg) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_chunk(self, t):
""" Read out the next chunk of memory Values in fortran binary streams begin and end with the number of bytes :param t: Data type (same format as used by struct). :return: Numpy array if the variable is an array, otherwise a scalar. """ |
size = self.data[self.pos : self.pos + 4].cast("i")[0]
d = self.data[self.pos + 4 : self.pos + 4 + size]
assert (
self.data[self.pos + 4 + size : self.pos + 4 + size + 4].cast("i")[0]
== size
)
self.pos = self.pos + 4 + size + 4
res = np.array(d.cast(t))
# Return as a scalar or a numpy array if it is an array
if res.size == 1:
return res[0]
return res |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_data(self, stream, metadata):
""" Extract the tabulated data from the input file # Arguments stream (Streamlike object):
A Streamlike object (nominally StringIO) containing the table to be extracted metadata (dict):
metadata read in from the header and the namelist # Returns df (pandas.DataFrame):
contains the data, processed to the standard MAGICCData format metadata (dict):
updated metadata based on the processing performed """ |
index = np.arange(metadata["firstyear"], metadata["lastyear"] + 1)
# The first variable is the global values
globe = stream.read_chunk("d")
assert len(globe) == len(index)
regions = stream.read_chunk("d")
num_regions = int(len(regions) / len(index))
regions = regions.reshape((-1, num_regions), order="F")
data = np.concatenate((globe[:, np.newaxis], regions), axis=1)
df = pd.DataFrame(data, index=index)
if isinstance(df.index, pd.core.indexes.numeric.Float64Index):
df.index = df.index.to_series().round(3)
df.index.name = "time"
regions = [
"World",
"World|Northern Hemisphere|Ocean",
"World|Northern Hemisphere|Land",
"World|Southern Hemisphere|Ocean",
"World|Southern Hemisphere|Land",
]
variable = convert_magicc6_to_magicc7_variables(
self._get_variable_from_filepath()
)
variable = convert_magicc7_to_openscm_variables(variable)
column_headers = {
"variable": [variable] * (num_regions + 1),
"region": regions,
"unit": ["unknown"] * len(regions),
"todo": ["SET"] * len(regions),
}
return df, metadata, self._set_column_defaults(column_headers) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def process_header(self, data):
""" Reads the first part of the file to get some essential metadata # Returns return (dict):
the metadata in the header """ |
metadata = {
"datacolumns": data.read_chunk("I"),
"firstyear": data.read_chunk("I"),
"lastyear": data.read_chunk("I"),
"annualsteps": data.read_chunk("I"),
}
if metadata["annualsteps"] != 1:
raise InvalidTemporalResError(
"{}: Only annual files can currently be processed".format(self.filepath)
)
return metadata |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write(self, magicc_input, filepath):
""" Write a MAGICC input file from df and metadata Parameters magicc_input : :obj:`pymagicc.io.MAGICCData` MAGICCData object which holds the data to write filepath : str Filepath of the file to write to. """ |
self._filepath = filepath
# TODO: make copy attribute for MAGICCData
self.minput = deepcopy(magicc_input)
self.data_block = self._get_data_block()
output = StringIO()
output = self._write_header(output)
output = self._write_namelist(output)
output = self._write_datablock(output)
with open(
filepath, "w", encoding="utf-8", newline=self._newline_char
) as output_file:
output.seek(0)
copyfileobj(output, output_file) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def append(self, other, inplace=False, **kwargs):
""" Append any input which can be converted to MAGICCData to self. Parameters other : MAGICCData, pd.DataFrame, pd.Series, str Source of data to append. inplace : bool If True, append ``other`` inplace, otherwise return a new ``MAGICCData`` instance. **kwargs Passed to ``MAGICCData`` constructor (only used if ``MAGICCData`` is not a ``MAGICCData`` instance). """ |
if not isinstance(other, MAGICCData):
other = MAGICCData(other, **kwargs)
if inplace:
super().append(other, inplace=inplace)
self.metadata.update(other.metadata)
else:
res = super().append(other, inplace=inplace)
res.metadata = deepcopy(self.metadata)
res.metadata.update(other.metadata)
return res |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write(self, filepath, magicc_version):
""" Write an input file to disk. Parameters filepath : str Filepath of the file to write. magicc_version : int The MAGICC version for which we want to write files. MAGICC7 and MAGICC6 namelists are incompatible hence we need to know which one we're writing for. """ |
writer = determine_tool(filepath, "writer")(magicc_version=magicc_version)
writer.write(self, filepath) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_python_identifier_attributes(fully_qualified_name: str, spec: Dict[str, Any], *attributes: str) -> List[InvalidIdentifierError]: """ Validates a set of attributes as identifiers in a spec """ |
errors: List[InvalidIdentifierError] = []
checks: List[Tuple[Callable, InvalidIdentifierError.Reason]] = [
(lambda x: x.startswith('_'), InvalidIdentifierError.Reason.STARTS_WITH_UNDERSCORE),
(lambda x: x.startswith('run_'), InvalidIdentifierError.Reason.STARTS_WITH_RUN),
(lambda x: not x.isidentifier(), InvalidIdentifierError.Reason.INVALID_PYTHON_IDENTIFIER),
]
for attribute in attributes:
if attribute not in spec or spec.get(ATTRIBUTE_INTERNAL, False):
continue
for check in checks:
if check[0](spec[attribute]):
errors.append(
InvalidIdentifierError(fully_qualified_name, spec, attribute, check[1]))
break
return errors |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_required_attributes(fully_qualified_name: str, spec: Dict[str, Any], *attributes: str) -> List[RequiredAttributeError]: """ Validates to ensure that a set of attributes are present in spec """ |
return [
RequiredAttributeError(fully_qualified_name, spec, attribute)
for attribute in attributes
if attribute not in spec
] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_empty_attributes(fully_qualified_name: str, spec: Dict[str, Any], *attributes: str) -> List[EmptyAttributeError]: """ Validates to ensure that a set of attributes do not contain empty values """ |
return [
EmptyAttributeError(fully_qualified_name, spec, attribute)
for attribute in attributes
if not spec.get(attribute, None)
] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_number_attribute( fully_qualified_name: str, spec: Dict[str, Any], attribute: str, value_type: Union[Type[int], Type[float]] = int, minimum: Optional[Union[int, float]] = None, maximum: Optional[Union[int, float]] = None) -> Optional[InvalidNumberError]: """ Validates to ensure that the value is a number of the specified type, and lies with the specified range """ |
if attribute not in spec:
return
try:
value = value_type(spec[attribute])
if (minimum is not None and value < minimum) or (maximum is not None and value > maximum):
raise None
except:
return InvalidNumberError(fully_qualified_name, spec, attribute, value_type, minimum,
maximum) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_enum_attribute(fully_qualified_name: str, spec: Dict[str, Any], attribute: str, candidates: Set[Union[str, int, float]]) -> Optional[InvalidValueError]: """ Validates to ensure that the value of an attribute lies within an allowed set of candidates """ |
if attribute not in spec:
return
if spec[attribute] not in candidates:
return InvalidValueError(fully_qualified_name, spec, attribute, candidates) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def starts_with(self, other: 'Key') -> bool: """ Checks if this key starts with the other key provided. Returns False if key_type, identity or group are different. For `KeyType.TIMESTAMP` returns True. For `KeyType.DIMENSION` does prefix match between the two dimensions property. """ |
if (self.key_type, self.identity, self.group) != (other.key_type, other.identity,
other.group):
return False
if self.key_type == KeyType.TIMESTAMP:
return True
if self.key_type == KeyType.DIMENSION:
if len(self.dimensions) < len(other.dimensions):
return False
return self.dimensions[0:len(other.dimensions)] == other.dimensions |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _evaluate_dimension_fields(self) -> bool: """ Evaluates the dimension fields. Returns False if any of the fields could not be evaluated. """ |
for _, item in self._dimension_fields.items():
item.run_evaluate()
if item.eval_error:
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _compare_dimensions_to_fields(self) -> bool: """ Compares the dimension field values to the value in regular fields.""" |
for name, item in self._dimension_fields.items():
if item.value != self._nested_items[name].value:
return False
return True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _key(self):
""" Generates the Key object based on dimension fields. """ |
return Key(self._schema.key_type, self._identity, self._name,
[str(item.value) for item in self._dimension_fields.values()]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def extend_schema_spec(self) -> None: """ Injects the block start and end times """ |
super().extend_schema_spec()
if self.ATTRIBUTE_FIELDS in self._spec:
# Add new fields to the schema spec. Since `_identity` is added by the super, new elements are added after
predefined_field = self._build_time_fields_spec(self._spec[self.ATTRIBUTE_NAME])
self._spec[self.ATTRIBUTE_FIELDS][1:1] = predefined_field
# Add new field schema to the schema loader
for field_schema in predefined_field:
self.schema_loader.add_schema_spec(field_schema, self.fully_qualified_name) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def build_expression(self, attribute: str) -> Optional[Expression]: """ Builds an expression object. Adds an error if expression creation has errors. """ |
expression_string = self._spec.get(attribute, None)
if expression_string:
try:
return Expression(str(expression_string))
except Exception as err:
self.add_errors(
InvalidExpressionError(self.fully_qualified_name, self._spec, attribute, err))
return None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_errors(self, *errors: Union[BaseSchemaError, List[BaseSchemaError]]) -> None: """ Adds errors to the error repository in schema loader """ |
self.schema_loader.add_errors(*errors) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_required_attributes(self, *attributes: str) -> None: """ Validates that the schema contains a series of required attributes """ |
self.add_errors(
validate_required_attributes(self.fully_qualified_name, self._spec, *attributes)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_number_attribute(self, attribute: str, value_type: Union[Type[int], Type[float]] = int, minimum: Optional[Union[int, float]] = None, maximum: Optional[Union[int, float]] = None) -> None: """ Validates that the attribute contains a numeric value within boundaries if specified """ |
self.add_errors(
validate_number_attribute(self.fully_qualified_name, self._spec, attribute, value_type,
minimum, maximum)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def validate_enum_attribute(self, attribute: str, candidates: Set[Union[str, int, float]]) -> None: """ Validates that the attribute value is among the candidates """ |
self.add_errors(
validate_enum_attribute(self.fully_qualified_name, self._spec, attribute, candidates)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _snapshot(self) -> Dict[str, Any]: """ Implements snapshot for collections by recursively invoking snapshot of all child items """ |
try:
return {name: item._snapshot for name, item in self._nested_items.items()}
except Exception as e:
raise SnapshotError('Error while creating snapshot for {}'.format(self._name)) from e |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def run_restore(self, snapshot: Dict[Union[str, Key], Any]) -> 'BaseItemCollection': """ Restores the state of a collection from a snapshot """ |
try:
for name, snap in snapshot.items():
if isinstance(name, Key):
self._nested_items[name.group].run_restore(snap)
else:
self._nested_items[name].run_restore(snap)
return self
except Exception as e:
raise SnapshotError('Error while restoring snapshot: {}'.format(self._snapshot)) from e |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def execute_per_identity_records( self, identity: str, records: List[TimeAndRecord], old_state: Optional[Dict[Key, Any]] = None) -> Tuple[str, Tuple[Dict, List]]: """ Executes the streaming and window BTS on the given records. An option old state can provided which initializes the state for execution. This is useful for batch execution where the previous state is written out to storage and can be loaded for the next batch run. :param identity: Identity of the records. :param records: List of TimeAndRecord to be processed. :param old_state: Streaming BTS state dictionary from a previous execution. :return: Tuple[Identity, Tuple[Identity, Tuple[Streaming BTS state dictionary, List of window BTS output]]. """ |
schema_loader = SchemaLoader()
if records:
records.sort(key=lambda x: x[0])
else:
records = []
block_data = self._execute_stream_bts(records, identity, schema_loader, old_state)
window_data = self._execute_window_bts(identity, schema_loader)
return identity, (block_data, window_data) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def to_string(self, hdr, other):
"""String representation with additional information""" |
result = "%s[%s,%s" % (
hdr, self.get_type(self.type), self.get_clazz(self.clazz))
if self.unique:
result += "-unique,"
else:
result += ","
result += self.name
if other is not None:
result += ",%s]" % (other)
else:
result += "]"
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def answered_by(self, rec):
"""Returns true if the question is answered by the record""" |
return self.clazz == rec.clazz and \
(self.type == rec.type or self.type == _TYPE_ANY) and \
self.name == rec.name |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def reset_ttl(self, other):
"""Sets this record's TTL and created time to that of another record.""" |
self.created = other.created
self.ttl = other.ttl |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def to_string(self, other):
"""String representation with addtional information""" |
arg = "%s/%s,%s" % (
self.ttl, self.get_remaining_ttl(current_time_millis()), other)
return DNSEntry.to_string(self, "record", arg) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def set_property(self, key, value):
""" Update only one property in the dict """ |
self.properties[key] = value
self.sync_properties() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_header(self):
"""Reads header portion of packet""" |
format = '!HHHHHH'
length = struct.calcsize(format)
info = struct.unpack(format,
self.data[self.offset:self.offset + length])
self.offset += length
self.id = info[0]
self.flags = info[1]
self.num_questions = info[2]
self.num_answers = info[3]
self.num_authorities = info[4]
self.num_additionals = info[5] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_questions(self):
"""Reads questions section of packet""" |
format = '!HH'
length = struct.calcsize(format)
for i in range(0, self.num_questions):
name = self.read_name()
info = struct.unpack(format,
self.data[self.offset:self.offset + length])
self.offset += length
question = DNSQuestion(name, info[0], info[1])
self.questions.append(question) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_int(self):
"""Reads an integer from the packet""" |
format = '!I'
length = struct.calcsize(format)
info = struct.unpack(format,
self.data[self.offset:self.offset + length])
self.offset += length
return info[0] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_character_string(self):
"""Reads a character string from the packet""" |
length = ord(self.data[self.offset])
self.offset += 1
return self.read_string(length) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_string(self, len):
"""Reads a string of a given length from the packet""" |
format = '!' + str(len) + 's'
length = struct.calcsize(format)
info = struct.unpack(format,
self.data[self.offset:self.offset + length])
self.offset += length
return info[0] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_others(self):
"""Reads the answers, authorities and additionals section of the packet""" |
format = '!HHiH'
length = struct.calcsize(format)
n = self.num_answers + self.num_authorities + self.num_additionals
for i in range(0, n):
domain = self.read_name()
info = struct.unpack(format,
self.data[self.offset:self.offset + length])
self.offset += length
rec = None
if info[0] == _TYPE_A:
rec = DNSAddress(domain,
info[0], info[1], info[2],
self.read_string(4))
elif info[0] == _TYPE_CNAME or info[0] == _TYPE_PTR:
rec = DNSPointer(domain,
info[0], info[1], info[2],
self.read_name())
elif info[0] == _TYPE_TXT:
rec = DNSText(domain,
info[0], info[1], info[2],
self.read_string(info[3]))
elif info[0] == _TYPE_SRV:
rec = DNSService(domain,
info[0], info[1], info[2],
self.read_unsigned_short(),
self.read_unsigned_short(),
self.read_unsigned_short(),
self.read_name())
elif info[0] == _TYPE_HINFO:
rec = DNSHinfo(domain,
info[0], info[1], info[2],
self.read_character_string(),
self.read_character_string())
elif info[0] == _TYPE_RRSIG:
rec = DNSSignatureI(domain,
info[0], info[1], info[2],
self.read_string(18),
self.read_name(),
self.read_character_string())
elif info[0] == _TYPE_AAAA:
rec = DNSAddress(domain,
info[0], info[1], info[2],
self.read_string(16))
else:
# Try to ignore types we don't know about
# this may mean the rest of the name is
# unable to be parsed, and may show errors
# so this is left for debugging. New types
# encountered need to be parsed properly.
#
#print "UNKNOWN TYPE = " + str(info[0])
#raise BadTypeInNameException
pass
if rec is not None:
self.answers.append(rec) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_utf(self, offset, len):
"""Reads a UTF-8 string of a given length from the packet""" |
try:
result = self.data[offset:offset + len].decode('utf-8')
except UnicodeDecodeError:
result = str('')
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def read_name(self):
"""Reads a domain name from the packet""" |
result = ''
off = self.offset
next = -1
first = off
while 1:
len = ord(self.data[off])
off += 1
if len == 0:
break
t = len & 0xC0
if t == 0x00:
result = ''.join((result, self.read_utf(off, len) + '.'))
off += len
elif t == 0xC0:
if next < 0:
next = off + 1
off = ((len & 0x3F) << 8) | ord(self.data[off])
if off >= first:
raise Exception(
"Bad domain name (circular) at " + str(off))
first = off
else:
raise Exception("Bad domain name at " + str(off))
if next >= 0:
self.offset = next
else:
self.offset = off
return result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_answer(self, inp, record):
"""Adds an answer""" |
if not record.suppressed_by(inp):
self.add_answer_at_time(record, 0) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_answer_at_time(self, record, now):
"""Adds an answer if if does not expire by a certain time""" |
if record is not None:
if now == 0 or not record.is_expired(now):
self.answers.append((record, now))
if record.rrsig is not None:
self.answers.append((record.rrsig, now)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_byte(self, value):
"""Writes a single byte to the packet""" |
format = '!B'
self.data.append(struct.pack(format, value))
self.size += 1 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def insert_short(self, index, value):
"""Inserts an unsigned short in a certain position in the packet""" |
format = '!H'
self.data.insert(index, struct.pack(format, value))
self.size += 2 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_int(self, value):
"""Writes an unsigned integer to the packet""" |
format = '!I'
self.data.append(struct.pack(format, int(value)))
self.size += 4 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_string(self, value, length):
"""Writes a string to the packet""" |
format = '!' + str(length) + 's'
self.data.append(struct.pack(format, value))
self.size += length |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def write_utf(self, s):
"""Writes a UTF-8 string of a given length to the packet""" |
utfstr = s.encode('utf-8')
length = len(utfstr)
if length > 64:
raise NamePartTooLongException
self.write_byte(length)
self.write_string(utfstr, length) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.